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