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