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