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