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