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->writesize = 1;
 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;
 268    else
 269       MTD->read = jedec_read;
 270    MTD->write = flash_write;
 271    MTD->sync = jedec_sync;
 272    MTD->priv = map;
 273    map->fldrv_priv = priv;
 274    map->fldrv = &jedec_chipdrv;
 275    __module_get(THIS_MODULE);
 276    return MTD;
 277 }
 278
 279 /* Helper for the JEDEC function, JEDEC numbers all have odd parity */
 280 static int checkparity(u_char C)
 281 {
 282    u_char parity = 0;
 283    while (C != 0)
 284    {
 285       parity ^= C & 1;
 286       C >>= 1;
 287    }
 288
 289    return parity == 1;
 290 }
 291
 292
 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)
 298 {
 299    unsigned I,J;
 300    unsigned long Size;
 301    unsigned long SectorSize;
 302    const struct JEDECTable *JEDEC;
 303
 304    // Test #2 JEDEC numbers exhibit odd parity
 305    for (I = 0; I != Count; I++)
 306    {
 307       if (checkparity(Mfg[I]) == 0 || checkparity(Id[I]) == 0)
 308          return 0;
 309    }
 310
 311    // Finally, just make sure all the chip sizes are the same
 312    JEDEC = jedec_idtoinf(Mfg[0],Id[0]);
 313
 314    if (JEDEC == 0)
 315    {
 316       printk("mtd: Found JEDEC flash chip, but do not have a table entry for %x:%x\n",Mfg[0],Mfg[1]);
 317       return 0;
 318    }
 319
 320    Size = JEDEC->size;
 321    SectorSize = JEDEC->sectorsize;
 322    for (I = 0; I != Count; I++)
 323    {
 324       JEDEC = jedec_idtoinf(Mfg[0],Id[0]);
 325       if (JEDEC == 0)
 326       {
 327          printk("mtd: Found JEDEC flash chip, but do not have a table entry for %x:%x\n",Mfg[0],Mfg[1]);
 328          return 0;
 329       }
 330
 331       if (Size != JEDEC->size || SectorSize != JEDEC->sectorsize)
 332       {
 333          printk("mtd: Failed. Interleved flash does not have matching characteristics\n");
 334          return 0;
 335       }
 336    }
 337
 338    // Load the Chips
 339    for (I = 0; I != MAX_JEDEC_CHIPS; I++)
 340    {
 341       if (priv->chips[I].jedec == 0)
 342          break;
 343    }
 344
 345    if (I + Count > MAX_JEDEC_CHIPS)
 346    {
 347       printk("mtd: Device has too many chips. Increase MAX_JEDEC_CHIPS\n");
 348       return 0;
 349    }
 350
 351    // Add them to the table
 352    for (J = 0; J != Count; J++)
 353    {
 354       unsigned long Bank;
 355
 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;
 364
 365       // log2 n :|
 366       priv->chips[I].addrshift = 0;
 367       for (Bank = Count; Bank != 1; Bank >>= 1, priv->chips[I].addrshift++);
 368
 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;
 374       I++;
 375    }
 376
 377    priv->size += priv->chips[I-1].size*Count;
 378
 379    return priv->chips[I-1].size;
 380 }
 381
 382 /* Lookup the chip information from the JEDEC ID table. */
 383 static const struct JEDECTable *jedec_idtoinf(__u8 mfr,__u8 id)
 384 {
 385    __u16 Id = (mfr << 8) | id;
 386    unsigned long I = 0;
 387    for (I = 0; JEDEC_table[I].jedec != 0; I++)
 388       if (JEDEC_table[I].jedec == Id)
 389          return JEDEC_table + I;
 390    return NULL;
 391 }
 392
 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)
 396 {
 397    #define flread(x) map_read8(map,base+x)
 398    #define flwrite(v,x) map_write8(map,v,base+x)
 399
 400    const unsigned long AutoSel1 = 0xAA;
 401    const unsigned long AutoSel2 = 0x55;
 402    const unsigned long AutoSel3 = 0x90;
 403    const unsigned long Reset = 0xF0;
 404    __u32 OldVal;
 405    __u8 Mfg[1];
 406    __u8 Id[1];
 407    unsigned I;
 408    unsigned long Size;
 409
 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);
 414
 415    // Reset the chip
 416    flwrite(Reset,0x555);
 417
 418    // Send the sequence
 419    flwrite(AutoSel1,0x555);
 420    flwrite(AutoSel2,0x2AA);
 421    flwrite(AutoSel3,0x555);
 422
 423    //  Get the JEDEC numbers
 424    Mfg[0] = flread(0);
 425    Id[0] = flread(1);
 426    //   printk("Mfg is %x, Id is %x\n",Mfg[0],Id[0]);
 427
 428    Size = handle_jedecs(map,Mfg,Id,1,base,priv);
 429    //   printk("handle_jedecs Size is %x\n",(unsigned int)Size);
 430    if (Size == 0)
 431    {
 432       flwrite(Reset,0x555);
 433       return 0;
 434    }
 435
 436
 437    // Reset.
 438    flwrite(Reset,0x555);
 439
 440    return 1;
 441
 442    #undef flread
 443    #undef flwrite
 444 }
 445
 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)
 449 {
 450    return 0;
 451 }
 452
 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)
 456 {
 457    #define flread(x) map_read32(map,base+((x)<<2))
 458    #define flwrite(v,x) map_write32(map,v,base+((x)<<2))
 459
 460    const unsigned long AutoSel1 = 0xAAAAAAAA;
 461    const unsigned long AutoSel2 = 0x55555555;
 462    const unsigned long AutoSel3 = 0x90909090;
 463    const unsigned long Reset = 0xF0F0F0F0;
 464    __u32 OldVal;
 465    __u8 Mfg[4];
 466    __u8 Id[4];
 467    unsigned I;
 468    unsigned long Size;
 469
 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);
 474
 475    // Reset the chip
 476    flwrite(Reset,0x555);
 477
 478    // Send the sequence
 479    flwrite(AutoSel1,0x555);
 480    flwrite(AutoSel2,0x2AA);
 481    flwrite(AutoSel3,0x555);
 482
 483    // Test #1, JEDEC numbers are readable from 0x??00/0x??01
 484    if (flread(0) != flread(0x100) ||
 485        flread(1) != flread(0x101))
 486    {
 487       flwrite(Reset,0x555);
 488       return 0;
 489    }
 490
 491    // Split up the JEDEC numbers
 492    OldVal = flread(0);
 493    for (I = 0; I != 4; I++)
 494       Mfg[I] = (OldVal >> (I*8));
 495    OldVal = flread(1);
 496    for (I = 0; I != 4; I++)
 497       Id[I] = (OldVal >> (I*8));
 498
 499    Size = handle_jedecs(map,Mfg,Id,4,base,priv);
 500    if (Size == 0)
 501    {
 502       flwrite(Reset,0x555);
 503       return 0;
 504    }
 505
 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
 510       work */
 511    if (base + (Size<<2)+0x555 < map->size &&
 512        base + (Size<<2)+0x555 < (base & (~(my_bank_size-1))) + my_bank_size)
 513    {
 514       if (flread(base+Size) != flread(base+Size + 0x100) ||
 515           flread(base+Size + 1) != flread(base+Size + 0x101))
 516       {
 517          jedec_probe32(map,base+Size,priv);
 518       }
 519    }
 520
 521    // Reset.
 522    flwrite(0xF0F0F0F0,0x555);
 523
 524    return 1;
 525
 526    #undef flread
 527    #undef flwrite
 528 }
 529
 530 /* Linear read. */
 531 static int jedec_read(struct mtd_info *mtd, loff_t from, size_t len,
 532                       size_t *retlen, u_char *buf)
 533 {
 534    struct map_info *map = mtd->priv;
 535
 536    map_copy_from(map, buf, from, len);
 537    *retlen = len;
 538    return 0;
 539 }
 540
 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)
 545 {
 546    struct map_info *map = mtd->priv;
 547    struct jedec_private *priv = map->fldrv_priv;
 548
 549    *retlen = 0;
 550    while (len > 0)
 551    {
 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;
 558
 559       bank /= priv->bank_fill[0];
 560       map_copy_from(map,buf + *retlen,bank*my_bank_size + offset,get);
 561
 562       len -= get;
 563       *retlen += get;
 564       from += get;
 565    }
 566    return 0;
 567 }
 568
 569 /* Pass the flags value that the flash return before it re-entered read
 570    mode. */
 571 static void jedec_flash_failed(unsigned char code)
 572 {
 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)
 576    {
 577       printk("mtd: Internal Flash failure\n");
 578       return;
 579    }
 580    printk("mtd: Programming didn't take\n");
 581 }
 582
 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
 587    where possible */
 588 static int flash_erase(struct mtd_info *mtd, struct erase_info *instr)
 589 {
 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))
 593
 594    unsigned long Time = 0;
 595    unsigned long NoTime = 0;
 596    unsigned long start = instr->addr, len = instr->len;
 597    unsigned int I;
 598    struct map_info *map = mtd->priv;
 599    struct jedec_private *priv = map->fldrv_priv;
 600
 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)
 606       return -EINVAL;
 607
 608    jedec_flash_chip_scan(priv,start,len);
 609
 610    // Start the erase sequence on each chip
 611    for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
 612    {
 613       unsigned long off;
 614       struct jedec_flash_chip *chip = priv->chips + I;
 615
 616       if (chip->length == 0)
 617          continue;
 618
 619       if (chip->start + chip->length > chip->size)
 620       {
 621          printk("DIE\n");
 622          return -EIO;
 623       }
 624
 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);
 631
 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)
 636       {
 637          // Check to make sure we didn't timeout
 638          flwrite(0x30,chip->start + off);
 639          if (off == 0)
 640             continue;
 641          if ((flread(chip->start + off) & (1 << 3)) != 0)
 642          {
 643             printk("mtd: Ack! We timed out the erase timer!\n");
 644             return -EIO;
 645          }
 646       }
 647    }
 648
 649    /* We could split this into a timer routine and return early, performing
 650       background erasure.. Maybe later if the need warrents */
 651
 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.. */
 655
 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 */
 659    Time = 0;
 660    NoTime = 0;
 661    for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
 662    {
 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;
 667       unsigned J;
 668
 669       if (chip->length == 0)
 670          continue;
 671
 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++)
 675       {
 676          if ((priv->chips[J].base & (~((1<<chip->addrshift)-1))) ==
 677              (chip->base & (~((1<<chip->addrshift)-1))))
 678          {
 679             todo_left++;
 680             todo[priv->chips[J].base & ((1<<chip->addrshift)-1)] = 1;
 681          }
 682       }
 683
 684       /*      printk("todo: %x %x %x %x\n",(short)todo[0],(short)todo[1],
 685               (short)todo[2],(short)todo[3]);
 686       */
 687       while (1)
 688       {
 689          __u32 Last[4];
 690          unsigned long Count = 0;
 691
 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) {
 696          case 1:
 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);
 700             break;
 701          case 2:
 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);
 705             break;
 706          case 3:
 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);
 710             break;
 711          }
 712          Count = 3;
 713          while (todo_left != 0)
 714          {
 715             for (J = 0; J != 4; J++)
 716             {
 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;
 720                if (todo[J] == 0)
 721                   continue;
 722
 723                if ((Byte1 & (1 << 7)) == 0 && Byte1 != Byte2)
 724                {
 725 //                printk("Check %x %x %x\n",(short)J,(short)Byte1,(short)Byte2);
 726                   continue;
 727                }
 728
 729                if (Byte1 == Byte2)
 730                {
 731                   jedec_flash_failed(Byte3);
 732                   return -EIO;
 733                }
 734
 735                todo[J] = 0;
 736                todo_left--;
 737             }
 738
 739 /*          if (NoTime == 0)
 740                Time += HZ/10 - schedule_timeout(HZ/10);*/
 741             NoTime = 0;
 742
 743             switch (map->buswidth) {
 744             case 1:
 745                Last[Count % 4] = map_read8(map,(chip->base >> chip->addrshift) + chip->start + off);
 746               break;
 747             case 2:
 748                Last[Count % 4] = map_read16(map,(chip->base >> chip->addrshift) + chip->start + off);
 749               break;
 750             case 4:
 751                Last[Count % 4] = map_read32(map,(chip->base >> chip->addrshift) + chip->start + off);
 752               break;
 753             }
 754             Count++;
 755
 756 /*          // Count time, max of 15s per sector (according to AMD)
 757             if (Time > 15*len/mtd->erasesize*HZ)
 758             {
 759                printk("mtd: Flash Erase Timed out\n");
 760                return -EIO;
 761             }       */
 762          }
 763
 764          // Skip to the next chip if we used chip erase
 765          if (chip->length == chip->size)
 766             off = chip->size;
 767          else
 768             off += chip->sectorsize;
 769
 770          if (off >= chip->length)
 771             break;
 772          NoTime = 1;
 773       }
 774
 775       for (J = 0; priv->chips[J].jedec != 0 && J < MAX_JEDEC_CHIPS; J++)
 776       {
 777          if ((priv->chips[J].base & (~((1<<chip->addrshift)-1))) ==
 778              (chip->base & (~((1<<chip->addrshift)-1))))
 779             priv->chips[J].length = 0;
 780       }
 781    }
 782
 783    //printk("done\n");
 784    instr->state = MTD_ERASE_DONE;
 785    mtd_erase_callback(instr);
 786    return 0;
 787
 788    #undef flread
 789    #undef flwrite
 790 }
 791
 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)
 798 {
 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))
 804
 805    struct map_info *map = mtd->priv;
 806    struct jedec_private *priv = map->fldrv_priv;
 807    unsigned long base;
 808    unsigned long off;
 809    size_t save_len = len;
 810
 811    if (start + len > mtd->size)
 812       return -EIO;
 813
 814    //printk("Here");
 815
 816    //printk("flash_write: start is %x, len is %x\n",start,(unsigned long)len);
 817    while (len != 0)
 818    {
 819       struct jedec_flash_chip *chip = priv->chips;
 820       unsigned long bank;
 821       unsigned long boffset;
 822
 823       // Compute the base of the flash.
 824       off = ((unsigned long)start) % (chip->size << chip->addrshift);
 825       base = start - off;
 826
 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;
 832
 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);
 835
 836       // Loop over this page
 837       for (; off != (chip->size << chip->addrshift) && len != 0; start++, len--, off++,buf++)
 838       {
 839          unsigned char oldbyte = map_read8(map,base+off);
 840          unsigned char Last[4];
 841          unsigned long Count = 0;
 842
 843          if (oldbyte == *buf) {
 844         //       printk("oldbyte and *buf is %x,len is %x\n",oldbyte,len);
 845             continue;
 846          }
 847          if (((~oldbyte) & *buf) != 0)
 848             printk("mtd: warn: Trying to set a 0 to a 1\n");
 849
 850          // Write
 851          flwrite(0xAA,0x555);
 852          flwrite(0x55,0x2AA);
 853          flwrite(0xA0,0x555);
 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);
 858
 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
 862             failure */
 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)
 867          {
 868             jedec_flash_failed(Last[(Count - 3) % 4]);
 869             return -EIO;
 870          }
 871       }
 872    }
 873    *retlen = save_len;
 874    return 0;
 875 }
 876
 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,
 882                      unsigned long len)
 883 {
 884    unsigned int I;
 885
 886    // Zero the records
 887    for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
 888       priv->chips[I].start = priv->chips[I].length = 0;
 889
 890    // Intersect the region with each chip
 891    for (I = 0; priv->chips[I].jedec != 0 && I < MAX_JEDEC_CHIPS; I++)
 892    {
 893       struct jedec_flash_chip *chip = priv->chips + I;
 894       unsigned long ByteStart;
 895       unsigned long ChipEndByte = chip->offset + (chip->size << chip->addrshift);
 896
 897       // End is before this chip or the start is after it
 898       if (start+len < chip->offset ||
 899           ChipEndByte - (1 << chip->addrshift) < start)
 900          continue;
 901
 902       if (start < chip->offset)
 903       {
 904          ByteStart = chip->offset;
 905          chip->start = 0;
 906       }
 907       else
 908       {
 909          chip->start = (start - chip->offset + (1 << chip->addrshift)-1) >> chip->addrshift;
 910          ByteStart = start;
 911       }
 912
 913       if (start + len >= ChipEndByte)
 914          chip->length = (ChipEndByte - ByteStart) >> chip->addrshift;
 915       else
 916          chip->length = (start + len - ByteStart + (1 << chip->addrshift)-1) >> chip->addrshift;
 917    }
 918 }
 919
 920 int __init jedec_init(void)
 921 {
 922         register_mtd_chip_driver(&jedec_chipdrv);
 923         return 0;
 924 }
 925
 926 static void __exit jedec_exit(void)
 927 {
 928         unregister_mtd_chip_driver(&jedec_chipdrv);
 929 }
 930
 931 module_init(jedec_init);
 932 module_exit(jedec_exit);
 933
 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");