2 * Common Flash Interface support:
3 * Intel Extended Vendor Command Set (ID 0x0001)
5 * (C) 2000 Red Hat. GPL'd
8 * 10/10/2000 Nicolas Pitre <nico@fluxnic.net>
9 * - completely revamped method functions so they are aware and
10 * independent of the flash geometry (buswidth, interleave, etc.)
11 * - scalability vs code size is completely set at compile-time
12 * (see include/linux/mtd/cfi.h for selection)
13 * - optimized write buffer method
14 * 02/05/2002 Christopher Hoover <ch@hpl.hp.com>/<ch@murgatroid.com>
15 * - reworked lock/unlock/erase support for var size flash
16 * 21/03/2007 Rodolfo Giometti <giometti@linux.it>
17 * - auto unlock sectors on resume for auto locking flash on power up
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>
26 #include <asm/byteorder.h>
28 #include <linux/errno.h>
29 #include <linux/slab.h>
30 #include <linux/delay.h>
31 #include <linux/interrupt.h>
32 #include <linux/reboot.h>
33 #include <linux/bitmap.h>
34 #include <linux/mtd/xip.h>
35 #include <linux/mtd/map.h>
36 #include <linux/mtd/mtd.h>
37 #include <linux/mtd/cfi.h>
39 /* #define CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE */
40 /* #define CMDSET0001_DISABLE_WRITE_SUSPEND */
42 // debugging, turns off buffer write mode if set to 1
43 #define FORCE_WORD_WRITE 0
46 #define I82802AB 0x00ad
47 #define I82802AC 0x00ac
48 #define PF38F4476 0x881c
49 /* STMicroelectronics chips */
50 #define M50LPW080 0x002F
51 #define M50FLW080A 0x0080
52 #define M50FLW080B 0x0081
54 #define AT49BV640D 0x02de
55 #define AT49BV640DT 0x02db
57 static int cfi_intelext_read (struct mtd_info
*, loff_t
, size_t, size_t *, u_char
*);
58 static int cfi_intelext_write_words(struct mtd_info
*, loff_t
, size_t, size_t *, const u_char
*);
59 static int cfi_intelext_write_buffers(struct mtd_info
*, loff_t
, size_t, size_t *, const u_char
*);
60 static int cfi_intelext_writev(struct mtd_info
*, const struct kvec
*, unsigned long, loff_t
, size_t *);
61 static int cfi_intelext_erase_varsize(struct mtd_info
*, struct erase_info
*);
62 static void cfi_intelext_sync (struct mtd_info
*);
63 static int cfi_intelext_lock(struct mtd_info
*mtd
, loff_t ofs
, uint64_t len
);
64 static int cfi_intelext_unlock(struct mtd_info
*mtd
, loff_t ofs
, uint64_t len
);
65 static int cfi_intelext_is_locked(struct mtd_info
*mtd
, loff_t ofs
,
68 static int cfi_intelext_read_fact_prot_reg (struct mtd_info
*, loff_t
, size_t, size_t *, u_char
*);
69 static int cfi_intelext_read_user_prot_reg (struct mtd_info
*, loff_t
, size_t, size_t *, u_char
*);
70 static int cfi_intelext_write_user_prot_reg (struct mtd_info
*, loff_t
, size_t, size_t *, u_char
*);
71 static int cfi_intelext_lock_user_prot_reg (struct mtd_info
*, loff_t
, size_t);
72 static int cfi_intelext_get_fact_prot_info (struct mtd_info
*,
73 struct otp_info
*, size_t);
74 static int cfi_intelext_get_user_prot_info (struct mtd_info
*,
75 struct otp_info
*, size_t);
77 static int cfi_intelext_suspend (struct mtd_info
*);
78 static void cfi_intelext_resume (struct mtd_info
*);
79 static int cfi_intelext_reboot (struct notifier_block
*, unsigned long, void *);
81 static void cfi_intelext_destroy(struct mtd_info
*);
83 struct mtd_info
*cfi_cmdset_0001(struct map_info
*, int);
85 static struct mtd_info
*cfi_intelext_setup (struct mtd_info
*);
86 static int cfi_intelext_partition_fixup(struct mtd_info
*, struct cfi_private
**);
88 static int cfi_intelext_point (struct mtd_info
*mtd
, loff_t from
, size_t len
,
89 size_t *retlen
, void **virt
, resource_size_t
*phys
);
90 static void cfi_intelext_unpoint(struct mtd_info
*mtd
, loff_t from
, size_t len
);
92 static int chip_ready (struct map_info
*map
, struct flchip
*chip
, unsigned long adr
, int mode
);
93 static int get_chip(struct map_info
*map
, struct flchip
*chip
, unsigned long adr
, int mode
);
94 static void put_chip(struct map_info
*map
, struct flchip
*chip
, unsigned long adr
);
100 * *********** SETUP AND PROBE BITS ***********
103 static struct mtd_chip_driver cfi_intelext_chipdrv
= {
104 .probe
= NULL
, /* Not usable directly */
105 .destroy
= cfi_intelext_destroy
,
106 .name
= "cfi_cmdset_0001",
107 .module
= THIS_MODULE
110 /* #define DEBUG_LOCK_BITS */
111 /* #define DEBUG_CFI_FEATURES */
113 #ifdef DEBUG_CFI_FEATURES
114 static void cfi_tell_features(struct cfi_pri_intelext
*extp
)
117 printk(" Extended Query version %c.%c\n", extp
->MajorVersion
, extp
->MinorVersion
);
118 printk(" Feature/Command Support: %4.4X\n", extp
->FeatureSupport
);
119 printk(" - Chip Erase: %s\n", extp
->FeatureSupport
&1?"supported":"unsupported");
120 printk(" - Suspend Erase: %s\n", extp
->FeatureSupport
&2?"supported":"unsupported");
121 printk(" - Suspend Program: %s\n", extp
->FeatureSupport
&4?"supported":"unsupported");
122 printk(" - Legacy Lock/Unlock: %s\n", extp
->FeatureSupport
&8?"supported":"unsupported");
123 printk(" - Queued Erase: %s\n", extp
->FeatureSupport
&16?"supported":"unsupported");
124 printk(" - Instant block lock: %s\n", extp
->FeatureSupport
&32?"supported":"unsupported");
125 printk(" - Protection Bits: %s\n", extp
->FeatureSupport
&64?"supported":"unsupported");
126 printk(" - Page-mode read: %s\n", extp
->FeatureSupport
&128?"supported":"unsupported");
127 printk(" - Synchronous read: %s\n", extp
->FeatureSupport
&256?"supported":"unsupported");
128 printk(" - Simultaneous operations: %s\n", extp
->FeatureSupport
&512?"supported":"unsupported");
129 printk(" - Extended Flash Array: %s\n", extp
->FeatureSupport
&1024?"supported":"unsupported");
130 for (i
=11; i
<32; i
++) {
131 if (extp
->FeatureSupport
& (1<<i
))
132 printk(" - Unknown Bit %X: supported\n", i
);
135 printk(" Supported functions after Suspend: %2.2X\n", extp
->SuspendCmdSupport
);
136 printk(" - Program after Erase Suspend: %s\n", extp
->SuspendCmdSupport
&1?"supported":"unsupported");
137 for (i
=1; i
<8; i
++) {
138 if (extp
->SuspendCmdSupport
& (1<<i
))
139 printk(" - Unknown Bit %X: supported\n", i
);
142 printk(" Block Status Register Mask: %4.4X\n", extp
->BlkStatusRegMask
);
143 printk(" - Lock Bit Active: %s\n", extp
->BlkStatusRegMask
&1?"yes":"no");
144 printk(" - Lock-Down Bit Active: %s\n", extp
->BlkStatusRegMask
&2?"yes":"no");
145 for (i
=2; i
<3; i
++) {
146 if (extp
->BlkStatusRegMask
& (1<<i
))
147 printk(" - Unknown Bit %X Active: yes\n",i
);
149 printk(" - EFA Lock Bit: %s\n", extp
->BlkStatusRegMask
&16?"yes":"no");
150 printk(" - EFA Lock-Down Bit: %s\n", extp
->BlkStatusRegMask
&32?"yes":"no");
151 for (i
=6; i
<16; i
++) {
152 if (extp
->BlkStatusRegMask
& (1<<i
))
153 printk(" - Unknown Bit %X Active: yes\n",i
);
156 printk(" Vcc Logic Supply Optimum Program/Erase Voltage: %d.%d V\n",
157 extp
->VccOptimal
>> 4, extp
->VccOptimal
& 0xf);
158 if (extp
->VppOptimal
)
159 printk(" Vpp Programming Supply Optimum Program/Erase Voltage: %d.%d V\n",
160 extp
->VppOptimal
>> 4, extp
->VppOptimal
& 0xf);
164 /* Atmel chips don't use the same PRI format as Intel chips */
165 static void fixup_convert_atmel_pri(struct mtd_info
*mtd
)
167 struct map_info
*map
= mtd
->priv
;
168 struct cfi_private
*cfi
= map
->fldrv_priv
;
169 struct cfi_pri_intelext
*extp
= cfi
->cmdset_priv
;
170 struct cfi_pri_atmel atmel_pri
;
171 uint32_t features
= 0;
173 /* Reverse byteswapping */
174 extp
->FeatureSupport
= cpu_to_le32(extp
->FeatureSupport
);
175 extp
->BlkStatusRegMask
= cpu_to_le16(extp
->BlkStatusRegMask
);
176 extp
->ProtRegAddr
= cpu_to_le16(extp
->ProtRegAddr
);
178 memcpy(&atmel_pri
, extp
, sizeof(atmel_pri
));
179 memset((char *)extp
+ 5, 0, sizeof(*extp
) - 5);
181 printk(KERN_ERR
"atmel Features: %02x\n", atmel_pri
.Features
);
183 if (atmel_pri
.Features
& 0x01) /* chip erase supported */
185 if (atmel_pri
.Features
& 0x02) /* erase suspend supported */
187 if (atmel_pri
.Features
& 0x04) /* program suspend supported */
189 if (atmel_pri
.Features
& 0x08) /* simultaneous operations supported */
191 if (atmel_pri
.Features
& 0x20) /* page mode read supported */
193 if (atmel_pri
.Features
& 0x40) /* queued erase supported */
195 if (atmel_pri
.Features
& 0x80) /* Protection bits supported */
198 extp
->FeatureSupport
= features
;
200 /* burst write mode not supported */
201 cfi
->cfiq
->BufWriteTimeoutTyp
= 0;
202 cfi
->cfiq
->BufWriteTimeoutMax
= 0;
205 static void fixup_at49bv640dx_lock(struct mtd_info
*mtd
)
207 struct map_info
*map
= mtd
->priv
;
208 struct cfi_private
*cfi
= map
->fldrv_priv
;
209 struct cfi_pri_intelext
*cfip
= cfi
->cmdset_priv
;
211 cfip
->FeatureSupport
|= (1 << 5);
212 mtd
->flags
|= MTD_POWERUP_LOCK
;
215 #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
216 /* Some Intel Strata Flash prior to FPO revision C has bugs in this area */
217 static void fixup_intel_strataflash(struct mtd_info
*mtd
)
219 struct map_info
*map
= mtd
->priv
;
220 struct cfi_private
*cfi
= map
->fldrv_priv
;
221 struct cfi_pri_intelext
*extp
= cfi
->cmdset_priv
;
223 printk(KERN_WARNING
"cfi_cmdset_0001: Suspend "
224 "erase on write disabled.\n");
225 extp
->SuspendCmdSupport
&= ~1;
229 #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
230 static void fixup_no_write_suspend(struct mtd_info
*mtd
)
232 struct map_info
*map
= mtd
->priv
;
233 struct cfi_private
*cfi
= map
->fldrv_priv
;
234 struct cfi_pri_intelext
*cfip
= cfi
->cmdset_priv
;
236 if (cfip
&& (cfip
->FeatureSupport
&4)) {
237 cfip
->FeatureSupport
&= ~4;
238 printk(KERN_WARNING
"cfi_cmdset_0001: write suspend disabled\n");
243 static void fixup_st_m28w320ct(struct mtd_info
*mtd
)
245 struct map_info
*map
= mtd
->priv
;
246 struct cfi_private
*cfi
= map
->fldrv_priv
;
248 cfi
->cfiq
->BufWriteTimeoutTyp
= 0; /* Not supported */
249 cfi
->cfiq
->BufWriteTimeoutMax
= 0; /* Not supported */
252 static void fixup_st_m28w320cb(struct mtd_info
*mtd
)
254 struct map_info
*map
= mtd
->priv
;
255 struct cfi_private
*cfi
= map
->fldrv_priv
;
257 /* Note this is done after the region info is endian swapped */
258 cfi
->cfiq
->EraseRegionInfo
[1] =
259 (cfi
->cfiq
->EraseRegionInfo
[1] & 0xffff0000) | 0x3e;
262 static void fixup_use_point(struct mtd_info
*mtd
)
264 struct map_info
*map
= mtd
->priv
;
265 if (!mtd
->point
&& map_is_linear(map
)) {
266 mtd
->point
= cfi_intelext_point
;
267 mtd
->unpoint
= cfi_intelext_unpoint
;
271 static void fixup_use_write_buffers(struct mtd_info
*mtd
)
273 struct map_info
*map
= mtd
->priv
;
274 struct cfi_private
*cfi
= map
->fldrv_priv
;
275 if (cfi
->cfiq
->BufWriteTimeoutTyp
) {
276 printk(KERN_INFO
"Using buffer write method\n" );
277 mtd
->write
= cfi_intelext_write_buffers
;
278 mtd
->writev
= cfi_intelext_writev
;
283 * Some chips power-up with all sectors locked by default.
285 static void fixup_unlock_powerup_lock(struct mtd_info
*mtd
)
287 struct map_info
*map
= mtd
->priv
;
288 struct cfi_private
*cfi
= map
->fldrv_priv
;
289 struct cfi_pri_intelext
*cfip
= cfi
->cmdset_priv
;
291 if (cfip
->FeatureSupport
&32) {
292 printk(KERN_INFO
"Using auto-unlock on power-up/resume\n" );
293 mtd
->flags
|= MTD_POWERUP_LOCK
;
297 static struct cfi_fixup cfi_fixup_table
[] = {
298 { CFI_MFR_ATMEL
, CFI_ID_ANY
, fixup_convert_atmel_pri
},
299 { CFI_MFR_ATMEL
, AT49BV640D
, fixup_at49bv640dx_lock
},
300 { CFI_MFR_ATMEL
, AT49BV640DT
, fixup_at49bv640dx_lock
},
301 #ifdef CMDSET0001_DISABLE_ERASE_SUSPEND_ON_WRITE
302 { CFI_MFR_ANY
, CFI_ID_ANY
, fixup_intel_strataflash
},
304 #ifdef CMDSET0001_DISABLE_WRITE_SUSPEND
305 { CFI_MFR_ANY
, CFI_ID_ANY
, fixup_no_write_suspend
},
307 #if !FORCE_WORD_WRITE
308 { CFI_MFR_ANY
, CFI_ID_ANY
, fixup_use_write_buffers
},
310 { CFI_MFR_ST
, 0x00ba, /* M28W320CT */ fixup_st_m28w320ct
},
311 { CFI_MFR_ST
, 0x00bb, /* M28W320CB */ fixup_st_m28w320cb
},
312 { CFI_MFR_INTEL
, CFI_ID_ANY
, fixup_unlock_powerup_lock
},
316 static struct cfi_fixup jedec_fixup_table
[] = {
317 { CFI_MFR_INTEL
, I82802AB
, fixup_use_fwh_lock
},
318 { CFI_MFR_INTEL
, I82802AC
, fixup_use_fwh_lock
},
319 { CFI_MFR_ST
, M50LPW080
, fixup_use_fwh_lock
},
320 { CFI_MFR_ST
, M50FLW080A
, fixup_use_fwh_lock
},
321 { CFI_MFR_ST
, M50FLW080B
, fixup_use_fwh_lock
},
324 static struct cfi_fixup fixup_table
[] = {
325 /* The CFI vendor ids and the JEDEC vendor IDs appear
326 * to be common. It is like the devices id's are as
327 * well. This table is to pick all cases where
328 * we know that is the case.
330 { CFI_MFR_ANY
, CFI_ID_ANY
, fixup_use_point
},
334 static void cfi_fixup_major_minor(struct cfi_private
*cfi
,
335 struct cfi_pri_intelext
*extp
)
337 if (cfi
->mfr
== CFI_MFR_INTEL
&&
338 cfi
->id
== PF38F4476
&& extp
->MinorVersion
== '3')
339 extp
->MinorVersion
= '1';
342 static inline struct cfi_pri_intelext
*
343 read_pri_intelext(struct map_info
*map
, __u16 adr
)
345 struct cfi_private
*cfi
= map
->fldrv_priv
;
346 struct cfi_pri_intelext
*extp
;
347 unsigned int extra_size
= 0;
348 unsigned int extp_size
= sizeof(*extp
);
351 extp
= (struct cfi_pri_intelext
*)cfi_read_pri(map
, adr
, extp_size
, "Intel/Sharp");
355 cfi_fixup_major_minor(cfi
, extp
);
357 if (extp
->MajorVersion
!= '1' ||
358 (extp
->MinorVersion
< '0' || extp
->MinorVersion
> '5')) {
359 printk(KERN_ERR
" Unknown Intel/Sharp Extended Query "
360 "version %c.%c.\n", extp
->MajorVersion
,
366 /* Do some byteswapping if necessary */
367 extp
->FeatureSupport
= le32_to_cpu(extp
->FeatureSupport
);
368 extp
->BlkStatusRegMask
= le16_to_cpu(extp
->BlkStatusRegMask
);
369 extp
->ProtRegAddr
= le16_to_cpu(extp
->ProtRegAddr
);
371 if (extp
->MinorVersion
>= '0') {
374 /* Protection Register info */
375 extra_size
+= (extp
->NumProtectionFields
- 1) *
376 sizeof(struct cfi_intelext_otpinfo
);
379 if (extp
->MinorVersion
>= '1') {
380 /* Burst Read info */
382 if (extp_size
< sizeof(*extp
) + extra_size
)
384 extra_size
+= extp
->extra
[extra_size
- 1];
387 if (extp
->MinorVersion
>= '3') {
390 /* Number of hardware-partitions */
392 if (extp_size
< sizeof(*extp
) + extra_size
)
394 nb_parts
= extp
->extra
[extra_size
- 1];
396 /* skip the sizeof(partregion) field in CFI 1.4 */
397 if (extp
->MinorVersion
>= '4')
400 for (i
= 0; i
< nb_parts
; i
++) {
401 struct cfi_intelext_regioninfo
*rinfo
;
402 rinfo
= (struct cfi_intelext_regioninfo
*)&extp
->extra
[extra_size
];
403 extra_size
+= sizeof(*rinfo
);
404 if (extp_size
< sizeof(*extp
) + extra_size
)
406 rinfo
->NumIdentPartitions
=le16_to_cpu(rinfo
->NumIdentPartitions
);
407 extra_size
+= (rinfo
->NumBlockTypes
- 1)
408 * sizeof(struct cfi_intelext_blockinfo
);
411 if (extp
->MinorVersion
>= '4')
412 extra_size
+= sizeof(struct cfi_intelext_programming_regioninfo
);
414 if (extp_size
< sizeof(*extp
) + extra_size
) {
416 extp_size
= sizeof(*extp
) + extra_size
;
418 if (extp_size
> 4096) {
420 "%s: cfi_pri_intelext is too fat\n",
431 struct mtd_info
*cfi_cmdset_0001(struct map_info
*map
, int primary
)
433 struct cfi_private
*cfi
= map
->fldrv_priv
;
434 struct mtd_info
*mtd
;
437 mtd
= kzalloc(sizeof(*mtd
), GFP_KERNEL
);
439 printk(KERN_ERR
"Failed to allocate memory for MTD device\n");
443 mtd
->type
= MTD_NORFLASH
;
445 /* Fill in the default mtd operations */
446 mtd
->erase
= cfi_intelext_erase_varsize
;
447 mtd
->read
= cfi_intelext_read
;
448 mtd
->write
= cfi_intelext_write_words
;
449 mtd
->sync
= cfi_intelext_sync
;
450 mtd
->lock
= cfi_intelext_lock
;
451 mtd
->unlock
= cfi_intelext_unlock
;
452 mtd
->is_locked
= cfi_intelext_is_locked
;
453 mtd
->suspend
= cfi_intelext_suspend
;
454 mtd
->resume
= cfi_intelext_resume
;
455 mtd
->flags
= MTD_CAP_NORFLASH
;
456 mtd
->name
= map
->name
;
458 mtd
->writebufsize
= cfi_interleave(cfi
) << cfi
->cfiq
->MaxBufWriteSize
;
460 mtd
->reboot_notifier
.notifier_call
= cfi_intelext_reboot
;
462 if (cfi
->cfi_mode
== CFI_MODE_CFI
) {
464 * It's a real CFI chip, not one for which the probe
465 * routine faked a CFI structure. So we read the feature
468 __u16 adr
= primary
?cfi
->cfiq
->P_ADR
:cfi
->cfiq
->A_ADR
;
469 struct cfi_pri_intelext
*extp
;
471 extp
= read_pri_intelext(map
, adr
);
477 /* Install our own private info structure */
478 cfi
->cmdset_priv
= extp
;
480 cfi_fixup(mtd
, cfi_fixup_table
);
482 #ifdef DEBUG_CFI_FEATURES
483 /* Tell the user about it in lots of lovely detail */
484 cfi_tell_features(extp
);
487 if(extp
->SuspendCmdSupport
& 1) {
488 printk(KERN_NOTICE
"cfi_cmdset_0001: Erase suspend on write enabled\n");
491 else if (cfi
->cfi_mode
== CFI_MODE_JEDEC
) {
492 /* Apply jedec specific fixups */
493 cfi_fixup(mtd
, jedec_fixup_table
);
495 /* Apply generic fixups */
496 cfi_fixup(mtd
, fixup_table
);
498 for (i
=0; i
< cfi
->numchips
; i
++) {
499 if (cfi
->cfiq
->WordWriteTimeoutTyp
)
500 cfi
->chips
[i
].word_write_time
=
501 1<<cfi
->cfiq
->WordWriteTimeoutTyp
;
503 cfi
->chips
[i
].word_write_time
= 50000;
505 if (cfi
->cfiq
->BufWriteTimeoutTyp
)
506 cfi
->chips
[i
].buffer_write_time
=
507 1<<cfi
->cfiq
->BufWriteTimeoutTyp
;
508 /* No default; if it isn't specified, we won't use it */
510 if (cfi
->cfiq
->BlockEraseTimeoutTyp
)
511 cfi
->chips
[i
].erase_time
=
512 1000<<cfi
->cfiq
->BlockEraseTimeoutTyp
;
514 cfi
->chips
[i
].erase_time
= 2000000;
516 if (cfi
->cfiq
->WordWriteTimeoutTyp
&&
517 cfi
->cfiq
->WordWriteTimeoutMax
)
518 cfi
->chips
[i
].word_write_time_max
=
519 1<<(cfi
->cfiq
->WordWriteTimeoutTyp
+
520 cfi
->cfiq
->WordWriteTimeoutMax
);
522 cfi
->chips
[i
].word_write_time_max
= 50000 * 8;
524 if (cfi
->cfiq
->BufWriteTimeoutTyp
&&
525 cfi
->cfiq
->BufWriteTimeoutMax
)
526 cfi
->chips
[i
].buffer_write_time_max
=
527 1<<(cfi
->cfiq
->BufWriteTimeoutTyp
+
528 cfi
->cfiq
->BufWriteTimeoutMax
);
530 if (cfi
->cfiq
->BlockEraseTimeoutTyp
&&
531 cfi
->cfiq
->BlockEraseTimeoutMax
)
532 cfi
->chips
[i
].erase_time_max
=
533 1000<<(cfi
->cfiq
->BlockEraseTimeoutTyp
+
534 cfi
->cfiq
->BlockEraseTimeoutMax
);
536 cfi
->chips
[i
].erase_time_max
= 2000000 * 8;
538 cfi
->chips
[i
].ref_point_counter
= 0;
539 init_waitqueue_head(&(cfi
->chips
[i
].wq
));
542 map
->fldrv
= &cfi_intelext_chipdrv
;
544 return cfi_intelext_setup(mtd
);
546 struct mtd_info
*cfi_cmdset_0003(struct map_info
*map
, int primary
) __attribute__((alias("cfi_cmdset_0001")));
547 struct mtd_info
*cfi_cmdset_0200(struct map_info
*map
, int primary
) __attribute__((alias("cfi_cmdset_0001")));
548 EXPORT_SYMBOL_GPL(cfi_cmdset_0001
);
549 EXPORT_SYMBOL_GPL(cfi_cmdset_0003
);
550 EXPORT_SYMBOL_GPL(cfi_cmdset_0200
);
552 static struct mtd_info
*cfi_intelext_setup(struct mtd_info
*mtd
)
554 struct map_info
*map
= mtd
->priv
;
555 struct cfi_private
*cfi
= map
->fldrv_priv
;
556 unsigned long offset
= 0;
558 unsigned long devsize
= (1<<cfi
->cfiq
->DevSize
) * cfi
->interleave
;
560 //printk(KERN_DEBUG "number of CFI chips: %d\n", cfi->numchips);
562 mtd
->size
= devsize
* cfi
->numchips
;
564 mtd
->numeraseregions
= cfi
->cfiq
->NumEraseRegions
* cfi
->numchips
;
565 mtd
->eraseregions
= kmalloc(sizeof(struct mtd_erase_region_info
)
566 * mtd
->numeraseregions
, GFP_KERNEL
);
567 if (!mtd
->eraseregions
) {
568 printk(KERN_ERR
"Failed to allocate memory for MTD erase region info\n");
572 for (i
=0; i
<cfi
->cfiq
->NumEraseRegions
; i
++) {
573 unsigned long ernum
, ersize
;
574 ersize
= ((cfi
->cfiq
->EraseRegionInfo
[i
] >> 8) & ~0xff) * cfi
->interleave
;
575 ernum
= (cfi
->cfiq
->EraseRegionInfo
[i
] & 0xffff) + 1;
577 if (mtd
->erasesize
< ersize
) {
578 mtd
->erasesize
= ersize
;
580 for (j
=0; j
<cfi
->numchips
; j
++) {
581 mtd
->eraseregions
[(j
*cfi
->cfiq
->NumEraseRegions
)+i
].offset
= (j
*devsize
)+offset
;
582 mtd
->eraseregions
[(j
*cfi
->cfiq
->NumEraseRegions
)+i
].erasesize
= ersize
;
583 mtd
->eraseregions
[(j
*cfi
->cfiq
->NumEraseRegions
)+i
].numblocks
= ernum
;
584 mtd
->eraseregions
[(j
*cfi
->cfiq
->NumEraseRegions
)+i
].lockmap
= kmalloc(ernum
/ 8 + 1, GFP_KERNEL
);
586 offset
+= (ersize
* ernum
);
589 if (offset
!= devsize
) {
591 printk(KERN_WARNING
"Sum of regions (%lx) != total size of set of interleaved chips (%lx)\n", offset
, devsize
);
595 for (i
=0; i
<mtd
->numeraseregions
;i
++){
596 printk(KERN_DEBUG
"erase region %d: offset=0x%llx,size=0x%x,blocks=%d\n",
597 i
,(unsigned long long)mtd
->eraseregions
[i
].offset
,
598 mtd
->eraseregions
[i
].erasesize
,
599 mtd
->eraseregions
[i
].numblocks
);
602 #ifdef CONFIG_MTD_OTP
603 mtd
->read_fact_prot_reg
= cfi_intelext_read_fact_prot_reg
;
604 mtd
->read_user_prot_reg
= cfi_intelext_read_user_prot_reg
;
605 mtd
->write_user_prot_reg
= cfi_intelext_write_user_prot_reg
;
606 mtd
->lock_user_prot_reg
= cfi_intelext_lock_user_prot_reg
;
607 mtd
->get_fact_prot_info
= cfi_intelext_get_fact_prot_info
;
608 mtd
->get_user_prot_info
= cfi_intelext_get_user_prot_info
;
611 /* This function has the potential to distort the reality
612 a bit and therefore should be called last. */
613 if (cfi_intelext_partition_fixup(mtd
, &cfi
) != 0)
616 __module_get(THIS_MODULE
);
617 register_reboot_notifier(&mtd
->reboot_notifier
);
621 kfree(mtd
->eraseregions
);
623 kfree(cfi
->cmdset_priv
);
627 static int cfi_intelext_partition_fixup(struct mtd_info
*mtd
,
628 struct cfi_private
**pcfi
)
630 struct map_info
*map
= mtd
->priv
;
631 struct cfi_private
*cfi
= *pcfi
;
632 struct cfi_pri_intelext
*extp
= cfi
->cmdset_priv
;
635 * Probing of multi-partition flash chips.
637 * To support multiple partitions when available, we simply arrange
638 * for each of them to have their own flchip structure even if they
639 * are on the same physical chip. This means completely recreating
640 * a new cfi_private structure right here which is a blatent code
641 * layering violation, but this is still the least intrusive
642 * arrangement at this point. This can be rearranged in the future
643 * if someone feels motivated enough. --nico
645 if (extp
&& extp
->MajorVersion
== '1' && extp
->MinorVersion
>= '3'
646 && extp
->FeatureSupport
& (1 << 9)) {
647 struct cfi_private
*newcfi
;
649 struct flchip_shared
*shared
;
650 int offs
, numregions
, numparts
, partshift
, numvirtchips
, i
, j
;
652 /* Protection Register info */
653 offs
= (extp
->NumProtectionFields
- 1) *
654 sizeof(struct cfi_intelext_otpinfo
);
656 /* Burst Read info */
657 offs
+= extp
->extra
[offs
+1]+2;
659 /* Number of partition regions */
660 numregions
= extp
->extra
[offs
];
663 /* skip the sizeof(partregion) field in CFI 1.4 */
664 if (extp
->MinorVersion
>= '4')
667 /* Number of hardware partitions */
669 for (i
= 0; i
< numregions
; i
++) {
670 struct cfi_intelext_regioninfo
*rinfo
;
671 rinfo
= (struct cfi_intelext_regioninfo
*)&extp
->extra
[offs
];
672 numparts
+= rinfo
->NumIdentPartitions
;
673 offs
+= sizeof(*rinfo
)
674 + (rinfo
->NumBlockTypes
- 1) *
675 sizeof(struct cfi_intelext_blockinfo
);
681 /* Programming Region info */
682 if (extp
->MinorVersion
>= '4') {
683 struct cfi_intelext_programming_regioninfo
*prinfo
;
684 prinfo
= (struct cfi_intelext_programming_regioninfo
*)&extp
->extra
[offs
];
685 mtd
->writesize
= cfi
->interleave
<< prinfo
->ProgRegShift
;
686 mtd
->flags
&= ~MTD_BIT_WRITEABLE
;
687 printk(KERN_DEBUG
"%s: program region size/ctrl_valid/ctrl_inval = %d/%d/%d\n",
688 map
->name
, mtd
->writesize
,
689 cfi
->interleave
* prinfo
->ControlValid
,
690 cfi
->interleave
* prinfo
->ControlInvalid
);
694 * All functions below currently rely on all chips having
695 * the same geometry so we'll just assume that all hardware
696 * partitions are of the same size too.
698 partshift
= cfi
->chipshift
- __ffs(numparts
);
700 if ((1 << partshift
) < mtd
->erasesize
) {
702 "%s: bad number of hw partitions (%d)\n",
707 numvirtchips
= cfi
->numchips
* numparts
;
708 newcfi
= kmalloc(sizeof(struct cfi_private
) + numvirtchips
* sizeof(struct flchip
), GFP_KERNEL
);
711 shared
= kmalloc(sizeof(struct flchip_shared
) * cfi
->numchips
, GFP_KERNEL
);
716 memcpy(newcfi
, cfi
, sizeof(struct cfi_private
));
717 newcfi
->numchips
= numvirtchips
;
718 newcfi
->chipshift
= partshift
;
720 chip
= &newcfi
->chips
[0];
721 for (i
= 0; i
< cfi
->numchips
; i
++) {
722 shared
[i
].writing
= shared
[i
].erasing
= NULL
;
723 mutex_init(&shared
[i
].lock
);
724 for (j
= 0; j
< numparts
; j
++) {
725 *chip
= cfi
->chips
[i
];
726 chip
->start
+= j
<< partshift
;
727 chip
->priv
= &shared
[i
];
728 /* those should be reset too since
729 they create memory references. */
730 init_waitqueue_head(&chip
->wq
);
731 mutex_init(&chip
->mutex
);
736 printk(KERN_DEBUG
"%s: %d set(s) of %d interleaved chips "
737 "--> %d partitions of %d KiB\n",
738 map
->name
, cfi
->numchips
, cfi
->interleave
,
739 newcfi
->numchips
, 1<<(newcfi
->chipshift
-10));
741 map
->fldrv_priv
= newcfi
;
750 * *********** CHIP ACCESS FUNCTIONS ***********
752 static int chip_ready (struct map_info
*map
, struct flchip
*chip
, unsigned long adr
, int mode
)
754 DECLARE_WAITQUEUE(wait
, current
);
755 struct cfi_private
*cfi
= map
->fldrv_priv
;
756 map_word status
, status_OK
= CMD(0x80), status_PWS
= CMD(0x01);
757 struct cfi_pri_intelext
*cfip
= cfi
->cmdset_priv
;
758 unsigned long timeo
= jiffies
+ HZ
;
760 /* Prevent setting state FL_SYNCING for chip in suspended state. */
761 if (mode
== FL_SYNCING
&& chip
->oldstate
!= FL_READY
)
764 switch (chip
->state
) {
768 status
= map_read(map
, adr
);
769 if (map_word_andequal(map
, status
, status_OK
, status_OK
))
772 /* At this point we're fine with write operations
773 in other partitions as they don't conflict. */
774 if (chip
->priv
&& map_word_andequal(map
, status
, status_PWS
, status_PWS
))
777 mutex_unlock(&chip
->mutex
);
779 mutex_lock(&chip
->mutex
);
780 /* Someone else might have been playing with it. */
791 !(cfip
->FeatureSupport
& 2) ||
792 !(mode
== FL_READY
|| mode
== FL_POINT
||
793 (mode
== FL_WRITING
&& (cfip
->SuspendCmdSupport
& 1))))
798 map_write(map
, CMD(0xB0), adr
);
800 /* If the flash has finished erasing, then 'erase suspend'
801 * appears to make some (28F320) flash devices switch to
802 * 'read' mode. Make sure that we switch to 'read status'
803 * mode so we get the right data. --rmk
805 map_write(map
, CMD(0x70), adr
);
806 chip
->oldstate
= FL_ERASING
;
807 chip
->state
= FL_ERASE_SUSPENDING
;
808 chip
->erase_suspended
= 1;
810 status
= map_read(map
, adr
);
811 if (map_word_andequal(map
, status
, status_OK
, status_OK
))
814 if (time_after(jiffies
, timeo
)) {
815 /* Urgh. Resume and pretend we weren't here. */
816 map_write(map
, CMD(0xd0), adr
);
817 /* Make sure we're in 'read status' mode if it had finished */
818 map_write(map
, CMD(0x70), adr
);
819 chip
->state
= FL_ERASING
;
820 chip
->oldstate
= FL_READY
;
821 printk(KERN_ERR
"%s: Chip not ready after erase "
822 "suspended: status = 0x%lx\n", map
->name
, status
.x
[0]);
826 mutex_unlock(&chip
->mutex
);
828 mutex_lock(&chip
->mutex
);
829 /* Nobody will touch it while it's in state FL_ERASE_SUSPENDING.
830 So we can just loop here. */
832 chip
->state
= FL_STATUS
;
835 case FL_XIP_WHILE_ERASING
:
836 if (mode
!= FL_READY
&& mode
!= FL_POINT
&&
837 (mode
!= FL_WRITING
|| !cfip
|| !(cfip
->SuspendCmdSupport
&1)))
839 chip
->oldstate
= chip
->state
;
840 chip
->state
= FL_READY
;
844 /* The machine is rebooting now,so no one can get chip anymore */
847 /* Only if there's no operation suspended... */
848 if (mode
== FL_READY
&& chip
->oldstate
== FL_READY
)
853 set_current_state(TASK_UNINTERRUPTIBLE
);
854 add_wait_queue(&chip
->wq
, &wait
);
855 mutex_unlock(&chip
->mutex
);
857 remove_wait_queue(&chip
->wq
, &wait
);
858 mutex_lock(&chip
->mutex
);
863 static int get_chip(struct map_info
*map
, struct flchip
*chip
, unsigned long adr
, int mode
)
866 DECLARE_WAITQUEUE(wait
, current
);
870 (mode
== FL_WRITING
|| mode
== FL_ERASING
|| mode
== FL_OTP_WRITE
871 || mode
== FL_SHUTDOWN
) && chip
->state
!= FL_SYNCING
) {
873 * OK. We have possibility for contention on the write/erase
874 * operations which are global to the real chip and not per
875 * partition. So let's fight it over in the partition which
876 * currently has authority on the operation.
878 * The rules are as follows:
880 * - any write operation must own shared->writing.
882 * - any erase operation must own _both_ shared->writing and
885 * - contention arbitration is handled in the owner's context.
887 * The 'shared' struct can be read and/or written only when
890 struct flchip_shared
*shared
= chip
->priv
;
891 struct flchip
*contender
;
892 mutex_lock(&shared
->lock
);
893 contender
= shared
->writing
;
894 if (contender
&& contender
!= chip
) {
896 * The engine to perform desired operation on this
897 * partition is already in use by someone else.
898 * Let's fight over it in the context of the chip
899 * currently using it. If it is possible to suspend,
900 * that other partition will do just that, otherwise
901 * it'll happily send us to sleep. In any case, when
902 * get_chip returns success we're clear to go ahead.
904 ret
= mutex_trylock(&contender
->mutex
);
905 mutex_unlock(&shared
->lock
);
908 mutex_unlock(&chip
->mutex
);
909 ret
= chip_ready(map
, contender
, contender
->start
, mode
);
910 mutex_lock(&chip
->mutex
);
912 if (ret
== -EAGAIN
) {
913 mutex_unlock(&contender
->mutex
);
917 mutex_unlock(&contender
->mutex
);
920 mutex_lock(&shared
->lock
);
922 /* We should not own chip if it is already
923 * in FL_SYNCING state. Put contender and retry. */
924 if (chip
->state
== FL_SYNCING
) {
925 put_chip(map
, contender
, contender
->start
);
926 mutex_unlock(&contender
->mutex
);
929 mutex_unlock(&contender
->mutex
);
932 /* Check if we already have suspended erase
933 * on this chip. Sleep. */
934 if (mode
== FL_ERASING
&& shared
->erasing
935 && shared
->erasing
->oldstate
== FL_ERASING
) {
936 mutex_unlock(&shared
->lock
);
937 set_current_state(TASK_UNINTERRUPTIBLE
);
938 add_wait_queue(&chip
->wq
, &wait
);
939 mutex_unlock(&chip
->mutex
);
941 remove_wait_queue(&chip
->wq
, &wait
);
942 mutex_lock(&chip
->mutex
);
947 shared
->writing
= chip
;
948 if (mode
== FL_ERASING
)
949 shared
->erasing
= chip
;
950 mutex_unlock(&shared
->lock
);
952 ret
= chip_ready(map
, chip
, adr
, mode
);
959 static void put_chip(struct map_info
*map
, struct flchip
*chip
, unsigned long adr
)
961 struct cfi_private
*cfi
= map
->fldrv_priv
;
964 struct flchip_shared
*shared
= chip
->priv
;
965 mutex_lock(&shared
->lock
);
966 if (shared
->writing
== chip
&& chip
->oldstate
== FL_READY
) {
967 /* We own the ability to write, but we're done */
968 shared
->writing
= shared
->erasing
;
969 if (shared
->writing
&& shared
->writing
!= chip
) {
970 /* give back ownership to who we loaned it from */
971 struct flchip
*loaner
= shared
->writing
;
972 mutex_lock(&loaner
->mutex
);
973 mutex_unlock(&shared
->lock
);
974 mutex_unlock(&chip
->mutex
);
975 put_chip(map
, loaner
, loaner
->start
);
976 mutex_lock(&chip
->mutex
);
977 mutex_unlock(&loaner
->mutex
);
981 shared
->erasing
= NULL
;
982 shared
->writing
= NULL
;
983 } else if (shared
->erasing
== chip
&& shared
->writing
!= chip
) {
985 * We own the ability to erase without the ability
986 * to write, which means the erase was suspended
987 * and some other partition is currently writing.
988 * Don't let the switch below mess things up since
989 * we don't have ownership to resume anything.
991 mutex_unlock(&shared
->lock
);
995 mutex_unlock(&shared
->lock
);
998 switch(chip
->oldstate
) {
1000 chip
->state
= chip
->oldstate
;
1001 /* What if one interleaved chip has finished and the
1002 other hasn't? The old code would leave the finished
1003 one in READY mode. That's bad, and caused -EROFS
1004 errors to be returned from do_erase_oneblock because
1005 that's the only bit it checked for at the time.
1006 As the state machine appears to explicitly allow
1007 sending the 0x70 (Read Status) command to an erasing
1008 chip and expecting it to be ignored, that's what we
1010 map_write(map
, CMD(0xd0), adr
);
1011 map_write(map
, CMD(0x70), adr
);
1012 chip
->oldstate
= FL_READY
;
1013 chip
->state
= FL_ERASING
;
1016 case FL_XIP_WHILE_ERASING
:
1017 chip
->state
= chip
->oldstate
;
1018 chip
->oldstate
= FL_READY
;
1023 case FL_JEDEC_QUERY
:
1024 /* We should really make set_vpp() count, rather than doing this */
1028 printk(KERN_ERR
"%s: put_chip() called with oldstate %d!!\n", map
->name
, chip
->oldstate
);
1033 #ifdef CONFIG_MTD_XIP
1036 * No interrupt what so ever can be serviced while the flash isn't in array
1037 * mode. This is ensured by the xip_disable() and xip_enable() functions
1038 * enclosing any code path where the flash is known not to be in array mode.
1039 * And within a XIP disabled code path, only functions marked with __xipram
1040 * may be called and nothing else (it's a good thing to inspect generated
1041 * assembly to make sure inline functions were actually inlined and that gcc
1042 * didn't emit calls to its own support functions). Also configuring MTD CFI
1043 * support to a single buswidth and a single interleave is also recommended.
1046 static void xip_disable(struct map_info
*map
, struct flchip
*chip
,
1049 /* TODO: chips with no XIP use should ignore and return */
1050 (void) map_read(map
, adr
); /* ensure mmu mapping is up to date */
1051 local_irq_disable();
1054 static void __xipram
xip_enable(struct map_info
*map
, struct flchip
*chip
,
1057 struct cfi_private
*cfi
= map
->fldrv_priv
;
1058 if (chip
->state
!= FL_POINT
&& chip
->state
!= FL_READY
) {
1059 map_write(map
, CMD(0xff), adr
);
1060 chip
->state
= FL_READY
;
1062 (void) map_read(map
, adr
);
1068 * When a delay is required for the flash operation to complete, the
1069 * xip_wait_for_operation() function is polling for both the given timeout
1070 * and pending (but still masked) hardware interrupts. Whenever there is an
1071 * interrupt pending then the flash erase or write operation is suspended,
1072 * array mode restored and interrupts unmasked. Task scheduling might also
1073 * happen at that point. The CPU eventually returns from the interrupt or
1074 * the call to schedule() and the suspended flash operation is resumed for
1075 * the remaining of the delay period.
1077 * Warning: this function _will_ fool interrupt latency tracing tools.
1080 static int __xipram
xip_wait_for_operation(
1081 struct map_info
*map
, struct flchip
*chip
,
1082 unsigned long adr
, unsigned int chip_op_time_max
)
1084 struct cfi_private
*cfi
= map
->fldrv_priv
;
1085 struct cfi_pri_intelext
*cfip
= cfi
->cmdset_priv
;
1086 map_word status
, OK
= CMD(0x80);
1087 unsigned long usec
, suspended
, start
, done
;
1088 flstate_t oldstate
, newstate
;
1090 start
= xip_currtime();
1091 usec
= chip_op_time_max
;
1098 if (xip_irqpending() && cfip
&&
1099 ((chip
->state
== FL_ERASING
&& (cfip
->FeatureSupport
&2)) ||
1100 (chip
->state
== FL_WRITING
&& (cfip
->FeatureSupport
&4))) &&
1101 (cfi_interleave_is_1(cfi
) || chip
->oldstate
== FL_READY
)) {
1103 * Let's suspend the erase or write operation when
1104 * supported. Note that we currently don't try to
1105 * suspend interleaved chips if there is already
1106 * another operation suspended (imagine what happens
1107 * when one chip was already done with the current
1108 * operation while another chip suspended it, then
1109 * we resume the whole thing at once). Yes, it
1113 map_write(map
, CMD(0xb0), adr
);
1114 map_write(map
, CMD(0x70), adr
);
1115 suspended
= xip_currtime();
1117 if (xip_elapsed_since(suspended
) > 100000) {
1119 * The chip doesn't want to suspend
1120 * after waiting for 100 msecs.
1121 * This is a critical error but there
1122 * is not much we can do here.
1126 status
= map_read(map
, adr
);
1127 } while (!map_word_andequal(map
, status
, OK
, OK
));
1129 /* Suspend succeeded */
1130 oldstate
= chip
->state
;
1131 if (oldstate
== FL_ERASING
) {
1132 if (!map_word_bitsset(map
, status
, CMD(0x40)))
1134 newstate
= FL_XIP_WHILE_ERASING
;
1135 chip
->erase_suspended
= 1;
1137 if (!map_word_bitsset(map
, status
, CMD(0x04)))
1139 newstate
= FL_XIP_WHILE_WRITING
;
1140 chip
->write_suspended
= 1;
1142 chip
->state
= newstate
;
1143 map_write(map
, CMD(0xff), adr
);
1144 (void) map_read(map
, adr
);
1147 mutex_unlock(&chip
->mutex
);
1152 * We're back. However someone else might have
1153 * decided to go write to the chip if we are in
1154 * a suspended erase state. If so let's wait
1157 mutex_lock(&chip
->mutex
);
1158 while (chip
->state
!= newstate
) {
1159 DECLARE_WAITQUEUE(wait
, current
);
1160 set_current_state(TASK_UNINTERRUPTIBLE
);
1161 add_wait_queue(&chip
->wq
, &wait
);
1162 mutex_unlock(&chip
->mutex
);
1164 remove_wait_queue(&chip
->wq
, &wait
);
1165 mutex_lock(&chip
->mutex
);
1167 /* Disallow XIP again */
1168 local_irq_disable();
1170 /* Resume the write or erase operation */
1171 map_write(map
, CMD(0xd0), adr
);
1172 map_write(map
, CMD(0x70), adr
);
1173 chip
->state
= oldstate
;
1174 start
= xip_currtime();
1175 } else if (usec
>= 1000000/HZ
) {
1177 * Try to save on CPU power when waiting delay
1178 * is at least a system timer tick period.
1179 * No need to be extremely accurate here.
1183 status
= map_read(map
, adr
);
1184 done
= xip_elapsed_since(start
);
1185 } while (!map_word_andequal(map
, status
, OK
, OK
)
1188 return (done
>= usec
) ? -ETIME
: 0;
1192 * The INVALIDATE_CACHED_RANGE() macro is normally used in parallel while
1193 * the flash is actively programming or erasing since we have to poll for
1194 * the operation to complete anyway. We can't do that in a generic way with
1195 * a XIP setup so do it before the actual flash operation in this case
1196 * and stub it out from INVAL_CACHE_AND_WAIT.
1198 #define XIP_INVAL_CACHED_RANGE(map, from, size) \
1199 INVALIDATE_CACHED_RANGE(map, from, size)
1201 #define INVAL_CACHE_AND_WAIT(map, chip, cmd_adr, inval_adr, inval_len, usec, usec_max) \
1202 xip_wait_for_operation(map, chip, cmd_adr, usec_max)
1206 #define xip_disable(map, chip, adr)
1207 #define xip_enable(map, chip, adr)
1208 #define XIP_INVAL_CACHED_RANGE(x...)
1209 #define INVAL_CACHE_AND_WAIT inval_cache_and_wait_for_operation
1211 static int inval_cache_and_wait_for_operation(
1212 struct map_info
*map
, struct flchip
*chip
,
1213 unsigned long cmd_adr
, unsigned long inval_adr
, int inval_len
,
1214 unsigned int chip_op_time
, unsigned int chip_op_time_max
)
1216 struct cfi_private
*cfi
= map
->fldrv_priv
;
1217 map_word status
, status_OK
= CMD(0x80);
1218 int chip_state
= chip
->state
;
1219 unsigned int timeo
, sleep_time
, reset_timeo
;
1221 mutex_unlock(&chip
->mutex
);
1223 INVALIDATE_CACHED_RANGE(map
, inval_adr
, inval_len
);
1224 mutex_lock(&chip
->mutex
);
1226 timeo
= chip_op_time_max
;
1229 reset_timeo
= timeo
;
1230 sleep_time
= chip_op_time
/ 2;
1233 if (chip
->state
!= chip_state
) {
1234 /* Someone's suspended the operation: sleep */
1235 DECLARE_WAITQUEUE(wait
, current
);
1236 set_current_state(TASK_UNINTERRUPTIBLE
);
1237 add_wait_queue(&chip
->wq
, &wait
);
1238 mutex_unlock(&chip
->mutex
);
1240 remove_wait_queue(&chip
->wq
, &wait
);
1241 mutex_lock(&chip
->mutex
);
1245 status
= map_read(map
, cmd_adr
);
1246 if (map_word_andequal(map
, status
, status_OK
, status_OK
))
1249 if (chip
->erase_suspended
&& chip_state
== FL_ERASING
) {
1250 /* Erase suspend occurred while sleep: reset timeout */
1251 timeo
= reset_timeo
;
1252 chip
->erase_suspended
= 0;
1254 if (chip
->write_suspended
&& chip_state
== FL_WRITING
) {
1255 /* Write suspend occurred while sleep: reset timeout */
1256 timeo
= reset_timeo
;
1257 chip
->write_suspended
= 0;
1260 map_write(map
, CMD(0x70), cmd_adr
);
1261 chip
->state
= FL_STATUS
;
1265 /* OK Still waiting. Drop the lock, wait a while and retry. */
1266 mutex_unlock(&chip
->mutex
);
1267 if (sleep_time
>= 1000000/HZ
) {
1269 * Half of the normal delay still remaining
1270 * can be performed with a sleeping delay instead
1273 msleep(sleep_time
/1000);
1274 timeo
-= sleep_time
;
1275 sleep_time
= 1000000/HZ
;
1281 mutex_lock(&chip
->mutex
);
1284 /* Done and happy. */
1285 chip
->state
= FL_STATUS
;
1291 #define WAIT_TIMEOUT(map, chip, adr, udelay, udelay_max) \
1292 INVAL_CACHE_AND_WAIT(map, chip, adr, 0, 0, udelay, udelay_max);
1295 static int do_point_onechip (struct map_info
*map
, struct flchip
*chip
, loff_t adr
, size_t len
)
1297 unsigned long cmd_addr
;
1298 struct cfi_private
*cfi
= map
->fldrv_priv
;
1303 /* Ensure cmd read/writes are aligned. */
1304 cmd_addr
= adr
& ~(map_bankwidth(map
)-1);
1306 mutex_lock(&chip
->mutex
);
1308 ret
= get_chip(map
, chip
, cmd_addr
, FL_POINT
);
1311 if (chip
->state
!= FL_POINT
&& chip
->state
!= FL_READY
)
1312 map_write(map
, CMD(0xff), cmd_addr
);
1314 chip
->state
= FL_POINT
;
1315 chip
->ref_point_counter
++;
1317 mutex_unlock(&chip
->mutex
);
1322 static int cfi_intelext_point(struct mtd_info
*mtd
, loff_t from
, size_t len
,
1323 size_t *retlen
, void **virt
, resource_size_t
*phys
)
1325 struct map_info
*map
= mtd
->priv
;
1326 struct cfi_private
*cfi
= map
->fldrv_priv
;
1327 unsigned long ofs
, last_end
= 0;
1331 if (!map
->virt
|| (from
+ len
> mtd
->size
))
1334 /* Now lock the chip(s) to POINT state */
1336 /* ofs: offset within the first chip that the first read should start */
1337 chipnum
= (from
>> cfi
->chipshift
);
1338 ofs
= from
- (chipnum
<< cfi
->chipshift
);
1340 *virt
= map
->virt
+ cfi
->chips
[chipnum
].start
+ ofs
;
1343 *phys
= map
->phys
+ cfi
->chips
[chipnum
].start
+ ofs
;
1346 unsigned long thislen
;
1348 if (chipnum
>= cfi
->numchips
)
1351 /* We cannot point across chips that are virtually disjoint */
1353 last_end
= cfi
->chips
[chipnum
].start
;
1354 else if (cfi
->chips
[chipnum
].start
!= last_end
)
1357 if ((len
+ ofs
-1) >> cfi
->chipshift
)
1358 thislen
= (1<<cfi
->chipshift
) - ofs
;
1362 ret
= do_point_onechip(map
, &cfi
->chips
[chipnum
], ofs
, thislen
);
1370 last_end
+= 1 << cfi
->chipshift
;
1376 static void cfi_intelext_unpoint(struct mtd_info
*mtd
, loff_t from
, size_t len
)
1378 struct map_info
*map
= mtd
->priv
;
1379 struct cfi_private
*cfi
= map
->fldrv_priv
;
1383 /* Now unlock the chip(s) POINT state */
1385 /* ofs: offset within the first chip that the first read should start */
1386 chipnum
= (from
>> cfi
->chipshift
);
1387 ofs
= from
- (chipnum
<< cfi
->chipshift
);
1390 unsigned long thislen
;
1391 struct flchip
*chip
;
1393 chip
= &cfi
->chips
[chipnum
];
1394 if (chipnum
>= cfi
->numchips
)
1397 if ((len
+ ofs
-1) >> cfi
->chipshift
)
1398 thislen
= (1<<cfi
->chipshift
) - ofs
;
1402 mutex_lock(&chip
->mutex
);
1403 if (chip
->state
== FL_POINT
) {
1404 chip
->ref_point_counter
--;
1405 if(chip
->ref_point_counter
== 0)
1406 chip
->state
= FL_READY
;
1408 printk(KERN_ERR
"%s: Warning: unpoint called on non pointed region\n", map
->name
); /* Should this give an error? */
1410 put_chip(map
, chip
, chip
->start
);
1411 mutex_unlock(&chip
->mutex
);
1419 static inline int do_read_onechip(struct map_info
*map
, struct flchip
*chip
, loff_t adr
, size_t len
, u_char
*buf
)
1421 unsigned long cmd_addr
;
1422 struct cfi_private
*cfi
= map
->fldrv_priv
;
1427 /* Ensure cmd read/writes are aligned. */
1428 cmd_addr
= adr
& ~(map_bankwidth(map
)-1);
1430 mutex_lock(&chip
->mutex
);
1431 ret
= get_chip(map
, chip
, cmd_addr
, FL_READY
);
1433 mutex_unlock(&chip
->mutex
);
1437 if (chip
->state
!= FL_POINT
&& chip
->state
!= FL_READY
) {
1438 map_write(map
, CMD(0xff), cmd_addr
);
1440 chip
->state
= FL_READY
;
1443 map_copy_from(map
, buf
, adr
, len
);
1445 put_chip(map
, chip
, cmd_addr
);
1447 mutex_unlock(&chip
->mutex
);
1451 static int cfi_intelext_read (struct mtd_info
*mtd
, loff_t from
, size_t len
, size_t *retlen
, u_char
*buf
)
1453 struct map_info
*map
= mtd
->priv
;
1454 struct cfi_private
*cfi
= map
->fldrv_priv
;
1459 /* ofs: offset within the first chip that the first read should start */
1460 chipnum
= (from
>> cfi
->chipshift
);
1461 ofs
= from
- (chipnum
<< cfi
->chipshift
);
1466 unsigned long thislen
;
1468 if (chipnum
>= cfi
->numchips
)
1471 if ((len
+ ofs
-1) >> cfi
->chipshift
)
1472 thislen
= (1<<cfi
->chipshift
) - ofs
;
1476 ret
= do_read_onechip(map
, &cfi
->chips
[chipnum
], ofs
, thislen
, buf
);
1490 static int __xipram
do_write_oneword(struct map_info
*map
, struct flchip
*chip
,
1491 unsigned long adr
, map_word datum
, int mode
)
1493 struct cfi_private
*cfi
= map
->fldrv_priv
;
1494 map_word status
, write_cmd
;
1501 write_cmd
= (cfi
->cfiq
->P_ID
!= P_ID_INTEL_PERFORMANCE
) ? CMD(0x40) : CMD(0x41);
1504 write_cmd
= CMD(0xc0);
1510 mutex_lock(&chip
->mutex
);
1511 ret
= get_chip(map
, chip
, adr
, mode
);
1513 mutex_unlock(&chip
->mutex
);
1517 XIP_INVAL_CACHED_RANGE(map
, adr
, map_bankwidth(map
));
1519 xip_disable(map
, chip
, adr
);
1520 map_write(map
, write_cmd
, adr
);
1521 map_write(map
, datum
, adr
);
1524 ret
= INVAL_CACHE_AND_WAIT(map
, chip
, adr
,
1525 adr
, map_bankwidth(map
),
1526 chip
->word_write_time
,
1527 chip
->word_write_time_max
);
1529 xip_enable(map
, chip
, adr
);
1530 printk(KERN_ERR
"%s: word write error (status timeout)\n", map
->name
);
1534 /* check for errors */
1535 status
= map_read(map
, adr
);
1536 if (map_word_bitsset(map
, status
, CMD(0x1a))) {
1537 unsigned long chipstatus
= MERGESTATUS(status
);
1540 map_write(map
, CMD(0x50), adr
);
1541 map_write(map
, CMD(0x70), adr
);
1542 xip_enable(map
, chip
, adr
);
1544 if (chipstatus
& 0x02) {
1546 } else if (chipstatus
& 0x08) {
1547 printk(KERN_ERR
"%s: word write error (bad VPP)\n", map
->name
);
1550 printk(KERN_ERR
"%s: word write error (status 0x%lx)\n", map
->name
, chipstatus
);
1557 xip_enable(map
, chip
, adr
);
1558 out
: put_chip(map
, chip
, adr
);
1559 mutex_unlock(&chip
->mutex
);
1564 static int cfi_intelext_write_words (struct mtd_info
*mtd
, loff_t to
, size_t len
, size_t *retlen
, const u_char
*buf
)
1566 struct map_info
*map
= mtd
->priv
;
1567 struct cfi_private
*cfi
= map
->fldrv_priv
;
1576 chipnum
= to
>> cfi
->chipshift
;
1577 ofs
= to
- (chipnum
<< cfi
->chipshift
);
1579 /* If it's not bus-aligned, do the first byte write */
1580 if (ofs
& (map_bankwidth(map
)-1)) {
1581 unsigned long bus_ofs
= ofs
& ~(map_bankwidth(map
)-1);
1582 int gap
= ofs
- bus_ofs
;
1586 n
= min_t(int, len
, map_bankwidth(map
)-gap
);
1587 datum
= map_word_ff(map
);
1588 datum
= map_word_load_partial(map
, datum
, buf
, gap
, n
);
1590 ret
= do_write_oneword(map
, &cfi
->chips
[chipnum
],
1591 bus_ofs
, datum
, FL_WRITING
);
1600 if (ofs
>> cfi
->chipshift
) {
1603 if (chipnum
== cfi
->numchips
)
1608 while(len
>= map_bankwidth(map
)) {
1609 map_word datum
= map_word_load(map
, buf
);
1611 ret
= do_write_oneword(map
, &cfi
->chips
[chipnum
],
1612 ofs
, datum
, FL_WRITING
);
1616 ofs
+= map_bankwidth(map
);
1617 buf
+= map_bankwidth(map
);
1618 (*retlen
) += map_bankwidth(map
);
1619 len
-= map_bankwidth(map
);
1621 if (ofs
>> cfi
->chipshift
) {
1624 if (chipnum
== cfi
->numchips
)
1629 if (len
& (map_bankwidth(map
)-1)) {
1632 datum
= map_word_ff(map
);
1633 datum
= map_word_load_partial(map
, datum
, buf
, 0, len
);
1635 ret
= do_write_oneword(map
, &cfi
->chips
[chipnum
],
1636 ofs
, datum
, FL_WRITING
);
1647 static int __xipram
do_write_buffer(struct map_info
*map
, struct flchip
*chip
,
1648 unsigned long adr
, const struct kvec
**pvec
,
1649 unsigned long *pvec_seek
, int len
)
1651 struct cfi_private
*cfi
= map
->fldrv_priv
;
1652 map_word status
, write_cmd
, datum
;
1653 unsigned long cmd_adr
;
1654 int ret
, wbufsize
, word_gap
, words
;
1655 const struct kvec
*vec
;
1656 unsigned long vec_seek
;
1657 unsigned long initial_adr
;
1658 int initial_len
= len
;
1660 wbufsize
= cfi_interleave(cfi
) << cfi
->cfiq
->MaxBufWriteSize
;
1663 cmd_adr
= adr
& ~(wbufsize
-1);
1665 /* Let's determine this according to the interleave only once */
1666 write_cmd
= (cfi
->cfiq
->P_ID
!= P_ID_INTEL_PERFORMANCE
) ? CMD(0xe8) : CMD(0xe9);
1668 mutex_lock(&chip
->mutex
);
1669 ret
= get_chip(map
, chip
, cmd_adr
, FL_WRITING
);
1671 mutex_unlock(&chip
->mutex
);
1675 XIP_INVAL_CACHED_RANGE(map
, initial_adr
, initial_len
);
1677 xip_disable(map
, chip
, cmd_adr
);
1679 /* §4.8 of the 28FxxxJ3A datasheet says "Any time SR.4 and/or SR.5 is set
1680 [...], the device will not accept any more Write to Buffer commands".
1681 So we must check here and reset those bits if they're set. Otherwise
1682 we're just pissing in the wind */
1683 if (chip
->state
!= FL_STATUS
) {
1684 map_write(map
, CMD(0x70), cmd_adr
);
1685 chip
->state
= FL_STATUS
;
1687 status
= map_read(map
, cmd_adr
);
1688 if (map_word_bitsset(map
, status
, CMD(0x30))) {
1689 xip_enable(map
, chip
, cmd_adr
);
1690 printk(KERN_WARNING
"SR.4 or SR.5 bits set in buffer write (status %lx). Clearing.\n", status
.x
[0]);
1691 xip_disable(map
, chip
, cmd_adr
);
1692 map_write(map
, CMD(0x50), cmd_adr
);
1693 map_write(map
, CMD(0x70), cmd_adr
);
1696 chip
->state
= FL_WRITING_TO_BUFFER
;
1697 map_write(map
, write_cmd
, cmd_adr
);
1698 ret
= WAIT_TIMEOUT(map
, chip
, cmd_adr
, 0, 0);
1700 /* Argh. Not ready for write to buffer */
1701 map_word Xstatus
= map_read(map
, cmd_adr
);
1702 map_write(map
, CMD(0x70), cmd_adr
);
1703 chip
->state
= FL_STATUS
;
1704 status
= map_read(map
, cmd_adr
);
1705 map_write(map
, CMD(0x50), cmd_adr
);
1706 map_write(map
, CMD(0x70), cmd_adr
);
1707 xip_enable(map
, chip
, cmd_adr
);
1708 printk(KERN_ERR
"%s: Chip not ready for buffer write. Xstatus = %lx, status = %lx\n",
1709 map
->name
, Xstatus
.x
[0], status
.x
[0]);
1713 /* Figure out the number of words to write */
1714 word_gap
= (-adr
& (map_bankwidth(map
)-1));
1715 words
= DIV_ROUND_UP(len
- word_gap
, map_bankwidth(map
));
1719 word_gap
= map_bankwidth(map
) - word_gap
;
1721 datum
= map_word_ff(map
);
1724 /* Write length of data to come */
1725 map_write(map
, CMD(words
), cmd_adr
);
1729 vec_seek
= *pvec_seek
;
1731 int n
= map_bankwidth(map
) - word_gap
;
1732 if (n
> vec
->iov_len
- vec_seek
)
1733 n
= vec
->iov_len
- vec_seek
;
1737 if (!word_gap
&& len
< map_bankwidth(map
))
1738 datum
= map_word_ff(map
);
1740 datum
= map_word_load_partial(map
, datum
,
1741 vec
->iov_base
+ vec_seek
,
1746 if (!len
|| word_gap
== map_bankwidth(map
)) {
1747 map_write(map
, datum
, adr
);
1748 adr
+= map_bankwidth(map
);
1753 if (vec_seek
== vec
->iov_len
) {
1759 *pvec_seek
= vec_seek
;
1762 map_write(map
, CMD(0xd0), cmd_adr
);
1763 chip
->state
= FL_WRITING
;
1765 ret
= INVAL_CACHE_AND_WAIT(map
, chip
, cmd_adr
,
1766 initial_adr
, initial_len
,
1767 chip
->buffer_write_time
,
1768 chip
->buffer_write_time_max
);
1770 map_write(map
, CMD(0x70), cmd_adr
);
1771 chip
->state
= FL_STATUS
;
1772 xip_enable(map
, chip
, cmd_adr
);
1773 printk(KERN_ERR
"%s: buffer write error (status timeout)\n", map
->name
);
1777 /* check for errors */
1778 status
= map_read(map
, cmd_adr
);
1779 if (map_word_bitsset(map
, status
, CMD(0x1a))) {
1780 unsigned long chipstatus
= MERGESTATUS(status
);
1783 map_write(map
, CMD(0x50), cmd_adr
);
1784 map_write(map
, CMD(0x70), cmd_adr
);
1785 xip_enable(map
, chip
, cmd_adr
);
1787 if (chipstatus
& 0x02) {
1789 } else if (chipstatus
& 0x08) {
1790 printk(KERN_ERR
"%s: buffer write error (bad VPP)\n", map
->name
);
1793 printk(KERN_ERR
"%s: buffer write error (status 0x%lx)\n", map
->name
, chipstatus
);
1800 xip_enable(map
, chip
, cmd_adr
);
1801 out
: put_chip(map
, chip
, cmd_adr
);
1802 mutex_unlock(&chip
->mutex
);
1806 static int cfi_intelext_writev (struct mtd_info
*mtd
, const struct kvec
*vecs
,
1807 unsigned long count
, loff_t to
, size_t *retlen
)
1809 struct map_info
*map
= mtd
->priv
;
1810 struct cfi_private
*cfi
= map
->fldrv_priv
;
1811 int wbufsize
= cfi_interleave(cfi
) << cfi
->cfiq
->MaxBufWriteSize
;
1814 unsigned long ofs
, vec_seek
, i
;
1817 for (i
= 0; i
< count
; i
++)
1818 len
+= vecs
[i
].iov_len
;
1824 chipnum
= to
>> cfi
->chipshift
;
1825 ofs
= to
- (chipnum
<< cfi
->chipshift
);
1829 /* We must not cross write block boundaries */
1830 int size
= wbufsize
- (ofs
& (wbufsize
-1));
1834 ret
= do_write_buffer(map
, &cfi
->chips
[chipnum
],
1835 ofs
, &vecs
, &vec_seek
, size
);
1843 if (ofs
>> cfi
->chipshift
) {
1846 if (chipnum
== cfi
->numchips
)
1850 /* Be nice and reschedule with the chip in a usable state for other
1859 static int cfi_intelext_write_buffers (struct mtd_info
*mtd
, loff_t to
,
1860 size_t len
, size_t *retlen
, const u_char
*buf
)
1864 vec
.iov_base
= (void *) buf
;
1867 return cfi_intelext_writev(mtd
, &vec
, 1, to
, retlen
);
1870 static int __xipram
do_erase_oneblock(struct map_info
*map
, struct flchip
*chip
,
1871 unsigned long adr
, int len
, void *thunk
)
1873 struct cfi_private
*cfi
= map
->fldrv_priv
;
1881 mutex_lock(&chip
->mutex
);
1882 ret
= get_chip(map
, chip
, adr
, FL_ERASING
);
1884 mutex_unlock(&chip
->mutex
);
1888 XIP_INVAL_CACHED_RANGE(map
, adr
, len
);
1890 xip_disable(map
, chip
, adr
);
1892 /* Clear the status register first */
1893 map_write(map
, CMD(0x50), adr
);
1896 map_write(map
, CMD(0x20), adr
);
1897 map_write(map
, CMD(0xD0), adr
);
1898 chip
->state
= FL_ERASING
;
1899 chip
->erase_suspended
= 0;
1901 ret
= INVAL_CACHE_AND_WAIT(map
, chip
, adr
,
1904 chip
->erase_time_max
);
1906 map_write(map
, CMD(0x70), adr
);
1907 chip
->state
= FL_STATUS
;
1908 xip_enable(map
, chip
, adr
);
1909 printk(KERN_ERR
"%s: block erase error: (status timeout)\n", map
->name
);
1913 /* We've broken this before. It doesn't hurt to be safe */
1914 map_write(map
, CMD(0x70), adr
);
1915 chip
->state
= FL_STATUS
;
1916 status
= map_read(map
, adr
);
1918 /* check for errors */
1919 if (map_word_bitsset(map
, status
, CMD(0x3a))) {
1920 unsigned long chipstatus
= MERGESTATUS(status
);
1922 /* Reset the error bits */
1923 map_write(map
, CMD(0x50), adr
);
1924 map_write(map
, CMD(0x70), adr
);
1925 xip_enable(map
, chip
, adr
);
1927 if ((chipstatus
& 0x30) == 0x30) {
1928 printk(KERN_ERR
"%s: block erase error: (bad command sequence, status 0x%lx)\n", map
->name
, chipstatus
);
1930 } else if (chipstatus
& 0x02) {
1931 /* Protection bit set */
1933 } else if (chipstatus
& 0x8) {
1935 printk(KERN_ERR
"%s: block erase error: (bad VPP)\n", map
->name
);
1937 } else if (chipstatus
& 0x20 && retries
--) {
1938 printk(KERN_DEBUG
"block erase failed at 0x%08lx: status 0x%lx. Retrying...\n", adr
, chipstatus
);
1939 put_chip(map
, chip
, adr
);
1940 mutex_unlock(&chip
->mutex
);
1943 printk(KERN_ERR
"%s: block erase failed at 0x%08lx (status 0x%lx)\n", map
->name
, adr
, chipstatus
);
1950 xip_enable(map
, chip
, adr
);
1951 out
: put_chip(map
, chip
, adr
);
1952 mutex_unlock(&chip
->mutex
);
1956 static int cfi_intelext_erase_varsize(struct mtd_info
*mtd
, struct erase_info
*instr
)
1958 unsigned long ofs
, len
;
1964 ret
= cfi_varsize_frob(mtd
, do_erase_oneblock
, ofs
, len
, NULL
);
1968 instr
->state
= MTD_ERASE_DONE
;
1969 mtd_erase_callback(instr
);
1974 static void cfi_intelext_sync (struct mtd_info
*mtd
)
1976 struct map_info
*map
= mtd
->priv
;
1977 struct cfi_private
*cfi
= map
->fldrv_priv
;
1979 struct flchip
*chip
;
1982 for (i
=0; !ret
&& i
<cfi
->numchips
; i
++) {
1983 chip
= &cfi
->chips
[i
];
1985 mutex_lock(&chip
->mutex
);
1986 ret
= get_chip(map
, chip
, chip
->start
, FL_SYNCING
);
1989 chip
->oldstate
= chip
->state
;
1990 chip
->state
= FL_SYNCING
;
1991 /* No need to wake_up() on this state change -
1992 * as the whole point is that nobody can do anything
1993 * with the chip now anyway.
1996 mutex_unlock(&chip
->mutex
);
1999 /* Unlock the chips again */
2001 for (i
--; i
>=0; i
--) {
2002 chip
= &cfi
->chips
[i
];
2004 mutex_lock(&chip
->mutex
);
2006 if (chip
->state
== FL_SYNCING
) {
2007 chip
->state
= chip
->oldstate
;
2008 chip
->oldstate
= FL_READY
;
2011 mutex_unlock(&chip
->mutex
);
2015 static int __xipram
do_getlockstatus_oneblock(struct map_info
*map
,
2016 struct flchip
*chip
,
2018 int len
, void *thunk
)
2020 struct cfi_private
*cfi
= map
->fldrv_priv
;
2021 int status
, ofs_factor
= cfi
->interleave
* cfi
->device_type
;
2024 xip_disable(map
, chip
, adr
+(2*ofs_factor
));
2025 map_write(map
, CMD(0x90), adr
+(2*ofs_factor
));
2026 chip
->state
= FL_JEDEC_QUERY
;
2027 status
= cfi_read_query(map
, adr
+(2*ofs_factor
));
2028 xip_enable(map
, chip
, 0);
2032 #ifdef DEBUG_LOCK_BITS
2033 static int __xipram
do_printlockstatus_oneblock(struct map_info
*map
,
2034 struct flchip
*chip
,
2036 int len
, void *thunk
)
2038 printk(KERN_DEBUG
"block status register for 0x%08lx is %x\n",
2039 adr
, do_getlockstatus_oneblock(map
, chip
, adr
, len
, thunk
));
2044 #define DO_XXLOCK_ONEBLOCK_LOCK ((void *) 1)
2045 #define DO_XXLOCK_ONEBLOCK_UNLOCK ((void *) 2)
2047 static int __xipram
do_xxlock_oneblock(struct map_info
*map
, struct flchip
*chip
,
2048 unsigned long adr
, int len
, void *thunk
)
2050 struct cfi_private
*cfi
= map
->fldrv_priv
;
2051 struct cfi_pri_intelext
*extp
= cfi
->cmdset_priv
;
2057 mutex_lock(&chip
->mutex
);
2058 ret
= get_chip(map
, chip
, adr
, FL_LOCKING
);
2060 mutex_unlock(&chip
->mutex
);
2065 xip_disable(map
, chip
, adr
);
2067 map_write(map
, CMD(0x60), adr
);
2068 if (thunk
== DO_XXLOCK_ONEBLOCK_LOCK
) {
2069 map_write(map
, CMD(0x01), adr
);
2070 chip
->state
= FL_LOCKING
;
2071 } else if (thunk
== DO_XXLOCK_ONEBLOCK_UNLOCK
) {
2072 map_write(map
, CMD(0xD0), adr
);
2073 chip
->state
= FL_UNLOCKING
;
2078 * If Instant Individual Block Locking supported then no need
2081 udelay
= (!extp
|| !(extp
->FeatureSupport
& (1 << 5))) ? 1000000/HZ
: 0;
2083 ret
= WAIT_TIMEOUT(map
, chip
, adr
, udelay
, udelay
* 100);
2085 map_write(map
, CMD(0x70), adr
);
2086 chip
->state
= FL_STATUS
;
2087 xip_enable(map
, chip
, adr
);
2088 printk(KERN_ERR
"%s: block unlock error: (status timeout)\n", map
->name
);
2092 xip_enable(map
, chip
, adr
);
2093 out
: put_chip(map
, chip
, adr
);
2094 mutex_unlock(&chip
->mutex
);
2098 static int cfi_intelext_lock(struct mtd_info
*mtd
, loff_t ofs
, uint64_t len
)
2102 #ifdef DEBUG_LOCK_BITS
2103 printk(KERN_DEBUG
"%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
2104 __func__
, ofs
, len
);
2105 cfi_varsize_frob(mtd
, do_printlockstatus_oneblock
,
2109 ret
= cfi_varsize_frob(mtd
, do_xxlock_oneblock
,
2110 ofs
, len
, DO_XXLOCK_ONEBLOCK_LOCK
);
2112 #ifdef DEBUG_LOCK_BITS
2113 printk(KERN_DEBUG
"%s: lock status after, ret=%d\n",
2115 cfi_varsize_frob(mtd
, do_printlockstatus_oneblock
,
2122 static int cfi_intelext_unlock(struct mtd_info
*mtd
, loff_t ofs
, uint64_t len
)
2126 #ifdef DEBUG_LOCK_BITS
2127 printk(KERN_DEBUG
"%s: lock status before, ofs=0x%08llx, len=0x%08X\n",
2128 __func__
, ofs
, len
);
2129 cfi_varsize_frob(mtd
, do_printlockstatus_oneblock
,
2133 ret
= cfi_varsize_frob(mtd
, do_xxlock_oneblock
,
2134 ofs
, len
, DO_XXLOCK_ONEBLOCK_UNLOCK
);
2136 #ifdef DEBUG_LOCK_BITS
2137 printk(KERN_DEBUG
"%s: lock status after, ret=%d\n",
2139 cfi_varsize_frob(mtd
, do_printlockstatus_oneblock
,
2146 static int cfi_intelext_is_locked(struct mtd_info
*mtd
, loff_t ofs
,
2149 return cfi_varsize_frob(mtd
, do_getlockstatus_oneblock
,
2150 ofs
, len
, NULL
) ? 1 : 0;
2153 #ifdef CONFIG_MTD_OTP
2155 typedef int (*otp_op_t
)(struct map_info
*map
, struct flchip
*chip
,
2156 u_long data_offset
, u_char
*buf
, u_int size
,
2157 u_long prot_offset
, u_int groupno
, u_int groupsize
);
2160 do_otp_read(struct map_info
*map
, struct flchip
*chip
, u_long offset
,
2161 u_char
*buf
, u_int size
, u_long prot
, u_int grpno
, u_int grpsz
)
2163 struct cfi_private
*cfi
= map
->fldrv_priv
;
2166 mutex_lock(&chip
->mutex
);
2167 ret
= get_chip(map
, chip
, chip
->start
, FL_JEDEC_QUERY
);
2169 mutex_unlock(&chip
->mutex
);
2173 /* let's ensure we're not reading back cached data from array mode */
2174 INVALIDATE_CACHED_RANGE(map
, chip
->start
+ offset
, size
);
2176 xip_disable(map
, chip
, chip
->start
);
2177 if (chip
->state
!= FL_JEDEC_QUERY
) {
2178 map_write(map
, CMD(0x90), chip
->start
);
2179 chip
->state
= FL_JEDEC_QUERY
;
2181 map_copy_from(map
, buf
, chip
->start
+ offset
, size
);
2182 xip_enable(map
, chip
, chip
->start
);
2184 /* then ensure we don't keep OTP data in the cache */
2185 INVALIDATE_CACHED_RANGE(map
, chip
->start
+ offset
, size
);
2187 put_chip(map
, chip
, chip
->start
);
2188 mutex_unlock(&chip
->mutex
);
2193 do_otp_write(struct map_info
*map
, struct flchip
*chip
, u_long offset
,
2194 u_char
*buf
, u_int size
, u_long prot
, u_int grpno
, u_int grpsz
)
2199 unsigned long bus_ofs
= offset
& ~(map_bankwidth(map
)-1);
2200 int gap
= offset
- bus_ofs
;
2201 int n
= min_t(int, size
, map_bankwidth(map
)-gap
);
2202 map_word datum
= map_word_ff(map
);
2204 datum
= map_word_load_partial(map
, datum
, buf
, gap
, n
);
2205 ret
= do_write_oneword(map
, chip
, bus_ofs
, datum
, FL_OTP_WRITE
);
2218 do_otp_lock(struct map_info
*map
, struct flchip
*chip
, u_long offset
,
2219 u_char
*buf
, u_int size
, u_long prot
, u_int grpno
, u_int grpsz
)
2221 struct cfi_private
*cfi
= map
->fldrv_priv
;
2224 /* make sure area matches group boundaries */
2228 datum
= map_word_ff(map
);
2229 datum
= map_word_clr(map
, datum
, CMD(1 << grpno
));
2230 return do_write_oneword(map
, chip
, prot
, datum
, FL_OTP_WRITE
);
2233 static int cfi_intelext_otp_walk(struct mtd_info
*mtd
, loff_t from
, size_t len
,
2234 size_t *retlen
, u_char
*buf
,
2235 otp_op_t action
, int user_regs
)
2237 struct map_info
*map
= mtd
->priv
;
2238 struct cfi_private
*cfi
= map
->fldrv_priv
;
2239 struct cfi_pri_intelext
*extp
= cfi
->cmdset_priv
;
2240 struct flchip
*chip
;
2241 struct cfi_intelext_otpinfo
*otp
;
2242 u_long devsize
, reg_prot_offset
, data_offset
;
2243 u_int chip_num
, chip_step
, field
, reg_fact_size
, reg_user_size
;
2244 u_int groups
, groupno
, groupsize
, reg_fact_groups
, reg_user_groups
;
2249 /* Check that we actually have some OTP registers */
2250 if (!extp
|| !(extp
->FeatureSupport
& 64) || !extp
->NumProtectionFields
)
2253 /* we need real chips here not virtual ones */
2254 devsize
= (1 << cfi
->cfiq
->DevSize
) * cfi
->interleave
;
2255 chip_step
= devsize
>> cfi
->chipshift
;
2258 /* Some chips have OTP located in the _top_ partition only.
2259 For example: Intel 28F256L18T (T means top-parameter device) */
2260 if (cfi
->mfr
== CFI_MFR_INTEL
) {
2265 chip_num
= chip_step
- 1;
2269 for ( ; chip_num
< cfi
->numchips
; chip_num
+= chip_step
) {
2270 chip
= &cfi
->chips
[chip_num
];
2271 otp
= (struct cfi_intelext_otpinfo
*)&extp
->extra
[0];
2273 /* first OTP region */
2275 reg_prot_offset
= extp
->ProtRegAddr
;
2276 reg_fact_groups
= 1;
2277 reg_fact_size
= 1 << extp
->FactProtRegSize
;
2278 reg_user_groups
= 1;
2279 reg_user_size
= 1 << extp
->UserProtRegSize
;
2282 /* flash geometry fixup */
2283 data_offset
= reg_prot_offset
+ 1;
2284 data_offset
*= cfi
->interleave
* cfi
->device_type
;
2285 reg_prot_offset
*= cfi
->interleave
* cfi
->device_type
;
2286 reg_fact_size
*= cfi
->interleave
;
2287 reg_user_size
*= cfi
->interleave
;
2290 groups
= reg_user_groups
;
2291 groupsize
= reg_user_size
;
2292 /* skip over factory reg area */
2293 groupno
= reg_fact_groups
;
2294 data_offset
+= reg_fact_groups
* reg_fact_size
;
2296 groups
= reg_fact_groups
;
2297 groupsize
= reg_fact_size
;
2301 while (len
> 0 && groups
> 0) {
2304 * Special case: if action is NULL
2305 * we fill buf with otp_info records.
2307 struct otp_info
*otpinfo
;
2309 len
-= sizeof(struct otp_info
);
2312 ret
= do_otp_read(map
, chip
,
2314 (u_char
*)&lockword
,
2319 otpinfo
= (struct otp_info
*)buf
;
2320 otpinfo
->start
= from
;
2321 otpinfo
->length
= groupsize
;
2323 !map_word_bitsset(map
, lockword
,
2326 buf
+= sizeof(*otpinfo
);
2327 *retlen
+= sizeof(*otpinfo
);
2328 } else if (from
>= groupsize
) {
2330 data_offset
+= groupsize
;
2332 int size
= groupsize
;
2333 data_offset
+= from
;
2338 ret
= action(map
, chip
, data_offset
,
2339 buf
, size
, reg_prot_offset
,
2340 groupno
, groupsize
);
2346 data_offset
+= size
;
2352 /* next OTP region */
2353 if (++field
== extp
->NumProtectionFields
)
2355 reg_prot_offset
= otp
->ProtRegAddr
;
2356 reg_fact_groups
= otp
->FactGroups
;
2357 reg_fact_size
= 1 << otp
->FactProtRegSize
;
2358 reg_user_groups
= otp
->UserGroups
;
2359 reg_user_size
= 1 << otp
->UserProtRegSize
;
2367 static int cfi_intelext_read_fact_prot_reg(struct mtd_info
*mtd
, loff_t from
,
2368 size_t len
, size_t *retlen
,
2371 return cfi_intelext_otp_walk(mtd
, from
, len
, retlen
,
2372 buf
, do_otp_read
, 0);
2375 static int cfi_intelext_read_user_prot_reg(struct mtd_info
*mtd
, loff_t from
,
2376 size_t len
, size_t *retlen
,
2379 return cfi_intelext_otp_walk(mtd
, from
, len
, retlen
,
2380 buf
, do_otp_read
, 1);
2383 static int cfi_intelext_write_user_prot_reg(struct mtd_info
*mtd
, loff_t from
,
2384 size_t len
, size_t *retlen
,
2387 return cfi_intelext_otp_walk(mtd
, from
, len
, retlen
,
2388 buf
, do_otp_write
, 1);
2391 static int cfi_intelext_lock_user_prot_reg(struct mtd_info
*mtd
,
2392 loff_t from
, size_t len
)
2395 return cfi_intelext_otp_walk(mtd
, from
, len
, &retlen
,
2396 NULL
, do_otp_lock
, 1);
2399 static int cfi_intelext_get_fact_prot_info(struct mtd_info
*mtd
,
2400 struct otp_info
*buf
, size_t len
)
2405 ret
= cfi_intelext_otp_walk(mtd
, 0, len
, &retlen
, (u_char
*)buf
, NULL
, 0);
2406 return ret
? : retlen
;
2409 static int cfi_intelext_get_user_prot_info(struct mtd_info
*mtd
,
2410 struct otp_info
*buf
, size_t len
)
2415 ret
= cfi_intelext_otp_walk(mtd
, 0, len
, &retlen
, (u_char
*)buf
, NULL
, 1);
2416 return ret
? : retlen
;
2421 static void cfi_intelext_save_locks(struct mtd_info
*mtd
)
2423 struct mtd_erase_region_info
*region
;
2424 int block
, status
, i
;
2428 for (i
= 0; i
< mtd
->numeraseregions
; i
++) {
2429 region
= &mtd
->eraseregions
[i
];
2430 if (!region
->lockmap
)
2433 for (block
= 0; block
< region
->numblocks
; block
++){
2434 len
= region
->erasesize
;
2435 adr
= region
->offset
+ block
* len
;
2437 status
= cfi_varsize_frob(mtd
,
2438 do_getlockstatus_oneblock
, adr
, len
, NULL
);
2440 set_bit(block
, region
->lockmap
);
2442 clear_bit(block
, region
->lockmap
);
2447 static int cfi_intelext_suspend(struct mtd_info
*mtd
)
2449 struct map_info
*map
= mtd
->priv
;
2450 struct cfi_private
*cfi
= map
->fldrv_priv
;
2451 struct cfi_pri_intelext
*extp
= cfi
->cmdset_priv
;
2453 struct flchip
*chip
;
2456 if ((mtd
->flags
& MTD_POWERUP_LOCK
)
2457 && extp
&& (extp
->FeatureSupport
& (1 << 5)))
2458 cfi_intelext_save_locks(mtd
);
2460 for (i
=0; !ret
&& i
<cfi
->numchips
; i
++) {
2461 chip
= &cfi
->chips
[i
];
2463 mutex_lock(&chip
->mutex
);
2465 switch (chip
->state
) {
2469 case FL_JEDEC_QUERY
:
2470 if (chip
->oldstate
== FL_READY
) {
2471 /* place the chip in a known state before suspend */
2472 map_write(map
, CMD(0xFF), cfi
->chips
[i
].start
);
2473 chip
->oldstate
= chip
->state
;
2474 chip
->state
= FL_PM_SUSPENDED
;
2475 /* No need to wake_up() on this state change -
2476 * as the whole point is that nobody can do anything
2477 * with the chip now anyway.
2480 /* There seems to be an operation pending. We must wait for it. */
2481 printk(KERN_NOTICE
"Flash device refused suspend due to pending operation (oldstate %d)\n", chip
->oldstate
);
2486 /* Should we actually wait? Once upon a time these routines weren't
2487 allowed to. Or should we return -EAGAIN, because the upper layers
2488 ought to have already shut down anything which was using the device
2489 anyway? The latter for now. */
2490 printk(KERN_NOTICE
"Flash device refused suspend due to active operation (state %d)\n", chip
->oldstate
);
2492 case FL_PM_SUSPENDED
:
2495 mutex_unlock(&chip
->mutex
);
2498 /* Unlock the chips again */
2501 for (i
--; i
>=0; i
--) {
2502 chip
= &cfi
->chips
[i
];
2504 mutex_lock(&chip
->mutex
);
2506 if (chip
->state
== FL_PM_SUSPENDED
) {
2507 /* No need to force it into a known state here,
2508 because we're returning failure, and it didn't
2510 chip
->state
= chip
->oldstate
;
2511 chip
->oldstate
= FL_READY
;
2514 mutex_unlock(&chip
->mutex
);
2521 static void cfi_intelext_restore_locks(struct mtd_info
*mtd
)
2523 struct mtd_erase_region_info
*region
;
2528 for (i
= 0; i
< mtd
->numeraseregions
; i
++) {
2529 region
= &mtd
->eraseregions
[i
];
2530 if (!region
->lockmap
)
2533 for (block
= 0; block
< region
->numblocks
; block
++) {
2534 len
= region
->erasesize
;
2535 adr
= region
->offset
+ block
* len
;
2537 if (!test_bit(block
, region
->lockmap
))
2538 cfi_intelext_unlock(mtd
, adr
, len
);
2543 static void cfi_intelext_resume(struct mtd_info
*mtd
)
2545 struct map_info
*map
= mtd
->priv
;
2546 struct cfi_private
*cfi
= map
->fldrv_priv
;
2547 struct cfi_pri_intelext
*extp
= cfi
->cmdset_priv
;
2549 struct flchip
*chip
;
2551 for (i
=0; i
<cfi
->numchips
; i
++) {
2553 chip
= &cfi
->chips
[i
];
2555 mutex_lock(&chip
->mutex
);
2557 /* Go to known state. Chip may have been power cycled */
2558 if (chip
->state
== FL_PM_SUSPENDED
) {
2559 map_write(map
, CMD(0xFF), cfi
->chips
[i
].start
);
2560 chip
->oldstate
= chip
->state
= FL_READY
;
2564 mutex_unlock(&chip
->mutex
);
2567 if ((mtd
->flags
& MTD_POWERUP_LOCK
)
2568 && extp
&& (extp
->FeatureSupport
& (1 << 5)))
2569 cfi_intelext_restore_locks(mtd
);
2572 static int cfi_intelext_reset(struct mtd_info
*mtd
)
2574 struct map_info
*map
= mtd
->priv
;
2575 struct cfi_private
*cfi
= map
->fldrv_priv
;
2578 for (i
=0; i
< cfi
->numchips
; i
++) {
2579 struct flchip
*chip
= &cfi
->chips
[i
];
2581 /* force the completion of any ongoing operation
2582 and switch to array mode so any bootloader in
2583 flash is accessible for soft reboot. */
2584 mutex_lock(&chip
->mutex
);
2585 ret
= get_chip(map
, chip
, chip
->start
, FL_SHUTDOWN
);
2587 map_write(map
, CMD(0xff), chip
->start
);
2588 chip
->state
= FL_SHUTDOWN
;
2589 put_chip(map
, chip
, chip
->start
);
2591 mutex_unlock(&chip
->mutex
);
2597 static int cfi_intelext_reboot(struct notifier_block
*nb
, unsigned long val
,
2600 struct mtd_info
*mtd
;
2602 mtd
= container_of(nb
, struct mtd_info
, reboot_notifier
);
2603 cfi_intelext_reset(mtd
);
2607 static void cfi_intelext_destroy(struct mtd_info
*mtd
)
2609 struct map_info
*map
= mtd
->priv
;
2610 struct cfi_private
*cfi
= map
->fldrv_priv
;
2611 struct mtd_erase_region_info
*region
;
2613 cfi_intelext_reset(mtd
);
2614 unregister_reboot_notifier(&mtd
->reboot_notifier
);
2615 kfree(cfi
->cmdset_priv
);
2617 kfree(cfi
->chips
[0].priv
);
2619 for (i
= 0; i
< mtd
->numeraseregions
; i
++) {
2620 region
= &mtd
->eraseregions
[i
];
2621 if (region
->lockmap
)
2622 kfree(region
->lockmap
);
2624 kfree(mtd
->eraseregions
);
2627 MODULE_LICENSE("GPL");
2628 MODULE_AUTHOR("David Woodhouse <dwmw2@infradead.org> et al.");
2629 MODULE_DESCRIPTION("MTD chip driver for Intel/Sharp flash chips");
2630 MODULE_ALIAS("cfi_cmdset_0003");
2631 MODULE_ALIAS("cfi_cmdset_0200");