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