c40b48dabed362c00a5bc2c001a75d2131a6b05c
[sfrench/cifs-2.6.git] / drivers / mtd / chips / jedec.c
1
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
6  * for the chips.
7  *
8  * See the AMD flash databook for information on how to operate the interface.
9  *
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
12  * all speak CFI..
13  *
14  * $Id: jedec.c,v 1.22 2005/01/05 18:05:11 dwmw2 Exp $
15  */
16
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>
25
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,
34                             unsigned long len);
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);
38
39 static unsigned long my_bank_size;
40
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[] = {
44         {
45                 .jedec          = 0x013D,
46                 .name           = "AMD Am29F017D",
47                 .size           = 2*1024*1024,
48                 .sectorsize     = 64*1024,
49                 .capabilities   = MTD_CAP_NORFLASH
50         },
51         {
52                 .jedec          = 0x01AD,
53                 .name           = "AMD Am29F016",
54                 .size           = 2*1024*1024,
55                 .sectorsize     = 64*1024,
56                 .capabilities   = MTD_CAP_NORFLASH
57         },
58         {
59                 .jedec          = 0x01D5,
60                 .name           = "AMD Am29F080",
61                 .size           = 1*1024*1024,
62                 .sectorsize     = 64*1024,
63                 .capabilities   = MTD_CAP_NORFLASH
64         },
65         {
66                 .jedec          = 0x01A4,
67                 .name           = "AMD Am29F040",
68                 .size           = 512*1024,
69                 .sectorsize     = 64*1024,
70                 .capabilities   = MTD_CAP_NORFLASH
71         },
72         {
73                 .jedec          = 0x20E3,
74                 .name           = "AMD Am29W040B",
75                 .size           = 512*1024,
76                 .sectorsize     = 64*1024,
77                 .capabilities   = MTD_CAP_NORFLASH
78         },
79         {
80                 .jedec          = 0xC2AD,
81                 .name           = "Macronix MX29F016",
82                 .size           = 2*1024*1024,
83                 .sectorsize     = 64*1024,
84                 .capabilities   = MTD_CAP_NORFLASH
85         },
86         { .jedec = 0x0 }
87 };
88
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);
95
96 static struct mtd_info *jedec_probe(struct map_info *map);
97
98
99
100 static struct mtd_chip_driver jedec_chipdrv = {
101         .probe  = jedec_probe,
102         .name   = "jedec",
103         .module = THIS_MODULE
104 };
105
106 /* Probe entry point */
107
108 static struct mtd_info *jedec_probe(struct map_info *map)
109 {
110    struct mtd_info *MTD;
111    struct jedec_private *priv;
112    unsigned long Base;
113    unsigned long SectorSize;
114    unsigned count;
115    unsigned I,Uniq;
116    char Part[200];
117    memset(&priv,0,sizeof(priv));
118
119    MTD = kmalloc(sizeof(struct mtd_info) + sizeof(struct jedec_private), GFP_KERNEL);
120    if (!MTD)
121            return NULL;
122
123    memset(MTD, 0, sizeof(struct mtd_info) + sizeof(struct jedec_private));
124    priv = (struct jedec_private *)&MTD[1];
125
126    my_bank_size = map->size;
127
128    if (map->size/my_bank_size > MAX_JEDEC_CHIPS)
129    {
130       printk("mtd: Increase MAX_JEDEC_CHIPS, too many banks.\n");
131       kfree(MTD);
132       return NULL;
133    }
134
135    for (Base = 0; Base < map->size; Base += my_bank_size)
136    {
137       // Perhaps zero could designate all tests?
138       if (map->buswidth == 0)
139          map->buswidth = 1;
140
141       if (map->buswidth == 1){
142          if (jedec_probe8(map,Base,priv) == 0) {
143                  printk("did recognize jedec chip\n");
144                  kfree(MTD);
145                  return NULL;
146          }
147       }
148       if (map->buswidth == 2)
149          jedec_probe16(map,Base,priv);
150       if (map->buswidth == 4)
151          jedec_probe32(map,Base,priv);
152    }
153
154    // Get the biggest sector size
155    SectorSize = 0;
156    for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
157    {
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;
162    }
163
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++)
166    {
167       if ((SectorSize/priv->chips[I].sectorsize)*priv->chips[I].sectorsize != SectorSize)
168       {
169          printk("mtd: Failed. Device has incompatible mixed sector sizes\n");
170          kfree(MTD);
171          return NULL;
172       }
173    }
174
175    /* Generate a part name that includes the number of different chips and
176       other configuration information */
177    count = 1;
178    strlcpy(Part,map->name,sizeof(Part)-10);
179    strcat(Part," ");
180    Uniq = 0;
181    for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
182    {
183       const struct JEDECTable *JEDEC;
184
185       if (priv->chips[I+1].jedec == priv->chips[I].jedec)
186       {
187          count++;
188          continue;
189       }
190
191       // Locate the chip in the jedec table
192       JEDEC = jedec_idtoinf(priv->chips[I].jedec >> 8,priv->chips[I].jedec);
193       if (JEDEC == 0)
194       {
195          printk("mtd: Internal Error, JEDEC not set\n");
196          kfree(MTD);
197          return NULL;
198       }
199
200       if (Uniq != 0)
201          strcat(Part,",");
202       Uniq++;
203
204       if (count != 1)
205          sprintf(Part+strlen(Part),"%x*[%s]",count,JEDEC->name);
206       else
207          sprintf(Part+strlen(Part),"%s",JEDEC->name);
208       if (strlen(Part) > sizeof(Part)*2/3)
209          break;
210       count = 1;
211    }
212
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;
219    priv->is_banked = 0;
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]);
222    if (!priv->size) {
223            printk("priv->size is zero\n");
224            kfree(MTD);
225            return NULL;
226    }
227    if (priv->size/my_bank_size) {
228            if (priv->size/my_bank_size == 1) {
229                    priv->size = my_bank_size;
230            }
231            else {
232                    for (I = 0; I != priv->size/my_bank_size - 1; I++)
233                    {
234                       if (priv->bank_fill[I] != my_bank_size)
235                          priv->is_banked = 1;
236
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])
241                       {
242                          printk("mtd: Failed. Cannot handle unsymmetric banking\n");
243                          kfree(MTD);
244                          return NULL;
245                       }
246                    }
247            }
248    }
249    if (priv->is_banked == 1)
250       strcat(Part,", banked");
251
252    //   printk("Part: '%s'\n",Part);
253
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;
259    MTD->erasesize = SectorSize*(map->buswidth);
260    //   printk("MTD->erasesize is %x\n",(unsigned int)MTD->erasesize);
261    MTD->size = priv->size;
262    //   printk("MTD->size is %x\n",(unsigned int)MTD->size);
263    //MTD->module = THIS_MODULE; // ? Maybe this should be the low level module?
264    MTD->erase = flash_erase;
265    if (priv->is_banked == 1)
266       MTD->read = jedec_read_banked;
267    else
268       MTD->read = jedec_read;
269    MTD->write = flash_write;
270    MTD->sync = jedec_sync;
271    MTD->priv = map;
272    map->fldrv_priv = priv;
273    map->fldrv = &jedec_chipdrv;
274    __module_get(THIS_MODULE);
275    return MTD;
276 }
277
278 /* Helper for the JEDEC function, JEDEC numbers all have odd parity */
279 static int checkparity(u_char C)
280 {
281    u_char parity = 0;
282    while (C != 0)
283    {
284       parity ^= C & 1;
285       C >>= 1;
286    }
287
288    return parity == 1;
289 }
290
291
292 /* Take an array of JEDEC numbers that represent interleved flash chips
293    and process them. Check to make sure they are good JEDEC numbers, look
294    them up and then add them to the chip list */
295 static int handle_jedecs(struct map_info *map,__u8 *Mfg,__u8 *Id,unsigned Count,
296                   unsigned long base,struct jedec_private *priv)
297 {
298    unsigned I,J;
299    unsigned long Size;
300    unsigned long SectorSize;
301    const struct JEDECTable *JEDEC;
302
303    // Test #2 JEDEC numbers exhibit odd parity
304    for (I = 0; I != Count; I++)
305    {
306       if (checkparity(Mfg[I]) == 0 || checkparity(Id[I]) == 0)
307          return 0;
308    }
309
310    // Finally, just make sure all the chip sizes are the same
311    JEDEC = jedec_idtoinf(Mfg[0],Id[0]);
312
313    if (JEDEC == 0)
314    {
315       printk("mtd: Found JEDEC flash chip, but do not have a table entry for %x:%x\n",Mfg[0],Mfg[1]);
316       return 0;
317    }
318
319    Size = JEDEC->size;
320    SectorSize = JEDEC->sectorsize;
321    for (I = 0; I != Count; I++)
322    {
323       JEDEC = jedec_idtoinf(Mfg[0],Id[0]);
324       if (JEDEC == 0)
325       {
326          printk("mtd: Found JEDEC flash chip, but do not have a table entry for %x:%x\n",Mfg[0],Mfg[1]);
327          return 0;
328       }
329
330       if (Size != JEDEC->size || SectorSize != JEDEC->sectorsize)
331       {
332          printk("mtd: Failed. Interleved flash does not have matching characteristics\n");
333          return 0;
334       }
335    }
336
337    // Load the Chips
338    for (I = 0; I != MAX_JEDEC_CHIPS; I++)
339    {
340       if (priv->chips[I].jedec == 0)
341          break;
342    }
343
344    if (I + Count > MAX_JEDEC_CHIPS)
345    {
346       printk("mtd: Device has too many chips. Increase MAX_JEDEC_CHIPS\n");
347       return 0;
348    }
349
350    // Add them to the table
351    for (J = 0; J != Count; J++)
352    {
353       unsigned long Bank;
354
355       JEDEC = jedec_idtoinf(Mfg[J],Id[J]);
356       priv->chips[I].jedec = (Mfg[J] << 8) | Id[J];
357       priv->chips[I].size = JEDEC->size;
358       priv->chips[I].sectorsize = JEDEC->sectorsize;
359       priv->chips[I].base = base + J;
360       priv->chips[I].datashift = J*8;
361       priv->chips[I].capabilities = JEDEC->capabilities;
362       priv->chips[I].offset = priv->size + J;
363
364       // log2 n :|
365       priv->chips[I].addrshift = 0;
366       for (Bank = Count; Bank != 1; Bank >>= 1, priv->chips[I].addrshift++);
367
368       // Determine how filled this bank is.
369       Bank = base & (~(my_bank_size-1));
370       if (priv->bank_fill[Bank/my_bank_size] < base +
371           (JEDEC->size << priv->chips[I].addrshift) - Bank)
372          priv->bank_fill[Bank/my_bank_size] =  base + (JEDEC->size << priv->chips[I].addrshift) - Bank;
373       I++;
374    }
375
376    priv->size += priv->chips[I-1].size*Count;
377
378    return priv->chips[I-1].size;
379 }
380
381 /* Lookup the chip information from the JEDEC ID table. */
382 static const struct JEDECTable *jedec_idtoinf(__u8 mfr,__u8 id)
383 {
384    __u16 Id = (mfr << 8) | id;
385    unsigned long I = 0;
386    for (I = 0; JEDEC_table[I].jedec != 0; I++)
387       if (JEDEC_table[I].jedec == Id)
388          return JEDEC_table + I;
389    return NULL;
390 }
391
392 // Look for flash using an 8 bit bus interface
393 static int jedec_probe8(struct map_info *map,unsigned long base,
394                   struct jedec_private *priv)
395 {
396    #define flread(x) map_read8(map,base+x)
397    #define flwrite(v,x) map_write8(map,v,base+x)
398
399    const unsigned long AutoSel1 = 0xAA;
400    const unsigned long AutoSel2 = 0x55;
401    const unsigned long AutoSel3 = 0x90;
402    const unsigned long Reset = 0xF0;
403    __u32 OldVal;
404    __u8 Mfg[1];
405    __u8 Id[1];
406    unsigned I;
407    unsigned long Size;
408
409    // Wait for any write/erase operation to settle
410    OldVal = flread(base);
411    for (I = 0; OldVal != flread(base) && I < 10000; I++)
412       OldVal = flread(base);
413
414    // Reset the chip
415    flwrite(Reset,0x555);
416
417    // Send the sequence
418    flwrite(AutoSel1,0x555);
419    flwrite(AutoSel2,0x2AA);
420    flwrite(AutoSel3,0x555);
421
422    //  Get the JEDEC numbers
423    Mfg[0] = flread(0);
424    Id[0] = flread(1);
425    //   printk("Mfg is %x, Id is %x\n",Mfg[0],Id[0]);
426
427    Size = handle_jedecs(map,Mfg,Id,1,base,priv);
428    //   printk("handle_jedecs Size is %x\n",(unsigned int)Size);
429    if (Size == 0)
430    {
431       flwrite(Reset,0x555);
432       return 0;
433    }
434
435
436    // Reset.
437    flwrite(Reset,0x555);
438
439    return 1;
440
441    #undef flread
442    #undef flwrite
443 }
444
445 // Look for flash using a 16 bit bus interface (ie 2 8-bit chips)
446 static int jedec_probe16(struct map_info *map,unsigned long base,
447                   struct jedec_private *priv)
448 {
449    return 0;
450 }
451
452 // Look for flash using a 32 bit bus interface (ie 4 8-bit chips)
453 static int jedec_probe32(struct map_info *map,unsigned long base,
454                   struct jedec_private *priv)
455 {
456    #define flread(x) map_read32(map,base+((x)<<2))
457    #define flwrite(v,x) map_write32(map,v,base+((x)<<2))
458
459    const unsigned long AutoSel1 = 0xAAAAAAAA;
460    const unsigned long AutoSel2 = 0x55555555;
461    const unsigned long AutoSel3 = 0x90909090;
462    const unsigned long Reset = 0xF0F0F0F0;
463    __u32 OldVal;
464    __u8 Mfg[4];
465    __u8 Id[4];
466    unsigned I;
467    unsigned long Size;
468
469    // Wait for any write/erase operation to settle
470    OldVal = flread(base);
471    for (I = 0; OldVal != flread(base) && I < 10000; I++)
472       OldVal = flread(base);
473
474    // Reset the chip
475    flwrite(Reset,0x555);
476
477    // Send the sequence
478    flwrite(AutoSel1,0x555);
479    flwrite(AutoSel2,0x2AA);
480    flwrite(AutoSel3,0x555);
481
482    // Test #1, JEDEC numbers are readable from 0x??00/0x??01
483    if (flread(0) != flread(0x100) ||
484        flread(1) != flread(0x101))
485    {
486       flwrite(Reset,0x555);
487       return 0;
488    }
489
490    // Split up the JEDEC numbers
491    OldVal = flread(0);
492    for (I = 0; I != 4; I++)
493       Mfg[I] = (OldVal >> (I*8));
494    OldVal = flread(1);
495    for (I = 0; I != 4; I++)
496       Id[I] = (OldVal >> (I*8));
497
498    Size = handle_jedecs(map,Mfg,Id,4,base,priv);
499    if (Size == 0)
500    {
501       flwrite(Reset,0x555);
502       return 0;
503    }
504
505    /* Check if there is address wrap around within a single bank, if this
506       returns JEDEC numbers then we assume that it is wrap around. Notice
507       we call this routine with the JEDEC return still enabled, if two or
508       more flashes have a truncated address space the probe test will still
509       work */
510    if (base + (Size<<2)+0x555 < map->size &&
511        base + (Size<<2)+0x555 < (base & (~(my_bank_size-1))) + my_bank_size)
512    {
513       if (flread(base+Size) != flread(base+Size + 0x100) ||
514           flread(base+Size + 1) != flread(base+Size + 0x101))
515       {
516          jedec_probe32(map,base+Size,priv);
517       }
518    }
519
520    // Reset.
521    flwrite(0xF0F0F0F0,0x555);
522
523    return 1;
524
525    #undef flread
526    #undef flwrite
527 }
528
529 /* Linear read. */
530 static int jedec_read(struct mtd_info *mtd, loff_t from, size_t len,
531                       size_t *retlen, u_char *buf)
532 {
533    struct map_info *map = mtd->priv;
534
535    map_copy_from(map, buf, from, len);
536    *retlen = len;
537    return 0;
538 }
539
540 /* Banked read. Take special care to jump past the holes in the bank
541    mapping. This version assumes symetry in the holes.. */
542 static int jedec_read_banked(struct mtd_info *mtd, loff_t from, size_t len,
543                              size_t *retlen, u_char *buf)
544 {
545    struct map_info *map = mtd->priv;
546    struct jedec_private *priv = map->fldrv_priv;
547
548    *retlen = 0;
549    while (len > 0)
550    {
551       // Determine what bank and offset into that bank the first byte is
552       unsigned long bank = from & (~(priv->bank_fill[0]-1));
553       unsigned long offset = from & (priv->bank_fill[0]-1);
554       unsigned long get = len;
555       if (priv->bank_fill[0] - offset < len)
556          get = priv->bank_fill[0] - offset;
557
558       bank /= priv->bank_fill[0];
559       map_copy_from(map,buf + *retlen,bank*my_bank_size + offset,get);
560
561       len -= get;
562       *retlen += get;
563       from += get;
564    }
565    return 0;
566 }
567
568 /* Pass the flags value that the flash return before it re-entered read
569    mode. */
570 static void jedec_flash_failed(unsigned char code)
571 {
572    /* Bit 5 being high indicates that there was an internal device
573       failure, erasure time limits exceeded or something */
574    if ((code & (1 << 5)) != 0)
575    {
576       printk("mtd: Internal Flash failure\n");
577       return;
578    }
579    printk("mtd: Programming didn't take\n");
580 }
581
582 /* This uses the erasure function described in the AMD Flash Handbook,
583    it will work for flashes with a fixed sector size only. Flashes with
584    a selection of sector sizes (ie the AMD Am29F800B) will need a different
585    routine. This routine tries to parallize erasing multiple chips/sectors
586    where possible */
587 static int flash_erase(struct mtd_info *mtd, struct erase_info *instr)
588 {
589    // Does IO to the currently selected chip
590    #define flread(x) map_read8(map,chip->base+((x)<<chip->addrshift))
591    #define flwrite(v,x) map_write8(map,v,chip->base+((x)<<chip->addrshift))
592
593    unsigned long Time = 0;
594    unsigned long NoTime = 0;
595    unsigned long start = instr->addr, len = instr->len;
596    unsigned int I;
597    struct map_info *map = mtd->priv;
598    struct jedec_private *priv = map->fldrv_priv;
599
600    // Verify the arguments..
601    if (start + len > mtd->size ||
602        (start % mtd->erasesize) != 0 ||
603        (len % mtd->erasesize) != 0 ||
604        (len/mtd->erasesize) == 0)
605       return -EINVAL;
606
607    jedec_flash_chip_scan(priv,start,len);
608
609    // Start the erase sequence on each chip
610    for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
611    {
612       unsigned long off;
613       struct jedec_flash_chip *chip = priv->chips + I;
614
615       if (chip->length == 0)
616          continue;
617
618       if (chip->start + chip->length > chip->size)
619       {
620          printk("DIE\n");
621          return -EIO;
622       }
623
624       flwrite(0xF0,chip->start + 0x555);
625       flwrite(0xAA,chip->start + 0x555);
626       flwrite(0x55,chip->start + 0x2AA);
627       flwrite(0x80,chip->start + 0x555);
628       flwrite(0xAA,chip->start + 0x555);
629       flwrite(0x55,chip->start + 0x2AA);
630
631       /* Once we start selecting the erase sectors the delay between each
632          command must not exceed 50us or it will immediately start erasing
633          and ignore the other sectors */
634       for (off = 0; off < len; off += chip->sectorsize)
635       {
636          // Check to make sure we didn't timeout
637          flwrite(0x30,chip->start + off);
638          if (off == 0)
639             continue;
640          if ((flread(chip->start + off) & (1 << 3)) != 0)
641          {
642             printk("mtd: Ack! We timed out the erase timer!\n");
643             return -EIO;
644          }
645       }
646    }
647
648    /* We could split this into a timer routine and return early, performing
649       background erasure.. Maybe later if the need warrents */
650
651    /* Poll the flash for erasure completion, specs say this can take as long
652       as 480 seconds to do all the sectors (for a 2 meg flash).
653       Erasure time is dependent on chip age, temp and wear.. */
654
655    /* This being a generic routine assumes a 32 bit bus. It does read32s
656       and bundles interleved chips into the same grouping. This will work
657       for all bus widths */
658    Time = 0;
659    NoTime = 0;
660    for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
661    {
662       struct jedec_flash_chip *chip = priv->chips + I;
663       unsigned long off = 0;
664       unsigned todo[4] = {0,0,0,0};
665       unsigned todo_left = 0;
666       unsigned J;
667
668       if (chip->length == 0)
669          continue;
670
671       /* Find all chips in this data line, realistically this is all
672          or nothing up to the interleve count */
673       for (J = 0; priv->chips[J].jedec != 0 && J < MAX_JEDEC_CHIPS; J++)
674       {
675          if ((priv->chips[J].base & (~((1<<chip->addrshift)-1))) ==
676              (chip->base & (~((1<<chip->addrshift)-1))))
677          {
678             todo_left++;
679             todo[priv->chips[J].base & ((1<<chip->addrshift)-1)] = 1;
680          }
681       }
682
683       /*      printk("todo: %x %x %x %x\n",(short)todo[0],(short)todo[1],
684               (short)todo[2],(short)todo[3]);
685       */
686       while (1)
687       {
688          __u32 Last[4];
689          unsigned long Count = 0;
690
691          /* During erase bit 7 is held low and bit 6 toggles, we watch this,
692             should it stop toggling or go high then the erase is completed,
693             or this is not really flash ;> */
694          switch (map->buswidth) {
695          case 1:
696             Last[0] = map_read8(map,(chip->base >> chip->addrshift) + chip->start + off);
697             Last[1] = map_read8(map,(chip->base >> chip->addrshift) + chip->start + off);
698             Last[2] = map_read8(map,(chip->base >> chip->addrshift) + chip->start + off);
699             break;
700          case 2:
701             Last[0] = map_read16(map,(chip->base >> chip->addrshift) + chip->start + off);
702             Last[1] = map_read16(map,(chip->base >> chip->addrshift) + chip->start + off);
703             Last[2] = map_read16(map,(chip->base >> chip->addrshift) + chip->start + off);
704             break;
705          case 3:
706             Last[0] = map_read32(map,(chip->base >> chip->addrshift) + chip->start + off);
707             Last[1] = map_read32(map,(chip->base >> chip->addrshift) + chip->start + off);
708             Last[2] = map_read32(map,(chip->base >> chip->addrshift) + chip->start + off);
709             break;
710          }
711          Count = 3;
712          while (todo_left != 0)
713          {
714             for (J = 0; J != 4; J++)
715             {
716                __u8 Byte1 = (Last[(Count-1)%4] >> (J*8)) & 0xFF;
717                __u8 Byte2 = (Last[(Count-2)%4] >> (J*8)) & 0xFF;
718                __u8 Byte3 = (Last[(Count-3)%4] >> (J*8)) & 0xFF;
719                if (todo[J] == 0)
720                   continue;
721
722                if ((Byte1 & (1 << 7)) == 0 && Byte1 != Byte2)
723                {
724 //                printk("Check %x %x %x\n",(short)J,(short)Byte1,(short)Byte2);
725                   continue;
726                }
727
728                if (Byte1 == Byte2)
729                {
730                   jedec_flash_failed(Byte3);
731                   return -EIO;
732                }
733
734                todo[J] = 0;
735                todo_left--;
736             }
737
738 /*          if (NoTime == 0)
739                Time += HZ/10 - schedule_timeout(HZ/10);*/
740             NoTime = 0;
741
742             switch (map->buswidth) {
743             case 1:
744                Last[Count % 4] = map_read8(map,(chip->base >> chip->addrshift) + chip->start + off);
745               break;
746             case 2:
747                Last[Count % 4] = map_read16(map,(chip->base >> chip->addrshift) + chip->start + off);
748               break;
749             case 4:
750                Last[Count % 4] = map_read32(map,(chip->base >> chip->addrshift) + chip->start + off);
751               break;
752             }
753             Count++;
754
755 /*          // Count time, max of 15s per sector (according to AMD)
756             if (Time > 15*len/mtd->erasesize*HZ)
757             {
758                printk("mtd: Flash Erase Timed out\n");
759                return -EIO;
760             }       */
761          }
762
763          // Skip to the next chip if we used chip erase
764          if (chip->length == chip->size)
765             off = chip->size;
766          else
767             off += chip->sectorsize;
768
769          if (off >= chip->length)
770             break;
771          NoTime = 1;
772       }
773
774       for (J = 0; priv->chips[J].jedec != 0 && J < MAX_JEDEC_CHIPS; J++)
775       {
776          if ((priv->chips[J].base & (~((1<<chip->addrshift)-1))) ==
777              (chip->base & (~((1<<chip->addrshift)-1))))
778             priv->chips[J].length = 0;
779       }
780    }
781
782    //printk("done\n");
783    instr->state = MTD_ERASE_DONE;
784    mtd_erase_callback(instr);
785    return 0;
786
787    #undef flread
788    #undef flwrite
789 }
790
791 /* This is the simple flash writing function. It writes to every byte, in
792    sequence. It takes care of how to properly address the flash if
793    the flash is interleved. It can only be used if all the chips in the
794    array are identical!*/
795 static int flash_write(struct mtd_info *mtd, loff_t start, size_t len,
796                        size_t *retlen, const u_char *buf)
797 {
798    /* Does IO to the currently selected chip. It takes the bank addressing
799       base (which is divisible by the chip size) adds the necessary lower bits
800       of addrshift (interleave index) and then adds the control register index. */
801    #define flread(x) map_read8(map,base+(off&((1<<chip->addrshift)-1))+((x)<<chip->addrshift))
802    #define flwrite(v,x) map_write8(map,v,base+(off&((1<<chip->addrshift)-1))+((x)<<chip->addrshift))
803
804    struct map_info *map = mtd->priv;
805    struct jedec_private *priv = map->fldrv_priv;
806    unsigned long base;
807    unsigned long off;
808    size_t save_len = len;
809
810    if (start + len > mtd->size)
811       return -EIO;
812
813    //printk("Here");
814
815    //printk("flash_write: start is %x, len is %x\n",start,(unsigned long)len);
816    while (len != 0)
817    {
818       struct jedec_flash_chip *chip = priv->chips;
819       unsigned long bank;
820       unsigned long boffset;
821
822       // Compute the base of the flash.
823       off = ((unsigned long)start) % (chip->size << chip->addrshift);
824       base = start - off;
825
826       // Perform banked addressing translation.
827       bank = base & (~(priv->bank_fill[0]-1));
828       boffset = base & (priv->bank_fill[0]-1);
829       bank = (bank/priv->bank_fill[0])*my_bank_size;
830       base = bank + boffset;
831
832     //  printk("Flasing %X %X %X\n",base,chip->size,len);
833      // printk("off is %x, compare with %x\n",off,chip->size << chip->addrshift);
834
835       // Loop over this page
836       for (; off != (chip->size << chip->addrshift) && len != 0; start++, len--, off++,buf++)
837       {
838          unsigned char oldbyte = map_read8(map,base+off);
839          unsigned char Last[4];
840          unsigned long Count = 0;
841
842          if (oldbyte == *buf) {
843         //       printk("oldbyte and *buf is %x,len is %x\n",oldbyte,len);
844             continue;
845          }
846          if (((~oldbyte) & *buf) != 0)
847             printk("mtd: warn: Trying to set a 0 to a 1\n");
848
849          // Write
850          flwrite(0xAA,0x555);
851          flwrite(0x55,0x2AA);
852          flwrite(0xA0,0x555);
853          map_write8(map,*buf,base + off);
854          Last[0] = map_read8(map,base + off);
855          Last[1] = map_read8(map,base + off);
856          Last[2] = map_read8(map,base + off);
857
858          /* Wait for the flash to finish the operation. We store the last 4
859             status bytes that have been retrieved so we can determine why
860             it failed. The toggle bits keep toggling when there is a
861             failure */
862          for (Count = 3; Last[(Count - 1) % 4] != Last[(Count - 2) % 4] &&
863               Count < 10000; Count++)
864             Last[Count % 4] = map_read8(map,base + off);
865          if (Last[(Count - 1) % 4] != *buf)
866          {
867             jedec_flash_failed(Last[(Count - 3) % 4]);
868             return -EIO;
869          }
870       }
871    }
872    *retlen = save_len;
873    return 0;
874 }
875
876 /* This is used to enhance the speed of the erase routine,
877    when things are being done to multiple chips it is possible to
878    parallize the operations, particularly full memory erases of multi
879    chip memories benifit */
880 static void jedec_flash_chip_scan(struct jedec_private *priv,unsigned long start,
881                      unsigned long len)
882 {
883    unsigned int I;
884
885    // Zero the records
886    for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
887       priv->chips[I].start = priv->chips[I].length = 0;
888
889    // Intersect the region with each chip
890    for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
891    {
892       struct jedec_flash_chip *chip = priv->chips + I;
893       unsigned long ByteStart;
894       unsigned long ChipEndByte = chip->offset + (chip->size << chip->addrshift);
895
896       // End is before this chip or the start is after it
897       if (start+len < chip->offset ||
898           ChipEndByte - (1 << chip->addrshift) < start)
899          continue;
900
901       if (start < chip->offset)
902       {
903          ByteStart = chip->offset;
904          chip->start = 0;
905       }
906       else
907       {
908          chip->start = (start - chip->offset + (1 << chip->addrshift)-1) >> chip->addrshift;
909          ByteStart = start;
910       }
911
912       if (start + len >= ChipEndByte)
913          chip->length = (ChipEndByte - ByteStart) >> chip->addrshift;
914       else
915          chip->length = (start + len - ByteStart + (1 << chip->addrshift)-1) >> chip->addrshift;
916    }
917 }
918
919 int __init jedec_init(void)
920 {
921         register_mtd_chip_driver(&jedec_chipdrv);
922         return 0;
923 }
924
925 static void __exit jedec_exit(void)
926 {
927         unregister_mtd_chip_driver(&jedec_chipdrv);
928 }
929
930 module_init(jedec_init);
931 module_exit(jedec_exit);
932
933 MODULE_LICENSE("GPL");
934 MODULE_AUTHOR("Jason Gunthorpe <jgg@deltatee.com> et al.");
935 MODULE_DESCRIPTION("Old MTD chip driver for JEDEC-compliant flash chips");