?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Full support for Ginger Console
[linux-ginger.git] / drivers / mtd / chips / cfi_cmdset_0001.c
blobe7563a9872d0af6404f64adae9610a9fffad027f
1 /*
2 * Common Flash Interface support:
3 * Intel Extended Vendor Command Set (ID 0x0001)
4 *
5 * (C) 2000 Red Hat. GPL'd
6 *
7 *
8 * 10/10/2000 Nicolas Pitre <nico@fluxnic.net>
9 * - 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
16 * 21/03/2007 Rodolfo Giometti <giometti@linux.it>
17 * - auto unlock sectors on resume for auto locking flash on power up
18 */
19
20 #include <linux/module.h>
21 #include <linux/types.h>
22 #include <linux/kernel.h>
23 #include <linux/sched.h>
24 #include <linux/init.h>
25 #include <asm/io.h>
26 #include <asm/byteorder.h>
27
28 #include <linux/errno.h>
29 #include <linux/slab.h>
30 #include <linux/delay.h>
31 #include <linux/interrupt.h>
32 #include <linux/reboot.h>
33 #include <linux/bitmap.h>
34 #include <linux/mtd/xip.h>
35 #include <linux/mtd/map.h>
36 #include <linux/mtd/mtd.h>
37 #include <linux/mtd/compatmac.h>
38 #include <linux/mtd/cfi.h>
39
40 /* #define CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE */
41 /* #define CMDSET0001_DISABLE_WRITE_SUSPEND */
42
43 // debugging, turns off buffer write mode if set to 1
44 #define FORCE_WORD_WRITE 0
45
46 #define MANUFACTURER_INTEL 0x0089
47 #define I82802AB 0x00ad
48 #define I82802AC 0x00ac
49 #define PF38F4476 0x881c
50 #define MANUFACTURER_ST 0x0020
51 #define M50LPW080 0x002F
52 #define M50FLW080A 0x0080
53 #define M50FLW080B 0x0081
54 #define AT49BV640D 0x02de
55
56 static int cfi_intelext_read (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
57 static int cfi_intelext_write_words(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
58 static int cfi_intelext_write_buffers(struct mtd_info *, loff_t, size_t, size_t *, const u_char *);
59 static int cfi_intelext_writev(struct mtd_info *, const struct kvec *, unsigned long, loff_t, size_t *);
60 static int cfi_intelext_erase_varsize(struct mtd_info *, struct erase_info *);
61 static void cfi_intelext_sync (struct mtd_info *);
62 static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
63 static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len);
64 #ifdef CONFIG_MTD_OTP
65 static int cfi_intelext_read_fact_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
66 static int cfi_intelext_read_user_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
67 static int cfi_intelext_write_user_prot_reg (struct mtd_info *, loff_t, size_t, size_t *, u_char *);
68 static int cfi_intelext_lock_user_prot_reg (struct mtd_info *, loff_t, size_t);
69 static int cfi_intelext_get_fact_prot_info (struct mtd_info *,
70 struct otp_info *, size_t);
71 static int cfi_intelext_get_user_prot_info (struct mtd_info *,
72 struct otp_info *, size_t);
73 #endif
74 static int cfi_intelext_suspend (struct mtd_info *);
75 static void cfi_intelext_resume (struct mtd_info *);
76 static int cfi_intelext_reboot (struct notifier_block *, unsigned long, void *);
77
78 static void cfi_intelext_destroy(struct mtd_info *);
79
80 struct mtd_info *cfi_cmdset_0001(struct map_info *, int);
81
82 static struct mtd_info *cfi_intelext_setup (struct mtd_info *);
83 static int cfi_intelext_partition_fixup(struct mtd_info *, struct cfi_private **);
84
85 static int cfi_intelext_point (struct mtd_info *mtd, loff_t from, size_t len,
86 size_t *retlen, void **virt, resource_size_t *phys);
87 static void cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len);
88
89 static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long adr, int mode);
90 static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode);
91 static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr);
92 #include "fwh_lock.h"
93
94
95
96 /*
97 * *********** SETUP AND PROBE BITS ***********
98 */
99
100 static struct mtd_chip_driver cfi_intelext_chipdrv = {
101 .probe = NULL, /* Not usable directly */
102 .destroy = cfi_intelext_destroy,
103 .name = "cfi_cmdset_0001",
104 .module = THIS_MODULE
105 };
106
107 /* #define DEBUG_LOCK_BITS */
108 /* #define DEBUG_CFI_FEATURES */
109
110 #ifdef DEBUG_CFI_FEATURES
111 static void cfi_tell_features(struct cfi_pri_intelext *extp)
112 {
113 int i;
114 printk(" Extended Query version %c.%c\n", extp->MajorVersion, extp->MinorVersion);
115 printk(" Feature/Command Support: %4.4X\n", extp->FeatureSupport);
116 printk(" - Chip Erase: %s\n", extp->FeatureSupport&1?"supported":"unsupported");
117 printk(" - Suspend Erase: %s\n", extp->FeatureSupport&2?"supported":"unsupported");
118 printk(" - Suspend Program: %s\n", extp->FeatureSupport&4?"supported":"unsupported");
119 printk(" - Legacy Lock/Unlock: %s\n", extp->FeatureSupport&8?"supported":"unsupported");
120 printk(" - Queued Erase: %s\n", extp->FeatureSupport&16?"supported":"unsupported");
121 printk(" - Instant block lock: %s\n", extp->FeatureSupport&32?"supported":"unsupported");
122 printk(" - Protection Bits: %s\n", extp->FeatureSupport&64?"supported":"unsupported");
123 printk(" - Page-mode read: %s\n", extp->FeatureSupport&128?"supported":"unsupported");
124 printk(" - Synchronous read: %s\n", extp->FeatureSupport&256?"supported":"unsupported");
125 printk(" - Simultaneous operations: %s\n", extp->FeatureSupport&512?"supported":"unsupported");
126 printk(" - Extended Flash Array: %s\n", extp->FeatureSupport&1024?"supported":"unsupported");
127 for (i=11; i<32; i++) {
128 if (extp->FeatureSupport & (1<<i))
129 printk(" - Unknown Bit %X: supported\n", i);
130 }
131
132 printk(" Supported functions after Suspend: %2.2X\n", extp->SuspendCmdSupport);
133 printk(" - Program after Erase Suspend: %s\n", extp->SuspendCmdSupport&1?"supported":"unsupported");
134 for (i=1; i<8; i++) {
135 if (extp->SuspendCmdSupport & (1<<i))
136 printk(" - Unknown Bit %X: supported\n", i);
137 }
138
139 printk(" Block Status Register Mask: %4.4X\n", extp->BlkStatusRegMask);
140 printk(" - Lock Bit Active: %s\n", extp->BlkStatusRegMask&1?"yes":"no");
141 printk(" - Lock-Down Bit Active: %s\n", extp->BlkStatusRegMask&2?"yes":"no");
142 for (i=2; i<3; i++) {
143 if (extp->BlkStatusRegMask & (1<<i))
144 printk(" - Unknown Bit %X Active: yes\n",i);
145 }
146 printk(" - EFA Lock Bit: %s\n", extp->BlkStatusRegMask&16?"yes":"no");
147 printk(" - EFA Lock-Down Bit: %s\n", extp->BlkStatusRegMask&32?"yes":"no");
148 for (i=6; i<16; i++) {
149 if (extp->BlkStatusRegMask & (1<<i))
150 printk(" - Unknown Bit %X Active: yes\n",i);
151 }
152
153 printk(" Vcc Logic Supply Optimum Program/Erase Voltage: %d.%d V\n",
154 extp->VccOptimal >> 4, extp->VccOptimal & 0xf);
155 if (extp->VppOptimal)
156 printk(" Vpp Programming Supply Optimum Program/Erase Voltage: %d.%d V\n",
157 extp->VppOptimal >> 4, extp->VppOptimal & 0xf);
158 }
159 #endif
160
161 /* Atmel chips don't use the same PRI format as Intel chips */
162 static void fixup_convert_atmel_pri(struct mtd_info *mtd, void *param)
163 {
164 struct map_info *map = mtd->priv;
165 struct cfi_private *cfi = map->fldrv_priv;
166 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
167 struct cfi_pri_atmel atmel_pri;
168 uint32_t features = 0;
169
170 /* Reverse byteswapping */
171 extp->FeatureSupport = cpu_to_le32(extp->FeatureSupport);
172 extp->BlkStatusRegMask = cpu_to_le16(extp->BlkStatusRegMask);
173 extp->ProtRegAddr = cpu_to_le16(extp->ProtRegAddr);
174
175 memcpy(&atmel_pri, extp, sizeof(atmel_pri));
176 memset((char *)extp + 5, 0, sizeof(*extp) - 5);
177
178 printk(KERN_ERR "atmel Features: %02x\n", atmel_pri.Features);
179
180 if (atmel_pri.Features & 0x01) /* chip erase supported */
181 features |= (1<<0);
182 if (atmel_pri.Features & 0x02) /* erase suspend supported */
183 features |= (1<<1);
184 if (atmel_pri.Features & 0x04) /* program suspend supported */
185 features |= (1<<2);
186 if (atmel_pri.Features & 0x08) /* simultaneous operations supported */
187 features |= (1<<9);
188 if (atmel_pri.Features & 0x20) /* page mode read supported */
189 features |= (1<<7);
190 if (atmel_pri.Features & 0x40) /* queued erase supported */
191 features |= (1<<4);
192 if (atmel_pri.Features & 0x80) /* Protection bits supported */
193 features |= (1<<6);
194
195 extp->FeatureSupport = features;
196
197 /* burst write mode not supported */
198 cfi->cfiq->BufWriteTimeoutTyp = 0;
199 cfi->cfiq->BufWriteTimeoutMax = 0;
200 }
201
202 #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
203 /* Some Intel Strata Flash prior to FPO revision C has bugs in this area */
204 static void fixup_intel_strataflash(struct mtd_info *mtd, void* param)
205 {
206 struct map_info *map = mtd->priv;
207 struct cfi_private *cfi = map->fldrv_priv;
208 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
209
210 printk(KERN_WARNING "cfi_cmdset_0001: Suspend "
211 "erase on write disabled.\n");
212 extp->SuspendCmdSupport &= ~1;
213 }
214 #endif
215
216 #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
217 static void fixup_no_write_suspend(struct mtd_info *mtd, void* param)
218 {
219 struct map_info *map = mtd->priv;
220 struct cfi_private *cfi = map->fldrv_priv;
221 struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
222
223 if (cfip && (cfip->FeatureSupport&4)) {
224 cfip->FeatureSupport &= ~4;
225 printk(KERN_WARNING "cfi_cmdset_0001: write suspend disabled\n");
226 }
227 }
228 #endif
229
230 static void fixup_st_m28w320ct(struct mtd_info *mtd, void* param)
231 {
232 struct map_info *map = mtd->priv;
233 struct cfi_private *cfi = map->fldrv_priv;
234
235 cfi->cfiq->BufWriteTimeoutTyp = 0; /* Not supported */
236 cfi->cfiq->BufWriteTimeoutMax = 0; /* Not supported */
237 }
238
239 static void fixup_st_m28w320cb(struct mtd_info *mtd, void* param)
240 {
241 struct map_info *map = mtd->priv;
242 struct cfi_private *cfi = map->fldrv_priv;
243
244 /* Note this is done after the region info is endian swapped */
245 cfi->cfiq->EraseRegionInfo[1] =
246 (cfi->cfiq->EraseRegionInfo[1] & 0xffff0000) | 0x3e;
247 };
248
249 static void fixup_use_point(struct mtd_info *mtd, void *param)
250 {
251 struct map_info *map = mtd->priv;
252 if (!mtd->point && map_is_linear(map)) {
253 mtd->point = cfi_intelext_point;
254 mtd->unpoint = cfi_intelext_unpoint;
255 }
256 }
257
258 static void fixup_use_write_buffers(struct mtd_info *mtd, void *param)
259 {
260 struct map_info *map = mtd->priv;
261 struct cfi_private *cfi = map->fldrv_priv;
262 if (cfi->cfiq->BufWriteTimeoutTyp) {
263 printk(KERN_INFO "Using buffer write method\n" );
264 mtd->write = cfi_intelext_write_buffers;
265 mtd->writev = cfi_intelext_writev;
266 }
267 }
268
269 /*
270 * Some chips power-up with all sectors locked by default.
271 */
272 static void fixup_unlock_powerup_lock(struct mtd_info *mtd, void *param)
273 {
274 struct map_info *map = mtd->priv;
275 struct cfi_private *cfi = map->fldrv_priv;
276 struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
277
278 if (cfip->FeatureSupport&32) {
279 printk(KERN_INFO "Using auto-unlock on power-up/resume\n" );
280 mtd->flags |= MTD_POWERUP_LOCK;
281 }
282 }
283
284 static struct cfi_fixup cfi_fixup_table[] = {
285 { CFI_MFR_ATMEL, CFI_ID_ANY, fixup_convert_atmel_pri, NULL },
286 #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
287 { CFI_MFR_ANY, CFI_ID_ANY, fixup_intel_strataflash, NULL },
288 #endif
289 #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
290 { CFI_MFR_ANY, CFI_ID_ANY, fixup_no_write_suspend, NULL },
291 #endif
292 #if !FORCE_WORD_WRITE
293 { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_write_buffers, NULL },
294 #endif
295 { CFI_MFR_ST, 0x00ba, /* M28W320CT */ fixup_st_m28w320ct, NULL },
296 { CFI_MFR_ST, 0x00bb, /* M28W320CB */ fixup_st_m28w320cb, NULL },
297 { MANUFACTURER_INTEL, CFI_ID_ANY, fixup_unlock_powerup_lock, NULL, },
298 { 0, 0, NULL, NULL }
299 };
300
301 static struct cfi_fixup jedec_fixup_table[] = {
302 { MANUFACTURER_INTEL, I82802AB, fixup_use_fwh_lock, NULL, },
303 { MANUFACTURER_INTEL, I82802AC, fixup_use_fwh_lock, NULL, },
304 { MANUFACTURER_ST, M50LPW080, fixup_use_fwh_lock, NULL, },
305 { MANUFACTURER_ST, M50FLW080A, fixup_use_fwh_lock, NULL, },
306 { MANUFACTURER_ST, M50FLW080B, fixup_use_fwh_lock, NULL, },
307 { 0, 0, NULL, NULL }
308 };
309 static struct cfi_fixup fixup_table[] = {
310 /* The CFI vendor ids and the JEDEC vendor IDs appear
311 * to be common. It is like the devices id's are as
312 * well. This table is to pick all cases where
313 * we know that is the case.
314 */
315 { CFI_MFR_ANY, CFI_ID_ANY, fixup_use_point, NULL },
316 { 0, 0, NULL, NULL }
317 };
318
319 static void cfi_fixup_major_minor(struct cfi_private *cfi,
320 struct cfi_pri_intelext *extp)
321 {
322 if (cfi->mfr == MANUFACTURER_INTEL &&
323 cfi->id == PF38F4476 && extp->MinorVersion == '3')
324 extp->MinorVersion = '1';
325 }
326
327 static inline struct cfi_pri_intelext *
328 read_pri_intelext(struct map_info *map, __u16 adr)
329 {
330 struct cfi_private *cfi = map->fldrv_priv;
331 struct cfi_pri_intelext *extp;
332 unsigned int extra_size = 0;
333 unsigned int extp_size = sizeof(*extp);
334
335 again:
336 extp = (struct cfi_pri_intelext *)cfi_read_pri(map, adr, extp_size, "Intel/Sharp");
337 if (!extp)
338 return NULL;
339
340 cfi_fixup_major_minor(cfi, extp);
341
342 if (extp->MajorVersion != '1' ||
343 (extp->MinorVersion < '0' || extp->MinorVersion > '5')) {
344 printk(KERN_ERR " Unknown Intel/Sharp Extended Query "
345 "version %c.%c.\n", extp->MajorVersion,
346 extp->MinorVersion);
347 kfree(extp);
348 return NULL;
349 }
350
351 /* Do some byteswapping if necessary */
352 extp->FeatureSupport = le32_to_cpu(extp->FeatureSupport);
353 extp->BlkStatusRegMask = le16_to_cpu(extp->BlkStatusRegMask);
354 extp->ProtRegAddr = le16_to_cpu(extp->ProtRegAddr);
355
356 if (extp->MinorVersion >= '0') {
357 extra_size = 0;
358
359 /* Protection Register info */
360 extra_size += (extp->NumProtectionFields - 1) *
361 sizeof(struct cfi_intelext_otpinfo);
362 }
363
364 if (extp->MinorVersion >= '1') {
365 /* Burst Read info */
366 extra_size += 2;
367 if (extp_size < sizeof(*extp) + extra_size)
368 goto need_more;
369 extra_size += extp->extra[extra_size - 1];
370 }
371
372 if (extp->MinorVersion >= '3') {
373 int nb_parts, i;
374
375 /* Number of hardware-partitions */
376 extra_size += 1;
377 if (extp_size < sizeof(*extp) + extra_size)
378 goto need_more;
379 nb_parts = extp->extra[extra_size - 1];
380
381 /* skip the sizeof(partregion) field in CFI 1.4 */
382 if (extp->MinorVersion >= '4')
383 extra_size += 2;
384
385 for (i = 0; i < nb_parts; i++) {
386 struct cfi_intelext_regioninfo *rinfo;
387 rinfo = (struct cfi_intelext_regioninfo *)&extp->extra[extra_size];
388 extra_size += sizeof(*rinfo);
389 if (extp_size < sizeof(*extp) + extra_size)
390 goto need_more;
391 rinfo->NumIdentPartitions=le16_to_cpu(rinfo->NumIdentPartitions);
392 extra_size += (rinfo->NumBlockTypes - 1)
393 * sizeof(struct cfi_intelext_blockinfo);
394 }
395
396 if (extp->MinorVersion >= '4')
397 extra_size += sizeof(struct cfi_intelext_programming_regioninfo);
398
399 if (extp_size < sizeof(*extp) + extra_size) {
400 need_more:
401 extp_size = sizeof(*extp) + extra_size;
402 kfree(extp);
403 if (extp_size > 4096) {
404 printk(KERN_ERR
405 "%s: cfi_pri_intelext is too fat\n",
406 __func__);
407 return NULL;
408 }
409 goto again;
410 }
411 }
412
413 return extp;
414 }
415
416 struct mtd_info *cfi_cmdset_0001(struct map_info *map, int primary)
417 {
418 struct cfi_private *cfi = map->fldrv_priv;
419 struct mtd_info *mtd;
420 int i;
421
422 mtd = kzalloc(sizeof(*mtd), GFP_KERNEL);
423 if (!mtd) {
424 printk(KERN_ERR "Failed to allocate memory for MTD device\n");
425 return NULL;
426 }
427 mtd->priv = map;
428 mtd->type = MTD_NORFLASH;
429
430 /* Fill in the default mtd operations */
431 mtd->erase = cfi_intelext_erase_varsize;
432 mtd->read = cfi_intelext_read;
433 mtd->write = cfi_intelext_write_words;
434 mtd->sync = cfi_intelext_sync;
435 mtd->lock = cfi_intelext_lock;
436 mtd->unlock = cfi_intelext_unlock;
437 mtd->suspend = cfi_intelext_suspend;
438 mtd->resume = cfi_intelext_resume;
439 mtd->flags = MTD_CAP_NORFLASH;
440 mtd->name = map->name;
441 mtd->writesize = 1;
442
443 mtd->reboot_notifier.notifier_call = cfi_intelext_reboot;
444
445 if (cfi->cfi_mode == CFI_MODE_CFI) {
446 /*
447 * It's a real CFI chip, not one for which the probe
448 * routine faked a CFI structure. So we read the feature
449 * table from it.
450 */
451 __u16 adr = primary?cfi->cfiq->P_ADR:cfi->cfiq->A_ADR;
452 struct cfi_pri_intelext *extp;
453
454 extp = read_pri_intelext(map, adr);
455 if (!extp) {
456 kfree(mtd);
457 return NULL;
458 }
459
460 /* Install our own private info structure */
461 cfi->cmdset_priv = extp;
462
463 cfi_fixup(mtd, cfi_fixup_table);
464
465 #ifdef DEBUG_CFI_FEATURES
466 /* Tell the user about it in lots of lovely detail */
467 cfi_tell_features(extp);
468 #endif
469
470 if(extp->SuspendCmdSupport & 1) {
471 printk(KERN_NOTICE "cfi_cmdset_0001: Erase suspend on write enabled\n");
472 }
473 }
474 else if (cfi->cfi_mode == CFI_MODE_JEDEC) {
475 /* Apply jedec specific fixups */
476 cfi_fixup(mtd, jedec_fixup_table);
477 }
478 /* Apply generic fixups */
479 cfi_fixup(mtd, fixup_table);
480
481 for (i=0; i< cfi->numchips; i++) {
482 if (cfi->cfiq->WordWriteTimeoutTyp)
483 cfi->chips[i].word_write_time =
484 1<<cfi->cfiq->WordWriteTimeoutTyp;
485 else
486 cfi->chips[i].word_write_time = 50000;
487
488 if (cfi->cfiq->BufWriteTimeoutTyp)
489 cfi->chips[i].buffer_write_time =
490 1<<cfi->cfiq->BufWriteTimeoutTyp;
491 /* No default; if it isn't specified, we won't use it */
492
493 if (cfi->cfiq->BlockEraseTimeoutTyp)
494 cfi->chips[i].erase_time =
495 1000<<cfi->cfiq->BlockEraseTimeoutTyp;
496 else
497 cfi->chips[i].erase_time = 2000000;
498
499 if (cfi->cfiq->WordWriteTimeoutTyp &&
500 cfi->cfiq->WordWriteTimeoutMax)
501 cfi->chips[i].word_write_time_max =
502 1<<(cfi->cfiq->WordWriteTimeoutTyp +
503 cfi->cfiq->WordWriteTimeoutMax);
504 else
505 cfi->chips[i].word_write_time_max = 50000 * 8;
506
507 if (cfi->cfiq->BufWriteTimeoutTyp &&
508 cfi->cfiq->BufWriteTimeoutMax)
509 cfi->chips[i].buffer_write_time_max =
510 1<<(cfi->cfiq->BufWriteTimeoutTyp +
511 cfi->cfiq->BufWriteTimeoutMax);
512
513 if (cfi->cfiq->BlockEraseTimeoutTyp &&
514 cfi->cfiq->BlockEraseTimeoutMax)
515 cfi->chips[i].erase_time_max =
516 1000<<(cfi->cfiq->BlockEraseTimeoutTyp +
517 cfi->cfiq->BlockEraseTimeoutMax);
518 else
519 cfi->chips[i].erase_time_max = 2000000 * 8;
520
521 cfi->chips[i].ref_point_counter = 0;
522 init_waitqueue_head(&(cfi->chips[i].wq));
523 }
524
525 map->fldrv = &cfi_intelext_chipdrv;
526
527 return cfi_intelext_setup(mtd);
528 }
529 struct mtd_info *cfi_cmdset_0003(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
530 struct mtd_info *cfi_cmdset_0200(struct map_info *map, int primary) __attribute__((alias("cfi_cmdset_0001")));
531 EXPORT_SYMBOL_GPL(cfi_cmdset_0001);
532 EXPORT_SYMBOL_GPL(cfi_cmdset_0003);
533 EXPORT_SYMBOL_GPL(cfi_cmdset_0200);
534
535 static struct mtd_info *cfi_intelext_setup(struct mtd_info *mtd)
536 {
537 struct map_info *map = mtd->priv;
538 struct cfi_private *cfi = map->fldrv_priv;
539 unsigned long offset = 0;
540 int i,j;
541 unsigned long devsize = (1<<cfi->cfiq->DevSize) * cfi->interleave;
542
543 //printk(KERN_DEBUG "number of CFI chips: %d\n", cfi->numchips);
544
545 mtd->size = devsize * cfi->numchips;
546
547 mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips;
548 mtd->eraseregions = kmalloc(sizeof(struct mtd_erase_region_info)
549 * mtd->numeraseregions, GFP_KERNEL);
550 if (!mtd->eraseregions) {
551 printk(KERN_ERR "Failed to allocate memory for MTD erase region info\n");
552 goto setup_err;
553 }
554
555 for (i=0; i<cfi->cfiq->NumEraseRegions; i++) {
556 unsigned long ernum, ersize;
557 ersize = ((cfi->cfiq->EraseRegionInfo[i] >> 8) & ~0xff) * cfi->interleave;
558 ernum = (cfi->cfiq->EraseRegionInfo[i] & 0xffff) + 1;
559
560 if (mtd->erasesize < ersize) {
561 mtd->erasesize = ersize;
562 }
563 for (j=0; j<cfi->numchips; j++) {
564 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].offset = (j*devsize)+offset;
565 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].erasesize = ersize;
566 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].numblocks = ernum;
567 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].lockmap = kmalloc(ernum / 8 + 1, GFP_KERNEL);
568 }
569 offset += (ersize * ernum);
570 }
571
572 if (offset != devsize) {
573 /* Argh */
574 printk(KERN_WARNING "Sum of regions (%lx) != total size of set of interleaved chips (%lx)\n", offset, devsize);
575 goto setup_err;
576 }
577
578 for (i=0; i<mtd->numeraseregions;i++){
579 printk(KERN_DEBUG "erase region %d: offset=0x%llx,size=0x%x,blocks=%d\n",
580 i,(unsigned long long)mtd->eraseregions[i].offset,
581 mtd->eraseregions[i].erasesize,
582 mtd->eraseregions[i].numblocks);
583 }
584
585 #ifdef CONFIG_MTD_OTP
586 mtd->read_fact_prot_reg = cfi_intelext_read_fact_prot_reg;
587 mtd->read_user_prot_reg = cfi_intelext_read_user_prot_reg;
588 mtd->write_user_prot_reg = cfi_intelext_write_user_prot_reg;
589 mtd->lock_user_prot_reg = cfi_intelext_lock_user_prot_reg;
590 mtd->get_fact_prot_info = cfi_intelext_get_fact_prot_info;
591 mtd->get_user_prot_info = cfi_intelext_get_user_prot_info;
592 #endif
593
594 /* This function has the potential to distort the reality
595 a bit and therefore should be called last. */
596 if (cfi_intelext_partition_fixup(mtd, &cfi) != 0)
597 goto setup_err;
598
599 __module_get(THIS_MODULE);
600 register_reboot_notifier(&mtd->reboot_notifier);
601 return mtd;
602
603 setup_err:
604 if(mtd) {
605 kfree(mtd->eraseregions);
606 kfree(mtd);
607 }
608 kfree(cfi->cmdset_priv);
609 return NULL;
610 }
611
612 static int cfi_intelext_partition_fixup(struct mtd_info *mtd,
613 struct cfi_private **pcfi)
614 {
615 struct map_info *map = mtd->priv;
616 struct cfi_private *cfi = *pcfi;
617 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
618
619 /*
620 * Probing of multi-partition flash chips.
621 *
622 * To support multiple partitions when available, we simply arrange
623 * for each of them to have their own flchip structure even if they
624 * are on the same physical chip. This means completely recreating
625 * a new cfi_private structure right here which is a blatent code
626 * layering violation, but this is still the least intrusive
627 * arrangement at this point. This can be rearranged in the future
628 * if someone feels motivated enough. --nico
629 */
630 if (extp && extp->MajorVersion == '1' && extp->MinorVersion >= '3'
631 && extp->FeatureSupport & (1 << 9)) {
632 struct cfi_private *newcfi;
633 struct flchip *chip;
634 struct flchip_shared *shared;
635 int offs, numregions, numparts, partshift, numvirtchips, i, j;
636
637 /* Protection Register info */
638 offs = (extp->NumProtectionFields - 1) *
639 sizeof(struct cfi_intelext_otpinfo);
640
641 /* Burst Read info */
642 offs += extp->extra[offs+1]+2;
643
644 /* Number of partition regions */
645 numregions = extp->extra[offs];
646 offs += 1;
647
648 /* skip the sizeof(partregion) field in CFI 1.4 */
649 if (extp->MinorVersion >= '4')
650 offs += 2;
651
652 /* Number of hardware partitions */
653 numparts = 0;
654 for (i = 0; i < numregions; i++) {
655 struct cfi_intelext_regioninfo *rinfo;
656 rinfo = (struct cfi_intelext_regioninfo *)&extp->extra[offs];
657 numparts += rinfo->NumIdentPartitions;
658 offs += sizeof(*rinfo)
659 + (rinfo->NumBlockTypes - 1) *
660 sizeof(struct cfi_intelext_blockinfo);
661 }
662
663 if (!numparts)
664 numparts = 1;
665
666 /* Programming Region info */
667 if (extp->MinorVersion >= '4') {
668 struct cfi_intelext_programming_regioninfo *prinfo;
669 prinfo = (struct cfi_intelext_programming_regioninfo *)&extp->extra[offs];
670 mtd->writesize = cfi->interleave << prinfo->ProgRegShift;
671 mtd->flags &= ~MTD_BIT_WRITEABLE;
672 printk(KERN_DEBUG "%s: program region size/ctrl_valid/ctrl_inval = %d/%d/%d\n",
673 map->name, mtd->writesize,
674 cfi->interleave * prinfo->ControlValid,
675 cfi->interleave * prinfo->ControlInvalid);
676 }
677
678 /*
679 * All functions below currently rely on all chips having
680 * the same geometry so we'll just assume that all hardware
681 * partitions are of the same size too.
682 */
683 partshift = cfi->chipshift - __ffs(numparts);
684
685 if ((1 << partshift) < mtd->erasesize) {
686 printk( KERN_ERR
687 "%s: bad number of hw partitions (%d)\n",
688 __func__, numparts);
689 return -EINVAL;
690 }
691
692 numvirtchips = cfi->numchips * numparts;
693 newcfi = kmalloc(sizeof(struct cfi_private) + numvirtchips * sizeof(struct flchip), GFP_KERNEL);
694 if (!newcfi)
695 return -ENOMEM;
696 shared = kmalloc(sizeof(struct flchip_shared) * cfi->numchips, GFP_KERNEL);
697 if (!shared) {
698 kfree(newcfi);
699 return -ENOMEM;
700 }
701 memcpy(newcfi, cfi, sizeof(struct cfi_private));
702 newcfi->numchips = numvirtchips;
703 newcfi->chipshift = partshift;
704
705 chip = &newcfi->chips[0];
706 for (i = 0; i < cfi->numchips; i++) {
707 shared[i].writing = shared[i].erasing = NULL;
708 spin_lock_init(&shared[i].lock);
709 for (j = 0; j < numparts; j++) {
710 *chip = cfi->chips[i];
711 chip->start += j << partshift;
712 chip->priv = &shared[i];
713 /* those should be reset too since
714 they create memory references. */
715 init_waitqueue_head(&chip->wq);
716 spin_lock_init(&chip->_spinlock);
717 chip->mutex = &chip->_spinlock;
718 chip++;
719 }
720 }
721
722 printk(KERN_DEBUG "%s: %d set(s) of %d interleaved chips "
723 "--> %d partitions of %d KiB\n",
724 map->name, cfi->numchips, cfi->interleave,
725 newcfi->numchips, 1<<(newcfi->chipshift-10));
726
727 map->fldrv_priv = newcfi;
728 *pcfi = newcfi;
729 kfree(cfi);
730 }
731
732 return 0;
733 }
734
735 /*
736 * *********** CHIP ACCESS FUNCTIONS ***********
737 */
738 static int chip_ready (struct map_info *map, struct flchip *chip, unsigned long adr, int mode)
739 {
740 DECLARE_WAITQUEUE(wait, current);
741 struct cfi_private *cfi = map->fldrv_priv;
742 map_word status, status_OK = CMD(0x80), status_PWS = CMD(0x01);
743 struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
744 unsigned long timeo = jiffies + HZ;
745
746 /* Prevent setting state FL_SYNCING for chip in suspended state. */
747 if (mode == FL_SYNCING && chip->oldstate != FL_READY)
748 goto sleep;
749
750 switch (chip->state) {
751
752 case FL_STATUS:
753 for (;;) {
754 status = map_read(map, adr);
755 if (map_word_andequal(map, status, status_OK, status_OK))
756 break;
757
758 /* At this point we're fine with write operations
759 in other partitions as they don't conflict. */
760 if (chip->priv && map_word_andequal(map, status, status_PWS, status_PWS))
761 break;
762
763 spin_unlock(chip->mutex);
764 cfi_udelay(1);
765 spin_lock(chip->mutex);
766 /* Someone else might have been playing with it. */
767 return -EAGAIN;
768 }
769 /* Fall through */
770 case FL_READY:
771 case FL_CFI_QUERY:
772 case FL_JEDEC_QUERY:
773 return 0;
774
775 case FL_ERASING:
776 if (!cfip ||
777 !(cfip->FeatureSupport & 2) ||
778 !(mode == FL_READY || mode == FL_POINT ||
779 (mode == FL_WRITING && (cfip->SuspendCmdSupport & 1))))
780 goto sleep;
781
782
783 /* Erase suspend */
784 map_write(map, CMD(0xB0), adr);
785
786 /* If the flash has finished erasing, then 'erase suspend'
787 * appears to make some (28F320) flash devices switch to
788 * 'read' mode. Make sure that we switch to 'read status'
789 * mode so we get the right data. --rmk
790 */
791 map_write(map, CMD(0x70), adr);
792 chip->oldstate = FL_ERASING;
793 chip->state = FL_ERASE_SUSPENDING;
794 chip->erase_suspended = 1;
795 for (;;) {
796 status = map_read(map, adr);
797 if (map_word_andequal(map, status, status_OK, status_OK))
798 break;
799
800 if (time_after(jiffies, timeo)) {
801 /* Urgh. Resume and pretend we weren't here. */
802 map_write(map, CMD(0xd0), adr);
803 /* Make sure we're in 'read status' mode if it had finished */
804 map_write(map, CMD(0x70), adr);
805 chip->state = FL_ERASING;
806 chip->oldstate = FL_READY;
807 printk(KERN_ERR "%s: Chip not ready after erase "
808 "suspended: status = 0x%lx\n", map->name, status.x[0]);
809 return -EIO;
810 }
811
812 spin_unlock(chip->mutex);
813 cfi_udelay(1);
814 spin_lock(chip->mutex);
815 /* Nobody will touch it while it's in state FL_ERASE_SUSPENDING.
816 So we can just loop here. */
817 }
818 chip->state = FL_STATUS;
819 return 0;
820
821 case FL_XIP_WHILE_ERASING:
822 if (mode != FL_READY && mode != FL_POINT &&
823 (mode != FL_WRITING || !cfip || !(cfip->SuspendCmdSupport&1)))
824 goto sleep;
825 chip->oldstate = chip->state;
826 chip->state = FL_READY;
827 return 0;
828
829 case FL_SHUTDOWN:
830 /* The machine is rebooting now,so no one can get chip anymore */
831 return -EIO;
832 case FL_POINT:
833 /* Only if there's no operation suspended... */
834 if (mode == FL_READY && chip->oldstate == FL_READY)
835 return 0;
836 /* Fall through */
837 default:
838 sleep:
839 set_current_state(TASK_UNINTERRUPTIBLE);
840 add_wait_queue(&chip->wq, &wait);
841 spin_unlock(chip->mutex);
842 schedule();
843 remove_wait_queue(&chip->wq, &wait);
844 spin_lock(chip->mutex);
845 return -EAGAIN;
846 }
847 }
848
849 static int get_chip(struct map_info *map, struct flchip *chip, unsigned long adr, int mode)
850 {
851 int ret;
852 DECLARE_WAITQUEUE(wait, current);
853
854 retry:
855 if (chip->priv &&
856 (mode == FL_WRITING || mode == FL_ERASING || mode == FL_OTP_WRITE
857 || mode == FL_SHUTDOWN) && chip->state != FL_SYNCING) {
858 /*
859 * OK. We have possibility for contention on the write/erase
860 * operations which are global to the real chip and not per
861 * partition. So let's fight it over in the partition which
862 * currently has authority on the operation.
863 *
864 * The rules are as follows:
865 *
866 * - any write operation must own shared->writing.
867 *
868 * - any erase operation must own _both_ shared->writing and
869 * shared->erasing.
870 *
871 * - contention arbitration is handled in the owner's context.
872 *
873 * The 'shared' struct can be read and/or written only when
874 * its lock is taken.
875 */
876 struct flchip_shared *shared = chip->priv;
877 struct flchip *contender;
878 spin_lock(&shared->lock);
879 contender = shared->writing;
880 if (contender && contender != chip) {
881 /*
882 * The engine to perform desired operation on this
883 * partition is already in use by someone else.
884 * Let's fight over it in the context of the chip
885 * currently using it. If it is possible to suspend,
886 * that other partition will do just that, otherwise
887 * it'll happily send us to sleep. In any case, when
888 * get_chip returns success we're clear to go ahead.
889 */
890 ret = spin_trylock(contender->mutex);
891 spin_unlock(&shared->lock);
892 if (!ret)
893 goto retry;
894 spin_unlock(chip->mutex);
895 ret = chip_ready(map, contender, contender->start, mode);
896 spin_lock(chip->mutex);
897
898 if (ret == -EAGAIN) {
899 spin_unlock(contender->mutex);
900 goto retry;
901 }
902 if (ret) {
903 spin_unlock(contender->mutex);
904 return ret;
905 }
906 spin_lock(&shared->lock);
907
908 /* We should not own chip if it is already
909 * in FL_SYNCING state. Put contender and retry. */
910 if (chip->state == FL_SYNCING) {
911 put_chip(map, contender, contender->start);
912 spin_unlock(contender->mutex);
913 goto retry;
914 }
915 spin_unlock(contender->mutex);
916 }
917
918 /* Check if we already have suspended erase
919 * on this chip. Sleep. */
920 if (mode == FL_ERASING && shared->erasing
921 && shared->erasing->oldstate == FL_ERASING) {
922 spin_unlock(&shared->lock);
923 set_current_state(TASK_UNINTERRUPTIBLE);
924 add_wait_queue(&chip->wq, &wait);
925 spin_unlock(chip->mutex);
926 schedule();
927 remove_wait_queue(&chip->wq, &wait);
928 spin_lock(chip->mutex);
929 goto retry;
930 }
931
932 /* We now own it */
933 shared->writing = chip;
934 if (mode == FL_ERASING)
935 shared->erasing = chip;
936 spin_unlock(&shared->lock);
937 }
938 ret = chip_ready(map, chip, adr, mode);
939 if (ret == -EAGAIN)
940 goto retry;
941
942 return ret;
943 }
944
945 static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr)
946 {
947 struct cfi_private *cfi = map->fldrv_priv;
948
949 if (chip->priv) {
950 struct flchip_shared *shared = chip->priv;
951 spin_lock(&shared->lock);
952 if (shared->writing == chip && chip->oldstate == FL_READY) {
953 /* We own the ability to write, but we're done */
954 shared->writing = shared->erasing;
955 if (shared->writing && shared->writing != chip) {
956 /* give back ownership to who we loaned it from */
957 struct flchip *loaner = shared->writing;
958 spin_lock(loaner->mutex);
959 spin_unlock(&shared->lock);
960 spin_unlock(chip->mutex);
961 put_chip(map, loaner, loaner->start);
962 spin_lock(chip->mutex);
963 spin_unlock(loaner->mutex);
964 wake_up(&chip->wq);
965 return;
966 }
967 shared->erasing = NULL;
968 shared->writing = NULL;
969 } else if (shared->erasing == chip && shared->writing != chip) {
970 /*
971 * We own the ability to erase without the ability
972 * to write, which means the erase was suspended
973 * and some other partition is currently writing.
974 * Don't let the switch below mess things up since
975 * we don't have ownership to resume anything.
976 */
977 spin_unlock(&shared->lock);
978 wake_up(&chip->wq);
979 return;
980 }
981 spin_unlock(&shared->lock);
982 }
983
984 switch(chip->oldstate) {
985 case FL_ERASING:
986 chip->state = chip->oldstate;
987 /* What if one interleaved chip has finished and the
988 other hasn't? The old code would leave the finished
989 one in READY mode. That's bad, and caused -EROFS
990 errors to be returned from do_erase_oneblock because
991 that's the only bit it checked for at the time.
992 As the state machine appears to explicitly allow
993 sending the 0x70 (Read Status) command to an erasing
994 chip and expecting it to be ignored, that's what we
995 do. */
996 map_write(map, CMD(0xd0), adr);
997 map_write(map, CMD(0x70), adr);
998 chip->oldstate = FL_READY;
999 chip->state = FL_ERASING;
1000 break;
1001
1002 case FL_XIP_WHILE_ERASING:
1003 chip->state = chip->oldstate;
1004 chip->oldstate = FL_READY;
1005 break;
1006
1007 case FL_READY:
1008 case FL_STATUS:
1009 case FL_JEDEC_QUERY:
1010 /* We should really make set_vpp() count, rather than doing this */
1011 DISABLE_VPP(map);
1012 break;
1013 default:
1014 printk(KERN_ERR "%s: put_chip() called with oldstate %d!!\n", map->name, chip->oldstate);
1015 }
1016 wake_up(&chip->wq);
1017 }
1018
1019 #ifdef CONFIG_MTD_XIP
1020
1021 /*
1022 * No interrupt what so ever can be serviced while the flash isn't in array
1023 * mode. This is ensured by the xip_disable() and xip_enable() functions
1024 * enclosing any code path where the flash is known not to be in array mode.
1025 * And within a XIP disabled code path, only functions marked with __xipram
1026 * may be called and nothing else (it's a good thing to inspect generated
1027 * assembly to make sure inline functions were actually inlined and that gcc
1028 * didn't emit calls to its own support functions). Also configuring MTD CFI
1029 * support to a single buswidth and a single interleave is also recommended.
1030 */
1031
1032 static void xip_disable(struct map_info *map, struct flchip *chip,
1033 unsigned long adr)
1034 {
1035 /* TODO: chips with no XIP use should ignore and return */
1036 (void) map_read(map, adr); /* ensure mmu mapping is up to date */
1037 local_irq_disable();
1038 }
1039
1040 static void __xipram xip_enable(struct map_info *map, struct flchip *chip,
1041 unsigned long adr)
1042 {
1043 struct cfi_private *cfi = map->fldrv_priv;
1044 if (chip->state != FL_POINT && chip->state != FL_READY) {
1045 map_write(map, CMD(0xff), adr);
1046 chip->state = FL_READY;
1047 }
1048 (void) map_read(map, adr);
1049 xip_iprefetch();
1050 local_irq_enable();
1051 }
1052
1053 /*
1054 * When a delay is required for the flash operation to complete, the
1055 * xip_wait_for_operation() function is polling for both the given timeout
1056 * and pending (but still masked) hardware interrupts. Whenever there is an
1057 * interrupt pending then the flash erase or write operation is suspended,
1058 * array mode restored and interrupts unmasked. Task scheduling might also
1059 * happen at that point. The CPU eventually returns from the interrupt or
1060 * the call to schedule() and the suspended flash operation is resumed for
1061 * the remaining of the delay period.
1062 *
1063 * Warning: this function _will_ fool interrupt latency tracing tools.
1064 */
1065
1066 static int __xipram xip_wait_for_operation(
1067 struct map_info *map, struct flchip *chip,
1068 unsigned long adr, unsigned int chip_op_time_max)
1069 {
1070 struct cfi_private *cfi = map->fldrv_priv;
1071 struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
1072 map_word status, OK = CMD(0x80);
1073 unsigned long usec, suspended, start, done;
1074 flstate_t oldstate, newstate;
1075
1076 start = xip_currtime();
1077 usec = chip_op_time_max;
1078 if (usec == 0)
1079 usec = 500000;
1080 done = 0;
1081
1082 do {
1083 cpu_relax();
1084 if (xip_irqpending() && cfip &&
1085 ((chip->state == FL_ERASING && (cfip->FeatureSupport&2)) ||
1086 (chip->state == FL_WRITING && (cfip->FeatureSupport&4))) &&
1087 (cfi_interleave_is_1(cfi) || chip->oldstate == FL_READY)) {
1088 /*
1089 * Let's suspend the erase or write operation when
1090 * supported. Note that we currently don't try to
1091 * suspend interleaved chips if there is already
1092 * another operation suspended (imagine what happens
1093 * when one chip was already done with the current
1094 * operation while another chip suspended it, then
1095 * we resume the whole thing at once). Yes, it
1096 * can happen!
1097 */
1098 usec -= done;
1099 map_write(map, CMD(0xb0), adr);
1100 map_write(map, CMD(0x70), adr);
1101 suspended = xip_currtime();
1102 do {
1103 if (xip_elapsed_since(suspended) > 100000) {
1104 /*
1105 * The chip doesn't want to suspend
1106 * after waiting for 100 msecs.
1107 * This is a critical error but there
1108 * is not much we can do here.
1109 */
1110 return -EIO;
1111 }
1112 status = map_read(map, adr);
1113 } while (!map_word_andequal(map, status, OK, OK));
1114
1115 /* Suspend succeeded */
1116 oldstate = chip->state;
1117 if (oldstate == FL_ERASING) {
1118 if (!map_word_bitsset(map, status, CMD(0x40)))
1119 break;
1120 newstate = FL_XIP_WHILE_ERASING;
1121 chip->erase_suspended = 1;
1122 } else {
1123 if (!map_word_bitsset(map, status, CMD(0x04)))
1124 break;
1125 newstate = FL_XIP_WHILE_WRITING;
1126 chip->write_suspended = 1;
1127 }
1128 chip->state = newstate;
1129 map_write(map, CMD(0xff), adr);
1130 (void) map_read(map, adr);
1131 xip_iprefetch();
1132 local_irq_enable();
1133 spin_unlock(chip->mutex);
1134 xip_iprefetch();
1135 cond_resched();
1136
1137 /*
1138 * We're back. However someone else might have
1139 * decided to go write to the chip if we are in
1140 * a suspended erase state. If so let's wait
1141 * until it's done.
1142 */
1143 spin_lock(chip->mutex);
1144 while (chip->state != newstate) {
1145 DECLARE_WAITQUEUE(wait, current);
1146 set_current_state(TASK_UNINTERRUPTIBLE);
1147 add_wait_queue(&chip->wq, &wait);
1148 spin_unlock(chip->mutex);
1149 schedule();
1150 remove_wait_queue(&chip->wq, &wait);
1151 spin_lock(chip->mutex);
1152 }
1153 /* Disallow XIP again */
1154 local_irq_disable();
1155
1156 /* Resume the write or erase operation */
1157 map_write(map, CMD(0xd0), adr);
1158 map_write(map, CMD(0x70), adr);
1159 chip->state = oldstate;
1160 start = xip_currtime();
1161 } else if (usec >= 1000000/HZ) {
1162 /*
1163 * Try to save on CPU power when waiting delay
1164 * is at least a system timer tick period.
1165 * No need to be extremely accurate here.
1166 */
1167 xip_cpu_idle();
1168 }
1169 status = map_read(map, adr);
1170 done = xip_elapsed_since(start);
1171 } while (!map_word_andequal(map, status, OK, OK)
1172 && done < usec);
1173
1174 return (done >= usec) ? -ETIME : 0;
1175 }
1176
1177 /*
1178 * The INVALIDATE_CACHED_RANGE() macro is normally used in parallel while
1179 * the flash is actively programming or erasing since we have to poll for
1180 * the operation to complete anyway. We can't do that in a generic way with
1181 * a XIP setup so do it before the actual flash operation in this case
1182 * and stub it out from INVAL_CACHE_AND_WAIT.
1183 */
1184 #define XIP_INVAL_CACHED_RANGE(map, from, size) \
1185 INVALIDATE_CACHED_RANGE(map, from, size)
1186
1187 #define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec, usec_max) \
1188 xip_wait_for_operation(map, chip, cmd_adr, usec_max)
1189
1190 #else
1191
1192 #define xip_disable(map, chip, adr)
1193 #define xip_enable(map, chip, adr)
1194 #define XIP_INVAL_CACHED_RANGE(x...)
1195 #define INVAL_CACHE_AND_WAIT inval_cache_and_wait_for_operation
1196
1197 static int inval_cache_and_wait_for_operation(
1198 struct map_info *map, struct flchip *chip,
1199 unsigned long cmd_adr, unsigned long inval_adr, int inval_len,
1200 unsigned int chip_op_time, unsigned int chip_op_time_max)
1201 {
1202 struct cfi_private *cfi = map->fldrv_priv;
1203 map_word status, status_OK = CMD(0x80);
1204 int chip_state = chip->state;
1205 unsigned int timeo, sleep_time, reset_timeo;
1206
1207 spin_unlock(chip->mutex);
1208 if (inval_len)
1209 INVALIDATE_CACHED_RANGE(map, inval_adr, inval_len);
1210 spin_lock(chip->mutex);
1211
1212 timeo = chip_op_time_max;
1213 if (!timeo)
1214 timeo = 500000;
1215 reset_timeo = timeo;
1216 sleep_time = chip_op_time / 2;
1217
1218 for (;;) {
1219 status = map_read(map, cmd_adr);
1220 if (map_word_andequal(map, status, status_OK, status_OK))
1221 break;
1222
1223 if (!timeo) {
1224 map_write(map, CMD(0x70), cmd_adr);
1225 chip->state = FL_STATUS;
1226 return -ETIME;
1227 }
1228
1229 /* OK Still waiting. Drop the lock, wait a while and retry. */
1230 spin_unlock(chip->mutex);
1231 if (sleep_time >= 1000000/HZ) {
1232 /*
1233 * Half of the normal delay still remaining
1234 * can be performed with a sleeping delay instead
1235 * of busy waiting.
1236 */
1237 msleep(sleep_time/1000);
1238 timeo -= sleep_time;
1239 sleep_time = 1000000/HZ;
1240 } else {
1241 udelay(1);
1242 cond_resched();
1243 timeo--;
1244 }
1245 spin_lock(chip->mutex);
1246
1247 while (chip->state != chip_state) {
1248 /* Someone's suspended the operation: sleep */
1249 DECLARE_WAITQUEUE(wait, current);
1250 set_current_state(TASK_UNINTERRUPTIBLE);
1251 add_wait_queue(&chip->wq, &wait);
1252 spin_unlock(chip->mutex);
1253 schedule();
1254 remove_wait_queue(&chip->wq, &wait);
1255 spin_lock(chip->mutex);
1256 }
1257 if (chip->erase_suspended && chip_state == FL_ERASING) {
1258 /* Erase suspend occured while sleep: reset timeout */
1259 timeo = reset_timeo;
1260 chip->erase_suspended = 0;
1261 }
1262 if (chip->write_suspended && chip_state == FL_WRITING) {
1263 /* Write suspend occured while sleep: reset timeout */
1264 timeo = reset_timeo;
1265 chip->write_suspended = 0;
1266 }
1267 }
1268
1269 /* Done and happy. */
1270 chip->state = FL_STATUS;
1271 return 0;
1272 }
1273
1274 #endif
1275
1276 #define WAIT_TIMEOUT(map, chip, adr, udelay, udelay_max) \
1277 INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay, udelay_max);
1278
1279
1280 static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t adr, size_t len)
1281 {
1282 unsigned long cmd_addr;
1283 struct cfi_private *cfi = map->fldrv_priv;
1284 int ret = 0;
1285
1286 adr += chip->start;
1287
1288 /* Ensure cmd read/writes are aligned. */
1289 cmd_addr = adr & ~(map_bankwidth(map)-1);
1290
1291 spin_lock(chip->mutex);
1292
1293 ret = get_chip(map, chip, cmd_addr, FL_POINT);
1294
1295 if (!ret) {
1296 if (chip->state != FL_POINT && chip->state != FL_READY)
1297 map_write(map, CMD(0xff), cmd_addr);
1298
1299 chip->state = FL_POINT;
1300 chip->ref_point_counter++;
1301 }
1302 spin_unlock(chip->mutex);
1303
1304 return ret;
1305 }
1306
1307 static int cfi_intelext_point(struct mtd_info *mtd, loff_t from, size_t len,
1308 size_t *retlen, void **virt, resource_size_t *phys)
1309 {
1310 struct map_info *map = mtd->priv;
1311 struct cfi_private *cfi = map->fldrv_priv;
1312 unsigned long ofs, last_end = 0;
1313 int chipnum;
1314 int ret = 0;
1315
1316 if (!map->virt || (from + len > mtd->size))
1317 return -EINVAL;
1318
1319 /* Now lock the chip(s) to POINT state */
1320
1321 /* ofs: offset within the first chip that the first read should start */
1322 chipnum = (from >> cfi->chipshift);
1323 ofs = from - (chipnum << cfi->chipshift);
1324
1325 *virt = map->virt + cfi->chips[chipnum].start + ofs;
1326 *retlen = 0;
1327 if (phys)
1328 *phys = map->phys + cfi->chips[chipnum].start + ofs;
1329
1330 while (len) {
1331 unsigned long thislen;
1332
1333 if (chipnum >= cfi->numchips)
1334 break;
1335
1336 /* We cannot point across chips that are virtually disjoint */
1337 if (!last_end)
1338 last_end = cfi->chips[chipnum].start;
1339 else if (cfi->chips[chipnum].start != last_end)
1340 break;
1341
1342 if ((len + ofs -1) >> cfi->chipshift)
1343 thislen = (1<<cfi->chipshift) - ofs;
1344 else
1345 thislen = len;
1346
1347 ret = do_point_onechip(map, &cfi->chips[chipnum], ofs, thislen);
1348 if (ret)
1349 break;
1350
1351 *retlen += thislen;
1352 len -= thislen;
1353
1354 ofs = 0;
1355 last_end += 1 << cfi->chipshift;
1356 chipnum++;
1357 }
1358 return 0;
1359 }
1360
1361 static void cfi_intelext_unpoint(struct mtd_info *mtd, loff_t from, size_t len)
1362 {
1363 struct map_info *map = mtd->priv;
1364 struct cfi_private *cfi = map->fldrv_priv;
1365 unsigned long ofs;
1366 int chipnum;
1367
1368 /* Now unlock the chip(s) POINT state */
1369
1370 /* ofs: offset within the first chip that the first read should start */
1371 chipnum = (from >> cfi->chipshift);
1372 ofs = from - (chipnum << cfi->chipshift);
1373
1374 while (len) {
1375 unsigned long thislen;
1376 struct flchip *chip;
1377
1378 chip = &cfi->chips[chipnum];
1379 if (chipnum >= cfi->numchips)
1380 break;
1381
1382 if ((len + ofs -1) >> cfi->chipshift)
1383 thislen = (1<<cfi->chipshift) - ofs;
1384 else
1385 thislen = len;
1386
1387 spin_lock(chip->mutex);
1388 if (chip->state == FL_POINT) {
1389 chip->ref_point_counter--;
1390 if(chip->ref_point_counter == 0)
1391 chip->state = FL_READY;
1392 } else
1393 printk(KERN_ERR "%s: Warning: unpoint called on non pointed region\n", map->name); /* Should this give an error? */
1394
1395 put_chip(map, chip, chip->start);
1396 spin_unlock(chip->mutex);
1397
1398 len -= thislen;
1399 ofs = 0;
1400 chipnum++;
1401 }
1402 }
1403
1404 static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf)
1405 {
1406 unsigned long cmd_addr;
1407 struct cfi_private *cfi = map->fldrv_priv;
1408 int ret;
1409
1410 adr += chip->start;
1411
1412 /* Ensure cmd read/writes are aligned. */
1413 cmd_addr = adr & ~(map_bankwidth(map)-1);
1414
1415 spin_lock(chip->mutex);
1416 ret = get_chip(map, chip, cmd_addr, FL_READY);
1417 if (ret) {
1418 spin_unlock(chip->mutex);
1419 return ret;
1420 }
1421
1422 if (chip->state != FL_POINT && chip->state != FL_READY) {
1423 map_write(map, CMD(0xff), cmd_addr);
1424
1425 chip->state = FL_READY;
1426 }
1427
1428 map_copy_from(map, buf, adr, len);
1429
1430 put_chip(map, chip, cmd_addr);
1431
1432 spin_unlock(chip->mutex);
1433 return 0;
1434 }
1435
1436 static int cfi_intelext_read (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
1437 {
1438 struct map_info *map = mtd->priv;
1439 struct cfi_private *cfi = map->fldrv_priv;
1440 unsigned long ofs;
1441 int chipnum;
1442 int ret = 0;
1443
1444 /* ofs: offset within the first chip that the first read should start */
1445 chipnum = (from >> cfi->chipshift);
1446 ofs = from - (chipnum << cfi->chipshift);
1447
1448 *retlen = 0;
1449
1450 while (len) {
1451 unsigned long thislen;
1452
1453 if (chipnum >= cfi->numchips)
1454 break;
1455
1456 if ((len + ofs -1) >> cfi->chipshift)
1457 thislen = (1<<cfi->chipshift) - ofs;
1458 else
1459 thislen = len;
1460
1461 ret = do_read_onechip(map, &cfi->chips[chipnum], ofs, thislen, buf);
1462 if (ret)
1463 break;
1464
1465 *retlen += thislen;
1466 len -= thislen;
1467 buf += thislen;
1468
1469 ofs = 0;
1470 chipnum++;
1471 }
1472 return ret;
1473 }
1474
1475 static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
1476 unsigned long adr, map_word datum, int mode)
1477 {
1478 struct cfi_private *cfi = map->fldrv_priv;
1479 map_word status, write_cmd;
1480 int ret=0;
1481
1482 adr += chip->start;
1483
1484 switch (mode) {
1485 case FL_WRITING:
1486 write_cmd = (cfi->cfiq->P_ID != 0x0200) ? CMD(0x40) : CMD(0x41);
1487 break;
1488 case FL_OTP_WRITE:
1489 write_cmd = CMD(0xc0);
1490 break;
1491 default:
1492 return -EINVAL;
1493 }
1494
1495 spin_lock(chip->mutex);
1496 ret = get_chip(map, chip, adr, mode);
1497 if (ret) {
1498 spin_unlock(chip->mutex);
1499 return ret;
1500 }
1501
1502 XIP_INVAL_CACHED_RANGE(map, adr, map_bankwidth(map));
1503 ENABLE_VPP(map);
1504 xip_disable(map, chip, adr);
1505 map_write(map, write_cmd, adr);
1506 map_write(map, datum, adr);
1507 chip->state = mode;
1508
1509 ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
1510 adr, map_bankwidth(map),
1511 chip->word_write_time,
1512 chip->word_write_time_max);
1513 if (ret) {
1514 xip_enable(map, chip, adr);
1515 printk(KERN_ERR "%s: word write error (status timeout)\n", map->name);
1516 goto out;
1517 }
1518
1519 /* check for errors */
1520 status = map_read(map, adr);
1521 if (map_word_bitsset(map, status, CMD(0x1a))) {
1522 unsigned long chipstatus = MERGESTATUS(status);
1523
1524 /* reset status */
1525 map_write(map, CMD(0x50), adr);
1526 map_write(map, CMD(0x70), adr);
1527 xip_enable(map, chip, adr);
1528
1529 if (chipstatus & 0x02) {
1530 ret = -EROFS;
1531 } else if (chipstatus & 0x08) {
1532 printk(KERN_ERR "%s: word write error (bad VPP)\n", map->name);
1533 ret = -EIO;
1534 } else {
1535 printk(KERN_ERR "%s: word write error (status 0x%lx)\n", map->name, chipstatus);
1536 ret = -EINVAL;
1537 }
1538
1539 goto out;
1540 }
1541
1542 xip_enable(map, chip, adr);
1543 out: put_chip(map, chip, adr);
1544 spin_unlock(chip->mutex);
1545 return ret;
1546 }
1547
1548
1549 static int cfi_intelext_write_words (struct mtd_info *mtd, loff_t to , size_t len, size_t *retlen, const u_char *buf)
1550 {
1551 struct map_info *map = mtd->priv;
1552 struct cfi_private *cfi = map->fldrv_priv;
1553 int ret = 0;
1554 int chipnum;
1555 unsigned long ofs;
1556
1557 *retlen = 0;
1558 if (!len)
1559 return 0;
1560
1561 chipnum = to >> cfi->chipshift;
1562 ofs = to - (chipnum << cfi->chipshift);
1563
1564 /* If it's not bus-aligned, do the first byte write */
1565 if (ofs & (map_bankwidth(map)-1)) {
1566 unsigned long bus_ofs = ofs & ~(map_bankwidth(map)-1);
1567 int gap = ofs - bus_ofs;
1568 int n;
1569 map_word datum;
1570
1571 n = min_t(int, len, map_bankwidth(map)-gap);
1572 datum = map_word_ff(map);
1573 datum = map_word_load_partial(map, datum, buf, gap, n);
1574
1575 ret = do_write_oneword(map, &cfi->chips[chipnum],
1576 bus_ofs, datum, FL_WRITING);
1577 if (ret)
1578 return ret;
1579
1580 len -= n;
1581 ofs += n;
1582 buf += n;
1583 (*retlen) += n;
1584
1585 if (ofs >> cfi->chipshift) {
1586 chipnum ++;
1587 ofs = 0;
1588 if (chipnum == cfi->numchips)
1589 return 0;
1590 }
1591 }
1592
1593 while(len >= map_bankwidth(map)) {
1594 map_word datum = map_word_load(map, buf);
1595
1596 ret = do_write_oneword(map, &cfi->chips[chipnum],
1597 ofs, datum, FL_WRITING);
1598 if (ret)
1599 return ret;
1600
1601 ofs += map_bankwidth(map);
1602 buf += map_bankwidth(map);
1603 (*retlen) += map_bankwidth(map);
1604 len -= map_bankwidth(map);
1605
1606 if (ofs >> cfi->chipshift) {
1607 chipnum ++;
1608 ofs = 0;
1609 if (chipnum == cfi->numchips)
1610 return 0;
1611 }
1612 }
1613
1614 if (len & (map_bankwidth(map)-1)) {
1615 map_word datum;
1616
1617 datum = map_word_ff(map);
1618 datum = map_word_load_partial(map, datum, buf, 0, len);
1619
1620 ret = do_write_oneword(map, &cfi->chips[chipnum],
1621 ofs, datum, FL_WRITING);
1622 if (ret)
1623 return ret;
1624
1625 (*retlen) += len;
1626 }
1627
1628 return 0;
1629 }
1630
1631
1632 static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
1633 unsigned long adr, const struct kvec **pvec,
1634 unsigned long *pvec_seek, int len)
1635 {
1636 struct cfi_private *cfi = map->fldrv_priv;
1637 map_word status, write_cmd, datum;
1638 unsigned long cmd_adr;
1639 int ret, wbufsize, word_gap, words;
1640 const struct kvec *vec;
1641 unsigned long vec_seek;
1642 unsigned long initial_adr;
1643 int initial_len = len;
1644
1645 wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1646 adr += chip->start;
1647 initial_adr = adr;
1648 cmd_adr = adr & ~(wbufsize-1);
1649
1650 /* Let's determine this according to the interleave only once */
1651 write_cmd = (cfi->cfiq->P_ID != 0x0200) ? CMD(0xe8) : CMD(0xe9);
1652
1653 spin_lock(chip->mutex);
1654 ret = get_chip(map, chip, cmd_adr, FL_WRITING);
1655 if (ret) {
1656 spin_unlock(chip->mutex);
1657 return ret;
1658 }
1659
1660 XIP_INVAL_CACHED_RANGE(map, initial_adr, initial_len);
1661 ENABLE_VPP(map);
1662 xip_disable(map, chip, cmd_adr);
1663
1664 /* §4.8 of the 28FxxxJ3A datasheet says "Any time SR.4 and/or SR.5 is set
1665 [...], the device will not accept any more Write to Buffer commands".
1666 So we must check here and reset those bits if they're set. Otherwise
1667 we're just pissing in the wind */
1668 if (chip->state != FL_STATUS) {
1669 map_write(map, CMD(0x70), cmd_adr);
1670 chip->state = FL_STATUS;
1671 }
1672 status = map_read(map, cmd_adr);
1673 if (map_word_bitsset(map, status, CMD(0x30))) {
1674 xip_enable(map, chip, cmd_adr);
1675 printk(KERN_WARNING "SR.4 or SR.5 bits set in buffer write (status %lx). Clearing.\n", status.x[0]);
1676 xip_disable(map, chip, cmd_adr);
1677 map_write(map, CMD(0x50), cmd_adr);
1678 map_write(map, CMD(0x70), cmd_adr);
1679 }
1680
1681 chip->state = FL_WRITING_TO_BUFFER;
1682 map_write(map, write_cmd, cmd_adr);
1683 ret = WAIT_TIMEOUT(map, chip, cmd_adr, 0, 0);
1684 if (ret) {
1685 /* Argh. Not ready for write to buffer */
1686 map_word Xstatus = map_read(map, cmd_adr);
1687 map_write(map, CMD(0x70), cmd_adr);
1688 chip->state = FL_STATUS;
1689 status = map_read(map, cmd_adr);
1690 map_write(map, CMD(0x50), cmd_adr);
1691 map_write(map, CMD(0x70), cmd_adr);
1692 xip_enable(map, chip, cmd_adr);
1693 printk(KERN_ERR "%s: Chip not ready for buffer write. Xstatus = %lx, status = %lx\n",
1694 map->name, Xstatus.x[0], status.x[0]);
1695 goto out;
1696 }
1697
1698 /* Figure out the number of words to write */
1699 word_gap = (-adr & (map_bankwidth(map)-1));
1700 words = DIV_ROUND_UP(len - word_gap, map_bankwidth(map));
1701 if (!word_gap) {
1702 words--;
1703 } else {
1704 word_gap = map_bankwidth(map) - word_gap;
1705 adr -= word_gap;
1706 datum = map_word_ff(map);
1707 }
1708
1709 /* Write length of data to come */
1710 map_write(map, CMD(words), cmd_adr );
1711
1712 /* Write data */
1713 vec = *pvec;
1714 vec_seek = *pvec_seek;
1715 do {
1716 int n = map_bankwidth(map) - word_gap;
1717 if (n > vec->iov_len - vec_seek)
1718 n = vec->iov_len - vec_seek;
1719 if (n > len)
1720 n = len;
1721
1722 if (!word_gap && len < map_bankwidth(map))
1723 datum = map_word_ff(map);
1724
1725 datum = map_word_load_partial(map, datum,
1726 vec->iov_base + vec_seek,
1727 word_gap, n);
1728
1729 len -= n;
1730 word_gap += n;
1731 if (!len || word_gap == map_bankwidth(map)) {
1732 map_write(map, datum, adr);
1733 adr += map_bankwidth(map);
1734 word_gap = 0;
1735 }
1736
1737 vec_seek += n;
1738 if (vec_seek == vec->iov_len) {
1739 vec++;
1740 vec_seek = 0;
1741 }
1742 } while (len);
1743 *pvec = vec;
1744 *pvec_seek = vec_seek;
1745
1746 /* GO GO GO */
1747 map_write(map, CMD(0xd0), cmd_adr);
1748 chip->state = FL_WRITING;
1749
1750 ret = INVAL_CACHE_AND_WAIT(map, chip, cmd_adr,
1751 initial_adr, initial_len,
1752 chip->buffer_write_time,
1753 chip->buffer_write_time_max);
1754 if (ret) {
1755 map_write(map, CMD(0x70), cmd_adr);
1756 chip->state = FL_STATUS;
1757 xip_enable(map, chip, cmd_adr);
1758 printk(KERN_ERR "%s: buffer write error (status timeout)\n", map->name);
1759 goto out;
1760 }
1761
1762 /* check for errors */
1763 status = map_read(map, cmd_adr);
1764 if (map_word_bitsset(map, status, CMD(0x1a))) {
1765 unsigned long chipstatus = MERGESTATUS(status);
1766
1767 /* reset status */
1768 map_write(map, CMD(0x50), cmd_adr);
1769 map_write(map, CMD(0x70), cmd_adr);
1770 xip_enable(map, chip, cmd_adr);
1771
1772 if (chipstatus & 0x02) {
1773 ret = -EROFS;
1774 } else if (chipstatus & 0x08) {
1775 printk(KERN_ERR "%s: buffer write error (bad VPP)\n", map->name);
1776 ret = -EIO;
1777 } else {
1778 printk(KERN_ERR "%s: buffer write error (status 0x%lx)\n", map->name, chipstatus);
1779 ret = -EINVAL;
1780 }
1781
1782 goto out;
1783 }
1784
1785 xip_enable(map, chip, cmd_adr);
1786 out: put_chip(map, chip, cmd_adr);
1787 spin_unlock(chip->mutex);
1788 return ret;
1789 }
1790
1791 static int cfi_intelext_writev (struct mtd_info *mtd, const struct kvec *vecs,
1792 unsigned long count, loff_t to, size_t *retlen)
1793 {
1794 struct map_info *map = mtd->priv;
1795 struct cfi_private *cfi = map->fldrv_priv;
1796 int wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1797 int ret = 0;
1798 int chipnum;
1799 unsigned long ofs, vec_seek, i;
1800 size_t len = 0;
1801
1802 for (i = 0; i < count; i++)
1803 len += vecs[i].iov_len;
1804
1805 *retlen = 0;
1806 if (!len)
1807 return 0;
1808
1809 chipnum = to >> cfi->chipshift;
1810 ofs = to - (chipnum << cfi->chipshift);
1811 vec_seek = 0;
1812
1813 do {
1814 /* We must not cross write block boundaries */
1815 int size = wbufsize - (ofs & (wbufsize-1));
1816
1817 if (size > len)
1818 size = len;
1819 ret = do_write_buffer(map, &cfi->chips[chipnum],
1820 ofs, &vecs, &vec_seek, size);
1821 if (ret)
1822 return ret;
1823
1824 ofs += size;
1825 (*retlen) += size;
1826 len -= size;
1827
1828 if (ofs >> cfi->chipshift) {
1829 chipnum ++;
1830 ofs = 0;
1831 if (chipnum == cfi->numchips)
1832 return 0;
1833 }
1834
1835 /* Be nice and reschedule with the chip in a usable state for other
1836 processes. */
1837 cond_resched();
1838
1839 } while (len);
1840
1841 return 0;
1842 }
1843
1844 static int cfi_intelext_write_buffers (struct mtd_info *mtd, loff_t to,
1845 size_t len, size_t *retlen, const u_char *buf)
1846 {
1847 struct kvec vec;
1848
1849 vec.iov_base = (void *) buf;
1850 vec.iov_len = len;
1851
1852 return cfi_intelext_writev(mtd, &vec, 1, to, retlen);
1853 }
1854
1855 static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
1856 unsigned long adr, int len, void *thunk)
1857 {
1858 struct cfi_private *cfi = map->fldrv_priv;
1859 map_word status;
1860 int retries = 3;
1861 int ret;
1862
1863 adr += chip->start;
1864
1865 retry:
1866 spin_lock(chip->mutex);
1867 ret = get_chip(map, chip, adr, FL_ERASING);
1868 if (ret) {
1869 spin_unlock(chip->mutex);
1870 return ret;
1871 }
1872
1873 XIP_INVAL_CACHED_RANGE(map, adr, len);
1874 ENABLE_VPP(map);
1875 xip_disable(map, chip, adr);
1876
1877 /* Clear the status register first */
1878 map_write(map, CMD(0x50), adr);
1879
1880 /* Now erase */
1881 map_write(map, CMD(0x20), adr);
1882 map_write(map, CMD(0xD0), adr);
1883 chip->state = FL_ERASING;
1884 chip->erase_suspended = 0;
1885
1886 ret = INVAL_CACHE_AND_WAIT(map, chip, adr,
1887 adr, len,
1888 chip->erase_time,
1889 chip->erase_time_max);
1890 if (ret) {
1891 map_write(map, CMD(0x70), adr);
1892 chip->state = FL_STATUS;
1893 xip_enable(map, chip, adr);
1894 printk(KERN_ERR "%s: block erase error: (status timeout)\n", map->name);
1895 goto out;
1896 }
1897
1898 /* We've broken this before. It doesn't hurt to be safe */
1899 map_write(map, CMD(0x70), adr);
1900 chip->state = FL_STATUS;
1901 status = map_read(map, adr);
1902
1903 /* check for errors */
1904 if (map_word_bitsset(map, status, CMD(0x3a))) {
1905 unsigned long chipstatus = MERGESTATUS(status);
1906
1907 /* Reset the error bits */
1908 map_write(map, CMD(0x50), adr);
1909 map_write(map, CMD(0x70), adr);
1910 xip_enable(map, chip, adr);
1911
1912 if ((chipstatus & 0x30) == 0x30) {
1913 printk(KERN_ERR "%s: block erase error: (bad command sequence, status 0x%lx)\n", map->name, chipstatus);
1914 ret = -EINVAL;
1915 } else if (chipstatus & 0x02) {
1916 /* Protection bit set */
1917 ret = -EROFS;
1918 } else if (chipstatus & 0x8) {
1919 /* Voltage */
1920 printk(KERN_ERR "%s: block erase error: (bad VPP)\n", map->name);
1921 ret = -EIO;
1922 } else if (chipstatus & 0x20 && retries--) {
1923 printk(KERN_DEBUG "block erase failed at 0x%08lx: status 0x%lx. Retrying...\n", adr, chipstatus);
1924 put_chip(map, chip, adr);
1925 spin_unlock(chip->mutex);
1926 goto retry;
1927 } else {
1928 printk(KERN_ERR "%s: block erase failed at 0x%08lx (status 0x%lx)\n", map->name, adr, chipstatus);
1929 ret = -EIO;
1930 }
1931
1932 goto out;
1933 }
1934
1935 xip_enable(map, chip, adr);
1936 out: put_chip(map, chip, adr);
1937 spin_unlock(chip->mutex);
1938 return ret;
1939 }
1940
1941 static int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
1942 {
1943 unsigned long ofs, len;
1944 int ret;
1945
1946 ofs = instr->addr;
1947 len = instr->len;
1948
1949 ret = cfi_varsize_frob(mtd, do_erase_oneblock, ofs, len, NULL);
1950 if (ret)
1951 return ret;
1952
1953 instr->state = MTD_ERASE_DONE;
1954 mtd_erase_callback(instr);
1955
1956 return 0;
1957 }
1958
1959 static void cfi_intelext_sync (struct mtd_info *mtd)
1960 {
1961 struct map_info *map = mtd->priv;
1962 struct cfi_private *cfi = map->fldrv_priv;
1963 int i;
1964 struct flchip *chip;
1965 int ret = 0;
1966
1967 for (i=0; !ret && i<cfi->numchips; i++) {
1968 chip = &cfi->chips[i];
1969
1970 spin_lock(chip->mutex);
1971 ret = get_chip(map, chip, chip->start, FL_SYNCING);
1972
1973 if (!ret) {
1974 chip->oldstate = chip->state;
1975 chip->state = FL_SYNCING;
1976 /* No need to wake_up() on this state change -
1977 * as the whole point is that nobody can do anything
1978 * with the chip now anyway.
1979 */
1980 }
1981 spin_unlock(chip->mutex);
1982 }
1983
1984 /* Unlock the chips again */
1985
1986 for (i--; i >=0; i--) {
1987 chip = &cfi->chips[i];
1988
1989 spin_lock(chip->mutex);
1990
1991 if (chip->state == FL_SYNCING) {
1992 chip->state = chip->oldstate;
1993 chip->oldstate = FL_READY;
1994 wake_up(&chip->wq);
1995 }
1996 spin_unlock(chip->mutex);
1997 }
1998 }
1999
2000 static int __xipram do_getlockstatus_oneblock(struct map_info *map,
2001 struct flchip *chip,
2002 unsigned long adr,
2003 int len, void *thunk)
2004 {
2005 struct cfi_private *cfi = map->fldrv_priv;
2006 int status, ofs_factor = cfi->interleave * cfi->device_type;
2007
2008 adr += chip->start;
2009 xip_disable(map, chip, adr+(2*ofs_factor));
2010 map_write(map, CMD(0x90), adr+(2*ofs_factor));
2011 chip->state = FL_JEDEC_QUERY;
2012 status = cfi_read_query(map, adr+(2*ofs_factor));
2013 xip_enable(map, chip, 0);
2014 return status;
2015 }
2016
2017 #ifdef DEBUG_LOCK_BITS
2018 static int __xipram do_printlockstatus_oneblock(struct map_info *map,
2019 struct flchip *chip,
2020 unsigned long adr,
2021 int len, void *thunk)
2022 {
2023 printk(KERN_DEBUG "block status register for 0x%08lx is %x\n",
2024 adr, do_getlockstatus_oneblock(map, chip, adr, len, thunk));
2025 return 0;
2026 }
2027 #endif
2028
2029 #define DO_XXLOCK_ONEBLOCK_LOCK ((void *) 1)
2030 #define DO_XXLOCK_ONEBLOCK_UNLOCK ((void *) 2)
2031
2032 static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip,
2033 unsigned long adr, int len, void *thunk)
2034 {
2035 struct cfi_private *cfi = map->fldrv_priv;
2036 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2037 int udelay;
2038 int ret;
2039
2040 adr += chip->start;
2041
2042 spin_lock(chip->mutex);
2043 ret = get_chip(map, chip, adr, FL_LOCKING);
2044 if (ret) {
2045 spin_unlock(chip->mutex);
2046 return ret;
2047 }
2048
2049 ENABLE_VPP(map);
2050 xip_disable(map, chip, adr);
2051
2052 map_write(map, CMD(0x60), adr);
2053 if (thunk == DO_XXLOCK_ONEBLOCK_LOCK) {
2054 map_write(map, CMD(0x01), adr);
2055 chip->state = FL_LOCKING;
2056 } else if (thunk == DO_XXLOCK_ONEBLOCK_UNLOCK) {
2057 map_write(map, CMD(0xD0), adr);
2058 chip->state = FL_UNLOCKING;
2059 } else
2060 BUG();
2061
2062 /*
2063 * If Instant Individual Block Locking supported then no need
2064 * to delay.
2065 */
2066 udelay = (!extp || !(extp->FeatureSupport & (1 << 5))) ? 1000000/HZ : 0;
2067
2068 ret = WAIT_TIMEOUT(map, chip, adr, udelay, udelay * 100);
2069 if (ret) {
2070 map_write(map, CMD(0x70), adr);
2071 chip->state = FL_STATUS;
2072 xip_enable(map, chip, adr);
2073 printk(KERN_ERR "%s: block unlock error: (status timeout)\n", map->name);
2074 goto out;
2075 }
2076
2077 xip_enable(map, chip, adr);
2078 out: put_chip(map, chip, adr);
2079 spin_unlock(chip->mutex);
2080 return ret;
2081 }
2082
2083 static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2084 {
2085 int ret;
2086
2087 #ifdef DEBUG_LOCK_BITS
2088 printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
2089 __func__, ofs, len);
2090 cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2091 ofs, len, NULL);
2092 #endif
2093
2094 ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
2095 ofs, len, DO_XXLOCK_ONEBLOCK_LOCK);
2096
2097 #ifdef DEBUG_LOCK_BITS
2098 printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
2099 __func__, ret);
2100 cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2101 ofs, len, NULL);
2102 #endif
2103
2104 return ret;
2105 }
2106
2107 static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, uint64_t len)
2108 {
2109 int ret;
2110
2111 #ifdef DEBUG_LOCK_BITS
2112 printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
2113 __func__, ofs, len);
2114 cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2115 ofs, len, NULL);
2116 #endif
2117
2118 ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
2119 ofs, len, DO_XXLOCK_ONEBLOCK_UNLOCK);
2120
2121 #ifdef DEBUG_LOCK_BITS
2122 printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
2123 __func__, ret);
2124 cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2125 ofs, len, NULL);
2126 #endif
2127
2128 return ret;
2129 }
2130
2131 #ifdef CONFIG_MTD_OTP
2132
2133 typedef int (*otp_op_t)(struct map_info *map, struct flchip *chip,
2134 u_long data_offset, u_char *buf, u_int size,
2135 u_long prot_offset, u_int groupno, u_int groupsize);
2136
2137 static int __xipram
2138 do_otp_read(struct map_info *map, struct flchip *chip, u_long offset,
2139 u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2140 {
2141 struct cfi_private *cfi = map->fldrv_priv;
2142 int ret;
2143
2144 spin_lock(chip->mutex);
2145 ret = get_chip(map, chip, chip->start, FL_JEDEC_QUERY);
2146 if (ret) {
2147 spin_unlock(chip->mutex);
2148 return ret;
2149 }
2150
2151 /* let's ensure we're not reading back cached data from array mode */
2152 INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
2153
2154 xip_disable(map, chip, chip->start);
2155 if (chip->state != FL_JEDEC_QUERY) {
2156 map_write(map, CMD(0x90), chip->start);
2157 chip->state = FL_JEDEC_QUERY;
2158 }
2159 map_copy_from(map, buf, chip->start + offset, size);
2160 xip_enable(map, chip, chip->start);
2161
2162 /* then ensure we don't keep OTP data in the cache */
2163 INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
2164
2165 put_chip(map, chip, chip->start);
2166 spin_unlock(chip->mutex);
2167 return 0;
2168 }
2169
2170 static int
2171 do_otp_write(struct map_info *map, struct flchip *chip, u_long offset,
2172 u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2173 {
2174 int ret;
2175
2176 while (size) {
2177 unsigned long bus_ofs = offset & ~(map_bankwidth(map)-1);
2178 int gap = offset - bus_ofs;
2179 int n = min_t(int, size, map_bankwidth(map)-gap);
2180 map_word datum = map_word_ff(map);
2181
2182 datum = map_word_load_partial(map, datum, buf, gap, n);
2183 ret = do_write_oneword(map, chip, bus_ofs, datum, FL_OTP_WRITE);
2184 if (ret)
2185 return ret;
2186
2187 offset += n;
2188 buf += n;
2189 size -= n;
2190 }
2191
2192 return 0;
2193 }
2194
2195 static int
2196 do_otp_lock(struct map_info *map, struct flchip *chip, u_long offset,
2197 u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2198 {
2199 struct cfi_private *cfi = map->fldrv_priv;
2200 map_word datum;
2201
2202 /* make sure area matches group boundaries */
2203 if (size != grpsz)
2204 return -EXDEV;
2205
2206 datum = map_word_ff(map);
2207 datum = map_word_clr(map, datum, CMD(1 << grpno));
2208 return do_write_oneword(map, chip, prot, datum, FL_OTP_WRITE);
2209 }
2210
2211 static int cfi_intelext_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
2212 size_t *retlen, u_char *buf,
2213 otp_op_t action, int user_regs)
2214 {
2215 struct map_info *map = mtd->priv;
2216 struct cfi_private *cfi = map->fldrv_priv;
2217 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2218 struct flchip *chip;
2219 struct cfi_intelext_otpinfo *otp;
2220 u_long devsize, reg_prot_offset, data_offset;
2221 u_int chip_num, chip_step, field, reg_fact_size, reg_user_size;
2222 u_int groups, groupno, groupsize, reg_fact_groups, reg_user_groups;
2223 int ret;
2224
2225 *retlen = 0;
2226
2227 /* Check that we actually have some OTP registers */
2228 if (!extp || !(extp->FeatureSupport & 64) || !extp->NumProtectionFields)
2229 return -ENODATA;
2230
2231 /* we need real chips here not virtual ones */
2232 devsize = (1 << cfi->cfiq->DevSize) * cfi->interleave;
2233 chip_step = devsize >> cfi->chipshift;
2234 chip_num = 0;
2235
2236 /* Some chips have OTP located in the _top_ partition only.
2237 For example: Intel 28F256L18T (T means top-parameter device) */
2238 if (cfi->mfr == MANUFACTURER_INTEL) {
2239 switch (cfi->id) {
2240 case 0x880b:
2241 case 0x880c:
2242 case 0x880d:
2243 chip_num = chip_step - 1;
2244 }
2245 }
2246
2247 for ( ; chip_num < cfi->numchips; chip_num += chip_step) {
2248 chip = &cfi->chips[chip_num];
2249 otp = (struct cfi_intelext_otpinfo *)&extp->extra[0];
2250
2251 /* first OTP region */
2252 field = 0;
2253 reg_prot_offset = extp->ProtRegAddr;
2254 reg_fact_groups = 1;
2255 reg_fact_size = 1 << extp->FactProtRegSize;
2256 reg_user_groups = 1;
2257 reg_user_size = 1 << extp->UserProtRegSize;
2258
2259 while (len > 0) {
2260 /* flash geometry fixup */
2261 data_offset = reg_prot_offset + 1;
2262 data_offset *= cfi->interleave * cfi->device_type;
2263 reg_prot_offset *= cfi->interleave * cfi->device_type;
2264 reg_fact_size *= cfi->interleave;
2265 reg_user_size *= cfi->interleave;
2266
2267 if (user_regs) {
2268 groups = reg_user_groups;
2269 groupsize = reg_user_size;
2270 /* skip over factory reg area */
2271 groupno = reg_fact_groups;
2272 data_offset += reg_fact_groups * reg_fact_size;
2273 } else {
2274 groups = reg_fact_groups;
2275 groupsize = reg_fact_size;
2276 groupno = 0;
2277 }
2278
2279 while (len > 0 && groups > 0) {
2280 if (!action) {
2281 /*
2282 * Special case: if action is NULL
2283 * we fill buf with otp_info records.
2284 */
2285 struct otp_info *otpinfo;
2286 map_word lockword;
2287 len -= sizeof(struct otp_info);
2288 if (len <= 0)
2289 return -ENOSPC;
2290 ret = do_otp_read(map, chip,
2291 reg_prot_offset,
2292 (u_char *)&lockword,
2293 map_bankwidth(map),
2294 0, 0, 0);
2295 if (ret)
2296 return ret;
2297 otpinfo = (struct otp_info *)buf;
2298 otpinfo->start = from;
2299 otpinfo->length = groupsize;
2300 otpinfo->locked =
2301 !map_word_bitsset(map, lockword,
2302 CMD(1 << groupno));
2303 from += groupsize;
2304 buf += sizeof(*otpinfo);
2305 *retlen += sizeof(*otpinfo);
2306 } else if (from >= groupsize) {
2307 from -= groupsize;
2308 data_offset += groupsize;
2309 } else {
2310 int size = groupsize;
2311 data_offset += from;
2312 size -= from;
2313 from = 0;
2314 if (size > len)
2315 size = len;
2316 ret = action(map, chip, data_offset,
2317 buf, size, reg_prot_offset,
2318 groupno, groupsize);
2319 if (ret < 0)
2320 return ret;
2321 buf += size;
2322 len -= size;
2323 *retlen += size;
2324 data_offset += size;
2325 }
2326 groupno++;
2327 groups--;
2328 }
2329
2330 /* next OTP region */
2331 if (++field == extp->NumProtectionFields)
2332 break;
2333 reg_prot_offset = otp->ProtRegAddr;
2334 reg_fact_groups = otp->FactGroups;
2335 reg_fact_size = 1 << otp->FactProtRegSize;
2336 reg_user_groups = otp->UserGroups;
2337 reg_user_size = 1 << otp->UserProtRegSize;
2338 otp++;
2339 }
2340 }
2341
2342 return 0;
2343 }
2344
2345 static int cfi_intelext_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
2346 size_t len, size_t *retlen,
2347 u_char *buf)
2348 {
2349 return cfi_intelext_otp_walk(mtd, from, len, retlen,
2350 buf, do_otp_read, 0);
2351 }
2352
2353 static int cfi_intelext_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
2354 size_t len, size_t *retlen,
2355 u_char *buf)
2356 {
2357 return cfi_intelext_otp_walk(mtd, from, len, retlen,
2358 buf, do_otp_read, 1);
2359 }
2360
2361 static int cfi_intelext_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
2362 size_t len, size_t *retlen,
2363 u_char *buf)
2364 {
2365 return cfi_intelext_otp_walk(mtd, from, len, retlen,
2366 buf, do_otp_write, 1);
2367 }
2368
2369 static int cfi_intelext_lock_user_prot_reg(struct mtd_info *mtd,
2370 loff_t from, size_t len)
2371 {
2372 size_t retlen;
2373 return cfi_intelext_otp_walk(mtd, from, len, &retlen,
2374 NULL, do_otp_lock, 1);
2375 }
2376
2377 static int cfi_intelext_get_fact_prot_info(struct mtd_info *mtd,
2378 struct otp_info *buf, size_t len)
2379 {
2380 size_t retlen;
2381 int ret;
2382
2383 ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 0);
2384 return ret ? : retlen;
2385 }
2386
2387 static int cfi_intelext_get_user_prot_info(struct mtd_info *mtd,
2388 struct otp_info *buf, size_t len)
2389 {
2390 size_t retlen;
2391 int ret;
2392
2393 ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 1);
2394 return ret ? : retlen;
2395 }
2396
2397 #endif
2398
2399 static void cfi_intelext_save_locks(struct mtd_info *mtd)
2400 {
2401 struct mtd_erase_region_info *region;
2402 int block, status, i;
2403 unsigned long adr;
2404 size_t len;
2405
2406 for (i = 0; i < mtd->numeraseregions; i++) {
2407 region = &mtd->eraseregions[i];
2408 if (!region->lockmap)
2409 continue;
2410
2411 for (block = 0; block < region->numblocks; block++){
2412 len = region->erasesize;
2413 adr = region->offset + block * len;
2414
2415 status = cfi_varsize_frob(mtd,
2416 do_getlockstatus_oneblock, adr, len, NULL);
2417 if (status)
2418 set_bit(block, region->lockmap);
2419 else
2420 clear_bit(block, region->lockmap);
2421 }
2422 }
2423 }
2424
2425 static int cfi_intelext_suspend(struct mtd_info *mtd)
2426 {
2427 struct map_info *map = mtd->priv;
2428 struct cfi_private *cfi = map->fldrv_priv;
2429 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2430 int i;
2431 struct flchip *chip;
2432 int ret = 0;
2433
2434 if ((mtd->flags & MTD_POWERUP_LOCK)
2435 && extp && (extp->FeatureSupport & (1 << 5)))
2436 cfi_intelext_save_locks(mtd);
2437
2438 for (i=0; !ret && i<cfi->numchips; i++) {
2439 chip = &cfi->chips[i];
2440
2441 spin_lock(chip->mutex);
2442
2443 switch (chip->state) {
2444 case FL_READY:
2445 case FL_STATUS:
2446 case FL_CFI_QUERY:
2447 case FL_JEDEC_QUERY:
2448 if (chip->oldstate == FL_READY) {
2449 /* place the chip in a known state before suspend */
2450 map_write(map, CMD(0xFF), cfi->chips[i].start);
2451 chip->oldstate = chip->state;
2452 chip->state = FL_PM_SUSPENDED;
2453 /* No need to wake_up() on this state change -
2454 * as the whole point is that nobody can do anything
2455 * with the chip now anyway.
2456 */
2457 } else {
2458 /* There seems to be an operation pending. We must wait for it. */
2459 printk(KERN_NOTICE "Flash device refused suspend due to pending operation (oldstate %d)\n", chip->oldstate);
2460 ret = -EAGAIN;
2461 }
2462 break;
2463 default:
2464 /* Should we actually wait? Once upon a time these routines weren't
2465 allowed to. Or should we return -EAGAIN, because the upper layers
2466 ought to have already shut down anything which was using the device
2467 anyway? The latter for now. */
2468 printk(KERN_NOTICE "Flash device refused suspend due to active operation (state %d)\n", chip->oldstate);
2469 ret = -EAGAIN;
2470 case FL_PM_SUSPENDED:
2471 break;
2472 }
2473 spin_unlock(chip->mutex);
2474 }
2475
2476 /* Unlock the chips again */
2477
2478 if (ret) {
2479 for (i--; i >=0; i--) {
2480 chip = &cfi->chips[i];
2481
2482 spin_lock(chip->mutex);
2483
2484 if (chip->state == FL_PM_SUSPENDED) {
2485 /* No need to force it into a known state here,
2486 because we're returning failure, and it didn't
2487 get power cycled */
2488 chip->state = chip->oldstate;
2489 chip->oldstate = FL_READY;
2490 wake_up(&chip->wq);
2491 }
2492 spin_unlock(chip->mutex);
2493 }
2494 }
2495
2496 return ret;
2497 }
2498
2499 static void cfi_intelext_restore_locks(struct mtd_info *mtd)
2500 {
2501 struct mtd_erase_region_info *region;
2502 int block, i;
2503 unsigned long adr;
2504 size_t len;
2505
2506 for (i = 0; i < mtd->numeraseregions; i++) {
2507 region = &mtd->eraseregions[i];
2508 if (!region->lockmap)
2509 continue;
2510
2511 for (block = 0; block < region->numblocks; block++) {
2512 len = region->erasesize;
2513 adr = region->offset + block * len;
2514
2515 if (!test_bit(block, region->lockmap))
2516 cfi_intelext_unlock(mtd, adr, len);
2517 }
2518 }
2519 }
2520
2521 static void cfi_intelext_resume(struct mtd_info *mtd)
2522 {
2523 struct map_info *map = mtd->priv;
2524 struct cfi_private *cfi = map->fldrv_priv;
2525 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2526 int i;
2527 struct flchip *chip;
2528
2529 for (i=0; i<cfi->numchips; i++) {
2530
2531 chip = &cfi->chips[i];
2532
2533 spin_lock(chip->mutex);
2534
2535 /* Go to known state. Chip may have been power cycled */
2536 if (chip->state == FL_PM_SUSPENDED) {
2537 map_write(map, CMD(0xFF), cfi->chips[i].start);
2538 chip->oldstate = chip->state = FL_READY;
2539 wake_up(&chip->wq);
2540 }
2541
2542 spin_unlock(chip->mutex);
2543 }
2544
2545 if ((mtd->flags & MTD_POWERUP_LOCK)
2546 && extp && (extp->FeatureSupport & (1 << 5)))
2547 cfi_intelext_restore_locks(mtd);
2548 }
2549
2550 static int cfi_intelext_reset(struct mtd_info *mtd)
2551 {
2552 struct map_info *map = mtd->priv;
2553 struct cfi_private *cfi = map->fldrv_priv;
2554 int i, ret;
2555
2556 for (i=0; i < cfi->numchips; i++) {
2557 struct flchip *chip = &cfi->chips[i];
2558
2559 /* force the completion of any ongoing operation
2560 and switch to array mode so any bootloader in
2561 flash is accessible for soft reboot. */
2562 spin_lock(chip->mutex);
2563 ret = get_chip(map, chip, chip->start, FL_SHUTDOWN);
2564 if (!ret) {
2565 map_write(map, CMD(0xff), chip->start);
2566 chip->state = FL_SHUTDOWN;
2567 }
2568 spin_unlock(chip->mutex);
2569 }
2570
2571 return 0;
2572 }
2573
2574 static int cfi_intelext_reboot(struct notifier_block *nb, unsigned long val,
2575 void *v)
2576 {
2577 struct mtd_info *mtd;
2578
2579 mtd = container_of(nb, struct mtd_info, reboot_notifier);
2580 cfi_intelext_reset(mtd);
2581 return NOTIFY_DONE;
2582 }
2583
2584 static void cfi_intelext_destroy(struct mtd_info *mtd)
2585 {
2586 struct map_info *map = mtd->priv;
2587 struct cfi_private *cfi = map->fldrv_priv;
2588 struct mtd_erase_region_info *region;
2589 int i;
2590 cfi_intelext_reset(mtd);
2591 unregister_reboot_notifier(&mtd->reboot_notifier);
2592 kfree(cfi->cmdset_priv);
2593 kfree(cfi->cfiq);
2594 kfree(cfi->chips[0].priv);
2595 kfree(cfi);
2596 for (i = 0; i < mtd->numeraseregions; i++) {
2597 region = &mtd->eraseregions[i];
2598 if (region->lockmap)
2599 kfree(region->lockmap);
2600 }
2601 kfree(mtd->eraseregions);
2602 }
2603
2604 MODULE_LICENSE("GPL");
2605 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al.");
2606 MODULE_DESCRIPTION("MTD chip driver for Intel/Sharp flash chips");
2607 MODULE_ALIAS("cfi_cmdset_0003");
2608 MODULE_ALIAS("cfi_cmdset_0200");
Linux for Ginger Game Console