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