blob: 5e74c860e532bc97275c440ee30cd6d8a4117762 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * Common Flash Interface support:
3 * Intel Extended Vendor Command Set (ID 0x0001)
4 *
5 * (C) 2000 Red Hat. GPL'd
6 *
Thomas Gleixner1f948b42005-11-07 11:15:37 +00007 *
Nicolas Pitre2f82af02009-09-14 03:25:28 -04008 * 10/10/2000 Nicolas Pitre <nico@fluxnic.net>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 * - completely revamped method functions so they are aware and
10 * independent of the flash geometry (buswidth, interleave, etc.)
11 * - scalability vs code size is completely set at compile-time
12 * (see include/linux/mtd/cfi.h for selection)
13 * - optimized write buffer method
14 * 02/05/2002 Christopher Hoover <ch@hpl.hp.com>/<ch@murgatroid.com>
15 * - reworked lock/unlock/erase support for var size flash
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -080016 * 21/03/2007 Rodolfo Giometti <giometti@linux.it>
17 * - auto unlock sectors on resume for auto locking flash on power up
Linus Torvalds1da177e2005-04-16 15:20:36 -070018 */
19
20#include <linux/module.h>
21#include <linux/types.h>
22#include <linux/kernel.h>
23#include <linux/sched.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024#include <asm/io.h>
25#include <asm/byteorder.h>
26
27#include <linux/errno.h>
28#include <linux/slab.h>
29#include <linux/delay.h>
30#include <linux/interrupt.h>
Nicolas Pitre963a6fb2005-04-01 02:59:56 +010031#include <linux/reboot.h>
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -080032#include <linux/bitmap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <linux/mtd/xip.h>
34#include <linux/mtd/map.h>
35#include <linux/mtd/mtd.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/mtd/cfi.h>
37
38/* #define CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE */
39/* #define CMDSET0001_DISABLE_WRITE_SUSPEND */
40
41// debugging, turns off buffer write mode if set to 1
42#define FORCE_WORD_WRITE 0
43
Hans-Christian Egtvedtb2ef1a22009-11-05 15:53:43 +010044/* Intel chips */
Linus Torvalds1da177e2005-04-16 15:20:36 -070045#define I82802AB 0x00ad
46#define I82802AC 0x00ac
Daniel Ribeiroec2d0d82009-05-17 08:02:17 -030047#define PF38F4476 0x881c
Hans-Christian Egtvedtb2ef1a22009-11-05 15:53:43 +010048/* STMicroelectronics chips */
Linus Torvalds1da177e2005-04-16 15:20:36 -070049#define M50LPW080 0x002F
Nate Casedeb1a5f2008-05-13 14:45:29 -050050#define M50FLW080A 0x0080
51#define M50FLW080B 0x0081
Hans-Christian Egtvedt8dbaea42009-11-05 15:53:37 +010052/* Atmel chips */
Hans-Christian Egtvedtd10a39d2007-10-30 16:33:07 +010053#define AT49BV640D 0x02de
Hans-Christian Egtvedt8dbaea42009-11-05 15:53:37 +010054#define AT49BV640DT 0x02db
Linus Torvalds1da177e2005-04-16 15:20:36 -070055
56static int cfi_intelext_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057static int cfi_intelext_write_words(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
58static int cfi_intelext_write_buffers(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
Nicolas Pitree102d542005-08-06 05:46:59 +010059static int cfi_intelext_writev(struct mtd_info *, const struct kvec *, unsigned long, loff_t, size_t *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070060static int cfi_intelext_erase_varsize(struct mtd_info *, struct erase_info *);
61static void cfi_intelext_sync (struct mtd_info *);
Adrian Hunter69423d92008-12-10 13:37:21 +000062static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
63static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
Richard Cochran99384242010-06-14 18:10:33 +020064static int cfi_intelext_is_locked(struct mtd_info *mtd, loff_t ofs,
65 uint64_t len);
Todd Poynor8048d2f2005-03-31 00:57:33 +010066#ifdef CONFIG_MTD_OTP
Nicolas Pitref77814d2005-02-08 17:11:19 +000067static int cfi_intelext_read_fact_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
68static int cfi_intelext_read_user_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
69static int cfi_intelext_write_user_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
70static int cfi_intelext_lock_user_prot_reg (struct mtd_info *, loff_t, size_t);
71static int cfi_intelext_get_fact_prot_info (struct mtd_info *,
72 struct otp_info *, size_t);
73static int cfi_intelext_get_user_prot_info (struct mtd_info *,
74 struct otp_info *, size_t);
Todd Poynor8048d2f2005-03-31 00:57:33 +010075#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -070076static int cfi_intelext_suspend (struct mtd_info *);
77static void cfi_intelext_resume (struct mtd_info *);
Nicolas Pitre963a6fb2005-04-01 02:59:56 +010078static int cfi_intelext_reboot (struct notifier_block *, unsigned long, void *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079
80static void cfi_intelext_destroy(struct mtd_info *);
81
82struct mtd_info *cfi_cmdset_0001(struct map_info *, int);
83
84static struct mtd_info *cfi_intelext_setup (struct mtd_info *);
85static int cfi_intelext_partition_fixup(struct mtd_info *, struct cfi_private **);
86
87static int cfi_intelext_point (struct mtd_info *mtd, loff_t from, size_t len,
Jared Hulberta98889f2008-04-29 23:26:49 -070088 size_t *retlen, void **virt, resource_size_t *phys);
Artem Bityutskiy5e4e6e32012-02-03 13:20:43 +020089static int cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len);
Linus Torvalds1da177e2005-04-16 15:20:36 -070090
Alexey Korolev5a37cf12007-10-22 17:55:20 +010091static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long adr, int mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -070092static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode);
93static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr);
94#include "fwh_lock.h"
95
96
97
98/*
99 * *********** SETUP AND PROBE BITS ***********
100 */
101
102static struct mtd_chip_driver cfi_intelext_chipdrv = {
103 .probe = NULL, /* Not usable directly */
104 .destroy = cfi_intelext_destroy,
105 .name = "cfi_cmdset_0001",
106 .module = THIS_MODULE
107};
108
109/* #define DEBUG_LOCK_BITS */
110/* #define DEBUG_CFI_FEATURES */
111
112#ifdef DEBUG_CFI_FEATURES
113static void cfi_tell_features(struct cfi_pri_intelext *extp)
114{
115 int i;
Nicolas Pitre638d9832005-08-06 05:40:46 +0100116 printk(" Extended Query version %c.%c\n", extp->MajorVersion, extp->MinorVersion);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117 printk(" Feature/Command Support: %4.4X\n", extp->FeatureSupport);
118 printk(" - Chip Erase: %s\n", extp->FeatureSupport&1?"supported":"unsupported");
119 printk(" - Suspend Erase: %s\n", extp->FeatureSupport&2?"supported":"unsupported");
120 printk(" - Suspend Program: %s\n", extp->FeatureSupport&4?"supported":"unsupported");
121 printk(" - Legacy Lock/Unlock: %s\n", extp->FeatureSupport&8?"supported":"unsupported");
122 printk(" - Queued Erase: %s\n", extp->FeatureSupport&16?"supported":"unsupported");
123 printk(" - Instant block lock: %s\n", extp->FeatureSupport&32?"supported":"unsupported");
124 printk(" - Protection Bits: %s\n", extp->FeatureSupport&64?"supported":"unsupported");
125 printk(" - Page-mode read: %s\n", extp->FeatureSupport&128?"supported":"unsupported");
126 printk(" - Synchronous read: %s\n", extp->FeatureSupport&256?"supported":"unsupported");
127 printk(" - Simultaneous operations: %s\n", extp->FeatureSupport&512?"supported":"unsupported");
Nicolas Pitre638d9832005-08-06 05:40:46 +0100128 printk(" - Extended Flash Array: %s\n", extp->FeatureSupport&1024?"supported":"unsupported");
129 for (i=11; i<32; i++) {
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000130 if (extp->FeatureSupport & (1<<i))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 printk(" - Unknown Bit %X: supported\n", i);
132 }
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000133
Linus Torvalds1da177e2005-04-16 15:20:36 -0700134 printk(" Supported functions after Suspend: %2.2X\n", extp->SuspendCmdSupport);
135 printk(" - Program after Erase Suspend: %s\n", extp->SuspendCmdSupport&1?"supported":"unsupported");
136 for (i=1; i<8; i++) {
137 if (extp->SuspendCmdSupport & (1<<i))
138 printk(" - Unknown Bit %X: supported\n", i);
139 }
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000140
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 printk(" Block Status Register Mask: %4.4X\n", extp->BlkStatusRegMask);
142 printk(" - Lock Bit Active: %s\n", extp->BlkStatusRegMask&1?"yes":"no");
Nicolas Pitre638d9832005-08-06 05:40:46 +0100143 printk(" - Lock-Down Bit Active: %s\n", extp->BlkStatusRegMask&2?"yes":"no");
144 for (i=2; i<3; i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 if (extp->BlkStatusRegMask & (1<<i))
146 printk(" - Unknown Bit %X Active: yes\n",i);
147 }
Nicolas Pitre638d9832005-08-06 05:40:46 +0100148 printk(" - EFA Lock Bit: %s\n", extp->BlkStatusRegMask&16?"yes":"no");
149 printk(" - EFA Lock-Down Bit: %s\n", extp->BlkStatusRegMask&32?"yes":"no");
150 for (i=6; i<16; i++) {
151 if (extp->BlkStatusRegMask & (1<<i))
152 printk(" - Unknown Bit %X Active: yes\n",i);
153 }
154
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000155 printk(" Vcc Logic Supply Optimum Program/Erase Voltage: %d.%d V\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700156 extp->VccOptimal >> 4, extp->VccOptimal & 0xf);
157 if (extp->VppOptimal)
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000158 printk(" Vpp Programming Supply Optimum Program/Erase Voltage: %d.%d V\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 extp->VppOptimal >> 4, extp->VppOptimal & 0xf);
160}
161#endif
162
Hans-Christian Egtvedtd10a39d2007-10-30 16:33:07 +0100163/* Atmel chips don't use the same PRI format as Intel chips */
Guillaume LECERFcc318222010-11-17 12:35:50 +0100164static void fixup_convert_atmel_pri(struct mtd_info *mtd)
Hans-Christian Egtvedtd10a39d2007-10-30 16:33:07 +0100165{
166 struct map_info *map = mtd->priv;
167 struct cfi_private *cfi = map->fldrv_priv;
168 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
169 struct cfi_pri_atmel atmel_pri;
170 uint32_t features = 0;
171
172 /* Reverse byteswapping */
173 extp->FeatureSupport = cpu_to_le32(extp->FeatureSupport);
174 extp->BlkStatusRegMask = cpu_to_le16(extp->BlkStatusRegMask);
175 extp->ProtRegAddr = cpu_to_le16(extp->ProtRegAddr);
176
177 memcpy(&atmel_pri, extp, sizeof(atmel_pri));
178 memset((char *)extp + 5, 0, sizeof(*extp) - 5);
179
180 printk(KERN_ERR "atmel Features: %02x\n", atmel_pri.Features);
181
182 if (atmel_pri.Features & 0x01) /* chip erase supported */
183 features |= (1<<0);
184 if (atmel_pri.Features & 0x02) /* erase suspend supported */
185 features |= (1<<1);
186 if (atmel_pri.Features & 0x04) /* program suspend supported */
187 features |= (1<<2);
188 if (atmel_pri.Features & 0x08) /* simultaneous operations supported */
189 features |= (1<<9);
190 if (atmel_pri.Features & 0x20) /* page mode read supported */
191 features |= (1<<7);
192 if (atmel_pri.Features & 0x40) /* queued erase supported */
193 features |= (1<<4);
194 if (atmel_pri.Features & 0x80) /* Protection bits supported */
195 features |= (1<<6);
196
197 extp->FeatureSupport = features;
198
199 /* burst write mode not supported */
200 cfi->cfiq->BufWriteTimeoutTyp = 0;
201 cfi->cfiq->BufWriteTimeoutMax = 0;
202}
203
Guillaume LECERFcc318222010-11-17 12:35:50 +0100204static void fixup_at49bv640dx_lock(struct mtd_info *mtd)
Hans-Christian Egtvedt8dbaea42009-11-05 15:53:37 +0100205{
206 struct map_info *map = mtd->priv;
207 struct cfi_private *cfi = map->fldrv_priv;
208 struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
209
210 cfip->FeatureSupport |= (1 << 5);
211 mtd->flags |= MTD_POWERUP_LOCK;
212}
213
Linus Torvalds1da177e2005-04-16 15:20:36 -0700214#ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000215/* Some Intel Strata Flash prior to FPO revision C has bugs in this area */
Guillaume LECERFcc318222010-11-17 12:35:50 +0100216static void fixup_intel_strataflash(struct mtd_info *mtd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217{
218 struct map_info *map = mtd->priv;
219 struct cfi_private *cfi = map->fldrv_priv;
Alexander Belyakov91949d62008-05-04 14:32:58 +0400220 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700221
222 printk(KERN_WARNING "cfi_cmdset_0001: Suspend "
223 "erase on write disabled.\n");
224 extp->SuspendCmdSupport &= ~1;
225}
226#endif
227
228#ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
Guillaume LECERFcc318222010-11-17 12:35:50 +0100229static void fixup_no_write_suspend(struct mtd_info *mtd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230{
231 struct map_info *map = mtd->priv;
232 struct cfi_private *cfi = map->fldrv_priv;
233 struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
234
235 if (cfip && (cfip->FeatureSupport&4)) {
236 cfip->FeatureSupport &= ~4;
237 printk(KERN_WARNING "cfi_cmdset_0001: write suspend disabled\n");
238 }
239}
240#endif
241
Guillaume LECERFcc318222010-11-17 12:35:50 +0100242static void fixup_st_m28w320ct(struct mtd_info *mtd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243{
244 struct map_info *map = mtd->priv;
245 struct cfi_private *cfi = map->fldrv_priv;
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000246
Linus Torvalds1da177e2005-04-16 15:20:36 -0700247 cfi->cfiq->BufWriteTimeoutTyp = 0; /* Not supported */
248 cfi->cfiq->BufWriteTimeoutMax = 0; /* Not supported */
249}
250
Guillaume LECERFcc318222010-11-17 12:35:50 +0100251static void fixup_st_m28w320cb(struct mtd_info *mtd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252{
253 struct map_info *map = mtd->priv;
254 struct cfi_private *cfi = map->fldrv_priv;
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000255
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 /* Note this is done after the region info is endian swapped */
257 cfi->cfiq->EraseRegionInfo[1] =
258 (cfi->cfiq->EraseRegionInfo[1] & 0xffff0000) | 0x3e;
259};
260
Guillaume LECERFcc318222010-11-17 12:35:50 +0100261static void fixup_use_point(struct mtd_info *mtd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700262{
263 struct map_info *map = mtd->priv;
Artem Bityutskiy3c3c10b2012-01-30 14:58:32 +0200264 if (!mtd->_point && map_is_linear(map)) {
265 mtd->_point = cfi_intelext_point;
266 mtd->_unpoint = cfi_intelext_unpoint;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 }
268}
269
Guillaume LECERFcc318222010-11-17 12:35:50 +0100270static void fixup_use_write_buffers(struct mtd_info *mtd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271{
272 struct map_info *map = mtd->priv;
273 struct cfi_private *cfi = map->fldrv_priv;
274 if (cfi->cfiq->BufWriteTimeoutTyp) {
275 printk(KERN_INFO "Using buffer write method\n" );
Artem Bityutskiy3c3c10b2012-01-30 14:58:32 +0200276 mtd->_write = cfi_intelext_write_buffers;
277 mtd->_writev = cfi_intelext_writev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700278 }
279}
280
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -0800281/*
282 * Some chips power-up with all sectors locked by default.
283 */
Guillaume LECERFcc318222010-11-17 12:35:50 +0100284static void fixup_unlock_powerup_lock(struct mtd_info *mtd)
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -0800285{
Justin Treone619a752008-01-30 10:25:49 -0800286 struct map_info *map = mtd->priv;
287 struct cfi_private *cfi = map->fldrv_priv;
288 struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
289
290 if (cfip->FeatureSupport&32) {
291 printk(KERN_INFO "Using auto-unlock on power-up/resume\n" );
292 mtd->flags |= MTD_POWERUP_LOCK;
293 }
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -0800294}
295
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296static struct cfi_fixup cfi_fixup_table[] = {
Guillaume LECERFcc318222010-11-17 12:35:50 +0100297 { CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri },
298 { CFI_MFR_ATMEL, AT49BV640D, fixup_at49bv640dx_lock },
299 { CFI_MFR_ATMEL, AT49BV640DT, fixup_at49bv640dx_lock },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700300#ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
Guillaume LECERFcc318222010-11-17 12:35:50 +0100301 { CFI_MFR_ANY, CFI_ID_ANY, fixup_intel_strataflash },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302#endif
303#ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
Guillaume LECERFcc318222010-11-17 12:35:50 +0100304 { CFI_MFR_ANY, CFI_ID_ANY, fixup_no_write_suspend },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305#endif
306#if !FORCE_WORD_WRITE
Guillaume LECERFcc318222010-11-17 12:35:50 +0100307 { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_write_buffers },
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308#endif
Guillaume LECERFcc318222010-11-17 12:35:50 +0100309 { CFI_MFR_ST, 0x00ba, /* M28W320CT */ fixup_st_m28w320ct },
310 { CFI_MFR_ST, 0x00bb, /* M28W320CB */ fixup_st_m28w320cb },
311 { CFI_MFR_INTEL, CFI_ID_ANY, fixup_unlock_powerup_lock },
312 { 0, 0, NULL }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313};
314
315static struct cfi_fixup jedec_fixup_table[] = {
Guillaume LECERFcc318222010-11-17 12:35:50 +0100316 { CFI_MFR_INTEL, I82802AB, fixup_use_fwh_lock },
317 { CFI_MFR_INTEL, I82802AC, fixup_use_fwh_lock },
318 { CFI_MFR_ST, M50LPW080, fixup_use_fwh_lock },
319 { CFI_MFR_ST, M50FLW080A, fixup_use_fwh_lock },
320 { CFI_MFR_ST, M50FLW080B, fixup_use_fwh_lock },
321 { 0, 0, NULL }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700322};
323static struct cfi_fixup fixup_table[] = {
324 /* The CFI vendor ids and the JEDEC vendor IDs appear
325 * to be common. It is like the devices id's are as
326 * well. This table is to pick all cases where
327 * we know that is the case.
328 */
Guillaume LECERFcc318222010-11-17 12:35:50 +0100329 { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_point },
330 { 0, 0, NULL }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331};
332
Daniel Ribeiroec2d0d82009-05-17 08:02:17 -0300333static void cfi_fixup_major_minor(struct cfi_private *cfi,
334 struct cfi_pri_intelext *extp)
335{
Hans-Christian Egtvedtb2ef1a22009-11-05 15:53:43 +0100336 if (cfi->mfr == CFI_MFR_INTEL &&
Daniel Ribeiroec2d0d82009-05-17 08:02:17 -0300337 cfi->id == PF38F4476 && extp->MinorVersion == '3')
338 extp->MinorVersion = '1';
339}
340
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341static inline struct cfi_pri_intelext *
342read_pri_intelext(struct map_info *map, __u16 adr)
343{
Daniel Ribeiroec2d0d82009-05-17 08:02:17 -0300344 struct cfi_private *cfi = map->fldrv_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700345 struct cfi_pri_intelext *extp;
Daniel Ribeiroe1b158a2009-05-17 08:02:08 -0300346 unsigned int extra_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347 unsigned int extp_size = sizeof(*extp);
348
349 again:
350 extp = (struct cfi_pri_intelext *)cfi_read_pri(map, adr, extp_size, "Intel/Sharp");
351 if (!extp)
352 return NULL;
353
Daniel Ribeiroec2d0d82009-05-17 08:02:17 -0300354 cfi_fixup_major_minor(cfi, extp);
355
Todd Poynord88f9772005-07-20 22:01:17 +0100356 if (extp->MajorVersion != '1' ||
Alexey Korolevb1c9c9b2007-11-23 09:31:56 +0000357 (extp->MinorVersion < '0' || extp->MinorVersion > '5')) {
Todd Poynord88f9772005-07-20 22:01:17 +0100358 printk(KERN_ERR " Unknown Intel/Sharp Extended Query "
359 "version %c.%c.\n", extp->MajorVersion,
360 extp->MinorVersion);
361 kfree(extp);
362 return NULL;
363 }
364
Linus Torvalds1da177e2005-04-16 15:20:36 -0700365 /* Do some byteswapping if necessary */
366 extp->FeatureSupport = le32_to_cpu(extp->FeatureSupport);
367 extp->BlkStatusRegMask = le16_to_cpu(extp->BlkStatusRegMask);
368 extp->ProtRegAddr = le16_to_cpu(extp->ProtRegAddr);
369
Daniel Ribeiroe1b158a2009-05-17 08:02:08 -0300370 if (extp->MinorVersion >= '0') {
371 extra_size = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
373 /* Protection Register info */
Nicolas Pitre72b56a22005-02-05 02:06:19 +0000374 extra_size += (extp->NumProtectionFields - 1) *
375 sizeof(struct cfi_intelext_otpinfo);
Daniel Ribeiroe1b158a2009-05-17 08:02:08 -0300376 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377
Daniel Ribeiroe1b158a2009-05-17 08:02:08 -0300378 if (extp->MinorVersion >= '1') {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 /* Burst Read info */
Nicolas Pitre6f6ed052005-10-25 21:28:43 +0100380 extra_size += 2;
381 if (extp_size < sizeof(*extp) + extra_size)
382 goto need_more;
Daniel Ribeiroe1b158a2009-05-17 08:02:08 -0300383 extra_size += extp->extra[extra_size - 1];
384 }
385
386 if (extp->MinorVersion >= '3') {
387 int nb_parts, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700388
389 /* Number of hardware-partitions */
390 extra_size += 1;
391 if (extp_size < sizeof(*extp) + extra_size)
392 goto need_more;
393 nb_parts = extp->extra[extra_size - 1];
394
Nicolas Pitre638d9832005-08-06 05:40:46 +0100395 /* skip the sizeof(partregion) field in CFI 1.4 */
396 if (extp->MinorVersion >= '4')
397 extra_size += 2;
398
Linus Torvalds1da177e2005-04-16 15:20:36 -0700399 for (i = 0; i < nb_parts; i++) {
400 struct cfi_intelext_regioninfo *rinfo;
401 rinfo = (struct cfi_intelext_regioninfo *)&extp->extra[extra_size];
402 extra_size += sizeof(*rinfo);
403 if (extp_size < sizeof(*extp) + extra_size)
404 goto need_more;
405 rinfo->NumIdentPartitions=le16_to_cpu(rinfo->NumIdentPartitions);
406 extra_size += (rinfo->NumBlockTypes - 1)
407 * sizeof(struct cfi_intelext_blockinfo);
408 }
409
Nicolas Pitre638d9832005-08-06 05:40:46 +0100410 if (extp->MinorVersion >= '4')
411 extra_size += sizeof(struct cfi_intelext_programming_regioninfo);
412
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 if (extp_size < sizeof(*extp) + extra_size) {
414 need_more:
415 extp_size = sizeof(*extp) + extra_size;
416 kfree(extp);
417 if (extp_size > 4096) {
418 printk(KERN_ERR
419 "%s: cfi_pri_intelext is too fat\n",
Harvey Harrisoncb53b3b2008-04-18 13:44:19 -0700420 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 return NULL;
422 }
423 goto again;
424 }
425 }
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000426
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 return extp;
428}
429
Linus Torvalds1da177e2005-04-16 15:20:36 -0700430struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
431{
432 struct cfi_private *cfi = map->fldrv_priv;
433 struct mtd_info *mtd;
434 int i;
435
Burman Yan95b93a02006-11-15 21:10:29 +0200436 mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
Jingoo Han5c8b1fb2014-02-06 15:19:35 +0900437 if (!mtd)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 return NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439 mtd->priv = map;
440 mtd->type = MTD_NORFLASH;
441
442 /* Fill in the default mtd operations */
Artem Bityutskiy3c3c10b2012-01-30 14:58:32 +0200443 mtd->_erase = cfi_intelext_erase_varsize;
444 mtd->_read = cfi_intelext_read;
445 mtd->_write = cfi_intelext_write_words;
446 mtd->_sync = cfi_intelext_sync;
447 mtd->_lock = cfi_intelext_lock;
448 mtd->_unlock = cfi_intelext_unlock;
449 mtd->_is_locked = cfi_intelext_is_locked;
450 mtd->_suspend = cfi_intelext_suspend;
451 mtd->_resume = cfi_intelext_resume;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 mtd->flags = MTD_CAP_NORFLASH;
453 mtd->name = map->name;
Artem B. Bityutskiy17ffc7b2006-06-22 18:15:48 +0400454 mtd->writesize = 1;
Anatolij Gustschin13ce77f2011-02-10 16:01:46 +0100455 mtd->writebufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
Nicolas Pitre963a6fb2005-04-01 02:59:56 +0100456
457 mtd->reboot_notifier.notifier_call = cfi_intelext_reboot;
458
Linus Torvalds1da177e2005-04-16 15:20:36 -0700459 if (cfi->cfi_mode == CFI_MODE_CFI) {
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000460 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700461 * It's a real CFI chip, not one for which the probe
462 * routine faked a CFI structure. So we read the feature
463 * table from it.
464 */
465 __u16 adr = primary?cfi->cfiq->P_ADR:cfi->cfiq->A_ADR;
466 struct cfi_pri_intelext *extp;
467
468 extp = read_pri_intelext(map, adr);
469 if (!extp) {
470 kfree(mtd);
471 return NULL;
472 }
473
474 /* Install our own private info structure */
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000475 cfi->cmdset_priv = extp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700476
477 cfi_fixup(mtd, cfi_fixup_table);
478
479#ifdef DEBUG_CFI_FEATURES
480 /* Tell the user about it in lots of lovely detail */
481 cfi_tell_features(extp);
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000482#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700483
484 if(extp->SuspendCmdSupport & 1) {
485 printk(KERN_NOTICE "cfi_cmdset_0001: Erase suspend on write enabled\n");
486 }
487 }
488 else if (cfi->cfi_mode == CFI_MODE_JEDEC) {
489 /* Apply jedec specific fixups */
490 cfi_fixup(mtd, jedec_fixup_table);
491 }
492 /* Apply generic fixups */
493 cfi_fixup(mtd, fixup_table);
494
495 for (i=0; i< cfi->numchips; i++) {
David Woodhouse2a5bd592007-02-09 14:39:10 +0000496 if (cfi->cfiq->WordWriteTimeoutTyp)
497 cfi->chips[i].word_write_time =
498 1<<cfi->cfiq->WordWriteTimeoutTyp;
499 else
500 cfi->chips[i].word_write_time = 50000;
501
502 if (cfi->cfiq->BufWriteTimeoutTyp)
503 cfi->chips[i].buffer_write_time =
504 1<<cfi->cfiq->BufWriteTimeoutTyp;
505 /* No default; if it isn't specified, we won't use it */
506
507 if (cfi->cfiq->BlockEraseTimeoutTyp)
508 cfi->chips[i].erase_time =
509 1000<<cfi->cfiq->BlockEraseTimeoutTyp;
510 else
511 cfi->chips[i].erase_time = 2000000;
512
Anders Grafströme93cafe2008-08-05 18:37:41 +0200513 if (cfi->cfiq->WordWriteTimeoutTyp &&
514 cfi->cfiq->WordWriteTimeoutMax)
515 cfi->chips[i].word_write_time_max =
516 1<<(cfi->cfiq->WordWriteTimeoutTyp +
517 cfi->cfiq->WordWriteTimeoutMax);
518 else
519 cfi->chips[i].word_write_time_max = 50000 * 8;
520
521 if (cfi->cfiq->BufWriteTimeoutTyp &&
522 cfi->cfiq->BufWriteTimeoutMax)
523 cfi->chips[i].buffer_write_time_max =
524 1<<(cfi->cfiq->BufWriteTimeoutTyp +
525 cfi->cfiq->BufWriteTimeoutMax);
526
527 if (cfi->cfiq->BlockEraseTimeoutTyp &&
528 cfi->cfiq->BlockEraseTimeoutMax)
529 cfi->chips[i].erase_time_max =
530 1000<<(cfi->cfiq->BlockEraseTimeoutTyp +
531 cfi->cfiq->BlockEraseTimeoutMax);
532 else
533 cfi->chips[i].erase_time_max = 2000000 * 8;
534
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 cfi->chips[i].ref_point_counter = 0;
Simon Voglc314b6f2006-02-24 13:04:09 -0800536 init_waitqueue_head(&(cfi->chips[i].wq));
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000537 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
539 map->fldrv = &cfi_intelext_chipdrv;
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000540
Linus Torvalds1da177e2005-04-16 15:20:36 -0700541 return cfi_intelext_setup(mtd);
542}
David Woodhousea15bdee2006-05-08 22:35:05 +0100543struct mtd_info *cfi_cmdset_0003(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
544struct mtd_info *cfi_cmdset_0200(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
545EXPORT_SYMBOL_GPL(cfi_cmdset_0001);
546EXPORT_SYMBOL_GPL(cfi_cmdset_0003);
547EXPORT_SYMBOL_GPL(cfi_cmdset_0200);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700548
549static struct mtd_info *cfi_intelext_setup(struct mtd_info *mtd)
550{
551 struct map_info *map = mtd->priv;
552 struct cfi_private *cfi = map->fldrv_priv;
553 unsigned long offset = 0;
554 int i,j;
555 unsigned long devsize = (1<<cfi->cfiq->DevSize) * cfi->interleave;
556
557 //printk(KERN_DEBUG "number of CFI chips: %d\n", cfi->numchips);
558
559 mtd->size = devsize * cfi->numchips;
560
561 mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips;
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000562 mtd->eraseregions = kmalloc(sizeof(struct mtd_erase_region_info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700563 * mtd->numeraseregions, GFP_KERNEL);
Jingoo Han5c8b1fb2014-02-06 15:19:35 +0900564 if (!mtd->eraseregions)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 goto setup_err;
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000566
Linus Torvalds1da177e2005-04-16 15:20:36 -0700567 for (i=0; i<cfi->cfiq->NumEraseRegions; i++) {
568 unsigned long ernum, ersize;
569 ersize = ((cfi->cfiq->EraseRegionInfo[i] >> 8) & ~0xff) * cfi->interleave;
570 ernum = (cfi->cfiq->EraseRegionInfo[i] & 0xffff) + 1;
571
572 if (mtd->erasesize < ersize) {
573 mtd->erasesize = ersize;
574 }
575 for (j=0; j<cfi->numchips; j++) {
576 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].offset = (j*devsize)+offset;
577 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].erasesize = ersize;
578 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].numblocks = ernum;
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -0800579 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].lockmap = kmalloc(ernum / 8 + 1, GFP_KERNEL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580 }
581 offset += (ersize * ernum);
582 }
583
584 if (offset != devsize) {
585 /* Argh */
586 printk(KERN_WARNING "Sum of regions (%lx) != total size of set of interleaved chips (%lx)\n", offset, devsize);
587 goto setup_err;
588 }
589
590 for (i=0; i<mtd->numeraseregions;i++){
Adrian Hunter69423d92008-12-10 13:37:21 +0000591 printk(KERN_DEBUG "erase region %d: offset=0x%llx,size=0x%x,blocks=%d\n",
592 i,(unsigned long long)mtd->eraseregions[i].offset,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 mtd->eraseregions[i].erasesize,
594 mtd->eraseregions[i].numblocks);
595 }
596
Nicolas Pitref77814d2005-02-08 17:11:19 +0000597#ifdef CONFIG_MTD_OTP
Artem Bityutskiy3c3c10b2012-01-30 14:58:32 +0200598 mtd->_read_fact_prot_reg = cfi_intelext_read_fact_prot_reg;
599 mtd->_read_user_prot_reg = cfi_intelext_read_user_prot_reg;
600 mtd->_write_user_prot_reg = cfi_intelext_write_user_prot_reg;
601 mtd->_lock_user_prot_reg = cfi_intelext_lock_user_prot_reg;
602 mtd->_get_fact_prot_info = cfi_intelext_get_fact_prot_info;
603 mtd->_get_user_prot_info = cfi_intelext_get_user_prot_info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604#endif
605
606 /* This function has the potential to distort the reality
607 a bit and therefore should be called last. */
608 if (cfi_intelext_partition_fixup(mtd, &cfi) != 0)
609 goto setup_err;
610
611 __module_get(THIS_MODULE);
Nicolas Pitre963a6fb2005-04-01 02:59:56 +0100612 register_reboot_notifier(&mtd->reboot_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613 return mtd;
614
615 setup_err:
Jiri Slaby17fabf12010-01-10 10:01:19 +0100616 kfree(mtd->eraseregions);
617 kfree(mtd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 kfree(cfi->cmdset_priv);
619 return NULL;
620}
621
622static int cfi_intelext_partition_fixup(struct mtd_info *mtd,
623 struct cfi_private **pcfi)
624{
625 struct map_info *map = mtd->priv;
626 struct cfi_private *cfi = *pcfi;
627 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
628
629 /*
Jesper Juhl8f1a8662007-07-05 02:18:34 +0200630 * Probing of multi-partition flash chips.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 *
632 * To support multiple partitions when available, we simply arrange
633 * for each of them to have their own flchip structure even if they
634 * are on the same physical chip. This means completely recreating
635 * a new cfi_private structure right here which is a blatent code
636 * layering violation, but this is still the least intrusive
637 * arrangement at this point. This can be rearranged in the future
638 * if someone feels motivated enough. --nico
639 */
Nicolas Pitre638d9832005-08-06 05:40:46 +0100640 if (extp && extp->MajorVersion == '1' && extp->MinorVersion >= '3'
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 && extp->FeatureSupport & (1 << 9)) {
642 struct cfi_private *newcfi;
643 struct flchip *chip;
644 struct flchip_shared *shared;
645 int offs, numregions, numparts, partshift, numvirtchips, i, j;
646
647 /* Protection Register info */
Nicolas Pitre72b56a22005-02-05 02:06:19 +0000648 offs = (extp->NumProtectionFields - 1) *
649 sizeof(struct cfi_intelext_otpinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650
651 /* Burst Read info */
Nicolas Pitre6f6ed052005-10-25 21:28:43 +0100652 offs += extp->extra[offs+1]+2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
654 /* Number of partition regions */
655 numregions = extp->extra[offs];
656 offs += 1;
657
Nicolas Pitre638d9832005-08-06 05:40:46 +0100658 /* skip the sizeof(partregion) field in CFI 1.4 */
659 if (extp->MinorVersion >= '4')
660 offs += 2;
661
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662 /* Number of hardware partitions */
663 numparts = 0;
664 for (i = 0; i < numregions; i++) {
665 struct cfi_intelext_regioninfo *rinfo;
666 rinfo = (struct cfi_intelext_regioninfo *)&extp->extra[offs];
667 numparts += rinfo->NumIdentPartitions;
668 offs += sizeof(*rinfo)
669 + (rinfo->NumBlockTypes - 1) *
670 sizeof(struct cfi_intelext_blockinfo);
671 }
672
Thomas Kunzefe224662008-04-23 01:40:52 +0200673 if (!numparts)
674 numparts = 1;
675
Nicolas Pitre638d9832005-08-06 05:40:46 +0100676 /* Programming Region info */
677 if (extp->MinorVersion >= '4') {
678 struct cfi_intelext_programming_regioninfo *prinfo;
679 prinfo = (struct cfi_intelext_programming_regioninfo *)&extp->extra[offs];
Joern Engel28318772006-05-22 23:18:05 +0200680 mtd->writesize = cfi->interleave << prinfo->ProgRegShift;
Joern Engel5fa43392006-05-22 23:18:29 +0200681 mtd->flags &= ~MTD_BIT_WRITEABLE;
Nicolas Pitre638d9832005-08-06 05:40:46 +0100682 printk(KERN_DEBUG "%s: program region size/ctrl_valid/ctrl_inval = %d/%d/%d\n",
Joern Engel28318772006-05-22 23:18:05 +0200683 map->name, mtd->writesize,
Artem Bityutskiyd4160852007-01-30 10:45:55 +0200684 cfi->interleave * prinfo->ControlValid,
685 cfi->interleave * prinfo->ControlInvalid);
Nicolas Pitre638d9832005-08-06 05:40:46 +0100686 }
687
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 /*
689 * All functions below currently rely on all chips having
690 * the same geometry so we'll just assume that all hardware
691 * partitions are of the same size too.
692 */
693 partshift = cfi->chipshift - __ffs(numparts);
694
695 if ((1 << partshift) < mtd->erasesize) {
696 printk( KERN_ERR
697 "%s: bad number of hw partitions (%d)\n",
Harvey Harrisoncb53b3b2008-04-18 13:44:19 -0700698 __func__, numparts);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 return -EINVAL;
700 }
701
702 numvirtchips = cfi->numchips * numparts;
703 newcfi = kmalloc(sizeof(struct cfi_private) + numvirtchips * sizeof(struct flchip), GFP_KERNEL);
704 if (!newcfi)
705 return -ENOMEM;
706 shared = kmalloc(sizeof(struct flchip_shared) * cfi->numchips, GFP_KERNEL);
707 if (!shared) {
708 kfree(newcfi);
709 return -ENOMEM;
710 }
711 memcpy(newcfi, cfi, sizeof(struct cfi_private));
712 newcfi->numchips = numvirtchips;
713 newcfi->chipshift = partshift;
714
715 chip = &newcfi->chips[0];
716 for (i = 0; i < cfi->numchips; i++) {
717 shared[i].writing = shared[i].erasing = NULL;
Stefani Seibold8ae66412010-08-05 09:19:26 +0200718 mutex_init(&shared[i].lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700719 for (j = 0; j < numparts; j++) {
720 *chip = cfi->chips[i];
721 chip->start += j << partshift;
722 chip->priv = &shared[i];
723 /* those should be reset too since
724 they create memory references. */
725 init_waitqueue_head(&chip->wq);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200726 mutex_init(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 chip++;
728 }
729 }
730
731 printk(KERN_DEBUG "%s: %d set(s) of %d interleaved chips "
732 "--> %d partitions of %d KiB\n",
733 map->name, cfi->numchips, cfi->interleave,
734 newcfi->numchips, 1<<(newcfi->chipshift-10));
735
736 map->fldrv_priv = newcfi;
737 *pcfi = newcfi;
738 kfree(cfi);
739 }
740
741 return 0;
742}
743
744/*
745 * *********** CHIP ACCESS FUNCTIONS ***********
746 */
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100747static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long adr, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748{
749 DECLARE_WAITQUEUE(wait, current);
750 struct cfi_private *cfi = map->fldrv_priv;
751 map_word status, status_OK = CMD(0x80), status_PWS = CMD(0x01);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700752 struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100753 unsigned long timeo = jiffies + HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
Alexander Belyakov3afe7eb2008-09-25 17:53:24 +0400755 /* Prevent setting state FL_SYNCING for chip in suspended state. */
756 if (mode == FL_SYNCING && chip->oldstate != FL_READY)
757 goto sleep;
758
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 switch (chip->state) {
760
761 case FL_STATUS:
762 for (;;) {
763 status = map_read(map, adr);
764 if (map_word_andequal(map, status, status_OK, status_OK))
765 break;
766
767 /* At this point we're fine with write operations
768 in other partitions as they don't conflict. */
769 if (chip->priv && map_word_andequal(map, status, status_PWS, status_PWS))
770 break;
771
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200772 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773 cfi_udelay(1);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200774 mutex_lock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775 /* Someone else might have been playing with it. */
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100776 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777 }
Alexey Korolevfb6d0802008-04-04 14:30:01 -0700778 /* Fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 case FL_READY:
780 case FL_CFI_QUERY:
781 case FL_JEDEC_QUERY:
782 return 0;
783
784 case FL_ERASING:
785 if (!cfip ||
786 !(cfip->FeatureSupport & 2) ||
787 !(mode == FL_READY || mode == FL_POINT ||
788 (mode == FL_WRITING && (cfip->SuspendCmdSupport & 1))))
789 goto sleep;
790
791
792 /* Erase suspend */
793 map_write(map, CMD(0xB0), adr);
794
795 /* If the flash has finished erasing, then 'erase suspend'
796 * appears to make some (28F320) flash devices switch to
797 * 'read' mode. Make sure that we switch to 'read status'
798 * mode so we get the right data. --rmk
799 */
800 map_write(map, CMD(0x70), adr);
801 chip->oldstate = FL_ERASING;
802 chip->state = FL_ERASE_SUSPENDING;
803 chip->erase_suspended = 1;
804 for (;;) {
805 status = map_read(map, adr);
806 if (map_word_andequal(map, status, status_OK, status_OK))
807 break;
808
809 if (time_after(jiffies, timeo)) {
Tadashi Abe100f2342011-05-19 15:58:15 +0900810 /* Urgh. Resume and pretend we weren't here.
811 * Make sure we're in 'read status' mode if it had finished */
812 put_chip(map, chip, adr);
Nicolas Pitre48436532005-08-06 05:16:52 +0100813 printk(KERN_ERR "%s: Chip not ready after erase "
814 "suspended: status = 0x%lx\n", map->name, status.x[0]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 return -EIO;
816 }
817
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200818 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 cfi_udelay(1);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200820 mutex_lock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 /* Nobody will touch it while it's in state FL_ERASE_SUSPENDING.
822 So we can just loop here. */
823 }
824 chip->state = FL_STATUS;
825 return 0;
826
827 case FL_XIP_WHILE_ERASING:
828 if (mode != FL_READY && mode != FL_POINT &&
829 (mode != FL_WRITING || !cfip || !(cfip->SuspendCmdSupport&1)))
830 goto sleep;
831 chip->oldstate = chip->state;
832 chip->state = FL_READY;
833 return 0;
834
Alexey Korolevfb6d0802008-04-04 14:30:01 -0700835 case FL_SHUTDOWN:
836 /* The machine is rebooting now,so no one can get chip anymore */
837 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 case FL_POINT:
839 /* Only if there's no operation suspended... */
840 if (mode == FL_READY && chip->oldstate == FL_READY)
841 return 0;
Alexey Korolevfb6d0802008-04-04 14:30:01 -0700842 /* Fall through */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843 default:
844 sleep:
845 set_current_state(TASK_UNINTERRUPTIBLE);
846 add_wait_queue(&chip->wq, &wait);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200847 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848 schedule();
849 remove_wait_queue(&chip->wq, &wait);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200850 mutex_lock(&chip->mutex);
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100851 return -EAGAIN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 }
853}
854
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100855static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode)
856{
857 int ret;
Alexander Belyakov6c24e412007-11-07 11:58:07 +0300858 DECLARE_WAITQUEUE(wait, current);
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100859
860 retry:
Alexander Belyakov3afe7eb2008-09-25 17:53:24 +0400861 if (chip->priv &&
862 (mode == FL_WRITING || mode == FL_ERASING || mode == FL_OTP_WRITE
863 || mode == FL_SHUTDOWN) && chip->state != FL_SYNCING) {
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100864 /*
865 * OK. We have possibility for contention on the write/erase
866 * operations which are global to the real chip and not per
867 * partition. So let's fight it over in the partition which
868 * currently has authority on the operation.
869 *
870 * The rules are as follows:
871 *
872 * - any write operation must own shared->writing.
873 *
874 * - any erase operation must own _both_ shared->writing and
875 * shared->erasing.
876 *
877 * - contention arbitration is handled in the owner's context.
878 *
879 * The 'shared' struct can be read and/or written only when
880 * its lock is taken.
881 */
882 struct flchip_shared *shared = chip->priv;
883 struct flchip *contender;
Stefani Seibold8ae66412010-08-05 09:19:26 +0200884 mutex_lock(&shared->lock);
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100885 contender = shared->writing;
886 if (contender && contender != chip) {
887 /*
888 * The engine to perform desired operation on this
889 * partition is already in use by someone else.
890 * Let's fight over it in the context of the chip
891 * currently using it. If it is possible to suspend,
892 * that other partition will do just that, otherwise
893 * it'll happily send us to sleep. In any case, when
894 * get_chip returns success we're clear to go ahead.
895 */
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200896 ret = mutex_trylock(&contender->mutex);
Stefani Seibold8ae66412010-08-05 09:19:26 +0200897 mutex_unlock(&shared->lock);
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100898 if (!ret)
899 goto retry;
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200900 mutex_unlock(&chip->mutex);
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100901 ret = chip_ready(map, contender, contender->start, mode);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200902 mutex_lock(&chip->mutex);
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100903
904 if (ret == -EAGAIN) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200905 mutex_unlock(&contender->mutex);
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100906 goto retry;
907 }
908 if (ret) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200909 mutex_unlock(&contender->mutex);
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100910 return ret;
911 }
Stefani Seibold8ae66412010-08-05 09:19:26 +0200912 mutex_lock(&shared->lock);
Alexander Belyakov3afe7eb2008-09-25 17:53:24 +0400913
914 /* We should not own chip if it is already
915 * in FL_SYNCING state. Put contender and retry. */
916 if (chip->state == FL_SYNCING) {
917 put_chip(map, contender, contender->start);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200918 mutex_unlock(&contender->mutex);
Alexander Belyakov3afe7eb2008-09-25 17:53:24 +0400919 goto retry;
920 }
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200921 mutex_unlock(&contender->mutex);
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100922 }
923
Alexander Belyakov6c24e412007-11-07 11:58:07 +0300924 /* Check if we already have suspended erase
925 * on this chip. Sleep. */
926 if (mode == FL_ERASING && shared->erasing
927 && shared->erasing->oldstate == FL_ERASING) {
Stefani Seibold8ae66412010-08-05 09:19:26 +0200928 mutex_unlock(&shared->lock);
Alexander Belyakov6c24e412007-11-07 11:58:07 +0300929 set_current_state(TASK_UNINTERRUPTIBLE);
930 add_wait_queue(&chip->wq, &wait);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200931 mutex_unlock(&chip->mutex);
Alexander Belyakov6c24e412007-11-07 11:58:07 +0300932 schedule();
933 remove_wait_queue(&chip->wq, &wait);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200934 mutex_lock(&chip->mutex);
Alexander Belyakov6c24e412007-11-07 11:58:07 +0300935 goto retry;
936 }
937
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100938 /* We now own it */
939 shared->writing = chip;
940 if (mode == FL_ERASING)
941 shared->erasing = chip;
Stefani Seibold8ae66412010-08-05 09:19:26 +0200942 mutex_unlock(&shared->lock);
Alexey Korolev5a37cf12007-10-22 17:55:20 +0100943 }
944 ret = chip_ready(map, chip, adr, mode);
945 if (ret == -EAGAIN)
946 goto retry;
947
948 return ret;
949}
950
Linus Torvalds1da177e2005-04-16 15:20:36 -0700951static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr)
952{
953 struct cfi_private *cfi = map->fldrv_priv;
954
955 if (chip->priv) {
956 struct flchip_shared *shared = chip->priv;
Stefani Seibold8ae66412010-08-05 09:19:26 +0200957 mutex_lock(&shared->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700958 if (shared->writing == chip && chip->oldstate == FL_READY) {
959 /* We own the ability to write, but we're done */
960 shared->writing = shared->erasing;
961 if (shared->writing && shared->writing != chip) {
962 /* give back ownership to who we loaned it from */
963 struct flchip *loaner = shared->writing;
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200964 mutex_lock(&loaner->mutex);
Stefani Seibold8ae66412010-08-05 09:19:26 +0200965 mutex_unlock(&shared->lock);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200966 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967 put_chip(map, loaner, loaner->start);
Stefani Seiboldc4e77372010-04-18 22:46:44 +0200968 mutex_lock(&chip->mutex);
969 mutex_unlock(&loaner->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 wake_up(&chip->wq);
971 return;
972 }
973 shared->erasing = NULL;
974 shared->writing = NULL;
975 } else if (shared->erasing == chip && shared->writing != chip) {
976 /*
977 * We own the ability to erase without the ability
978 * to write, which means the erase was suspended
979 * and some other partition is currently writing.
980 * Don't let the switch below mess things up since
981 * we don't have ownership to resume anything.
982 */
Stefani Seibold8ae66412010-08-05 09:19:26 +0200983 mutex_unlock(&shared->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984 wake_up(&chip->wq);
985 return;
986 }
Stefani Seibold8ae66412010-08-05 09:19:26 +0200987 mutex_unlock(&shared->lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700988 }
989
990 switch(chip->oldstate) {
991 case FL_ERASING:
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000992 /* What if one interleaved chip has finished and the
Linus Torvalds1da177e2005-04-16 15:20:36 -0700993 other hasn't? The old code would leave the finished
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000994 one in READY mode. That's bad, and caused -EROFS
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 errors to be returned from do_erase_oneblock because
996 that's the only bit it checked for at the time.
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000997 As the state machine appears to explicitly allow
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 sending the 0x70 (Read Status) command to an erasing
Thomas Gleixner1f948b42005-11-07 11:15:37 +0000999 chip and expecting it to be ignored, that's what we
Linus Torvalds1da177e2005-04-16 15:20:36 -07001000 do. */
1001 map_write(map, CMD(0xd0), adr);
1002 map_write(map, CMD(0x70), adr);
1003 chip->oldstate = FL_READY;
1004 chip->state = FL_ERASING;
1005 break;
1006
1007 case FL_XIP_WHILE_ERASING:
1008 chip->state = chip->oldstate;
1009 chip->oldstate = FL_READY;
1010 break;
1011
1012 case FL_READY:
1013 case FL_STATUS:
1014 case FL_JEDEC_QUERY:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001015 break;
1016 default:
Nicolas Pitre48436532005-08-06 05:16:52 +01001017 printk(KERN_ERR "%s: put_chip() called with oldstate %d!!\n", map->name, chip->oldstate);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 }
1019 wake_up(&chip->wq);
1020}
1021
1022#ifdef CONFIG_MTD_XIP
1023
1024/*
1025 * No interrupt what so ever can be serviced while the flash isn't in array
1026 * mode. This is ensured by the xip_disable() and xip_enable() functions
1027 * enclosing any code path where the flash is known not to be in array mode.
1028 * And within a XIP disabled code path, only functions marked with __xipram
1029 * may be called and nothing else (it's a good thing to inspect generated
1030 * assembly to make sure inline functions were actually inlined and that gcc
1031 * didn't emit calls to its own support functions). Also configuring MTD CFI
1032 * support to a single buswidth and a single interleave is also recommended.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033 */
1034
1035static void xip_disable(struct map_info *map, struct flchip *chip,
1036 unsigned long adr)
1037{
1038 /* TODO: chips with no XIP use should ignore and return */
1039 (void) map_read(map, adr); /* ensure mmu mapping is up to date */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001040 local_irq_disable();
1041}
1042
1043static void __xipram xip_enable(struct map_info *map, struct flchip *chip,
1044 unsigned long adr)
1045{
1046 struct cfi_private *cfi = map->fldrv_priv;
1047 if (chip->state != FL_POINT && chip->state != FL_READY) {
1048 map_write(map, CMD(0xff), adr);
1049 chip->state = FL_READY;
1050 }
1051 (void) map_read(map, adr);
Thomas Gleixner97f927a2005-07-07 16:50:16 +02001052 xip_iprefetch();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 local_irq_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054}
1055
1056/*
1057 * When a delay is required for the flash operation to complete, the
Nicolas Pitrec1724712006-03-30 15:52:41 +01001058 * xip_wait_for_operation() function is polling for both the given timeout
1059 * and pending (but still masked) hardware interrupts. Whenever there is an
1060 * interrupt pending then the flash erase or write operation is suspended,
1061 * array mode restored and interrupts unmasked. Task scheduling might also
1062 * happen at that point. The CPU eventually returns from the interrupt or
1063 * the call to schedule() and the suspended flash operation is resumed for
1064 * the remaining of the delay period.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065 *
1066 * Warning: this function _will_ fool interrupt latency tracing tools.
1067 */
1068
Nicolas Pitrec1724712006-03-30 15:52:41 +01001069static int __xipram xip_wait_for_operation(
1070 struct map_info *map, struct flchip *chip,
Anders Grafströme93cafe2008-08-05 18:37:41 +02001071 unsigned long adr, unsigned int chip_op_time_max)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072{
1073 struct cfi_private *cfi = map->fldrv_priv;
1074 struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
1075 map_word status, OK = CMD(0x80);
Nicolas Pitrec1724712006-03-30 15:52:41 +01001076 unsigned long usec, suspended, start, done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 flstate_t oldstate, newstate;
1078
Nicolas Pitrec1724712006-03-30 15:52:41 +01001079 start = xip_currtime();
Anders Grafströme93cafe2008-08-05 18:37:41 +02001080 usec = chip_op_time_max;
Nicolas Pitrec1724712006-03-30 15:52:41 +01001081 if (usec == 0)
1082 usec = 500000;
1083 done = 0;
1084
Linus Torvalds1da177e2005-04-16 15:20:36 -07001085 do {
1086 cpu_relax();
1087 if (xip_irqpending() && cfip &&
1088 ((chip->state == FL_ERASING && (cfip->FeatureSupport&2)) ||
1089 (chip->state == FL_WRITING && (cfip->FeatureSupport&4))) &&
1090 (cfi_interleave_is_1(cfi) || chip->oldstate == FL_READY)) {
1091 /*
1092 * Let's suspend the erase or write operation when
1093 * supported. Note that we currently don't try to
1094 * suspend interleaved chips if there is already
1095 * another operation suspended (imagine what happens
1096 * when one chip was already done with the current
1097 * operation while another chip suspended it, then
1098 * we resume the whole thing at once). Yes, it
1099 * can happen!
1100 */
Nicolas Pitrec1724712006-03-30 15:52:41 +01001101 usec -= done;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001102 map_write(map, CMD(0xb0), adr);
1103 map_write(map, CMD(0x70), adr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001104 suspended = xip_currtime();
1105 do {
1106 if (xip_elapsed_since(suspended) > 100000) {
1107 /*
1108 * The chip doesn't want to suspend
1109 * after waiting for 100 msecs.
1110 * This is a critical error but there
1111 * is not much we can do here.
1112 */
Nicolas Pitrec1724712006-03-30 15:52:41 +01001113 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114 }
1115 status = map_read(map, adr);
1116 } while (!map_word_andequal(map, status, OK, OK));
1117
1118 /* Suspend succeeded */
1119 oldstate = chip->state;
1120 if (oldstate == FL_ERASING) {
1121 if (!map_word_bitsset(map, status, CMD(0x40)))
1122 break;
1123 newstate = FL_XIP_WHILE_ERASING;
1124 chip->erase_suspended = 1;
1125 } else {
1126 if (!map_word_bitsset(map, status, CMD(0x04)))
1127 break;
1128 newstate = FL_XIP_WHILE_WRITING;
1129 chip->write_suspended = 1;
1130 }
1131 chip->state = newstate;
1132 map_write(map, CMD(0xff), adr);
1133 (void) map_read(map, adr);
Paulius Zaleckasca5c23c2008-02-27 01:42:39 +02001134 xip_iprefetch();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 local_irq_enable();
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001136 mutex_unlock(&chip->mutex);
Paulius Zaleckasca5c23c2008-02-27 01:42:39 +02001137 xip_iprefetch();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001138 cond_resched();
1139
1140 /*
1141 * We're back. However someone else might have
1142 * decided to go write to the chip if we are in
1143 * a suspended erase state. If so let's wait
1144 * until it's done.
1145 */
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001146 mutex_lock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001147 while (chip->state != newstate) {
1148 DECLARE_WAITQUEUE(wait, current);
1149 set_current_state(TASK_UNINTERRUPTIBLE);
1150 add_wait_queue(&chip->wq, &wait);
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001151 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001152 schedule();
1153 remove_wait_queue(&chip->wq, &wait);
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001154 mutex_lock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155 }
1156 /* Disallow XIP again */
1157 local_irq_disable();
1158
1159 /* Resume the write or erase operation */
1160 map_write(map, CMD(0xd0), adr);
1161 map_write(map, CMD(0x70), adr);
1162 chip->state = oldstate;
1163 start = xip_currtime();
1164 } else if (usec >= 1000000/HZ) {
1165 /*
1166 * Try to save on CPU power when waiting delay
1167 * is at least a system timer tick period.
1168 * No need to be extremely accurate here.
1169 */
1170 xip_cpu_idle();
1171 }
1172 status = map_read(map, adr);
Nicolas Pitrec1724712006-03-30 15:52:41 +01001173 done = xip_elapsed_since(start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 } while (!map_word_andequal(map, status, OK, OK)
Nicolas Pitrec1724712006-03-30 15:52:41 +01001175 && done < usec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001176
Nicolas Pitrec1724712006-03-30 15:52:41 +01001177 return (done >= usec) ? -ETIME : 0;
1178}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001179
1180/*
1181 * The INVALIDATE_CACHED_RANGE() macro is normally used in parallel while
1182 * the flash is actively programming or erasing since we have to poll for
1183 * the operation to complete anyway. We can't do that in a generic way with
Nicolas Pitre6da70122005-05-19 18:05:47 +01001184 * a XIP setup so do it before the actual flash operation in this case
Nicolas Pitrec1724712006-03-30 15:52:41 +01001185 * and stub it out from INVAL_CACHE_AND_WAIT.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186 */
Nicolas Pitre6da70122005-05-19 18:05:47 +01001187#define XIP_INVAL_CACHED_RANGE(map, from, size) \
1188 INVALIDATE_CACHED_RANGE(map, from, size)
1189
Anders Grafströme93cafe2008-08-05 18:37:41 +02001190#define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec, usec_max) \
1191 xip_wait_for_operation(map, chip, cmd_adr, usec_max)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001192
1193#else
1194
1195#define xip_disable(map, chip, adr)
1196#define xip_enable(map, chip, adr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001197#define XIP_INVAL_CACHED_RANGE(x...)
Nicolas Pitrec1724712006-03-30 15:52:41 +01001198#define INVAL_CACHE_AND_WAIT inval_cache_and_wait_for_operation
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199
Nicolas Pitrec1724712006-03-30 15:52:41 +01001200static int inval_cache_and_wait_for_operation(
1201 struct map_info *map, struct flchip *chip,
1202 unsigned long cmd_adr, unsigned long inval_adr, int inval_len,
Anders Grafströme93cafe2008-08-05 18:37:41 +02001203 unsigned int chip_op_time, unsigned int chip_op_time_max)
Nicolas Pitrec1724712006-03-30 15:52:41 +01001204{
1205 struct cfi_private *cfi = map->fldrv_priv;
1206 map_word status, status_OK = CMD(0x80);
Alexey Korolev46a16522006-06-28 19:22:07 +01001207 int chip_state = chip->state;
Alexey Korolev998453f2008-07-16 15:28:56 +01001208 unsigned int timeo, sleep_time, reset_timeo;
Nicolas Pitre6da70122005-05-19 18:05:47 +01001209
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001210 mutex_unlock(&chip->mutex);
Nicolas Pitrec1724712006-03-30 15:52:41 +01001211 if (inval_len)
1212 INVALIDATE_CACHED_RANGE(map, inval_adr, inval_len);
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001213 mutex_lock(&chip->mutex);
Nicolas Pitrec1724712006-03-30 15:52:41 +01001214
Anders Grafströme93cafe2008-08-05 18:37:41 +02001215 timeo = chip_op_time_max;
Alexey Korolev46a16522006-06-28 19:22:07 +01001216 if (!timeo)
1217 timeo = 500000;
Alexey Korolev998453f2008-07-16 15:28:56 +01001218 reset_timeo = timeo;
Alexey Korolev46a16522006-06-28 19:22:07 +01001219 sleep_time = chip_op_time / 2;
Nicolas Pitrec1724712006-03-30 15:52:41 +01001220
Nicolas Pitrec1724712006-03-30 15:52:41 +01001221 for (;;) {
Joakim Tjernlundecf3fde2011-02-07 17:07:11 +01001222 if (chip->state != chip_state) {
1223 /* Someone's suspended the operation: sleep */
1224 DECLARE_WAITQUEUE(wait, current);
1225 set_current_state(TASK_UNINTERRUPTIBLE);
1226 add_wait_queue(&chip->wq, &wait);
1227 mutex_unlock(&chip->mutex);
1228 schedule();
1229 remove_wait_queue(&chip->wq, &wait);
1230 mutex_lock(&chip->mutex);
1231 continue;
1232 }
1233
Nicolas Pitrec1724712006-03-30 15:52:41 +01001234 status = map_read(map, cmd_adr);
1235 if (map_word_andequal(map, status, status_OK, status_OK))
1236 break;
1237
Joakim Tjernlundecf3fde2011-02-07 17:07:11 +01001238 if (chip->erase_suspended && chip_state == FL_ERASING) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001239 /* Erase suspend occurred while sleep: reset timeout */
Joakim Tjernlundecf3fde2011-02-07 17:07:11 +01001240 timeo = reset_timeo;
1241 chip->erase_suspended = 0;
1242 }
1243 if (chip->write_suspended && chip_state == FL_WRITING) {
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001244 /* Write suspend occurred while sleep: reset timeout */
Joakim Tjernlundecf3fde2011-02-07 17:07:11 +01001245 timeo = reset_timeo;
1246 chip->write_suspended = 0;
1247 }
Alexey Korolev46a16522006-06-28 19:22:07 +01001248 if (!timeo) {
Nicolas Pitrec1724712006-03-30 15:52:41 +01001249 map_write(map, CMD(0x70), cmd_adr);
1250 chip->state = FL_STATUS;
1251 return -ETIME;
1252 }
1253
Alexey Korolev46a16522006-06-28 19:22:07 +01001254 /* OK Still waiting. Drop the lock, wait a while and retry. */
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001255 mutex_unlock(&chip->mutex);
Alexey Korolev46a16522006-06-28 19:22:07 +01001256 if (sleep_time >= 1000000/HZ) {
1257 /*
1258 * Half of the normal delay still remaining
1259 * can be performed with a sleeping delay instead
1260 * of busy waiting.
1261 */
1262 msleep(sleep_time/1000);
1263 timeo -= sleep_time;
1264 sleep_time = 1000000/HZ;
1265 } else {
1266 udelay(1);
1267 cond_resched();
1268 timeo--;
1269 }
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001270 mutex_lock(&chip->mutex);
Alexey Korolev46a16522006-06-28 19:22:07 +01001271 }
Nicolas Pitrec1724712006-03-30 15:52:41 +01001272
1273 /* Done and happy. */
1274 chip->state = FL_STATUS;
1275 return 0;
1276}
Nicolas Pitre6da70122005-05-19 18:05:47 +01001277
Linus Torvalds1da177e2005-04-16 15:20:36 -07001278#endif
1279
Anders Grafströme93cafe2008-08-05 18:37:41 +02001280#define WAIT_TIMEOUT(map, chip, adr, udelay, udelay_max) \
1281 INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay, udelay_max);
Nicolas Pitrec1724712006-03-30 15:52:41 +01001282
1283
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t adr, size_t len)
1285{
1286 unsigned long cmd_addr;
1287 struct cfi_private *cfi = map->fldrv_priv;
1288 int ret = 0;
1289
1290 adr += chip->start;
1291
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001292 /* Ensure cmd read/writes are aligned. */
1293 cmd_addr = adr & ~(map_bankwidth(map)-1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001294
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001295 mutex_lock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296
1297 ret = get_chip(map, chip, cmd_addr, FL_POINT);
1298
1299 if (!ret) {
1300 if (chip->state != FL_POINT && chip->state != FL_READY)
1301 map_write(map, CMD(0xff), cmd_addr);
1302
1303 chip->state = FL_POINT;
1304 chip->ref_point_counter++;
1305 }
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001306 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001307
1308 return ret;
1309}
1310
Jared Hulberta98889f2008-04-29 23:26:49 -07001311static int cfi_intelext_point(struct mtd_info *mtd, loff_t from, size_t len,
1312 size_t *retlen, void **virt, resource_size_t *phys)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001313{
1314 struct map_info *map = mtd->priv;
1315 struct cfi_private *cfi = map->fldrv_priv;
Andy Lowe097f2572007-01-12 18:05:10 -05001316 unsigned long ofs, last_end = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317 int chipnum;
1318 int ret = 0;
1319
Artem Bityutskiy5def4892012-02-03 16:23:52 +02001320 if (!map->virt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321 return -EINVAL;
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001322
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 /* Now lock the chip(s) to POINT state */
1324
1325 /* ofs: offset within the first chip that the first read should start */
1326 chipnum = (from >> cfi->chipshift);
1327 ofs = from - (chipnum << cfi->chipshift);
1328
Jared Hulberta98889f2008-04-29 23:26:49 -07001329 *virt = map->virt + cfi->chips[chipnum].start + ofs;
Jared Hulberta98889f2008-04-29 23:26:49 -07001330 if (phys)
1331 *phys = map->phys + cfi->chips[chipnum].start + ofs;
Andy Lowe097f2572007-01-12 18:05:10 -05001332
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333 while (len) {
1334 unsigned long thislen;
1335
1336 if (chipnum >= cfi->numchips)
1337 break;
1338
Andy Lowe097f2572007-01-12 18:05:10 -05001339 /* We cannot point across chips that are virtually disjoint */
1340 if (!last_end)
1341 last_end = cfi->chips[chipnum].start;
1342 else if (cfi->chips[chipnum].start != last_end)
1343 break;
1344
Linus Torvalds1da177e2005-04-16 15:20:36 -07001345 if ((len + ofs -1) >> cfi->chipshift)
1346 thislen = (1<<cfi->chipshift) - ofs;
1347 else
1348 thislen = len;
1349
1350 ret = do_point_onechip(map, &cfi->chips[chipnum], ofs, thislen);
1351 if (ret)
1352 break;
1353
1354 *retlen += thislen;
1355 len -= thislen;
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001356
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 ofs = 0;
Andy Lowe097f2572007-01-12 18:05:10 -05001358 last_end += 1 << cfi->chipshift;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359 chipnum++;
1360 }
1361 return 0;
1362}
1363
Artem Bityutskiy5e4e6e32012-02-03 13:20:43 +02001364static int cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001365{
1366 struct map_info *map = mtd->priv;
1367 struct cfi_private *cfi = map->fldrv_priv;
1368 unsigned long ofs;
Artem Bityutskiy5e4e6e32012-02-03 13:20:43 +02001369 int chipnum, err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370
1371 /* Now unlock the chip(s) POINT state */
1372
1373 /* ofs: offset within the first chip that the first read should start */
1374 chipnum = (from >> cfi->chipshift);
1375 ofs = from - (chipnum << cfi->chipshift);
1376
Artem Bityutskiy5e4e6e32012-02-03 13:20:43 +02001377 while (len && !err) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001378 unsigned long thislen;
1379 struct flchip *chip;
1380
1381 chip = &cfi->chips[chipnum];
1382 if (chipnum >= cfi->numchips)
1383 break;
1384
1385 if ((len + ofs -1) >> cfi->chipshift)
1386 thislen = (1<<cfi->chipshift) - ofs;
1387 else
1388 thislen = len;
1389
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001390 mutex_lock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391 if (chip->state == FL_POINT) {
1392 chip->ref_point_counter--;
1393 if(chip->ref_point_counter == 0)
1394 chip->state = FL_READY;
Artem Bityutskiy5e4e6e32012-02-03 13:20:43 +02001395 } else {
1396 printk(KERN_ERR "%s: Error: unpoint called on non pointed region\n", map->name);
1397 err = -EINVAL;
1398 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399
1400 put_chip(map, chip, chip->start);
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001401 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402
1403 len -= thislen;
1404 ofs = 0;
1405 chipnum++;
1406 }
Artem Bityutskiy5e4e6e32012-02-03 13:20:43 +02001407
1408 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409}
1410
1411static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf)
1412{
1413 unsigned long cmd_addr;
1414 struct cfi_private *cfi = map->fldrv_priv;
1415 int ret;
1416
1417 adr += chip->start;
1418
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001419 /* Ensure cmd read/writes are aligned. */
1420 cmd_addr = adr & ~(map_bankwidth(map)-1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001422 mutex_lock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001423 ret = get_chip(map, chip, cmd_addr, FL_READY);
1424 if (ret) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001425 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001426 return ret;
1427 }
1428
1429 if (chip->state != FL_POINT && chip->state != FL_READY) {
1430 map_write(map, CMD(0xff), cmd_addr);
1431
1432 chip->state = FL_READY;
1433 }
1434
1435 map_copy_from(map, buf, adr, len);
1436
1437 put_chip(map, chip, cmd_addr);
1438
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001439 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001440 return 0;
1441}
1442
1443static int cfi_intelext_read (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
1444{
1445 struct map_info *map = mtd->priv;
1446 struct cfi_private *cfi = map->fldrv_priv;
1447 unsigned long ofs;
1448 int chipnum;
1449 int ret = 0;
1450
1451 /* ofs: offset within the first chip that the first read should start */
1452 chipnum = (from >> cfi->chipshift);
1453 ofs = from - (chipnum << cfi->chipshift);
1454
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 while (len) {
1456 unsigned long thislen;
1457
1458 if (chipnum >= cfi->numchips)
1459 break;
1460
1461 if ((len + ofs -1) >> cfi->chipshift)
1462 thislen = (1<<cfi->chipshift) - ofs;
1463 else
1464 thislen = len;
1465
1466 ret = do_read_onechip(map, &cfi->chips[chipnum], ofs, thislen, buf);
1467 if (ret)
1468 break;
1469
1470 *retlen += thislen;
1471 len -= thislen;
1472 buf += thislen;
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001473
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474 ofs = 0;
1475 chipnum++;
1476 }
1477 return ret;
1478}
1479
Linus Torvalds1da177e2005-04-16 15:20:36 -07001480static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
Nicolas Pitref77814d2005-02-08 17:11:19 +00001481 unsigned long adr, map_word datum, int mode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001482{
1483 struct cfi_private *cfi = map->fldrv_priv;
Nicolas Pitrec1724712006-03-30 15:52:41 +01001484 map_word status, write_cmd;
1485 int ret=0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001486
1487 adr += chip->start;
1488
Nicolas Pitref77814d2005-02-08 17:11:19 +00001489 switch (mode) {
Nicolas Pitre638d9832005-08-06 05:40:46 +01001490 case FL_WRITING:
Guillaume LECERFb5d194c2010-10-26 10:55:29 +01001491 write_cmd = (cfi->cfiq->P_ID != P_ID_INTEL_PERFORMANCE) ? CMD(0x40) : CMD(0x41);
Nicolas Pitre638d9832005-08-06 05:40:46 +01001492 break;
1493 case FL_OTP_WRITE:
1494 write_cmd = CMD(0xc0);
1495 break;
1496 default:
1497 return -EINVAL;
Nicolas Pitref77814d2005-02-08 17:11:19 +00001498 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001499
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001500 mutex_lock(&chip->mutex);
Nicolas Pitref77814d2005-02-08 17:11:19 +00001501 ret = get_chip(map, chip, adr, mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502 if (ret) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001503 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 return ret;
1505 }
1506
1507 XIP_INVAL_CACHED_RANGE(map, adr, map_bankwidth(map));
1508 ENABLE_VPP(map);
1509 xip_disable(map, chip, adr);
Nicolas Pitref77814d2005-02-08 17:11:19 +00001510 map_write(map, write_cmd, adr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511 map_write(map, datum, adr);
Nicolas Pitref77814d2005-02-08 17:11:19 +00001512 chip->state = mode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001513
Nicolas Pitrec1724712006-03-30 15:52:41 +01001514 ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
1515 adr, map_bankwidth(map),
Anders Grafströme93cafe2008-08-05 18:37:41 +02001516 chip->word_write_time,
1517 chip->word_write_time_max);
Nicolas Pitrec1724712006-03-30 15:52:41 +01001518 if (ret) {
1519 xip_enable(map, chip, adr);
1520 printk(KERN_ERR "%s: word write error (status timeout)\n", map->name);
1521 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523
Nicolas Pitre48436532005-08-06 05:16:52 +01001524 /* check for errors */
Nicolas Pitrec1724712006-03-30 15:52:41 +01001525 status = map_read(map, adr);
Nicolas Pitre48436532005-08-06 05:16:52 +01001526 if (map_word_bitsset(map, status, CMD(0x1a))) {
1527 unsigned long chipstatus = MERGESTATUS(status);
1528
1529 /* reset status */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530 map_write(map, CMD(0x50), adr);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 map_write(map, CMD(0x70), adr);
Nicolas Pitre48436532005-08-06 05:16:52 +01001532 xip_enable(map, chip, adr);
1533
1534 if (chipstatus & 0x02) {
1535 ret = -EROFS;
1536 } else if (chipstatus & 0x08) {
1537 printk(KERN_ERR "%s: word write error (bad VPP)\n", map->name);
1538 ret = -EIO;
1539 } else {
1540 printk(KERN_ERR "%s: word write error (status 0x%lx)\n", map->name, chipstatus);
1541 ret = -EINVAL;
1542 }
1543
1544 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545 }
1546
1547 xip_enable(map, chip, adr);
Paul Parsons85e5b2f2012-03-07 14:10:33 +00001548 out: DISABLE_VPP(map);
1549 put_chip(map, chip, adr);
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001550 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001551 return ret;
1552}
1553
1554
1555static int cfi_intelext_write_words (struct mtd_info *mtd, loff_t to , size_t len, size_t *retlen, const u_char *buf)
1556{
1557 struct map_info *map = mtd->priv;
1558 struct cfi_private *cfi = map->fldrv_priv;
1559 int ret = 0;
1560 int chipnum;
1561 unsigned long ofs;
1562
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 chipnum = to >> cfi->chipshift;
1564 ofs = to - (chipnum << cfi->chipshift);
1565
1566 /* If it's not bus-aligned, do the first byte write */
1567 if (ofs & (map_bankwidth(map)-1)) {
1568 unsigned long bus_ofs = ofs & ~(map_bankwidth(map)-1);
1569 int gap = ofs - bus_ofs;
1570 int n;
1571 map_word datum;
1572
1573 n = min_t(int, len, map_bankwidth(map)-gap);
1574 datum = map_word_ff(map);
1575 datum = map_word_load_partial(map, datum, buf, gap, n);
1576
1577 ret = do_write_oneword(map, &cfi->chips[chipnum],
Nicolas Pitref77814d2005-02-08 17:11:19 +00001578 bus_ofs, datum, FL_WRITING);
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001579 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001580 return ret;
1581
1582 len -= n;
1583 ofs += n;
1584 buf += n;
1585 (*retlen) += n;
1586
1587 if (ofs >> cfi->chipshift) {
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001588 chipnum ++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589 ofs = 0;
1590 if (chipnum == cfi->numchips)
1591 return 0;
1592 }
1593 }
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001594
Linus Torvalds1da177e2005-04-16 15:20:36 -07001595 while(len >= map_bankwidth(map)) {
1596 map_word datum = map_word_load(map, buf);
1597
1598 ret = do_write_oneword(map, &cfi->chips[chipnum],
Nicolas Pitref77814d2005-02-08 17:11:19 +00001599 ofs, datum, FL_WRITING);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 if (ret)
1601 return ret;
1602
1603 ofs += map_bankwidth(map);
1604 buf += map_bankwidth(map);
1605 (*retlen) += map_bankwidth(map);
1606 len -= map_bankwidth(map);
1607
1608 if (ofs >> cfi->chipshift) {
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001609 chipnum ++;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 ofs = 0;
1611 if (chipnum == cfi->numchips)
1612 return 0;
1613 }
1614 }
1615
1616 if (len & (map_bankwidth(map)-1)) {
1617 map_word datum;
1618
1619 datum = map_word_ff(map);
1620 datum = map_word_load_partial(map, datum, buf, 0, len);
1621
1622 ret = do_write_oneword(map, &cfi->chips[chipnum],
Nicolas Pitref77814d2005-02-08 17:11:19 +00001623 ofs, datum, FL_WRITING);
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001624 if (ret)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001625 return ret;
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001626
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 (*retlen) += len;
1628 }
1629
1630 return 0;
1631}
1632
1633
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001634static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
Nicolas Pitree102d542005-08-06 05:46:59 +01001635 unsigned long adr, const struct kvec **pvec,
1636 unsigned long *pvec_seek, int len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637{
1638 struct cfi_private *cfi = map->fldrv_priv;
Nicolas Pitrec1724712006-03-30 15:52:41 +01001639 map_word status, write_cmd, datum;
1640 unsigned long cmd_adr;
1641 int ret, wbufsize, word_gap, words;
Nicolas Pitree102d542005-08-06 05:46:59 +01001642 const struct kvec *vec;
1643 unsigned long vec_seek;
Massimo Cirillo646fd122008-01-11 10:24:11 +00001644 unsigned long initial_adr;
1645 int initial_len = len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
1647 wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1648 adr += chip->start;
Massimo Cirillo646fd122008-01-11 10:24:11 +00001649 initial_adr = adr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650 cmd_adr = adr & ~(wbufsize-1);
Nicolas Pitre638d9832005-08-06 05:40:46 +01001651
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652 /* Let's determine this according to the interleave only once */
Guillaume LECERFb5d194c2010-10-26 10:55:29 +01001653 write_cmd = (cfi->cfiq->P_ID != P_ID_INTEL_PERFORMANCE) ? CMD(0xe8) : CMD(0xe9);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001655 mutex_lock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 ret = get_chip(map, chip, cmd_adr, FL_WRITING);
1657 if (ret) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001658 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 return ret;
1660 }
1661
Massimo Cirillo646fd122008-01-11 10:24:11 +00001662 XIP_INVAL_CACHED_RANGE(map, initial_adr, initial_len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 ENABLE_VPP(map);
1664 xip_disable(map, chip, cmd_adr);
1665
David Woodhouse151e7652006-05-14 01:51:54 +01001666 /* §4.8 of the 28FxxxJ3A datasheet says "Any time SR.4 and/or SR.5 is set
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001667 [...], the device will not accept any more Write to Buffer commands".
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 So we must check here and reset those bits if they're set. Otherwise
1669 we're just pissing in the wind */
Nicolas Pitre6e7a6802006-03-29 23:31:42 +01001670 if (chip->state != FL_STATUS) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 map_write(map, CMD(0x70), cmd_adr);
Nicolas Pitre6e7a6802006-03-29 23:31:42 +01001672 chip->state = FL_STATUS;
1673 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 status = map_read(map, cmd_adr);
1675 if (map_word_bitsset(map, status, CMD(0x30))) {
1676 xip_enable(map, chip, cmd_adr);
1677 printk(KERN_WARNING "SR.4 or SR.5 bits set in buffer write (status %lx). Clearing.\n", status.x[0]);
1678 xip_disable(map, chip, cmd_adr);
1679 map_write(map, CMD(0x50), cmd_adr);
1680 map_write(map, CMD(0x70), cmd_adr);
1681 }
1682
1683 chip->state = FL_WRITING_TO_BUFFER;
Nicolas Pitrec1724712006-03-30 15:52:41 +01001684 map_write(map, write_cmd, cmd_adr);
Anders Grafströme93cafe2008-08-05 18:37:41 +02001685 ret = WAIT_TIMEOUT(map, chip, cmd_adr, 0, 0);
Nicolas Pitrec1724712006-03-30 15:52:41 +01001686 if (ret) {
1687 /* Argh. Not ready for write to buffer */
1688 map_word Xstatus = map_read(map, cmd_adr);
1689 map_write(map, CMD(0x70), cmd_adr);
1690 chip->state = FL_STATUS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691 status = map_read(map, cmd_adr);
Nicolas Pitrec1724712006-03-30 15:52:41 +01001692 map_write(map, CMD(0x50), cmd_adr);
1693 map_write(map, CMD(0x70), cmd_adr);
1694 xip_enable(map, chip, cmd_adr);
1695 printk(KERN_ERR "%s: Chip not ready for buffer write. Xstatus = %lx, status = %lx\n",
1696 map->name, Xstatus.x[0], status.x[0]);
1697 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 }
1699
Nicolas Pitree102d542005-08-06 05:46:59 +01001700 /* Figure out the number of words to write */
1701 word_gap = (-adr & (map_bankwidth(map)-1));
Julia Lawallc8872b02008-08-02 17:14:21 +02001702 words = DIV_ROUND_UP(len - word_gap, map_bankwidth(map));
Nicolas Pitree102d542005-08-06 05:46:59 +01001703 if (!word_gap) {
1704 words--;
1705 } else {
1706 word_gap = map_bankwidth(map) - word_gap;
1707 adr -= word_gap;
1708 datum = map_word_ff(map);
1709 }
1710
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711 /* Write length of data to come */
Nicolas Pitree102d542005-08-06 05:46:59 +01001712 map_write(map, CMD(words), cmd_adr );
Linus Torvalds1da177e2005-04-16 15:20:36 -07001713
1714 /* Write data */
Nicolas Pitree102d542005-08-06 05:46:59 +01001715 vec = *pvec;
1716 vec_seek = *pvec_seek;
1717 do {
1718 int n = map_bankwidth(map) - word_gap;
1719 if (n > vec->iov_len - vec_seek)
1720 n = vec->iov_len - vec_seek;
1721 if (n > len)
1722 n = len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723
Nicolas Pitree102d542005-08-06 05:46:59 +01001724 if (!word_gap && len < map_bankwidth(map))
1725 datum = map_word_ff(map);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001726
Nicolas Pitree102d542005-08-06 05:46:59 +01001727 datum = map_word_load_partial(map, datum,
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001728 vec->iov_base + vec_seek,
Nicolas Pitree102d542005-08-06 05:46:59 +01001729 word_gap, n);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001730
Nicolas Pitree102d542005-08-06 05:46:59 +01001731 len -= n;
1732 word_gap += n;
1733 if (!len || word_gap == map_bankwidth(map)) {
1734 map_write(map, datum, adr);
1735 adr += map_bankwidth(map);
1736 word_gap = 0;
1737 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738
Nicolas Pitree102d542005-08-06 05:46:59 +01001739 vec_seek += n;
1740 if (vec_seek == vec->iov_len) {
1741 vec++;
1742 vec_seek = 0;
1743 }
1744 } while (len);
1745 *pvec = vec;
1746 *pvec_seek = vec_seek;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747
1748 /* GO GO GO */
1749 map_write(map, CMD(0xd0), cmd_adr);
1750 chip->state = FL_WRITING;
1751
Nicolas Pitrec1724712006-03-30 15:52:41 +01001752 ret = INVAL_CACHE_AND_WAIT(map, chip, cmd_adr,
Massimo Cirillo646fd122008-01-11 10:24:11 +00001753 initial_adr, initial_len,
Anders Grafströme93cafe2008-08-05 18:37:41 +02001754 chip->buffer_write_time,
1755 chip->buffer_write_time_max);
Nicolas Pitrec1724712006-03-30 15:52:41 +01001756 if (ret) {
1757 map_write(map, CMD(0x70), cmd_adr);
1758 chip->state = FL_STATUS;
1759 xip_enable(map, chip, cmd_adr);
1760 printk(KERN_ERR "%s: buffer write error (status timeout)\n", map->name);
1761 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001762 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001763
Nicolas Pitre48436532005-08-06 05:16:52 +01001764 /* check for errors */
Nicolas Pitrec1724712006-03-30 15:52:41 +01001765 status = map_read(map, cmd_adr);
Nicolas Pitre48436532005-08-06 05:16:52 +01001766 if (map_word_bitsset(map, status, CMD(0x1a))) {
1767 unsigned long chipstatus = MERGESTATUS(status);
1768
1769 /* reset status */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001770 map_write(map, CMD(0x50), cmd_adr);
Nicolas Pitre48436532005-08-06 05:16:52 +01001771 map_write(map, CMD(0x70), cmd_adr);
1772 xip_enable(map, chip, cmd_adr);
1773
1774 if (chipstatus & 0x02) {
1775 ret = -EROFS;
1776 } else if (chipstatus & 0x08) {
1777 printk(KERN_ERR "%s: buffer write error (bad VPP)\n", map->name);
1778 ret = -EIO;
1779 } else {
1780 printk(KERN_ERR "%s: buffer write error (status 0x%lx)\n", map->name, chipstatus);
1781 ret = -EINVAL;
1782 }
1783
1784 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001785 }
1786
1787 xip_enable(map, chip, cmd_adr);
Paul Parsons85e5b2f2012-03-07 14:10:33 +00001788 out: DISABLE_VPP(map);
1789 put_chip(map, chip, cmd_adr);
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001790 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001791 return ret;
1792}
1793
Nicolas Pitree102d542005-08-06 05:46:59 +01001794static int cfi_intelext_writev (struct mtd_info *mtd, const struct kvec *vecs,
1795 unsigned long count, loff_t to, size_t *retlen)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796{
1797 struct map_info *map = mtd->priv;
1798 struct cfi_private *cfi = map->fldrv_priv;
1799 int wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1800 int ret = 0;
1801 int chipnum;
Nicolas Pitree102d542005-08-06 05:46:59 +01001802 unsigned long ofs, vec_seek, i;
1803 size_t len = 0;
1804
1805 for (i = 0; i < count; i++)
1806 len += vecs[i].iov_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808 if (!len)
1809 return 0;
1810
1811 chipnum = to >> cfi->chipshift;
Nicolas Pitree102d542005-08-06 05:46:59 +01001812 ofs = to - (chipnum << cfi->chipshift);
1813 vec_seek = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001814
Nicolas Pitree102d542005-08-06 05:46:59 +01001815 do {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001816 /* We must not cross write block boundaries */
1817 int size = wbufsize - (ofs & (wbufsize-1));
1818
1819 if (size > len)
1820 size = len;
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001821 ret = do_write_buffer(map, &cfi->chips[chipnum],
Nicolas Pitree102d542005-08-06 05:46:59 +01001822 ofs, &vecs, &vec_seek, size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823 if (ret)
1824 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825
1826 ofs += size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827 (*retlen) += size;
1828 len -= size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829
1830 if (ofs >> cfi->chipshift) {
1831 chipnum ++;
1832 ofs = 0;
1833 if (chipnum == cfi->numchips)
1834 return 0;
1835 }
Josh Boyerdf54b52c2005-12-06 17:28:19 +00001836
1837 /* Be nice and reschedule with the chip in a usable state for other
1838 processes. */
1839 cond_resched();
1840
Nicolas Pitree102d542005-08-06 05:46:59 +01001841 } while (len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843 return 0;
1844}
1845
Nicolas Pitree102d542005-08-06 05:46:59 +01001846static int cfi_intelext_write_buffers (struct mtd_info *mtd, loff_t to,
1847 size_t len, size_t *retlen, const u_char *buf)
1848{
1849 struct kvec vec;
1850
1851 vec.iov_base = (void *) buf;
1852 vec.iov_len = len;
1853
1854 return cfi_intelext_writev(mtd, &vec, 1, to, retlen);
1855}
1856
Linus Torvalds1da177e2005-04-16 15:20:36 -07001857static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
1858 unsigned long adr, int len, void *thunk)
1859{
1860 struct cfi_private *cfi = map->fldrv_priv;
Nicolas Pitrec1724712006-03-30 15:52:41 +01001861 map_word status;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 int retries = 3;
Nicolas Pitrec1724712006-03-30 15:52:41 +01001863 int ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864
1865 adr += chip->start;
1866
Linus Torvalds1da177e2005-04-16 15:20:36 -07001867 retry:
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001868 mutex_lock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 ret = get_chip(map, chip, adr, FL_ERASING);
1870 if (ret) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001871 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 return ret;
1873 }
1874
1875 XIP_INVAL_CACHED_RANGE(map, adr, len);
1876 ENABLE_VPP(map);
1877 xip_disable(map, chip, adr);
1878
1879 /* Clear the status register first */
1880 map_write(map, CMD(0x50), adr);
1881
1882 /* Now erase */
1883 map_write(map, CMD(0x20), adr);
1884 map_write(map, CMD(0xD0), adr);
1885 chip->state = FL_ERASING;
1886 chip->erase_suspended = 0;
1887
Nicolas Pitrec1724712006-03-30 15:52:41 +01001888 ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
1889 adr, len,
Anders Grafströme93cafe2008-08-05 18:37:41 +02001890 chip->erase_time,
1891 chip->erase_time_max);
Nicolas Pitrec1724712006-03-30 15:52:41 +01001892 if (ret) {
1893 map_write(map, CMD(0x70), adr);
1894 chip->state = FL_STATUS;
1895 xip_enable(map, chip, adr);
1896 printk(KERN_ERR "%s: block erase error: (status timeout)\n", map->name);
1897 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001898 }
1899
1900 /* We've broken this before. It doesn't hurt to be safe */
1901 map_write(map, CMD(0x70), adr);
1902 chip->state = FL_STATUS;
1903 status = map_read(map, adr);
1904
Nicolas Pitre48436532005-08-06 05:16:52 +01001905 /* check for errors */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001906 if (map_word_bitsset(map, status, CMD(0x3a))) {
Nicolas Pitre48436532005-08-06 05:16:52 +01001907 unsigned long chipstatus = MERGESTATUS(status);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001908
1909 /* Reset the error bits */
1910 map_write(map, CMD(0x50), adr);
1911 map_write(map, CMD(0x70), adr);
1912 xip_enable(map, chip, adr);
1913
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 if ((chipstatus & 0x30) == 0x30) {
Nicolas Pitre48436532005-08-06 05:16:52 +01001915 printk(KERN_ERR "%s: block erase error: (bad command sequence, status 0x%lx)\n", map->name, chipstatus);
1916 ret = -EINVAL;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917 } else if (chipstatus & 0x02) {
1918 /* Protection bit set */
1919 ret = -EROFS;
1920 } else if (chipstatus & 0x8) {
1921 /* Voltage */
Nicolas Pitre48436532005-08-06 05:16:52 +01001922 printk(KERN_ERR "%s: block erase error: (bad VPP)\n", map->name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001923 ret = -EIO;
Nicolas Pitre48436532005-08-06 05:16:52 +01001924 } else if (chipstatus & 0x20 && retries--) {
1925 printk(KERN_DEBUG "block erase failed at 0x%08lx: status 0x%lx. Retrying...\n", adr, chipstatus);
Paul Parsons85e5b2f2012-03-07 14:10:33 +00001926 DISABLE_VPP(map);
Nicolas Pitre48436532005-08-06 05:16:52 +01001927 put_chip(map, chip, adr);
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001928 mutex_unlock(&chip->mutex);
Nicolas Pitre48436532005-08-06 05:16:52 +01001929 goto retry;
1930 } else {
1931 printk(KERN_ERR "%s: block erase failed at 0x%08lx (status 0x%lx)\n", map->name, adr, chipstatus);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001932 ret = -EIO;
1933 }
Nicolas Pitre48436532005-08-06 05:16:52 +01001934
1935 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001936 }
1937
Nicolas Pitre48436532005-08-06 05:16:52 +01001938 xip_enable(map, chip, adr);
Paul Parsons85e5b2f2012-03-07 14:10:33 +00001939 out: DISABLE_VPP(map);
1940 put_chip(map, chip, adr);
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001941 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001942 return ret;
1943}
1944
Ben Dooks029a9eb2007-05-28 20:11:37 +01001945static int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946{
1947 unsigned long ofs, len;
1948 int ret;
1949
1950 ofs = instr->addr;
1951 len = instr->len;
1952
1953 ret = cfi_varsize_frob(mtd, do_erase_oneblock, ofs, len, NULL);
1954 if (ret)
1955 return ret;
1956
1957 instr->state = MTD_ERASE_DONE;
1958 mtd_erase_callback(instr);
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001959
Linus Torvalds1da177e2005-04-16 15:20:36 -07001960 return 0;
1961}
1962
1963static void cfi_intelext_sync (struct mtd_info *mtd)
1964{
1965 struct map_info *map = mtd->priv;
1966 struct cfi_private *cfi = map->fldrv_priv;
1967 int i;
1968 struct flchip *chip;
1969 int ret = 0;
1970
1971 for (i=0; !ret && i<cfi->numchips; i++) {
1972 chip = &cfi->chips[i];
1973
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001974 mutex_lock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 ret = get_chip(map, chip, chip->start, FL_SYNCING);
1976
1977 if (!ret) {
1978 chip->oldstate = chip->state;
1979 chip->state = FL_SYNCING;
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001980 /* No need to wake_up() on this state change -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 * as the whole point is that nobody can do anything
1982 * with the chip now anyway.
1983 */
1984 }
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001985 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986 }
1987
1988 /* Unlock the chips again */
1989
1990 for (i--; i >=0; i--) {
1991 chip = &cfi->chips[i];
1992
Stefani Seiboldc4e77372010-04-18 22:46:44 +02001993 mutex_lock(&chip->mutex);
Thomas Gleixner1f948b42005-11-07 11:15:37 +00001994
Linus Torvalds1da177e2005-04-16 15:20:36 -07001995 if (chip->state == FL_SYNCING) {
1996 chip->state = chip->oldstate;
Nicolas Pitre09c79332005-03-16 22:41:09 +00001997 chip->oldstate = FL_READY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001998 wake_up(&chip->wq);
1999 }
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002000 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002001 }
2002}
2003
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002004static int __xipram do_getlockstatus_oneblock(struct map_info *map,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002005 struct flchip *chip,
2006 unsigned long adr,
2007 int len, void *thunk)
2008{
2009 struct cfi_private *cfi = map->fldrv_priv;
2010 int status, ofs_factor = cfi->interleave * cfi->device_type;
2011
Todd Poynorc25bb1f2005-04-27 21:01:52 +01002012 adr += chip->start;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013 xip_disable(map, chip, adr+(2*ofs_factor));
Todd Poynorc25bb1f2005-04-27 21:01:52 +01002014 map_write(map, CMD(0x90), adr+(2*ofs_factor));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015 chip->state = FL_JEDEC_QUERY;
2016 status = cfi_read_query(map, adr+(2*ofs_factor));
2017 xip_enable(map, chip, 0);
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002018 return status;
2019}
2020
2021#ifdef DEBUG_LOCK_BITS
2022static int __xipram do_printlockstatus_oneblock(struct map_info *map,
2023 struct flchip *chip,
2024 unsigned long adr,
2025 int len, void *thunk)
2026{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 printk(KERN_DEBUG "block status register for 0x%08lx is %x\n",
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002028 adr, do_getlockstatus_oneblock(map, chip, adr, len, thunk));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 return 0;
2030}
2031#endif
2032
2033#define DO_XXLOCK_ONEBLOCK_LOCK ((void *) 1)
2034#define DO_XXLOCK_ONEBLOCK_UNLOCK ((void *) 2)
2035
2036static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip,
2037 unsigned long adr, int len, void *thunk)
2038{
2039 struct cfi_private *cfi = map->fldrv_priv;
Todd Poynor9a6e73e2005-03-29 23:06:40 +01002040 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
Stefan Roese7be1f6b2012-08-28 11:34:13 +02002041 int mdelay;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042 int ret;
2043
2044 adr += chip->start;
2045
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002046 mutex_lock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002047 ret = get_chip(map, chip, adr, FL_LOCKING);
2048 if (ret) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002049 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050 return ret;
2051 }
2052
2053 ENABLE_VPP(map);
2054 xip_disable(map, chip, adr);
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002055
Linus Torvalds1da177e2005-04-16 15:20:36 -07002056 map_write(map, CMD(0x60), adr);
2057 if (thunk == DO_XXLOCK_ONEBLOCK_LOCK) {
2058 map_write(map, CMD(0x01), adr);
2059 chip->state = FL_LOCKING;
2060 } else if (thunk == DO_XXLOCK_ONEBLOCK_UNLOCK) {
2061 map_write(map, CMD(0xD0), adr);
2062 chip->state = FL_UNLOCKING;
2063 } else
2064 BUG();
2065
Todd Poynor9a6e73e2005-03-29 23:06:40 +01002066 /*
2067 * If Instant Individual Block Locking supported then no need
2068 * to delay.
2069 */
Stefan Roese7be1f6b2012-08-28 11:34:13 +02002070 /*
2071 * Unlocking may take up to 1.4 seconds on some Intel flashes. So
2072 * lets use a max of 1.5 seconds (1500ms) as timeout.
2073 *
2074 * See "Clear Block Lock-Bits Time" on page 40 in
2075 * "3 Volt Intel StrataFlash Memory" 28F128J3,28F640J3,28F320J3 manual
2076 * from February 2003
2077 */
2078 mdelay = (!extp || !(extp->FeatureSupport & (1 << 5))) ? 1500 : 0;
Todd Poynor9a6e73e2005-03-29 23:06:40 +01002079
Stefan Roese7be1f6b2012-08-28 11:34:13 +02002080 ret = WAIT_TIMEOUT(map, chip, adr, mdelay, mdelay * 1000);
Nicolas Pitrec1724712006-03-30 15:52:41 +01002081 if (ret) {
2082 map_write(map, CMD(0x70), adr);
2083 chip->state = FL_STATUS;
2084 xip_enable(map, chip, adr);
2085 printk(KERN_ERR "%s: block unlock error: (status timeout)\n", map->name);
2086 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002087 }
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002088
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 xip_enable(map, chip, adr);
Paul Parsons85e5b2f2012-03-07 14:10:33 +00002090 out: DISABLE_VPP(map);
2091 put_chip(map, chip, adr);
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002092 mutex_unlock(&chip->mutex);
Nicolas Pitrec1724712006-03-30 15:52:41 +01002093 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094}
2095
Adrian Hunter69423d92008-12-10 13:37:21 +00002096static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097{
2098 int ret;
2099
2100#ifdef DEBUG_LOCK_BITS
2101 printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
Harvey Harrisoncb53b3b2008-04-18 13:44:19 -07002102 __func__, ofs, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002103 cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
Randy Dunlap1da1caf2007-06-28 23:00:09 +01002104 ofs, len, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002105#endif
2106
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002107 ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002108 ofs, len, DO_XXLOCK_ONEBLOCK_LOCK);
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002109
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110#ifdef DEBUG_LOCK_BITS
2111 printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
Harvey Harrisoncb53b3b2008-04-18 13:44:19 -07002112 __func__, ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113 cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
Randy Dunlap1da1caf2007-06-28 23:00:09 +01002114 ofs, len, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115#endif
2116
2117 return ret;
2118}
2119
Adrian Hunter69423d92008-12-10 13:37:21 +00002120static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002121{
2122 int ret;
2123
2124#ifdef DEBUG_LOCK_BITS
2125 printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
Harvey Harrisoncb53b3b2008-04-18 13:44:19 -07002126 __func__, ofs, len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
Randy Dunlap1da1caf2007-06-28 23:00:09 +01002128 ofs, len, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002129#endif
2130
2131 ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
2132 ofs, len, DO_XXLOCK_ONEBLOCK_UNLOCK);
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002133
Linus Torvalds1da177e2005-04-16 15:20:36 -07002134#ifdef DEBUG_LOCK_BITS
2135 printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
Harvey Harrisoncb53b3b2008-04-18 13:44:19 -07002136 __func__, ret);
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002137 cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
Randy Dunlap1da1caf2007-06-28 23:00:09 +01002138 ofs, len, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002139#endif
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002140
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141 return ret;
2142}
2143
Richard Cochran99384242010-06-14 18:10:33 +02002144static int cfi_intelext_is_locked(struct mtd_info *mtd, loff_t ofs,
2145 uint64_t len)
2146{
2147 return cfi_varsize_frob(mtd, do_getlockstatus_oneblock,
2148 ofs, len, NULL) ? 1 : 0;
2149}
2150
Nicolas Pitref77814d2005-02-08 17:11:19 +00002151#ifdef CONFIG_MTD_OTP
2152
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002153typedef int (*otp_op_t)(struct map_info *map, struct flchip *chip,
Nicolas Pitref77814d2005-02-08 17:11:19 +00002154 u_long data_offset, u_char *buf, u_int size,
2155 u_long prot_offset, u_int groupno, u_int groupsize);
2156
2157static int __xipram
2158do_otp_read(struct map_info *map, struct flchip *chip, u_long offset,
2159 u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2160{
2161 struct cfi_private *cfi = map->fldrv_priv;
2162 int ret;
2163
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002164 mutex_lock(&chip->mutex);
Nicolas Pitref77814d2005-02-08 17:11:19 +00002165 ret = get_chip(map, chip, chip->start, FL_JEDEC_QUERY);
2166 if (ret) {
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002167 mutex_unlock(&chip->mutex);
Nicolas Pitref77814d2005-02-08 17:11:19 +00002168 return ret;
2169 }
2170
2171 /* let's ensure we're not reading back cached data from array mode */
Nicolas Pitre6da70122005-05-19 18:05:47 +01002172 INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
Nicolas Pitref77814d2005-02-08 17:11:19 +00002173
2174 xip_disable(map, chip, chip->start);
2175 if (chip->state != FL_JEDEC_QUERY) {
2176 map_write(map, CMD(0x90), chip->start);
2177 chip->state = FL_JEDEC_QUERY;
2178 }
2179 map_copy_from(map, buf, chip->start + offset, size);
2180 xip_enable(map, chip, chip->start);
2181
2182 /* then ensure we don't keep OTP data in the cache */
Nicolas Pitre6da70122005-05-19 18:05:47 +01002183 INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
Nicolas Pitref77814d2005-02-08 17:11:19 +00002184
2185 put_chip(map, chip, chip->start);
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002186 mutex_unlock(&chip->mutex);
Nicolas Pitref77814d2005-02-08 17:11:19 +00002187 return 0;
2188}
2189
2190static int
2191do_otp_write(struct map_info *map, struct flchip *chip, u_long offset,
2192 u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2193{
2194 int ret;
2195
2196 while (size) {
2197 unsigned long bus_ofs = offset & ~(map_bankwidth(map)-1);
2198 int gap = offset - bus_ofs;
2199 int n = min_t(int, size, map_bankwidth(map)-gap);
2200 map_word datum = map_word_ff(map);
2201
2202 datum = map_word_load_partial(map, datum, buf, gap, n);
2203 ret = do_write_oneword(map, chip, bus_ofs, datum, FL_OTP_WRITE);
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002204 if (ret)
Nicolas Pitref77814d2005-02-08 17:11:19 +00002205 return ret;
2206
2207 offset += n;
2208 buf += n;
2209 size -= n;
2210 }
2211
2212 return 0;
2213}
2214
2215static int
2216do_otp_lock(struct map_info *map, struct flchip *chip, u_long offset,
2217 u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2218{
2219 struct cfi_private *cfi = map->fldrv_priv;
2220 map_word datum;
2221
2222 /* make sure area matches group boundaries */
Nicolas Pitre332d71f2005-02-17 20:35:04 +00002223 if (size != grpsz)
Nicolas Pitref77814d2005-02-08 17:11:19 +00002224 return -EXDEV;
2225
2226 datum = map_word_ff(map);
2227 datum = map_word_clr(map, datum, CMD(1 << grpno));
2228 return do_write_oneword(map, chip, prot, datum, FL_OTP_WRITE);
2229}
2230
2231static int cfi_intelext_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
2232 size_t *retlen, u_char *buf,
2233 otp_op_t action, int user_regs)
2234{
2235 struct map_info *map = mtd->priv;
2236 struct cfi_private *cfi = map->fldrv_priv;
2237 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2238 struct flchip *chip;
2239 struct cfi_intelext_otpinfo *otp;
2240 u_long devsize, reg_prot_offset, data_offset;
2241 u_int chip_num, chip_step, field, reg_fact_size, reg_user_size;
2242 u_int groups, groupno, groupsize, reg_fact_groups, reg_user_groups;
2243 int ret;
2244
2245 *retlen = 0;
2246
2247 /* Check that we actually have some OTP registers */
2248 if (!extp || !(extp->FeatureSupport & 64) || !extp->NumProtectionFields)
2249 return -ENODATA;
2250
2251 /* we need real chips here not virtual ones */
2252 devsize = (1 << cfi->cfiq->DevSize) * cfi->interleave;
2253 chip_step = devsize >> cfi->chipshift;
Nicolas Pitredce2b4d2005-04-01 17:36:29 +01002254 chip_num = 0;
Nicolas Pitref77814d2005-02-08 17:11:19 +00002255
Nicolas Pitredce2b4d2005-04-01 17:36:29 +01002256 /* Some chips have OTP located in the _top_ partition only.
2257 For example: Intel 28F256L18T (T means top-parameter device) */
Hans-Christian Egtvedtb2ef1a22009-11-05 15:53:43 +01002258 if (cfi->mfr == CFI_MFR_INTEL) {
Nicolas Pitredce2b4d2005-04-01 17:36:29 +01002259 switch (cfi->id) {
2260 case 0x880b:
2261 case 0x880c:
2262 case 0x880d:
2263 chip_num = chip_step - 1;
2264 }
2265 }
2266
2267 for ( ; chip_num < cfi->numchips; chip_num += chip_step) {
Nicolas Pitref77814d2005-02-08 17:11:19 +00002268 chip = &cfi->chips[chip_num];
2269 otp = (struct cfi_intelext_otpinfo *)&extp->extra[0];
2270
2271 /* first OTP region */
2272 field = 0;
2273 reg_prot_offset = extp->ProtRegAddr;
2274 reg_fact_groups = 1;
2275 reg_fact_size = 1 << extp->FactProtRegSize;
2276 reg_user_groups = 1;
2277 reg_user_size = 1 << extp->UserProtRegSize;
2278
2279 while (len > 0) {
2280 /* flash geometry fixup */
2281 data_offset = reg_prot_offset + 1;
2282 data_offset *= cfi->interleave * cfi->device_type;
2283 reg_prot_offset *= cfi->interleave * cfi->device_type;
2284 reg_fact_size *= cfi->interleave;
2285 reg_user_size *= cfi->interleave;
2286
2287 if (user_regs) {
2288 groups = reg_user_groups;
2289 groupsize = reg_user_size;
2290 /* skip over factory reg area */
2291 groupno = reg_fact_groups;
2292 data_offset += reg_fact_groups * reg_fact_size;
2293 } else {
2294 groups = reg_fact_groups;
2295 groupsize = reg_fact_size;
2296 groupno = 0;
2297 }
2298
Nicolas Pitre332d71f2005-02-17 20:35:04 +00002299 while (len > 0 && groups > 0) {
Nicolas Pitref77814d2005-02-08 17:11:19 +00002300 if (!action) {
2301 /*
2302 * Special case: if action is NULL
2303 * we fill buf with otp_info records.
2304 */
2305 struct otp_info *otpinfo;
2306 map_word lockword;
2307 len -= sizeof(struct otp_info);
2308 if (len <= 0)
2309 return -ENOSPC;
2310 ret = do_otp_read(map, chip,
2311 reg_prot_offset,
2312 (u_char *)&lockword,
2313 map_bankwidth(map),
2314 0, 0, 0);
2315 if (ret)
2316 return ret;
2317 otpinfo = (struct otp_info *)buf;
2318 otpinfo->start = from;
2319 otpinfo->length = groupsize;
2320 otpinfo->locked =
2321 !map_word_bitsset(map, lockword,
2322 CMD(1 << groupno));
2323 from += groupsize;
2324 buf += sizeof(*otpinfo);
2325 *retlen += sizeof(*otpinfo);
2326 } else if (from >= groupsize) {
2327 from -= groupsize;
Nicolas Pitre332d71f2005-02-17 20:35:04 +00002328 data_offset += groupsize;
Nicolas Pitref77814d2005-02-08 17:11:19 +00002329 } else {
2330 int size = groupsize;
2331 data_offset += from;
2332 size -= from;
2333 from = 0;
2334 if (size > len)
2335 size = len;
2336 ret = action(map, chip, data_offset,
2337 buf, size, reg_prot_offset,
2338 groupno, groupsize);
2339 if (ret < 0)
2340 return ret;
2341 buf += size;
2342 len -= size;
2343 *retlen += size;
Nicolas Pitre332d71f2005-02-17 20:35:04 +00002344 data_offset += size;
Nicolas Pitref77814d2005-02-08 17:11:19 +00002345 }
2346 groupno++;
2347 groups--;
2348 }
2349
2350 /* next OTP region */
2351 if (++field == extp->NumProtectionFields)
2352 break;
2353 reg_prot_offset = otp->ProtRegAddr;
2354 reg_fact_groups = otp->FactGroups;
2355 reg_fact_size = 1 << otp->FactProtRegSize;
2356 reg_user_groups = otp->UserGroups;
2357 reg_user_size = 1 << otp->UserProtRegSize;
2358 otp++;
2359 }
2360 }
2361
2362 return 0;
2363}
2364
2365static int cfi_intelext_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
2366 size_t len, size_t *retlen,
2367 u_char *buf)
2368{
2369 return cfi_intelext_otp_walk(mtd, from, len, retlen,
2370 buf, do_otp_read, 0);
2371}
2372
2373static int cfi_intelext_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
2374 size_t len, size_t *retlen,
2375 u_char *buf)
2376{
2377 return cfi_intelext_otp_walk(mtd, from, len, retlen,
2378 buf, do_otp_read, 1);
2379}
2380
2381static int cfi_intelext_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
2382 size_t len, size_t *retlen,
2383 u_char *buf)
2384{
2385 return cfi_intelext_otp_walk(mtd, from, len, retlen,
2386 buf, do_otp_write, 1);
2387}
2388
2389static int cfi_intelext_lock_user_prot_reg(struct mtd_info *mtd,
2390 loff_t from, size_t len)
2391{
2392 size_t retlen;
2393 return cfi_intelext_otp_walk(mtd, from, len, &retlen,
2394 NULL, do_otp_lock, 1);
2395}
2396
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002397static int cfi_intelext_get_fact_prot_info(struct mtd_info *mtd,
Nicolas Pitref77814d2005-02-08 17:11:19 +00002398 struct otp_info *buf, size_t len)
2399{
2400 size_t retlen;
2401 int ret;
2402
2403 ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 0);
2404 return ret ? : retlen;
2405}
2406
2407static int cfi_intelext_get_user_prot_info(struct mtd_info *mtd,
2408 struct otp_info *buf, size_t len)
2409{
2410 size_t retlen;
2411 int ret;
2412
2413 ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 1);
2414 return ret ? : retlen;
2415}
2416
2417#endif
2418
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002419static void cfi_intelext_save_locks(struct mtd_info *mtd)
2420{
2421 struct mtd_erase_region_info *region;
2422 int block, status, i;
2423 unsigned long adr;
2424 size_t len;
2425
2426 for (i = 0; i < mtd->numeraseregions; i++) {
2427 region = &mtd->eraseregions[i];
2428 if (!region->lockmap)
2429 continue;
2430
2431 for (block = 0; block < region->numblocks; block++){
2432 len = region->erasesize;
2433 adr = region->offset + block * len;
2434
2435 status = cfi_varsize_frob(mtd,
Ben Dooks029a9eb2007-05-28 20:11:37 +01002436 do_getlockstatus_oneblock, adr, len, NULL);
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002437 if (status)
2438 set_bit(block, region->lockmap);
2439 else
2440 clear_bit(block, region->lockmap);
2441 }
2442 }
2443}
2444
Linus Torvalds1da177e2005-04-16 15:20:36 -07002445static int cfi_intelext_suspend(struct mtd_info *mtd)
2446{
2447 struct map_info *map = mtd->priv;
2448 struct cfi_private *cfi = map->fldrv_priv;
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002449 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002450 int i;
2451 struct flchip *chip;
2452 int ret = 0;
2453
Justin Treone619a752008-01-30 10:25:49 -08002454 if ((mtd->flags & MTD_POWERUP_LOCK)
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002455 && extp && (extp->FeatureSupport & (1 << 5)))
2456 cfi_intelext_save_locks(mtd);
2457
Linus Torvalds1da177e2005-04-16 15:20:36 -07002458 for (i=0; !ret && i<cfi->numchips; i++) {
2459 chip = &cfi->chips[i];
2460
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002461 mutex_lock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002462
2463 switch (chip->state) {
2464 case FL_READY:
2465 case FL_STATUS:
2466 case FL_CFI_QUERY:
2467 case FL_JEDEC_QUERY:
2468 if (chip->oldstate == FL_READY) {
David Andersa86aaa62006-10-19 19:33:19 +03002469 /* place the chip in a known state before suspend */
2470 map_write(map, CMD(0xFF), cfi->chips[i].start);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 chip->oldstate = chip->state;
2472 chip->state = FL_PM_SUSPENDED;
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002473 /* No need to wake_up() on this state change -
Linus Torvalds1da177e2005-04-16 15:20:36 -07002474 * as the whole point is that nobody can do anything
2475 * with the chip now anyway.
2476 */
2477 } else {
2478 /* There seems to be an operation pending. We must wait for it. */
2479 printk(KERN_NOTICE "Flash device refused suspend due to pending operation (oldstate %d)\n", chip->oldstate);
2480 ret = -EAGAIN;
2481 }
2482 break;
2483 default:
2484 /* Should we actually wait? Once upon a time these routines weren't
2485 allowed to. Or should we return -EAGAIN, because the upper layers
2486 ought to have already shut down anything which was using the device
2487 anyway? The latter for now. */
Russell King342d3a92012-02-15 11:48:34 +00002488 printk(KERN_NOTICE "Flash device refused suspend due to active operation (state %d)\n", chip->state);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002489 ret = -EAGAIN;
2490 case FL_PM_SUSPENDED:
2491 break;
2492 }
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002493 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002494 }
2495
2496 /* Unlock the chips again */
2497
2498 if (ret) {
2499 for (i--; i >=0; i--) {
2500 chip = &cfi->chips[i];
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002501
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002502 mutex_lock(&chip->mutex);
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002503
Linus Torvalds1da177e2005-04-16 15:20:36 -07002504 if (chip->state == FL_PM_SUSPENDED) {
2505 /* No need to force it into a known state here,
2506 because we're returning failure, and it didn't
2507 get power cycled */
2508 chip->state = chip->oldstate;
2509 chip->oldstate = FL_READY;
2510 wake_up(&chip->wq);
2511 }
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002512 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002513 }
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002514 }
2515
Linus Torvalds1da177e2005-04-16 15:20:36 -07002516 return ret;
2517}
2518
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002519static void cfi_intelext_restore_locks(struct mtd_info *mtd)
2520{
2521 struct mtd_erase_region_info *region;
2522 int block, i;
2523 unsigned long adr;
2524 size_t len;
2525
2526 for (i = 0; i < mtd->numeraseregions; i++) {
2527 region = &mtd->eraseregions[i];
2528 if (!region->lockmap)
2529 continue;
2530
Akinobu Mitac527b412012-03-23 15:02:05 -07002531 for_each_clear_bit(block, region->lockmap, region->numblocks) {
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002532 len = region->erasesize;
2533 adr = region->offset + block * len;
Akinobu Mitac527b412012-03-23 15:02:05 -07002534 cfi_intelext_unlock(mtd, adr, len);
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002535 }
2536 }
2537}
2538
Linus Torvalds1da177e2005-04-16 15:20:36 -07002539static void cfi_intelext_resume(struct mtd_info *mtd)
2540{
2541 struct map_info *map = mtd->priv;
2542 struct cfi_private *cfi = map->fldrv_priv;
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002543 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002544 int i;
2545 struct flchip *chip;
2546
2547 for (i=0; i<cfi->numchips; i++) {
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002548
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549 chip = &cfi->chips[i];
2550
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002551 mutex_lock(&chip->mutex);
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002552
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553 /* Go to known state. Chip may have been power cycled */
2554 if (chip->state == FL_PM_SUSPENDED) {
2555 map_write(map, CMD(0xFF), cfi->chips[i].start);
2556 chip->oldstate = chip->state = FL_READY;
2557 wake_up(&chip->wq);
2558 }
2559
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002560 mutex_unlock(&chip->mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002561 }
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002562
Justin Treone619a752008-01-30 10:25:49 -08002563 if ((mtd->flags & MTD_POWERUP_LOCK)
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002564 && extp && (extp->FeatureSupport & (1 << 5)))
2565 cfi_intelext_restore_locks(mtd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566}
2567
Nicolas Pitre963a6fb2005-04-01 02:59:56 +01002568static int cfi_intelext_reset(struct mtd_info *mtd)
2569{
2570 struct map_info *map = mtd->priv;
2571 struct cfi_private *cfi = map->fldrv_priv;
2572 int i, ret;
2573
2574 for (i=0; i < cfi->numchips; i++) {
2575 struct flchip *chip = &cfi->chips[i];
2576
2577 /* force the completion of any ongoing operation
Thomas Gleixner1f948b42005-11-07 11:15:37 +00002578 and switch to array mode so any bootloader in
Nicolas Pitre963a6fb2005-04-01 02:59:56 +01002579 flash is accessible for soft reboot. */
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002580 mutex_lock(&chip->mutex);
Kevin Haoc4a9f882007-10-02 13:56:04 -07002581 ret = get_chip(map, chip, chip->start, FL_SHUTDOWN);
Nicolas Pitre963a6fb2005-04-01 02:59:56 +01002582 if (!ret) {
2583 map_write(map, CMD(0xff), chip->start);
Kevin Haoc4a9f882007-10-02 13:56:04 -07002584 chip->state = FL_SHUTDOWN;
Nicolas Pitrec9f7ec32009-10-23 16:02:42 -04002585 put_chip(map, chip, chip->start);
Nicolas Pitre963a6fb2005-04-01 02:59:56 +01002586 }
Stefani Seiboldc4e77372010-04-18 22:46:44 +02002587 mutex_unlock(&chip->mutex);
Nicolas Pitre963a6fb2005-04-01 02:59:56 +01002588 }
2589
2590 return 0;
2591}
2592
2593static int cfi_intelext_reboot(struct notifier_block *nb, unsigned long val,
2594 void *v)
2595{
2596 struct mtd_info *mtd;
2597
2598 mtd = container_of(nb, struct mtd_info, reboot_notifier);
2599 cfi_intelext_reset(mtd);
2600 return NOTIFY_DONE;
2601}
2602
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603static void cfi_intelext_destroy(struct mtd_info *mtd)
2604{
2605 struct map_info *map = mtd->priv;
2606 struct cfi_private *cfi = map->fldrv_priv;
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002607 struct mtd_erase_region_info *region;
2608 int i;
Nicolas Pitre963a6fb2005-04-01 02:59:56 +01002609 cfi_intelext_reset(mtd);
2610 unregister_reboot_notifier(&mtd->reboot_notifier);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002611 kfree(cfi->cmdset_priv);
2612 kfree(cfi->cfiq);
2613 kfree(cfi->chips[0].priv);
2614 kfree(cfi);
Rodolfo Giometti0ecbc812007-03-26 21:45:43 -08002615 for (i = 0; i < mtd->numeraseregions; i++) {
2616 region = &mtd->eraseregions[i];
2617 if (region->lockmap)
2618 kfree(region->lockmap);
2619 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 kfree(mtd->eraseregions);
2621}
2622
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623MODULE_LICENSE("GPL");
2624MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al.");
2625MODULE_DESCRIPTION("MTD chip driver for Intel/Sharp flash chips");
David Woodhousea15bdee2006-05-08 22:35:05 +01002626MODULE_ALIAS("cfi_cmdset_0003");
2627MODULE_ALIAS("cfi_cmdset_0200");