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