?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 2.6.17.7
[linux/fpc-iii.git] / drivers / mtd / chips / cfi_cmdset_0001.c
blob1c074d63ff3af865d52acf29d59aa1be824c41bf
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.186 2005/11/23 22:07:52 nico 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 init_waitqueue_head(&(cfi->chips[i].wq));
412 }
413
414 map->fldrv = &cfi_intelext_chipdrv;
415
416 return cfi_intelext_setup(mtd);
417 }
418
419 static struct mtd_info *cfi_intelext_setup(struct mtd_info *mtd)
420 {
421 struct map_info *map = mtd->priv;
422 struct cfi_private *cfi = map->fldrv_priv;
423 unsigned long offset = 0;
424 int i,j;
425 unsigned long devsize = (1<<cfi->cfiq->DevSize) * cfi->interleave;
426
427 //printk(KERN_DEBUG "number of CFI chips: %d\n", cfi->numchips);
428
429 mtd->size = devsize * cfi->numchips;
430
431 mtd->numeraseregions = cfi->cfiq->NumEraseRegions * cfi->numchips;
432 mtd->eraseregions = kmalloc(sizeof(struct mtd_erase_region_info)
433 * mtd->numeraseregions, GFP_KERNEL);
434 if (!mtd->eraseregions) {
435 printk(KERN_ERR "Failed to allocate memory for MTD erase region info\n");
436 goto setup_err;
437 }
438
439 for (i=0; i<cfi->cfiq->NumEraseRegions; i++) {
440 unsigned long ernum, ersize;
441 ersize = ((cfi->cfiq->EraseRegionInfo[i] >> 8) & ~0xff) * cfi->interleave;
442 ernum = (cfi->cfiq->EraseRegionInfo[i] & 0xffff) + 1;
443
444 if (mtd->erasesize < ersize) {
445 mtd->erasesize = ersize;
446 }
447 for (j=0; j<cfi->numchips; j++) {
448 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].offset = (j*devsize)+offset;
449 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].erasesize = ersize;
450 mtd->eraseregions[(j*cfi->cfiq->NumEraseRegions)+i].numblocks = ernum;
451 }
452 offset += (ersize * ernum);
453 }
454
455 if (offset != devsize) {
456 /* Argh */
457 printk(KERN_WARNING "Sum of regions (%lx) != total size of set of interleaved chips (%lx)\n", offset, devsize);
458 goto setup_err;
459 }
460
461 for (i=0; i<mtd->numeraseregions;i++){
462 printk(KERN_DEBUG "erase region %d: offset=0x%x,size=0x%x,blocks=%d\n",
463 i,mtd->eraseregions[i].offset,
464 mtd->eraseregions[i].erasesize,
465 mtd->eraseregions[i].numblocks);
466 }
467
468 #ifdef CONFIG_MTD_OTP
469 mtd->read_fact_prot_reg = cfi_intelext_read_fact_prot_reg;
470 mtd->read_user_prot_reg = cfi_intelext_read_user_prot_reg;
471 mtd->write_user_prot_reg = cfi_intelext_write_user_prot_reg;
472 mtd->lock_user_prot_reg = cfi_intelext_lock_user_prot_reg;
473 mtd->get_fact_prot_info = cfi_intelext_get_fact_prot_info;
474 mtd->get_user_prot_info = cfi_intelext_get_user_prot_info;
475 #endif
476
477 /* This function has the potential to distort the reality
478 a bit and therefore should be called last. */
479 if (cfi_intelext_partition_fixup(mtd, &cfi) != 0)
480 goto setup_err;
481
482 __module_get(THIS_MODULE);
483 register_reboot_notifier(&mtd->reboot_notifier);
484 return mtd;
485
486 setup_err:
487 if(mtd) {
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 and/or written only when
649 * its lock is taken.
650 */
651 struct flchip_shared *shared = chip->priv;
652 struct flchip *contender;
653 spin_lock(&shared->lock);
654 contender = shared->writing;
655 if (contender && contender != chip) {
656 /*
657 * The engine to perform desired operation on this
658 * partition is already in use by someone else.
659 * Let's fight over it in the context of the chip
660 * currently using it. If it is possible to suspend,
661 * that other partition will do just that, otherwise
662 * it'll happily send us to sleep. In any case, when
663 * get_chip returns success we're clear to go ahead.
664 */
665 int ret = spin_trylock(contender->mutex);
666 spin_unlock(&shared->lock);
667 if (!ret)
668 goto retry;
669 spin_unlock(chip->mutex);
670 ret = get_chip(map, contender, contender->start, mode);
671 spin_lock(chip->mutex);
672 if (ret) {
673 spin_unlock(contender->mutex);
674 return ret;
675 }
676 timeo = jiffies + HZ;
677 spin_lock(&shared->lock);
678 spin_unlock(contender->mutex);
679 }
680
681 /* We now own it */
682 shared->writing = chip;
683 if (mode == FL_ERASING)
684 shared->erasing = chip;
685 spin_unlock(&shared->lock);
686 }
687
688 switch (chip->state) {
689
690 case FL_STATUS:
691 for (;;) {
692 status = map_read(map, adr);
693 if (map_word_andequal(map, status, status_OK, status_OK))
694 break;
695
696 /* At this point we're fine with write operations
697 in other partitions as they don't conflict. */
698 if (chip->priv && map_word_andequal(map, status, status_PWS, status_PWS))
699 break;
700
701 if (time_after(jiffies, timeo)) {
702 printk(KERN_ERR "%s: Waiting for chip to be ready timed out. Status %lx\n",
703 map->name, status.x[0]);
704 return -EIO;
705 }
706 spin_unlock(chip->mutex);
707 cfi_udelay(1);
708 spin_lock(chip->mutex);
709 /* Someone else might have been playing with it. */
710 goto retry;
711 }
712
713 case FL_READY:
714 case FL_CFI_QUERY:
715 case FL_JEDEC_QUERY:
716 return 0;
717
718 case FL_ERASING:
719 if (!cfip ||
720 !(cfip->FeatureSupport & 2) ||
721 !(mode == FL_READY || mode == FL_POINT ||
722 (mode == FL_WRITING && (cfip->SuspendCmdSupport & 1))))
723 goto sleep;
724
725
726 /* Erase suspend */
727 map_write(map, CMD(0xB0), adr);
728
729 /* If the flash has finished erasing, then 'erase suspend'
730 * appears to make some (28F320) flash devices switch to
731 * 'read' mode. Make sure that we switch to 'read status'
732 * mode so we get the right data. --rmk
733 */
734 map_write(map, CMD(0x70), adr);
735 chip->oldstate = FL_ERASING;
736 chip->state = FL_ERASE_SUSPENDING;
737 chip->erase_suspended = 1;
738 for (;;) {
739 status = map_read(map, adr);
740 if (map_word_andequal(map, status, status_OK, status_OK))
741 break;
742
743 if (time_after(jiffies, timeo)) {
744 /* Urgh. Resume and pretend we weren't here. */
745 map_write(map, CMD(0xd0), adr);
746 /* Make sure we're in 'read status' mode if it had finished */
747 map_write(map, CMD(0x70), adr);
748 chip->state = FL_ERASING;
749 chip->oldstate = FL_READY;
750 printk(KERN_ERR "%s: Chip not ready after erase "
751 "suspended: status = 0x%lx\n", map->name, status.x[0]);
752 return -EIO;
753 }
754
755 spin_unlock(chip->mutex);
756 cfi_udelay(1);
757 spin_lock(chip->mutex);
758 /* Nobody will touch it while it's in state FL_ERASE_SUSPENDING.
759 So we can just loop here. */
760 }
761 chip->state = FL_STATUS;
762 return 0;
763
764 case FL_XIP_WHILE_ERASING:
765 if (mode != FL_READY && mode != FL_POINT &&
766 (mode != FL_WRITING || !cfip || !(cfip->SuspendCmdSupport&1)))
767 goto sleep;
768 chip->oldstate = chip->state;
769 chip->state = FL_READY;
770 return 0;
771
772 case FL_POINT:
773 /* Only if there's no operation suspended... */
774 if (mode == FL_READY && chip->oldstate == FL_READY)
775 return 0;
776
777 default:
778 sleep:
779 set_current_state(TASK_UNINTERRUPTIBLE);
780 add_wait_queue(&chip->wq, &wait);
781 spin_unlock(chip->mutex);
782 schedule();
783 remove_wait_queue(&chip->wq, &wait);
784 spin_lock(chip->mutex);
785 goto resettime;
786 }
787 }
788
789 static void put_chip(struct map_info *map, struct flchip *chip, unsigned long adr)
790 {
791 struct cfi_private *cfi = map->fldrv_priv;
792
793 if (chip->priv) {
794 struct flchip_shared *shared = chip->priv;
795 spin_lock(&shared->lock);
796 if (shared->writing == chip && chip->oldstate == FL_READY) {
797 /* We own the ability to write, but we're done */
798 shared->writing = shared->erasing;
799 if (shared->writing && shared->writing != chip) {
800 /* give back ownership to who we loaned it from */
801 struct flchip *loaner = shared->writing;
802 spin_lock(loaner->mutex);
803 spin_unlock(&shared->lock);
804 spin_unlock(chip->mutex);
805 put_chip(map, loaner, loaner->start);
806 spin_lock(chip->mutex);
807 spin_unlock(loaner->mutex);
808 wake_up(&chip->wq);
809 return;
810 }
811 shared->erasing = NULL;
812 shared->writing = NULL;
813 } else if (shared->erasing == chip && shared->writing != chip) {
814 /*
815 * We own the ability to erase without the ability
816 * to write, which means the erase was suspended
817 * and some other partition is currently writing.
818 * Don't let the switch below mess things up since
819 * we don't have ownership to resume anything.
820 */
821 spin_unlock(&shared->lock);
822 wake_up(&chip->wq);
823 return;
824 }
825 spin_unlock(&shared->lock);
826 }
827
828 switch(chip->oldstate) {
829 case FL_ERASING:
830 chip->state = chip->oldstate;
831 /* What if one interleaved chip has finished and the
832 other hasn't? The old code would leave the finished
833 one in READY mode. That's bad, and caused -EROFS
834 errors to be returned from do_erase_oneblock because
835 that's the only bit it checked for at the time.
836 As the state machine appears to explicitly allow
837 sending the 0x70 (Read Status) command to an erasing
838 chip and expecting it to be ignored, that's what we
839 do. */
840 map_write(map, CMD(0xd0), adr);
841 map_write(map, CMD(0x70), adr);
842 chip->oldstate = FL_READY;
843 chip->state = FL_ERASING;
844 break;
845
846 case FL_XIP_WHILE_ERASING:
847 chip->state = chip->oldstate;
848 chip->oldstate = FL_READY;
849 break;
850
851 case FL_READY:
852 case FL_STATUS:
853 case FL_JEDEC_QUERY:
854 /* We should really make set_vpp() count, rather than doing this */
855 DISABLE_VPP(map);
856 break;
857 default:
858 printk(KERN_ERR "%s: put_chip() called with oldstate %d!!\n", map->name, chip->oldstate);
859 }
860 wake_up(&chip->wq);
861 }
862
863 #ifdef CONFIG_MTD_XIP
864
865 /*
866 * No interrupt what so ever can be serviced while the flash isn't in array
867 * mode. This is ensured by the xip_disable() and xip_enable() functions
868 * enclosing any code path where the flash is known not to be in array mode.
869 * And within a XIP disabled code path, only functions marked with __xipram
870 * may be called and nothing else (it's a good thing to inspect generated
871 * assembly to make sure inline functions were actually inlined and that gcc
872 * didn't emit calls to its own support functions). Also configuring MTD CFI
873 * support to a single buswidth and a single interleave is also recommended.
874 */
875
876 static void xip_disable(struct map_info *map, struct flchip *chip,
877 unsigned long adr)
878 {
879 /* TODO: chips with no XIP use should ignore and return */
880 (void) map_read(map, adr); /* ensure mmu mapping is up to date */
881 local_irq_disable();
882 }
883
884 static void __xipram xip_enable(struct map_info *map, struct flchip *chip,
885 unsigned long adr)
886 {
887 struct cfi_private *cfi = map->fldrv_priv;
888 if (chip->state != FL_POINT && chip->state != FL_READY) {
889 map_write(map, CMD(0xff), adr);
890 chip->state = FL_READY;
891 }
892 (void) map_read(map, adr);
893 xip_iprefetch();
894 local_irq_enable();
895 }
896
897 /*
898 * When a delay is required for the flash operation to complete, the
899 * xip_udelay() function is polling for both the given timeout and pending
900 * (but still masked) hardware interrupts. Whenever there is an interrupt
901 * pending then the flash erase or write operation is suspended, array mode
902 * restored and interrupts unmasked. Task scheduling might also happen at that
903 * point. The CPU eventually returns from the interrupt or the call to
904 * schedule() and the suspended flash operation is resumed for the remaining
905 * of the delay period.
906 *
907 * Warning: this function _will_ fool interrupt latency tracing tools.
908 */
909
910 static void __xipram xip_udelay(struct map_info *map, struct flchip *chip,
911 unsigned long adr, int usec)
912 {
913 struct cfi_private *cfi = map->fldrv_priv;
914 struct cfi_pri_intelext *cfip = cfi->cmdset_priv;
915 map_word status, OK = CMD(0x80);
916 unsigned long suspended, start = xip_currtime();
917 flstate_t oldstate, newstate;
918
919 do {
920 cpu_relax();
921 if (xip_irqpending() && cfip &&
922 ((chip->state == FL_ERASING && (cfip->FeatureSupport&2)) ||
923 (chip->state == FL_WRITING && (cfip->FeatureSupport&4))) &&
924 (cfi_interleave_is_1(cfi) || chip->oldstate == FL_READY)) {
925 /*
926 * Let's suspend the erase or write operation when
927 * supported. Note that we currently don't try to
928 * suspend interleaved chips if there is already
929 * another operation suspended (imagine what happens
930 * when one chip was already done with the current
931 * operation while another chip suspended it, then
932 * we resume the whole thing at once). Yes, it
933 * can happen!
934 */
935 map_write(map, CMD(0xb0), adr);
936 map_write(map, CMD(0x70), adr);
937 usec -= xip_elapsed_since(start);
938 suspended = xip_currtime();
939 do {
940 if (xip_elapsed_since(suspended) > 100000) {
941 /*
942 * The chip doesn't want to suspend
943 * after waiting for 100 msecs.
944 * This is a critical error but there
945 * is not much we can do here.
946 */
947 return;
948 }
949 status = map_read(map, adr);
950 } while (!map_word_andequal(map, status, OK, OK));
951
952 /* Suspend succeeded */
953 oldstate = chip->state;
954 if (oldstate == FL_ERASING) {
955 if (!map_word_bitsset(map, status, CMD(0x40)))
956 break;
957 newstate = FL_XIP_WHILE_ERASING;
958 chip->erase_suspended = 1;
959 } else {
960 if (!map_word_bitsset(map, status, CMD(0x04)))
961 break;
962 newstate = FL_XIP_WHILE_WRITING;
963 chip->write_suspended = 1;
964 }
965 chip->state = newstate;
966 map_write(map, CMD(0xff), adr);
967 (void) map_read(map, adr);
968 asm volatile (".rep 8; nop; .endr");
969 local_irq_enable();
970 spin_unlock(chip->mutex);
971 asm volatile (".rep 8; nop; .endr");
972 cond_resched();
973
974 /*
975 * We're back. However someone else might have
976 * decided to go write to the chip if we are in
977 * a suspended erase state. If so let's wait
978 * until it's done.
979 */
980 spin_lock(chip->mutex);
981 while (chip->state != newstate) {
982 DECLARE_WAITQUEUE(wait, current);
983 set_current_state(TASK_UNINTERRUPTIBLE);
984 add_wait_queue(&chip->wq, &wait);
985 spin_unlock(chip->mutex);
986 schedule();
987 remove_wait_queue(&chip->wq, &wait);
988 spin_lock(chip->mutex);
989 }
990 /* Disallow XIP again */
991 local_irq_disable();
992
993 /* Resume the write or erase operation */
994 map_write(map, CMD(0xd0), adr);
995 map_write(map, CMD(0x70), adr);
996 chip->state = oldstate;
997 start = xip_currtime();
998 } else if (usec >= 1000000/HZ) {
999 /*
1000 * Try to save on CPU power when waiting delay
1001 * is at least a system timer tick period.
1002 * No need to be extremely accurate here.
1003 */
1004 xip_cpu_idle();
1005 }
1006 status = map_read(map, adr);
1007 } while (!map_word_andequal(map, status, OK, OK)
1008 && xip_elapsed_since(start) < usec);
1009 }
1010
1011 #define UDELAY(map, chip, adr, usec) xip_udelay(map, chip, adr, usec)
1012
1013 /*
1014 * The INVALIDATE_CACHED_RANGE() macro is normally used in parallel while
1015 * the flash is actively programming or erasing since we have to poll for
1016 * the operation to complete anyway. We can't do that in a generic way with
1017 * a XIP setup so do it before the actual flash operation in this case
1018 * and stub it out from INVALIDATE_CACHE_UDELAY.
1019 */
1020 #define XIP_INVAL_CACHED_RANGE(map, from, size) \
1021 INVALIDATE_CACHED_RANGE(map, from, size)
1022
1023 #define INVALIDATE_CACHE_UDELAY(map, chip, cmd_adr, adr, len, usec) \
1024 UDELAY(map, chip, cmd_adr, usec)
1025
1026 /*
1027 * Extra notes:
1028 *
1029 * Activating this XIP support changes the way the code works a bit. For
1030 * example the code to suspend the current process when concurrent access
1031 * happens is never executed because xip_udelay() will always return with the
1032 * same chip state as it was entered with. This is why there is no care for
1033 * the presence of add_wait_queue() or schedule() calls from within a couple
1034 * xip_disable()'d areas of code, like in do_erase_oneblock for example.
1035 * The queueing and scheduling are always happening within xip_udelay().
1036 *
1037 * Similarly, get_chip() and put_chip() just happen to always be executed
1038 * with chip->state set to FL_READY (or FL_XIP_WHILE_*) where flash state
1039 * is in array mode, therefore never executing many cases therein and not
1040 * causing any problem with XIP.
1041 */
1042
1043 #else
1044
1045 #define xip_disable(map, chip, adr)
1046 #define xip_enable(map, chip, adr)
1047 #define XIP_INVAL_CACHED_RANGE(x...)
1048
1049 #define UDELAY(map, chip, adr, usec) \
1050 do { \
1051 spin_unlock(chip->mutex); \
1052 cfi_udelay(usec); \
1053 spin_lock(chip->mutex); \
1054 } while (0)
1055
1056 #define INVALIDATE_CACHE_UDELAY(map, chip, cmd_adr, adr, len, usec) \
1057 do { \
1058 spin_unlock(chip->mutex); \
1059 INVALIDATE_CACHED_RANGE(map, adr, len); \
1060 cfi_udelay(usec); \
1061 spin_lock(chip->mutex); \
1062 } while (0)
1063
1064 #endif
1065
1066 static int do_point_onechip (struct map_info *map, struct flchip *chip, loff_t adr, size_t len)
1067 {
1068 unsigned long cmd_addr;
1069 struct cfi_private *cfi = map->fldrv_priv;
1070 int ret = 0;
1071
1072 adr += chip->start;
1073
1074 /* Ensure cmd read/writes are aligned. */
1075 cmd_addr = adr & ~(map_bankwidth(map)-1);
1076
1077 spin_lock(chip->mutex);
1078
1079 ret = get_chip(map, chip, cmd_addr, FL_POINT);
1080
1081 if (!ret) {
1082 if (chip->state != FL_POINT && chip->state != FL_READY)
1083 map_write(map, CMD(0xff), cmd_addr);
1084
1085 chip->state = FL_POINT;
1086 chip->ref_point_counter++;
1087 }
1088 spin_unlock(chip->mutex);
1089
1090 return ret;
1091 }
1092
1093 static int cfi_intelext_point (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char **mtdbuf)
1094 {
1095 struct map_info *map = mtd->priv;
1096 struct cfi_private *cfi = map->fldrv_priv;
1097 unsigned long ofs;
1098 int chipnum;
1099 int ret = 0;
1100
1101 if (!map->virt || (from + len > mtd->size))
1102 return -EINVAL;
1103
1104 *mtdbuf = (void *)map->virt + from;
1105 *retlen = 0;
1106
1107 /* Now lock the chip(s) to POINT state */
1108
1109 /* ofs: offset within the first chip that the first read should start */
1110 chipnum = (from >> cfi->chipshift);
1111 ofs = from - (chipnum << cfi->chipshift);
1112
1113 while (len) {
1114 unsigned long thislen;
1115
1116 if (chipnum >= cfi->numchips)
1117 break;
1118
1119 if ((len + ofs -1) >> cfi->chipshift)
1120 thislen = (1<<cfi->chipshift) - ofs;
1121 else
1122 thislen = len;
1123
1124 ret = do_point_onechip(map, &cfi->chips[chipnum], ofs, thislen);
1125 if (ret)
1126 break;
1127
1128 *retlen += thislen;
1129 len -= thislen;
1130
1131 ofs = 0;
1132 chipnum++;
1133 }
1134 return 0;
1135 }
1136
1137 static void cfi_intelext_unpoint (struct mtd_info *mtd, u_char *addr, loff_t from, size_t len)
1138 {
1139 struct map_info *map = mtd->priv;
1140 struct cfi_private *cfi = map->fldrv_priv;
1141 unsigned long ofs;
1142 int chipnum;
1143
1144 /* Now unlock the chip(s) POINT state */
1145
1146 /* ofs: offset within the first chip that the first read should start */
1147 chipnum = (from >> cfi->chipshift);
1148 ofs = from - (chipnum << cfi->chipshift);
1149
1150 while (len) {
1151 unsigned long thislen;
1152 struct flchip *chip;
1153
1154 chip = &cfi->chips[chipnum];
1155 if (chipnum >= cfi->numchips)
1156 break;
1157
1158 if ((len + ofs -1) >> cfi->chipshift)
1159 thislen = (1<<cfi->chipshift) - ofs;
1160 else
1161 thislen = len;
1162
1163 spin_lock(chip->mutex);
1164 if (chip->state == FL_POINT) {
1165 chip->ref_point_counter--;
1166 if(chip->ref_point_counter == 0)
1167 chip->state = FL_READY;
1168 } else
1169 printk(KERN_ERR "%s: Warning: unpoint called on non pointed region\n", map->name); /* Should this give an error? */
1170
1171 put_chip(map, chip, chip->start);
1172 spin_unlock(chip->mutex);
1173
1174 len -= thislen;
1175 ofs = 0;
1176 chipnum++;
1177 }
1178 }
1179
1180 static inline int do_read_onechip(struct map_info *map, struct flchip *chip, loff_t adr, size_t len, u_char *buf)
1181 {
1182 unsigned long cmd_addr;
1183 struct cfi_private *cfi = map->fldrv_priv;
1184 int ret;
1185
1186 adr += chip->start;
1187
1188 /* Ensure cmd read/writes are aligned. */
1189 cmd_addr = adr & ~(map_bankwidth(map)-1);
1190
1191 spin_lock(chip->mutex);
1192 ret = get_chip(map, chip, cmd_addr, FL_READY);
1193 if (ret) {
1194 spin_unlock(chip->mutex);
1195 return ret;
1196 }
1197
1198 if (chip->state != FL_POINT && chip->state != FL_READY) {
1199 map_write(map, CMD(0xff), cmd_addr);
1200
1201 chip->state = FL_READY;
1202 }
1203
1204 map_copy_from(map, buf, adr, len);
1205
1206 put_chip(map, chip, cmd_addr);
1207
1208 spin_unlock(chip->mutex);
1209 return 0;
1210 }
1211
1212 static int cfi_intelext_read (struct mtd_info *mtd, loff_t from, size_t len, size_t *retlen, u_char *buf)
1213 {
1214 struct map_info *map = mtd->priv;
1215 struct cfi_private *cfi = map->fldrv_priv;
1216 unsigned long ofs;
1217 int chipnum;
1218 int ret = 0;
1219
1220 /* ofs: offset within the first chip that the first read should start */
1221 chipnum = (from >> cfi->chipshift);
1222 ofs = from - (chipnum << cfi->chipshift);
1223
1224 *retlen = 0;
1225
1226 while (len) {
1227 unsigned long thislen;
1228
1229 if (chipnum >= cfi->numchips)
1230 break;
1231
1232 if ((len + ofs -1) >> cfi->chipshift)
1233 thislen = (1<<cfi->chipshift) - ofs;
1234 else
1235 thislen = len;
1236
1237 ret = do_read_onechip(map, &cfi->chips[chipnum], ofs, thislen, buf);
1238 if (ret)
1239 break;
1240
1241 *retlen += thislen;
1242 len -= thislen;
1243 buf += thislen;
1244
1245 ofs = 0;
1246 chipnum++;
1247 }
1248 return ret;
1249 }
1250
1251 static int __xipram do_write_oneword(struct map_info *map, struct flchip *chip,
1252 unsigned long adr, map_word datum, int mode)
1253 {
1254 struct cfi_private *cfi = map->fldrv_priv;
1255 map_word status, status_OK, write_cmd;
1256 unsigned long timeo;
1257 int z, ret=0;
1258
1259 adr += chip->start;
1260
1261 /* Let's determine those according to the interleave only once */
1262 status_OK = CMD(0x80);
1263 switch (mode) {
1264 case FL_WRITING:
1265 write_cmd = (cfi->cfiq->P_ID != 0x0200) ? CMD(0x40) : CMD(0x41);
1266 break;
1267 case FL_OTP_WRITE:
1268 write_cmd = CMD(0xc0);
1269 break;
1270 default:
1271 return -EINVAL;
1272 }
1273
1274 spin_lock(chip->mutex);
1275 ret = get_chip(map, chip, adr, mode);
1276 if (ret) {
1277 spin_unlock(chip->mutex);
1278 return ret;
1279 }
1280
1281 XIP_INVAL_CACHED_RANGE(map, adr, map_bankwidth(map));
1282 ENABLE_VPP(map);
1283 xip_disable(map, chip, adr);
1284 map_write(map, write_cmd, adr);
1285 map_write(map, datum, adr);
1286 chip->state = mode;
1287
1288 INVALIDATE_CACHE_UDELAY(map, chip, adr,
1289 adr, map_bankwidth(map),
1290 chip->word_write_time);
1291
1292 timeo = jiffies + (HZ/2);
1293 z = 0;
1294 for (;;) {
1295 if (chip->state != mode) {
1296 /* Someone's suspended the write. Sleep */
1297 DECLARE_WAITQUEUE(wait, current);
1298
1299 set_current_state(TASK_UNINTERRUPTIBLE);
1300 add_wait_queue(&chip->wq, &wait);
1301 spin_unlock(chip->mutex);
1302 schedule();
1303 remove_wait_queue(&chip->wq, &wait);
1304 timeo = jiffies + (HZ / 2); /* FIXME */
1305 spin_lock(chip->mutex);
1306 continue;
1307 }
1308
1309 status = map_read(map, adr);
1310 if (map_word_andequal(map, status, status_OK, status_OK))
1311 break;
1312
1313 /* OK Still waiting */
1314 if (time_after(jiffies, timeo)) {
1315 map_write(map, CMD(0x70), adr);
1316 chip->state = FL_STATUS;
1317 xip_enable(map, chip, adr);
1318 printk(KERN_ERR "%s: word write error (status timeout)\n", map->name);
1319 ret = -EIO;
1320 goto out;
1321 }
1322
1323 /* Latency issues. Drop the lock, wait a while and retry */
1324 z++;
1325 UDELAY(map, chip, adr, 1);
1326 }
1327 if (!z) {
1328 chip->word_write_time--;
1329 if (!chip->word_write_time)
1330 chip->word_write_time = 1;
1331 }
1332 if (z > 1)
1333 chip->word_write_time++;
1334
1335 /* Done and happy. */
1336 chip->state = FL_STATUS;
1337
1338 /* check for errors */
1339 if (map_word_bitsset(map, status, CMD(0x1a))) {
1340 unsigned long chipstatus = MERGESTATUS(status);
1341
1342 /* reset status */
1343 map_write(map, CMD(0x50), adr);
1344 map_write(map, CMD(0x70), adr);
1345 xip_enable(map, chip, adr);
1346
1347 if (chipstatus & 0x02) {
1348 ret = -EROFS;
1349 } else if (chipstatus & 0x08) {
1350 printk(KERN_ERR "%s: word write error (bad VPP)\n", map->name);
1351 ret = -EIO;
1352 } else {
1353 printk(KERN_ERR "%s: word write error (status 0x%lx)\n", map->name, chipstatus);
1354 ret = -EINVAL;
1355 }
1356
1357 goto out;
1358 }
1359
1360 xip_enable(map, chip, adr);
1361 out: put_chip(map, chip, adr);
1362 spin_unlock(chip->mutex);
1363 return ret;
1364 }
1365
1366
1367 static int cfi_intelext_write_words (struct mtd_info *mtd, loff_t to , size_t len, size_t *retlen, const u_char *buf)
1368 {
1369 struct map_info *map = mtd->priv;
1370 struct cfi_private *cfi = map->fldrv_priv;
1371 int ret = 0;
1372 int chipnum;
1373 unsigned long ofs;
1374
1375 *retlen = 0;
1376 if (!len)
1377 return 0;
1378
1379 chipnum = to >> cfi->chipshift;
1380 ofs = to - (chipnum << cfi->chipshift);
1381
1382 /* If it's not bus-aligned, do the first byte write */
1383 if (ofs & (map_bankwidth(map)-1)) {
1384 unsigned long bus_ofs = ofs & ~(map_bankwidth(map)-1);
1385 int gap = ofs - bus_ofs;
1386 int n;
1387 map_word datum;
1388
1389 n = min_t(int, len, map_bankwidth(map)-gap);
1390 datum = map_word_ff(map);
1391 datum = map_word_load_partial(map, datum, buf, gap, n);
1392
1393 ret = do_write_oneword(map, &cfi->chips[chipnum],
1394 bus_ofs, datum, FL_WRITING);
1395 if (ret)
1396 return ret;
1397
1398 len -= n;
1399 ofs += n;
1400 buf += n;
1401 (*retlen) += n;
1402
1403 if (ofs >> cfi->chipshift) {
1404 chipnum ++;
1405 ofs = 0;
1406 if (chipnum == cfi->numchips)
1407 return 0;
1408 }
1409 }
1410
1411 while(len >= map_bankwidth(map)) {
1412 map_word datum = map_word_load(map, buf);
1413
1414 ret = do_write_oneword(map, &cfi->chips[chipnum],
1415 ofs, datum, FL_WRITING);
1416 if (ret)
1417 return ret;
1418
1419 ofs += map_bankwidth(map);
1420 buf += map_bankwidth(map);
1421 (*retlen) += map_bankwidth(map);
1422 len -= map_bankwidth(map);
1423
1424 if (ofs >> cfi->chipshift) {
1425 chipnum ++;
1426 ofs = 0;
1427 if (chipnum == cfi->numchips)
1428 return 0;
1429 }
1430 }
1431
1432 if (len & (map_bankwidth(map)-1)) {
1433 map_word datum;
1434
1435 datum = map_word_ff(map);
1436 datum = map_word_load_partial(map, datum, buf, 0, len);
1437
1438 ret = do_write_oneword(map, &cfi->chips[chipnum],
1439 ofs, datum, FL_WRITING);
1440 if (ret)
1441 return ret;
1442
1443 (*retlen) += len;
1444 }
1445
1446 return 0;
1447 }
1448
1449
1450 static int __xipram do_write_buffer(struct map_info *map, struct flchip *chip,
1451 unsigned long adr, const struct kvec **pvec,
1452 unsigned long *pvec_seek, int len)
1453 {
1454 struct cfi_private *cfi = map->fldrv_priv;
1455 map_word status, status_OK, write_cmd, datum;
1456 unsigned long cmd_adr, timeo;
1457 int wbufsize, z, ret=0, word_gap, words;
1458 const struct kvec *vec;
1459 unsigned long vec_seek;
1460
1461 wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1462 adr += chip->start;
1463 cmd_adr = adr & ~(wbufsize-1);
1464
1465 /* Let's determine this according to the interleave only once */
1466 status_OK = CMD(0x80);
1467 write_cmd = (cfi->cfiq->P_ID != 0x0200) ? CMD(0xe8) : CMD(0xe9);
1468
1469 spin_lock(chip->mutex);
1470 ret = get_chip(map, chip, cmd_adr, FL_WRITING);
1471 if (ret) {
1472 spin_unlock(chip->mutex);
1473 return ret;
1474 }
1475
1476 XIP_INVAL_CACHED_RANGE(map, adr, len);
1477 ENABLE_VPP(map);
1478 xip_disable(map, chip, cmd_adr);
1479
1480 /* §4.8 of the 28FxxxJ3A datasheet says "Any time SR.4 and/or SR.5 is set
1481 [...], the device will not accept any more Write to Buffer commands".
1482 So we must check here and reset those bits if they're set. Otherwise
1483 we're just pissing in the wind */
1484 if (chip->state != FL_STATUS)
1485 map_write(map, CMD(0x70), cmd_adr);
1486 status = map_read(map, cmd_adr);
1487 if (map_word_bitsset(map, status, CMD(0x30))) {
1488 xip_enable(map, chip, cmd_adr);
1489 printk(KERN_WARNING "SR.4 or SR.5 bits set in buffer write (status %lx). Clearing.\n", status.x[0]);
1490 xip_disable(map, chip, cmd_adr);
1491 map_write(map, CMD(0x50), cmd_adr);
1492 map_write(map, CMD(0x70), cmd_adr);
1493 }
1494
1495 chip->state = FL_WRITING_TO_BUFFER;
1496
1497 z = 0;
1498 for (;;) {
1499 map_write(map, write_cmd, cmd_adr);
1500
1501 status = map_read(map, cmd_adr);
1502 if (map_word_andequal(map, status, status_OK, status_OK))
1503 break;
1504
1505 UDELAY(map, chip, cmd_adr, 1);
1506
1507 if (++z > 20) {
1508 /* Argh. Not ready for write to buffer */
1509 map_word Xstatus;
1510 map_write(map, CMD(0x70), cmd_adr);
1511 chip->state = FL_STATUS;
1512 Xstatus = map_read(map, cmd_adr);
1513 /* Odd. Clear status bits */
1514 map_write(map, CMD(0x50), cmd_adr);
1515 map_write(map, CMD(0x70), cmd_adr);
1516 xip_enable(map, chip, cmd_adr);
1517 printk(KERN_ERR "%s: Chip not ready for buffer write. status = %lx, Xstatus = %lx\n",
1518 map->name, status.x[0], Xstatus.x[0]);
1519 ret = -EIO;
1520 goto out;
1521 }
1522 }
1523
1524 /* Figure out the number of words to write */
1525 word_gap = (-adr & (map_bankwidth(map)-1));
1526 words = (len - word_gap + map_bankwidth(map) - 1) / map_bankwidth(map);
1527 if (!word_gap) {
1528 words--;
1529 } else {
1530 word_gap = map_bankwidth(map) - word_gap;
1531 adr -= word_gap;
1532 datum = map_word_ff(map);
1533 }
1534
1535 /* Write length of data to come */
1536 map_write(map, CMD(words), cmd_adr );
1537
1538 /* Write data */
1539 vec = *pvec;
1540 vec_seek = *pvec_seek;
1541 do {
1542 int n = map_bankwidth(map) - word_gap;
1543 if (n > vec->iov_len - vec_seek)
1544 n = vec->iov_len - vec_seek;
1545 if (n > len)
1546 n = len;
1547
1548 if (!word_gap && len < map_bankwidth(map))
1549 datum = map_word_ff(map);
1550
1551 datum = map_word_load_partial(map, datum,
1552 vec->iov_base + vec_seek,
1553 word_gap, n);
1554
1555 len -= n;
1556 word_gap += n;
1557 if (!len || word_gap == map_bankwidth(map)) {
1558 map_write(map, datum, adr);
1559 adr += map_bankwidth(map);
1560 word_gap = 0;
1561 }
1562
1563 vec_seek += n;
1564 if (vec_seek == vec->iov_len) {
1565 vec++;
1566 vec_seek = 0;
1567 }
1568 } while (len);
1569 *pvec = vec;
1570 *pvec_seek = vec_seek;
1571
1572 /* GO GO GO */
1573 map_write(map, CMD(0xd0), cmd_adr);
1574 chip->state = FL_WRITING;
1575
1576 INVALIDATE_CACHE_UDELAY(map, chip, cmd_adr,
1577 adr, len,
1578 chip->buffer_write_time);
1579
1580 timeo = jiffies + (HZ/2);
1581 z = 0;
1582 for (;;) {
1583 if (chip->state != FL_WRITING) {
1584 /* Someone's suspended the write. Sleep */
1585 DECLARE_WAITQUEUE(wait, current);
1586 set_current_state(TASK_UNINTERRUPTIBLE);
1587 add_wait_queue(&chip->wq, &wait);
1588 spin_unlock(chip->mutex);
1589 schedule();
1590 remove_wait_queue(&chip->wq, &wait);
1591 timeo = jiffies + (HZ / 2); /* FIXME */
1592 spin_lock(chip->mutex);
1593 continue;
1594 }
1595
1596 status = map_read(map, cmd_adr);
1597 if (map_word_andequal(map, status, status_OK, status_OK))
1598 break;
1599
1600 /* OK Still waiting */
1601 if (time_after(jiffies, timeo)) {
1602 map_write(map, CMD(0x70), cmd_adr);
1603 chip->state = FL_STATUS;
1604 xip_enable(map, chip, cmd_adr);
1605 printk(KERN_ERR "%s: buffer write error (status timeout)\n", map->name);
1606 ret = -EIO;
1607 goto out;
1608 }
1609
1610 /* Latency issues. Drop the lock, wait a while and retry */
1611 z++;
1612 UDELAY(map, chip, cmd_adr, 1);
1613 }
1614 if (!z) {
1615 chip->buffer_write_time--;
1616 if (!chip->buffer_write_time)
1617 chip->buffer_write_time = 1;
1618 }
1619 if (z > 1)
1620 chip->buffer_write_time++;
1621
1622 /* Done and happy. */
1623 chip->state = FL_STATUS;
1624
1625 /* check for errors */
1626 if (map_word_bitsset(map, status, CMD(0x1a))) {
1627 unsigned long chipstatus = MERGESTATUS(status);
1628
1629 /* reset status */
1630 map_write(map, CMD(0x50), cmd_adr);
1631 map_write(map, CMD(0x70), cmd_adr);
1632 xip_enable(map, chip, cmd_adr);
1633
1634 if (chipstatus & 0x02) {
1635 ret = -EROFS;
1636 } else if (chipstatus & 0x08) {
1637 printk(KERN_ERR "%s: buffer write error (bad VPP)\n", map->name);
1638 ret = -EIO;
1639 } else {
1640 printk(KERN_ERR "%s: buffer write error (status 0x%lx)\n", map->name, chipstatus);
1641 ret = -EINVAL;
1642 }
1643
1644 goto out;
1645 }
1646
1647 xip_enable(map, chip, cmd_adr);
1648 out: put_chip(map, chip, cmd_adr);
1649 spin_unlock(chip->mutex);
1650 return ret;
1651 }
1652
1653 static int cfi_intelext_writev (struct mtd_info *mtd, const struct kvec *vecs,
1654 unsigned long count, loff_t to, size_t *retlen)
1655 {
1656 struct map_info *map = mtd->priv;
1657 struct cfi_private *cfi = map->fldrv_priv;
1658 int wbufsize = cfi_interleave(cfi) << cfi->cfiq->MaxBufWriteSize;
1659 int ret = 0;
1660 int chipnum;
1661 unsigned long ofs, vec_seek, i;
1662 size_t len = 0;
1663
1664 for (i = 0; i < count; i++)
1665 len += vecs[i].iov_len;
1666
1667 *retlen = 0;
1668 if (!len)
1669 return 0;
1670
1671 chipnum = to >> cfi->chipshift;
1672 ofs = to - (chipnum << cfi->chipshift);
1673 vec_seek = 0;
1674
1675 do {
1676 /* We must not cross write block boundaries */
1677 int size = wbufsize - (ofs & (wbufsize-1));
1678
1679 if (size > len)
1680 size = len;
1681 ret = do_write_buffer(map, &cfi->chips[chipnum],
1682 ofs, &vecs, &vec_seek, size);
1683 if (ret)
1684 return ret;
1685
1686 ofs += size;
1687 (*retlen) += size;
1688 len -= size;
1689
1690 if (ofs >> cfi->chipshift) {
1691 chipnum ++;
1692 ofs = 0;
1693 if (chipnum == cfi->numchips)
1694 return 0;
1695 }
1696 } while (len);
1697
1698 return 0;
1699 }
1700
1701 static int cfi_intelext_write_buffers (struct mtd_info *mtd, loff_t to,
1702 size_t len, size_t *retlen, const u_char *buf)
1703 {
1704 struct kvec vec;
1705
1706 vec.iov_base = (void *) buf;
1707 vec.iov_len = len;
1708
1709 return cfi_intelext_writev(mtd, &vec, 1, to, retlen);
1710 }
1711
1712 static int __xipram do_erase_oneblock(struct map_info *map, struct flchip *chip,
1713 unsigned long adr, int len, void *thunk)
1714 {
1715 struct cfi_private *cfi = map->fldrv_priv;
1716 map_word status, status_OK;
1717 unsigned long timeo;
1718 int retries = 3;
1719 DECLARE_WAITQUEUE(wait, current);
1720 int ret = 0;
1721
1722 adr += chip->start;
1723
1724 /* Let's determine this according to the interleave only once */
1725 status_OK = CMD(0x80);
1726
1727 retry:
1728 spin_lock(chip->mutex);
1729 ret = get_chip(map, chip, adr, FL_ERASING);
1730 if (ret) {
1731 spin_unlock(chip->mutex);
1732 return ret;
1733 }
1734
1735 XIP_INVAL_CACHED_RANGE(map, adr, len);
1736 ENABLE_VPP(map);
1737 xip_disable(map, chip, adr);
1738
1739 /* Clear the status register first */
1740 map_write(map, CMD(0x50), adr);
1741
1742 /* Now erase */
1743 map_write(map, CMD(0x20), adr);
1744 map_write(map, CMD(0xD0), adr);
1745 chip->state = FL_ERASING;
1746 chip->erase_suspended = 0;
1747
1748 INVALIDATE_CACHE_UDELAY(map, chip, adr,
1749 adr, len,
1750 chip->erase_time*1000/2);
1751
1752 /* FIXME. Use a timer to check this, and return immediately. */
1753 /* Once the state machine's known to be working I'll do that */
1754
1755 timeo = jiffies + (HZ*20);
1756 for (;;) {
1757 if (chip->state != FL_ERASING) {
1758 /* Someone's suspended the erase. Sleep */
1759 set_current_state(TASK_UNINTERRUPTIBLE);
1760 add_wait_queue(&chip->wq, &wait);
1761 spin_unlock(chip->mutex);
1762 schedule();
1763 remove_wait_queue(&chip->wq, &wait);
1764 spin_lock(chip->mutex);
1765 continue;
1766 }
1767 if (chip->erase_suspended) {
1768 /* This erase was suspended and resumed.
1769 Adjust the timeout */
1770 timeo = jiffies + (HZ*20); /* FIXME */
1771 chip->erase_suspended = 0;
1772 }
1773
1774 status = map_read(map, adr);
1775 if (map_word_andequal(map, status, status_OK, status_OK))
1776 break;
1777
1778 /* OK Still waiting */
1779 if (time_after(jiffies, timeo)) {
1780 map_write(map, CMD(0x70), adr);
1781 chip->state = FL_STATUS;
1782 xip_enable(map, chip, adr);
1783 printk(KERN_ERR "%s: block erase error: (status timeout)\n", map->name);
1784 ret = -EIO;
1785 goto out;
1786 }
1787
1788 /* Latency issues. Drop the lock, wait a while and retry */
1789 UDELAY(map, chip, adr, 1000000/HZ);
1790 }
1791
1792 /* We've broken this before. It doesn't hurt to be safe */
1793 map_write(map, CMD(0x70), adr);
1794 chip->state = FL_STATUS;
1795 status = map_read(map, adr);
1796
1797 /* check for errors */
1798 if (map_word_bitsset(map, status, CMD(0x3a))) {
1799 unsigned long chipstatus = MERGESTATUS(status);
1800
1801 /* Reset the error bits */
1802 map_write(map, CMD(0x50), adr);
1803 map_write(map, CMD(0x70), adr);
1804 xip_enable(map, chip, adr);
1805
1806 if ((chipstatus & 0x30) == 0x30) {
1807 printk(KERN_ERR "%s: block erase error: (bad command sequence, status 0x%lx)\n", map->name, chipstatus);
1808 ret = -EINVAL;
1809 } else if (chipstatus & 0x02) {
1810 /* Protection bit set */
1811 ret = -EROFS;
1812 } else if (chipstatus & 0x8) {
1813 /* Voltage */
1814 printk(KERN_ERR "%s: block erase error: (bad VPP)\n", map->name);
1815 ret = -EIO;
1816 } else if (chipstatus & 0x20 && retries--) {
1817 printk(KERN_DEBUG "block erase failed at 0x%08lx: status 0x%lx. Retrying...\n", adr, chipstatus);
1818 timeo = jiffies + HZ;
1819 put_chip(map, chip, adr);
1820 spin_unlock(chip->mutex);
1821 goto retry;
1822 } else {
1823 printk(KERN_ERR "%s: block erase failed at 0x%08lx (status 0x%lx)\n", map->name, adr, chipstatus);
1824 ret = -EIO;
1825 }
1826
1827 goto out;
1828 }
1829
1830 xip_enable(map, chip, adr);
1831 out: put_chip(map, chip, adr);
1832 spin_unlock(chip->mutex);
1833 return ret;
1834 }
1835
1836 int cfi_intelext_erase_varsize(struct mtd_info *mtd, struct erase_info *instr)
1837 {
1838 unsigned long ofs, len;
1839 int ret;
1840
1841 ofs = instr->addr;
1842 len = instr->len;
1843
1844 ret = cfi_varsize_frob(mtd, do_erase_oneblock, ofs, len, NULL);
1845 if (ret)
1846 return ret;
1847
1848 instr->state = MTD_ERASE_DONE;
1849 mtd_erase_callback(instr);
1850
1851 return 0;
1852 }
1853
1854 static void cfi_intelext_sync (struct mtd_info *mtd)
1855 {
1856 struct map_info *map = mtd->priv;
1857 struct cfi_private *cfi = map->fldrv_priv;
1858 int i;
1859 struct flchip *chip;
1860 int ret = 0;
1861
1862 for (i=0; !ret && i<cfi->numchips; i++) {
1863 chip = &cfi->chips[i];
1864
1865 spin_lock(chip->mutex);
1866 ret = get_chip(map, chip, chip->start, FL_SYNCING);
1867
1868 if (!ret) {
1869 chip->oldstate = chip->state;
1870 chip->state = FL_SYNCING;
1871 /* No need to wake_up() on this state change -
1872 * as the whole point is that nobody can do anything
1873 * with the chip now anyway.
1874 */
1875 }
1876 spin_unlock(chip->mutex);
1877 }
1878
1879 /* Unlock the chips again */
1880
1881 for (i--; i >=0; i--) {
1882 chip = &cfi->chips[i];
1883
1884 spin_lock(chip->mutex);
1885
1886 if (chip->state == FL_SYNCING) {
1887 chip->state = chip->oldstate;
1888 chip->oldstate = FL_READY;
1889 wake_up(&chip->wq);
1890 }
1891 spin_unlock(chip->mutex);
1892 }
1893 }
1894
1895 #ifdef DEBUG_LOCK_BITS
1896 static int __xipram do_printlockstatus_oneblock(struct map_info *map,
1897 struct flchip *chip,
1898 unsigned long adr,
1899 int len, void *thunk)
1900 {
1901 struct cfi_private *cfi = map->fldrv_priv;
1902 int status, ofs_factor = cfi->interleave * cfi->device_type;
1903
1904 adr += chip->start;
1905 xip_disable(map, chip, adr+(2*ofs_factor));
1906 map_write(map, CMD(0x90), adr+(2*ofs_factor));
1907 chip->state = FL_JEDEC_QUERY;
1908 status = cfi_read_query(map, adr+(2*ofs_factor));
1909 xip_enable(map, chip, 0);
1910 printk(KERN_DEBUG "block status register for 0x%08lx is %x\n",
1911 adr, status);
1912 return 0;
1913 }
1914 #endif
1915
1916 #define DO_XXLOCK_ONEBLOCK_LOCK ((void *) 1)
1917 #define DO_XXLOCK_ONEBLOCK_UNLOCK ((void *) 2)
1918
1919 static int __xipram do_xxlock_oneblock(struct map_info *map, struct flchip *chip,
1920 unsigned long adr, int len, void *thunk)
1921 {
1922 struct cfi_private *cfi = map->fldrv_priv;
1923 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
1924 map_word status, status_OK;
1925 unsigned long timeo = jiffies + HZ;
1926 int ret;
1927
1928 adr += chip->start;
1929
1930 /* Let's determine this according to the interleave only once */
1931 status_OK = CMD(0x80);
1932
1933 spin_lock(chip->mutex);
1934 ret = get_chip(map, chip, adr, FL_LOCKING);
1935 if (ret) {
1936 spin_unlock(chip->mutex);
1937 return ret;
1938 }
1939
1940 ENABLE_VPP(map);
1941 xip_disable(map, chip, adr);
1942
1943 map_write(map, CMD(0x60), adr);
1944 if (thunk == DO_XXLOCK_ONEBLOCK_LOCK) {
1945 map_write(map, CMD(0x01), adr);
1946 chip->state = FL_LOCKING;
1947 } else if (thunk == DO_XXLOCK_ONEBLOCK_UNLOCK) {
1948 map_write(map, CMD(0xD0), adr);
1949 chip->state = FL_UNLOCKING;
1950 } else
1951 BUG();
1952
1953 /*
1954 * If Instant Individual Block Locking supported then no need
1955 * to delay.
1956 */
1957
1958 if (!extp || !(extp->FeatureSupport & (1 << 5)))
1959 UDELAY(map, chip, adr, 1000000/HZ);
1960
1961 /* FIXME. Use a timer to check this, and return immediately. */
1962 /* Once the state machine's known to be working I'll do that */
1963
1964 timeo = jiffies + (HZ*20);
1965 for (;;) {
1966
1967 status = map_read(map, adr);
1968 if (map_word_andequal(map, status, status_OK, status_OK))
1969 break;
1970
1971 /* OK Still waiting */
1972 if (time_after(jiffies, timeo)) {
1973 map_write(map, CMD(0x70), adr);
1974 chip->state = FL_STATUS;
1975 xip_enable(map, chip, adr);
1976 printk(KERN_ERR "%s: block unlock error: (status timeout)\n", map->name);
1977 put_chip(map, chip, adr);
1978 spin_unlock(chip->mutex);
1979 return -EIO;
1980 }
1981
1982 /* Latency issues. Drop the lock, wait a while and retry */
1983 UDELAY(map, chip, adr, 1);
1984 }
1985
1986 /* Done and happy. */
1987 chip->state = FL_STATUS;
1988 xip_enable(map, chip, adr);
1989 put_chip(map, chip, adr);
1990 spin_unlock(chip->mutex);
1991 return 0;
1992 }
1993
1994 static int cfi_intelext_lock(struct mtd_info *mtd, loff_t ofs, size_t len)
1995 {
1996 int ret;
1997
1998 #ifdef DEBUG_LOCK_BITS
1999 printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
2000 __FUNCTION__, ofs, len);
2001 cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2002 ofs, len, 0);
2003 #endif
2004
2005 ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
2006 ofs, len, DO_XXLOCK_ONEBLOCK_LOCK);
2007
2008 #ifdef DEBUG_LOCK_BITS
2009 printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
2010 __FUNCTION__, ret);
2011 cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2012 ofs, len, 0);
2013 #endif
2014
2015 return ret;
2016 }
2017
2018 static int cfi_intelext_unlock(struct mtd_info *mtd, loff_t ofs, size_t len)
2019 {
2020 int ret;
2021
2022 #ifdef DEBUG_LOCK_BITS
2023 printk(KERN_DEBUG "%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
2024 __FUNCTION__, ofs, len);
2025 cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2026 ofs, len, 0);
2027 #endif
2028
2029 ret = cfi_varsize_frob(mtd, do_xxlock_oneblock,
2030 ofs, len, DO_XXLOCK_ONEBLOCK_UNLOCK);
2031
2032 #ifdef DEBUG_LOCK_BITS
2033 printk(KERN_DEBUG "%s: lock status after, ret=%d\n",
2034 __FUNCTION__, ret);
2035 cfi_varsize_frob(mtd, do_printlockstatus_oneblock,
2036 ofs, len, 0);
2037 #endif
2038
2039 return ret;
2040 }
2041
2042 #ifdef CONFIG_MTD_OTP
2043
2044 typedef int (*otp_op_t)(struct map_info *map, struct flchip *chip,
2045 u_long data_offset, u_char *buf, u_int size,
2046 u_long prot_offset, u_int groupno, u_int groupsize);
2047
2048 static int __xipram
2049 do_otp_read(struct map_info *map, struct flchip *chip, u_long offset,
2050 u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2051 {
2052 struct cfi_private *cfi = map->fldrv_priv;
2053 int ret;
2054
2055 spin_lock(chip->mutex);
2056 ret = get_chip(map, chip, chip->start, FL_JEDEC_QUERY);
2057 if (ret) {
2058 spin_unlock(chip->mutex);
2059 return ret;
2060 }
2061
2062 /* let's ensure we're not reading back cached data from array mode */
2063 INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
2064
2065 xip_disable(map, chip, chip->start);
2066 if (chip->state != FL_JEDEC_QUERY) {
2067 map_write(map, CMD(0x90), chip->start);
2068 chip->state = FL_JEDEC_QUERY;
2069 }
2070 map_copy_from(map, buf, chip->start + offset, size);
2071 xip_enable(map, chip, chip->start);
2072
2073 /* then ensure we don't keep OTP data in the cache */
2074 INVALIDATE_CACHED_RANGE(map, chip->start + offset, size);
2075
2076 put_chip(map, chip, chip->start);
2077 spin_unlock(chip->mutex);
2078 return 0;
2079 }
2080
2081 static int
2082 do_otp_write(struct map_info *map, struct flchip *chip, u_long offset,
2083 u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2084 {
2085 int ret;
2086
2087 while (size) {
2088 unsigned long bus_ofs = offset & ~(map_bankwidth(map)-1);
2089 int gap = offset - bus_ofs;
2090 int n = min_t(int, size, map_bankwidth(map)-gap);
2091 map_word datum = map_word_ff(map);
2092
2093 datum = map_word_load_partial(map, datum, buf, gap, n);
2094 ret = do_write_oneword(map, chip, bus_ofs, datum, FL_OTP_WRITE);
2095 if (ret)
2096 return ret;
2097
2098 offset += n;
2099 buf += n;
2100 size -= n;
2101 }
2102
2103 return 0;
2104 }
2105
2106 static int
2107 do_otp_lock(struct map_info *map, struct flchip *chip, u_long offset,
2108 u_char *buf, u_int size, u_long prot, u_int grpno, u_int grpsz)
2109 {
2110 struct cfi_private *cfi = map->fldrv_priv;
2111 map_word datum;
2112
2113 /* make sure area matches group boundaries */
2114 if (size != grpsz)
2115 return -EXDEV;
2116
2117 datum = map_word_ff(map);
2118 datum = map_word_clr(map, datum, CMD(1 << grpno));
2119 return do_write_oneword(map, chip, prot, datum, FL_OTP_WRITE);
2120 }
2121
2122 static int cfi_intelext_otp_walk(struct mtd_info *mtd, loff_t from, size_t len,
2123 size_t *retlen, u_char *buf,
2124 otp_op_t action, int user_regs)
2125 {
2126 struct map_info *map = mtd->priv;
2127 struct cfi_private *cfi = map->fldrv_priv;
2128 struct cfi_pri_intelext *extp = cfi->cmdset_priv;
2129 struct flchip *chip;
2130 struct cfi_intelext_otpinfo *otp;
2131 u_long devsize, reg_prot_offset, data_offset;
2132 u_int chip_num, chip_step, field, reg_fact_size, reg_user_size;
2133 u_int groups, groupno, groupsize, reg_fact_groups, reg_user_groups;
2134 int ret;
2135
2136 *retlen = 0;
2137
2138 /* Check that we actually have some OTP registers */
2139 if (!extp || !(extp->FeatureSupport & 64) || !extp->NumProtectionFields)
2140 return -ENODATA;
2141
2142 /* we need real chips here not virtual ones */
2143 devsize = (1 << cfi->cfiq->DevSize) * cfi->interleave;
2144 chip_step = devsize >> cfi->chipshift;
2145 chip_num = 0;
2146
2147 /* Some chips have OTP located in the _top_ partition only.
2148 For example: Intel 28F256L18T (T means top-parameter device) */
2149 if (cfi->mfr == MANUFACTURER_INTEL) {
2150 switch (cfi->id) {
2151 case 0x880b:
2152 case 0x880c:
2153 case 0x880d:
2154 chip_num = chip_step - 1;
2155 }
2156 }
2157
2158 for ( ; chip_num < cfi->numchips; chip_num += chip_step) {
2159 chip = &cfi->chips[chip_num];
2160 otp = (struct cfi_intelext_otpinfo *)&extp->extra[0];
2161
2162 /* first OTP region */
2163 field = 0;
2164 reg_prot_offset = extp->ProtRegAddr;
2165 reg_fact_groups = 1;
2166 reg_fact_size = 1 << extp->FactProtRegSize;
2167 reg_user_groups = 1;
2168 reg_user_size = 1 << extp->UserProtRegSize;
2169
2170 while (len > 0) {
2171 /* flash geometry fixup */
2172 data_offset = reg_prot_offset + 1;
2173 data_offset *= cfi->interleave * cfi->device_type;
2174 reg_prot_offset *= cfi->interleave * cfi->device_type;
2175 reg_fact_size *= cfi->interleave;
2176 reg_user_size *= cfi->interleave;
2177
2178 if (user_regs) {
2179 groups = reg_user_groups;
2180 groupsize = reg_user_size;
2181 /* skip over factory reg area */
2182 groupno = reg_fact_groups;
2183 data_offset += reg_fact_groups * reg_fact_size;
2184 } else {
2185 groups = reg_fact_groups;
2186 groupsize = reg_fact_size;
2187 groupno = 0;
2188 }
2189
2190 while (len > 0 && groups > 0) {
2191 if (!action) {
2192 /*
2193 * Special case: if action is NULL
2194 * we fill buf with otp_info records.
2195 */
2196 struct otp_info *otpinfo;
2197 map_word lockword;
2198 len -= sizeof(struct otp_info);
2199 if (len <= 0)
2200 return -ENOSPC;
2201 ret = do_otp_read(map, chip,
2202 reg_prot_offset,
2203 (u_char *)&lockword,
2204 map_bankwidth(map),
2205 0, 0, 0);
2206 if (ret)
2207 return ret;
2208 otpinfo = (struct otp_info *)buf;
2209 otpinfo->start = from;
2210 otpinfo->length = groupsize;
2211 otpinfo->locked =
2212 !map_word_bitsset(map, lockword,
2213 CMD(1 << groupno));
2214 from += groupsize;
2215 buf += sizeof(*otpinfo);
2216 *retlen += sizeof(*otpinfo);
2217 } else if (from >= groupsize) {
2218 from -= groupsize;
2219 data_offset += groupsize;
2220 } else {
2221 int size = groupsize;
2222 data_offset += from;
2223 size -= from;
2224 from = 0;
2225 if (size > len)
2226 size = len;
2227 ret = action(map, chip, data_offset,
2228 buf, size, reg_prot_offset,
2229 groupno, groupsize);
2230 if (ret < 0)
2231 return ret;
2232 buf += size;
2233 len -= size;
2234 *retlen += size;
2235 data_offset += size;
2236 }
2237 groupno++;
2238 groups--;
2239 }
2240
2241 /* next OTP region */
2242 if (++field == extp->NumProtectionFields)
2243 break;
2244 reg_prot_offset = otp->ProtRegAddr;
2245 reg_fact_groups = otp->FactGroups;
2246 reg_fact_size = 1 << otp->FactProtRegSize;
2247 reg_user_groups = otp->UserGroups;
2248 reg_user_size = 1 << otp->UserProtRegSize;
2249 otp++;
2250 }
2251 }
2252
2253 return 0;
2254 }
2255
2256 static int cfi_intelext_read_fact_prot_reg(struct mtd_info *mtd, loff_t from,
2257 size_t len, size_t *retlen,
2258 u_char *buf)
2259 {
2260 return cfi_intelext_otp_walk(mtd, from, len, retlen,
2261 buf, do_otp_read, 0);
2262 }
2263
2264 static int cfi_intelext_read_user_prot_reg(struct mtd_info *mtd, loff_t from,
2265 size_t len, size_t *retlen,
2266 u_char *buf)
2267 {
2268 return cfi_intelext_otp_walk(mtd, from, len, retlen,
2269 buf, do_otp_read, 1);
2270 }
2271
2272 static int cfi_intelext_write_user_prot_reg(struct mtd_info *mtd, loff_t from,
2273 size_t len, size_t *retlen,
2274 u_char *buf)
2275 {
2276 return cfi_intelext_otp_walk(mtd, from, len, retlen,
2277 buf, do_otp_write, 1);
2278 }
2279
2280 static int cfi_intelext_lock_user_prot_reg(struct mtd_info *mtd,
2281 loff_t from, size_t len)
2282 {
2283 size_t retlen;
2284 return cfi_intelext_otp_walk(mtd, from, len, &retlen,
2285 NULL, do_otp_lock, 1);
2286 }
2287
2288 static int cfi_intelext_get_fact_prot_info(struct mtd_info *mtd,
2289 struct otp_info *buf, size_t len)
2290 {
2291 size_t retlen;
2292 int ret;
2293
2294 ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 0);
2295 return ret ? : retlen;
2296 }
2297
2298 static int cfi_intelext_get_user_prot_info(struct mtd_info *mtd,
2299 struct otp_info *buf, size_t len)
2300 {
2301 size_t retlen;
2302 int ret;
2303
2304 ret = cfi_intelext_otp_walk(mtd, 0, len, &retlen, (u_char *)buf, NULL, 1);
2305 return ret ? : retlen;
2306 }
2307
2308 #endif
2309
2310 static int cfi_intelext_suspend(struct mtd_info *mtd)
2311 {
2312 struct map_info *map = mtd->priv;
2313 struct cfi_private *cfi = map->fldrv_priv;
2314 int i;
2315 struct flchip *chip;
2316 int ret = 0;
2317
2318 for (i=0; !ret && i<cfi->numchips; i++) {
2319 chip = &cfi->chips[i];
2320
2321 spin_lock(chip->mutex);
2322
2323 switch (chip->state) {
2324 case FL_READY:
2325 case FL_STATUS:
2326 case FL_CFI_QUERY:
2327 case FL_JEDEC_QUERY:
2328 if (chip->oldstate == FL_READY) {
2329 chip->oldstate = chip->state;
2330 chip->state = FL_PM_SUSPENDED;
2331 /* No need to wake_up() on this state change -
2332 * as the whole point is that nobody can do anything
2333 * with the chip now anyway.
2334 */
2335 } else {
2336 /* There seems to be an operation pending. We must wait for it. */
2337 printk(KERN_NOTICE "Flash device refused suspend due to pending operation (oldstate %d)\n", chip->oldstate);
2338 ret = -EAGAIN;
2339 }
2340 break;
2341 default:
2342 /* Should we actually wait? Once upon a time these routines weren't
2343 allowed to. Or should we return -EAGAIN, because the upper layers
2344 ought to have already shut down anything which was using the device
2345 anyway? The latter for now. */
2346 printk(KERN_NOTICE "Flash device refused suspend due to active operation (state %d)\n", chip->oldstate);
2347 ret = -EAGAIN;
2348 case FL_PM_SUSPENDED:
2349 break;
2350 }
2351 spin_unlock(chip->mutex);
2352 }
2353
2354 /* Unlock the chips again */
2355
2356 if (ret) {
2357 for (i--; i >=0; i--) {
2358 chip = &cfi->chips[i];
2359
2360 spin_lock(chip->mutex);
2361
2362 if (chip->state == FL_PM_SUSPENDED) {
2363 /* No need to force it into a known state here,
2364 because we're returning failure, and it didn't
2365 get power cycled */
2366 chip->state = chip->oldstate;
2367 chip->oldstate = FL_READY;
2368 wake_up(&chip->wq);
2369 }
2370 spin_unlock(chip->mutex);
2371 }
2372 }
2373
2374 return ret;
2375 }
2376
2377 static void cfi_intelext_resume(struct mtd_info *mtd)
2378 {
2379 struct map_info *map = mtd->priv;
2380 struct cfi_private *cfi = map->fldrv_priv;
2381 int i;
2382 struct flchip *chip;
2383
2384 for (i=0; i<cfi->numchips; i++) {
2385
2386 chip = &cfi->chips[i];
2387
2388 spin_lock(chip->mutex);
2389
2390 /* Go to known state. Chip may have been power cycled */
2391 if (chip->state == FL_PM_SUSPENDED) {
2392 map_write(map, CMD(0xFF), cfi->chips[i].start);
2393 chip->oldstate = chip->state = FL_READY;
2394 wake_up(&chip->wq);
2395 }
2396
2397 spin_unlock(chip->mutex);
2398 }
2399 }
2400
2401 static int cfi_intelext_reset(struct mtd_info *mtd)
2402 {
2403 struct map_info *map = mtd->priv;
2404 struct cfi_private *cfi = map->fldrv_priv;
2405 int i, ret;
2406
2407 for (i=0; i < cfi->numchips; i++) {
2408 struct flchip *chip = &cfi->chips[i];
2409
2410 /* force the completion of any ongoing operation
2411 and switch to array mode so any bootloader in
2412 flash is accessible for soft reboot. */
2413 spin_lock(chip->mutex);
2414 ret = get_chip(map, chip, chip->start, FL_SYNCING);
2415 if (!ret) {
2416 map_write(map, CMD(0xff), chip->start);
2417 chip->state = FL_READY;
2418 }
2419 spin_unlock(chip->mutex);
2420 }
2421
2422 return 0;
2423 }
2424
2425 static int cfi_intelext_reboot(struct notifier_block *nb, unsigned long val,
2426 void *v)
2427 {
2428 struct mtd_info *mtd;
2429
2430 mtd = container_of(nb, struct mtd_info, reboot_notifier);
2431 cfi_intelext_reset(mtd);
2432 return NOTIFY_DONE;
2433 }
2434
2435 static void cfi_intelext_destroy(struct mtd_info *mtd)
2436 {
2437 struct map_info *map = mtd->priv;
2438 struct cfi_private *cfi = map->fldrv_priv;
2439 cfi_intelext_reset(mtd);
2440 unregister_reboot_notifier(&mtd->reboot_notifier);
2441 kfree(cfi->cmdset_priv);
2442 kfree(cfi->cfiq);
2443 kfree(cfi->chips[0].priv);
2444 kfree(cfi);
2445 kfree(mtd->eraseregions);
2446 }
2447
2448 static char im_name_0001[] = "cfi_cmdset_0001";
2449 static char im_name_0003[] = "cfi_cmdset_0003";
2450 static char im_name_0200[] = "cfi_cmdset_0200";
2451
2452 static int __init cfi_intelext_init(void)
2453 {
2454 inter_module_register(im_name_0001, THIS_MODULE, &cfi_cmdset_0001);
2455 inter_module_register(im_name_0003, THIS_MODULE, &cfi_cmdset_0001);
2456 inter_module_register(im_name_0200, THIS_MODULE, &cfi_cmdset_0001);
2457 return 0;
2458 }
2459
2460 static void __exit cfi_intelext_exit(void)
2461 {
2462 inter_module_unregister(im_name_0001);
2463 inter_module_unregister(im_name_0003);
2464 inter_module_unregister(im_name_0200);
2465 }
2466
2467 module_init(cfi_intelext_init);
2468 module_exit(cfi_intelext_exit);
2469
2470 MODULE_LICENSE("GPL");
2471 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al.");
2472 MODULE_DESCRIPTION("MTD chip driver for Intel/Sharp flash chips");
Linux with added FPC-III support