2 /* JEDEC Flash Interface.
3 * This is an older type of interface for self programming flash. It is
4 * commonly use in older AMD chips and is obsolete compared with CFI.
5 * It is called JEDEC because the JEDEC association distributes the ID codes
8 * See the AMD flash databook for information on how to operate the interface.
10 * This code does not support anything wider than 8 bit flash chips, I am
11 * not going to guess how to send commands to them, plus I expect they will
14 * $Id: jedec.c,v 1.22 2005/01/05 18:05:11 dwmw2 Exp $
17 #include <linux/init.h>
18 #include <linux/module.h>
19 #include <linux/kernel.h>
20 #include <linux/slab.h>
21 #include <linux/mtd/jedec.h>
22 #include <linux/mtd/map.h>
23 #include <linux/mtd/mtd.h>
24 #include <linux/mtd/compatmac.h>
26 static struct mtd_info *jedec_probe(struct map_info *);
27 static int jedec_probe8(struct map_info *map,unsigned long base,
28 struct jedec_private *priv);
29 static int jedec_probe16(struct map_info *map,unsigned long base,
30 struct jedec_private *priv);
31 static int jedec_probe32(struct map_info *map,unsigned long base,
32 struct jedec_private *priv);
33 static void jedec_flash_chip_scan(struct jedec_private *priv,unsigned long start,
35 static int flash_erase(struct mtd_info *mtd, struct erase_info *instr);
36 static int flash_write(struct mtd_info *mtd, loff_t start, size_t len,
37 size_t *retlen, const u_char *buf);
39 static unsigned long my_bank_size;
41 /* Listing of parts and sizes. We need this table to learn the sector
42 size of the chip and the total length */
43 static const struct JEDECTable JEDEC_table[] = {
46 .name = "AMD Am29F017D",
48 .sectorsize = 64*1024,
49 .capabilities = MTD_CAP_NORFLASH
53 .name = "AMD Am29F016",
55 .sectorsize = 64*1024,
56 .capabilities = MTD_CAP_NORFLASH
60 .name = "AMD Am29F080",
62 .sectorsize = 64*1024,
63 .capabilities = MTD_CAP_NORFLASH
67 .name = "AMD Am29F040",
69 .sectorsize = 64*1024,
70 .capabilities = MTD_CAP_NORFLASH
74 .name = "AMD Am29W040B",
76 .sectorsize = 64*1024,
77 .capabilities = MTD_CAP_NORFLASH
81 .name = "Macronix MX29F016",
83 .sectorsize = 64*1024,
84 .capabilities = MTD_CAP_NORFLASH
89 static const struct JEDECTable *jedec_idtoinf(__u8 mfr,__u8 id);
90 static void jedec_sync(struct mtd_info *mtd) {};
91 static int jedec_read(struct mtd_info *mtd, loff_t from, size_t len,
92 size_t *retlen, u_char *buf);
93 static int jedec_read_banked(struct mtd_info *mtd, loff_t from, size_t len,
94 size_t *retlen, u_char *buf);
96 static struct mtd_info *jedec_probe(struct map_info *map);
100 static struct mtd_chip_driver jedec_chipdrv = {
101 .probe = jedec_probe,
103 .module = THIS_MODULE
106 /* Probe entry point */
108 static struct mtd_info *jedec_probe(struct map_info *map)
110 struct mtd_info *MTD;
111 struct jedec_private *priv;
113 unsigned long SectorSize;
117 memset(&priv,0,sizeof(priv));
119 MTD = kmalloc(sizeof(struct mtd_info) + sizeof(struct jedec_private), GFP_KERNEL);
123 memset(MTD, 0, sizeof(struct mtd_info) + sizeof(struct jedec_private));
124 priv = (struct jedec_private *)&MTD[1];
126 my_bank_size = map->size;
128 if (map->size/my_bank_size > MAX_JEDEC_CHIPS)
130 printk("mtd: Increase MAX_JEDEC_CHIPS, too many banks.\n");
135 for (Base = 0; Base < map->size; Base += my_bank_size)
137 // Perhaps zero could designate all tests?
138 if (map->buswidth == 0)
141 if (map->buswidth == 1){
142 if (jedec_probe8(map,Base,priv) == 0) {
143 printk("did recognize jedec chip\n");
148 if (map->buswidth == 2)
149 jedec_probe16(map,Base,priv);
150 if (map->buswidth == 4)
151 jedec_probe32(map,Base,priv);
154 // Get the biggest sector size
156 for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
158 // printk("priv->chips[%d].jedec is %x\n",I,priv->chips[I].jedec);
159 // printk("priv->chips[%d].sectorsize is %lx\n",I,priv->chips[I].sectorsize);
160 if (priv->chips[I].sectorsize > SectorSize)
161 SectorSize = priv->chips[I].sectorsize;
164 // Quickly ensure that the other sector sizes are factors of the largest
165 for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
167 if ((SectorSize/priv->chips[I].sectorsize)*priv->chips[I].sectorsize != SectorSize)
169 printk("mtd: Failed. Device has incompatible mixed sector sizes\n");
175 /* Generate a part name that includes the number of different chips and
176 other configuration information */
178 strlcpy(Part,map->name,sizeof(Part)-10);
181 for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
183 const struct JEDECTable *JEDEC;
185 if (priv->chips[I+1].jedec == priv->chips[I].jedec)
191 // Locate the chip in the jedec table
192 JEDEC = jedec_idtoinf(priv->chips[I].jedec >> 8,priv->chips[I].jedec);
195 printk("mtd: Internal Error, JEDEC not set\n");
205 sprintf(Part+strlen(Part),"%x*[%s]",count,JEDEC->name);
207 sprintf(Part+strlen(Part),"%s",JEDEC->name);
208 if (strlen(Part) > sizeof(Part)*2/3)
213 /* Determine if the chips are organized in a linear fashion, or if there
214 are empty banks. Note, the last bank does not count here, only the
215 first banks are important. Holes on non-bank boundaries can not exist
216 due to the way the detection algorithm works. */
217 if (priv->size < my_bank_size)
218 my_bank_size = priv->size;
220 //printk("priv->size is %x, my_bank_size is %x\n",priv->size,my_bank_size);
221 //printk("priv->bank_fill[0] is %x\n",priv->bank_fill[0]);
223 printk("priv->size is zero\n");
227 if (priv->size/my_bank_size) {
228 if (priv->size/my_bank_size == 1) {
229 priv->size = my_bank_size;
232 for (I = 0; I != priv->size/my_bank_size - 1; I++)
234 if (priv->bank_fill[I] != my_bank_size)
237 /* This even could be eliminated, but new de-optimized read/write
238 functions have to be written */
239 printk("priv->bank_fill[%d] is %lx, priv->bank_fill[0] is %lx\n",I,priv->bank_fill[I],priv->bank_fill[0]);
240 if (priv->bank_fill[I] != priv->bank_fill[0])
242 printk("mtd: Failed. Cannot handle unsymmetric banking\n");
249 if (priv->is_banked == 1)
250 strcat(Part,", banked");
252 // printk("Part: '%s'\n",Part);
254 memset(MTD,0,sizeof(*MTD));
255 // strlcpy(MTD->name,Part,sizeof(MTD->name));
256 MTD->name = map->name;
257 MTD->type = MTD_NORFLASH;
258 MTD->flags = MTD_CAP_NORFLASH;
260 MTD->erasesize = SectorSize*(map->buswidth);
261 // printk("MTD->erasesize is %x\n",(unsigned int)MTD->erasesize);
262 MTD->size = priv->size;
263 // printk("MTD->size is %x\n",(unsigned int)MTD->size);
264 //MTD->module = THIS_MODULE; // ? Maybe this should be the low level module?
265 MTD->erase = flash_erase;
266 if (priv->is_banked == 1)
267 MTD->read = jedec_read_banked;
269 MTD->read = jedec_read;
270 MTD->write = flash_write;
271 MTD->sync = jedec_sync;
273 map->fldrv_priv = priv;
274 map->fldrv = &jedec_chipdrv;
275 __module_get(THIS_MODULE);
279 /* Helper for the JEDEC function, JEDEC numbers all have odd parity */
280 static int checkparity(u_char C)
293 /* Take an array of JEDEC numbers that represent interleved flash chips
294 and process them. Check to make sure they are good JEDEC numbers, look
295 them up and then add them to the chip list */
296 static int handle_jedecs(struct map_info *map,__u8 *Mfg,__u8 *Id,unsigned Count,
297 unsigned long base,struct jedec_private *priv)
301 unsigned long SectorSize;
302 const struct JEDECTable *JEDEC;
304 // Test #2 JEDEC numbers exhibit odd parity
305 for (I = 0; I != Count; I++)
307 if (checkparity(Mfg[I]) == 0 || checkparity(Id[I]) == 0)
311 // Finally, just make sure all the chip sizes are the same
312 JEDEC = jedec_idtoinf(Mfg[0],Id[0]);
316 printk("mtd: Found JEDEC flash chip, but do not have a table entry for %x:%x\n",Mfg[0],Mfg[1]);
321 SectorSize = JEDEC->sectorsize;
322 for (I = 0; I != Count; I++)
324 JEDEC = jedec_idtoinf(Mfg[0],Id[0]);
327 printk("mtd: Found JEDEC flash chip, but do not have a table entry for %x:%x\n",Mfg[0],Mfg[1]);
331 if (Size != JEDEC->size || SectorSize != JEDEC->sectorsize)
333 printk("mtd: Failed. Interleved flash does not have matching characteristics\n");
339 for (I = 0; I != MAX_JEDEC_CHIPS; I++)
341 if (priv->chips[I].jedec == 0)
345 if (I + Count > MAX_JEDEC_CHIPS)
347 printk("mtd: Device has too many chips. Increase MAX_JEDEC_CHIPS\n");
351 // Add them to the table
352 for (J = 0; J != Count; J++)
356 JEDEC = jedec_idtoinf(Mfg[J],Id[J]);
357 priv->chips[I].jedec = (Mfg[J] << 8) | Id[J];
358 priv->chips[I].size = JEDEC->size;
359 priv->chips[I].sectorsize = JEDEC->sectorsize;
360 priv->chips[I].base = base + J;
361 priv->chips[I].datashift = J*8;
362 priv->chips[I].capabilities = JEDEC->capabilities;
363 priv->chips[I].offset = priv->size + J;
366 priv->chips[I].addrshift = 0;
367 for (Bank = Count; Bank != 1; Bank >>= 1, priv->chips[I].addrshift++);
369 // Determine how filled this bank is.
370 Bank = base & (~(my_bank_size-1));
371 if (priv->bank_fill[Bank/my_bank_size] < base +
372 (JEDEC->size << priv->chips[I].addrshift) - Bank)
373 priv->bank_fill[Bank/my_bank_size] = base + (JEDEC->size << priv->chips[I].addrshift) - Bank;
377 priv->size += priv->chips[I-1].size*Count;
379 return priv->chips[I-1].size;
382 /* Lookup the chip information from the JEDEC ID table. */
383 static const struct JEDECTable *jedec_idtoinf(__u8 mfr,__u8 id)
385 __u16 Id = (mfr << 8) | id;
387 for (I = 0; JEDEC_table[I].jedec != 0; I++)
388 if (JEDEC_table[I].jedec == Id)
389 return JEDEC_table + I;
393 // Look for flash using an 8 bit bus interface
394 static int jedec_probe8(struct map_info *map,unsigned long base,
395 struct jedec_private *priv)
397 #define flread(x) map_read8(map,base+x)
398 #define flwrite(v,x) map_write8(map,v,base+x)
400 const unsigned long AutoSel1 = 0xAA;
401 const unsigned long AutoSel2 = 0x55;
402 const unsigned long AutoSel3 = 0x90;
403 const unsigned long Reset = 0xF0;
410 // Wait for any write/erase operation to settle
411 OldVal = flread(base);
412 for (I = 0; OldVal != flread(base) && I < 10000; I++)
413 OldVal = flread(base);
416 flwrite(Reset,0x555);
419 flwrite(AutoSel1,0x555);
420 flwrite(AutoSel2,0x2AA);
421 flwrite(AutoSel3,0x555);
423 // Get the JEDEC numbers
426 // printk("Mfg is %x, Id is %x\n",Mfg[0],Id[0]);
428 Size = handle_jedecs(map,Mfg,Id,1,base,priv);
429 // printk("handle_jedecs Size is %x\n",(unsigned int)Size);
432 flwrite(Reset,0x555);
438 flwrite(Reset,0x555);
446 // Look for flash using a 16 bit bus interface (ie 2 8-bit chips)
447 static int jedec_probe16(struct map_info *map,unsigned long base,
448 struct jedec_private *priv)
453 // Look for flash using a 32 bit bus interface (ie 4 8-bit chips)
454 static int jedec_probe32(struct map_info *map,unsigned long base,
455 struct jedec_private *priv)
457 #define flread(x) map_read32(map,base+((x)<<2))
458 #define flwrite(v,x) map_write32(map,v,base+((x)<<2))
460 const unsigned long AutoSel1 = 0xAAAAAAAA;
461 const unsigned long AutoSel2 = 0x55555555;
462 const unsigned long AutoSel3 = 0x90909090;
463 const unsigned long Reset = 0xF0F0F0F0;
470 // Wait for any write/erase operation to settle
471 OldVal = flread(base);
472 for (I = 0; OldVal != flread(base) && I < 10000; I++)
473 OldVal = flread(base);
476 flwrite(Reset,0x555);
479 flwrite(AutoSel1,0x555);
480 flwrite(AutoSel2,0x2AA);
481 flwrite(AutoSel3,0x555);
483 // Test #1, JEDEC numbers are readable from 0x??00/0x??01
484 if (flread(0) != flread(0x100) ||
485 flread(1) != flread(0x101))
487 flwrite(Reset,0x555);
491 // Split up the JEDEC numbers
493 for (I = 0; I != 4; I++)
494 Mfg[I] = (OldVal >> (I*8));
496 for (I = 0; I != 4; I++)
497 Id[I] = (OldVal >> (I*8));
499 Size = handle_jedecs(map,Mfg,Id,4,base,priv);
502 flwrite(Reset,0x555);
506 /* Check if there is address wrap around within a single bank, if this
507 returns JEDEC numbers then we assume that it is wrap around. Notice
508 we call this routine with the JEDEC return still enabled, if two or
509 more flashes have a truncated address space the probe test will still
511 if (base + (Size<<2)+0x555 < map->size &&
512 base + (Size<<2)+0x555 < (base & (~(my_bank_size-1))) + my_bank_size)
514 if (flread(base+Size) != flread(base+Size + 0x100) ||
515 flread(base+Size + 1) != flread(base+Size + 0x101))
517 jedec_probe32(map,base+Size,priv);
522 flwrite(0xF0F0F0F0,0x555);
531 static int jedec_read(struct mtd_info *mtd, loff_t from, size_t len,
532 size_t *retlen, u_char *buf)
534 struct map_info *map = mtd->priv;
536 map_copy_from(map, buf, from, len);
541 /* Banked read. Take special care to jump past the holes in the bank
542 mapping. This version assumes symetry in the holes.. */
543 static int jedec_read_banked(struct mtd_info *mtd, loff_t from, size_t len,
544 size_t *retlen, u_char *buf)
546 struct map_info *map = mtd->priv;
547 struct jedec_private *priv = map->fldrv_priv;
552 // Determine what bank and offset into that bank the first byte is
553 unsigned long bank = from & (~(priv->bank_fill[0]-1));
554 unsigned long offset = from & (priv->bank_fill[0]-1);
555 unsigned long get = len;
556 if (priv->bank_fill[0] - offset < len)
557 get = priv->bank_fill[0] - offset;
559 bank /= priv->bank_fill[0];
560 map_copy_from(map,buf + *retlen,bank*my_bank_size + offset,get);
569 /* Pass the flags value that the flash return before it re-entered read
571 static void jedec_flash_failed(unsigned char code)
573 /* Bit 5 being high indicates that there was an internal device
574 failure, erasure time limits exceeded or something */
575 if ((code & (1 << 5)) != 0)
577 printk("mtd: Internal Flash failure\n");
580 printk("mtd: Programming didn't take\n");
583 /* This uses the erasure function described in the AMD Flash Handbook,
584 it will work for flashes with a fixed sector size only. Flashes with
585 a selection of sector sizes (ie the AMD Am29F800B) will need a different
586 routine. This routine tries to parallize erasing multiple chips/sectors
588 static int flash_erase(struct mtd_info *mtd, struct erase_info *instr)
590 // Does IO to the currently selected chip
591 #define flread(x) map_read8(map,chip->base+((x)<<chip->addrshift))
592 #define flwrite(v,x) map_write8(map,v,chip->base+((x)<<chip->addrshift))
594 unsigned long Time = 0;
595 unsigned long NoTime = 0;
596 unsigned long start = instr->addr, len = instr->len;
598 struct map_info *map = mtd->priv;
599 struct jedec_private *priv = map->fldrv_priv;
601 // Verify the arguments..
602 if (start + len > mtd->size ||
603 (start % mtd->erasesize) != 0 ||
604 (len % mtd->erasesize) != 0 ||
605 (len/mtd->erasesize) == 0)
608 jedec_flash_chip_scan(priv,start,len);
610 // Start the erase sequence on each chip
611 for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
614 struct jedec_flash_chip *chip = priv->chips + I;
616 if (chip->length == 0)
619 if (chip->start + chip->length > chip->size)
625 flwrite(0xF0,chip->start + 0x555);
626 flwrite(0xAA,chip->start + 0x555);
627 flwrite(0x55,chip->start + 0x2AA);
628 flwrite(0x80,chip->start + 0x555);
629 flwrite(0xAA,chip->start + 0x555);
630 flwrite(0x55,chip->start + 0x2AA);
632 /* Once we start selecting the erase sectors the delay between each
633 command must not exceed 50us or it will immediately start erasing
634 and ignore the other sectors */
635 for (off = 0; off < len; off += chip->sectorsize)
637 // Check to make sure we didn't timeout
638 flwrite(0x30,chip->start + off);
641 if ((flread(chip->start + off) & (1 << 3)) != 0)
643 printk("mtd: Ack! We timed out the erase timer!\n");
649 /* We could split this into a timer routine and return early, performing
650 background erasure.. Maybe later if the need warrents */
652 /* Poll the flash for erasure completion, specs say this can take as long
653 as 480 seconds to do all the sectors (for a 2 meg flash).
654 Erasure time is dependent on chip age, temp and wear.. */
656 /* This being a generic routine assumes a 32 bit bus. It does read32s
657 and bundles interleved chips into the same grouping. This will work
658 for all bus widths */
661 for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
663 struct jedec_flash_chip *chip = priv->chips + I;
664 unsigned long off = 0;
665 unsigned todo[4] = {0,0,0,0};
666 unsigned todo_left = 0;
669 if (chip->length == 0)
672 /* Find all chips in this data line, realistically this is all
673 or nothing up to the interleve count */
674 for (J = 0; priv->chips[J].jedec != 0 && J < MAX_JEDEC_CHIPS; J++)
676 if ((priv->chips[J].base & (~((1<<chip->addrshift)-1))) ==
677 (chip->base & (~((1<<chip->addrshift)-1))))
680 todo[priv->chips[J].base & ((1<<chip->addrshift)-1)] = 1;
684 /* printk("todo: %x %x %x %x\n",(short)todo[0],(short)todo[1],
685 (short)todo[2],(short)todo[3]);
690 unsigned long Count = 0;
692 /* During erase bit 7 is held low and bit 6 toggles, we watch this,
693 should it stop toggling or go high then the erase is completed,
694 or this is not really flash ;> */
695 switch (map->buswidth) {
697 Last[0] = map_read8(map,(chip->base >> chip->addrshift) + chip->start + off);
698 Last[1] = map_read8(map,(chip->base >> chip->addrshift) + chip->start + off);
699 Last[2] = map_read8(map,(chip->base >> chip->addrshift) + chip->start + off);
702 Last[0] = map_read16(map,(chip->base >> chip->addrshift) + chip->start + off);
703 Last[1] = map_read16(map,(chip->base >> chip->addrshift) + chip->start + off);
704 Last[2] = map_read16(map,(chip->base >> chip->addrshift) + chip->start + off);
707 Last[0] = map_read32(map,(chip->base >> chip->addrshift) + chip->start + off);
708 Last[1] = map_read32(map,(chip->base >> chip->addrshift) + chip->start + off);
709 Last[2] = map_read32(map,(chip->base >> chip->addrshift) + chip->start + off);
713 while (todo_left != 0)
715 for (J = 0; J != 4; J++)
717 __u8 Byte1 = (Last[(Count-1)%4] >> (J*8)) & 0xFF;
718 __u8 Byte2 = (Last[(Count-2)%4] >> (J*8)) & 0xFF;
719 __u8 Byte3 = (Last[(Count-3)%4] >> (J*8)) & 0xFF;
723 if ((Byte1 & (1 << 7)) == 0 && Byte1 != Byte2)
725 // printk("Check %x %x %x\n",(short)J,(short)Byte1,(short)Byte2);
731 jedec_flash_failed(Byte3);
740 Time += HZ/10 - schedule_timeout(HZ/10);*/
743 switch (map->buswidth) {
745 Last[Count % 4] = map_read8(map,(chip->base >> chip->addrshift) + chip->start + off);
748 Last[Count % 4] = map_read16(map,(chip->base >> chip->addrshift) + chip->start + off);
751 Last[Count % 4] = map_read32(map,(chip->base >> chip->addrshift) + chip->start + off);
756 /* // Count time, max of 15s per sector (according to AMD)
757 if (Time > 15*len/mtd->erasesize*HZ)
759 printk("mtd: Flash Erase Timed out\n");
764 // Skip to the next chip if we used chip erase
765 if (chip->length == chip->size)
768 off += chip->sectorsize;
770 if (off >= chip->length)
775 for (J = 0; priv->chips[J].jedec != 0 && J < MAX_JEDEC_CHIPS; J++)
777 if ((priv->chips[J].base & (~((1<<chip->addrshift)-1))) ==
778 (chip->base & (~((1<<chip->addrshift)-1))))
779 priv->chips[J].length = 0;
784 instr->state = MTD_ERASE_DONE;
785 mtd_erase_callback(instr);
792 /* This is the simple flash writing function. It writes to every byte, in
793 sequence. It takes care of how to properly address the flash if
794 the flash is interleved. It can only be used if all the chips in the
795 array are identical!*/
796 static int flash_write(struct mtd_info *mtd, loff_t start, size_t len,
797 size_t *retlen, const u_char *buf)
799 /* Does IO to the currently selected chip. It takes the bank addressing
800 base (which is divisible by the chip size) adds the necessary lower bits
801 of addrshift (interleave index) and then adds the control register index. */
802 #define flread(x) map_read8(map,base+(off&((1<<chip->addrshift)-1))+((x)<<chip->addrshift))
803 #define flwrite(v,x) map_write8(map,v,base+(off&((1<<chip->addrshift)-1))+((x)<<chip->addrshift))
805 struct map_info *map = mtd->priv;
806 struct jedec_private *priv = map->fldrv_priv;
809 size_t save_len = len;
811 if (start + len > mtd->size)
816 //printk("flash_write: start is %x, len is %x\n",start,(unsigned long)len);
819 struct jedec_flash_chip *chip = priv->chips;
821 unsigned long boffset;
823 // Compute the base of the flash.
824 off = ((unsigned long)start) % (chip->size << chip->addrshift);
827 // Perform banked addressing translation.
828 bank = base & (~(priv->bank_fill[0]-1));
829 boffset = base & (priv->bank_fill[0]-1);
830 bank = (bank/priv->bank_fill[0])*my_bank_size;
831 base = bank + boffset;
833 // printk("Flasing %X %X %X\n",base,chip->size,len);
834 // printk("off is %x, compare with %x\n",off,chip->size << chip->addrshift);
836 // Loop over this page
837 for (; off != (chip->size << chip->addrshift) && len != 0; start++, len--, off++,buf++)
839 unsigned char oldbyte = map_read8(map,base+off);
840 unsigned char Last[4];
841 unsigned long Count = 0;
843 if (oldbyte == *buf) {
844 // printk("oldbyte and *buf is %x,len is %x\n",oldbyte,len);
847 if (((~oldbyte) & *buf) != 0)
848 printk("mtd: warn: Trying to set a 0 to a 1\n");
854 map_write8(map,*buf,base + off);
855 Last[0] = map_read8(map,base + off);
856 Last[1] = map_read8(map,base + off);
857 Last[2] = map_read8(map,base + off);
859 /* Wait for the flash to finish the operation. We store the last 4
860 status bytes that have been retrieved so we can determine why
861 it failed. The toggle bits keep toggling when there is a
863 for (Count = 3; Last[(Count - 1) % 4] != Last[(Count - 2) % 4] &&
864 Count < 10000; Count++)
865 Last[Count % 4] = map_read8(map,base + off);
866 if (Last[(Count - 1) % 4] != *buf)
868 jedec_flash_failed(Last[(Count - 3) % 4]);
877 /* This is used to enhance the speed of the erase routine,
878 when things are being done to multiple chips it is possible to
879 parallize the operations, particularly full memory erases of multi
880 chip memories benifit */
881 static void jedec_flash_chip_scan(struct jedec_private *priv,unsigned long start,
887 for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
888 priv->chips[I].start = priv->chips[I].length = 0;
890 // Intersect the region with each chip
891 for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
893 struct jedec_flash_chip *chip = priv->chips + I;
894 unsigned long ByteStart;
895 unsigned long ChipEndByte = chip->offset + (chip->size << chip->addrshift);
897 // End is before this chip or the start is after it
898 if (start+len < chip->offset ||
899 ChipEndByte - (1 << chip->addrshift) < start)
902 if (start < chip->offset)
904 ByteStart = chip->offset;
909 chip->start = (start - chip->offset + (1 << chip->addrshift)-1) >> chip->addrshift;
913 if (start + len >= ChipEndByte)
914 chip->length = (ChipEndByte - ByteStart) >> chip->addrshift;
916 chip->length = (start + len - ByteStart + (1 << chip->addrshift)-1) >> chip->addrshift;
920 int __init jedec_init(void)
922 register_mtd_chip_driver(&jedec_chipdrv);
926 static void __exit jedec_exit(void)
928 unregister_mtd_chip_driver(&jedec_chipdrv);
931 module_init(jedec_init);
932 module_exit(jedec_exit);
934 MODULE_LICENSE("GPL");
935 MODULE_AUTHOR("Jason Gunthorpe <jgg@deltatee.com> et al.");
936 MODULE_DESCRIPTION("Old MTD chip driver for JEDEC-compliant flash chips");