target/linux/etrax-2.6/image/e100boot/src/cbl/src/flash.c

   1 /* $Id: flash.c,v 1.39 2004/04/20 07:57:57 jonashg Exp $
   2  *
   3  * Stolen from the eLinux kernel and stripped down.
   4  *
   5  * HISTORY:
   6  *
   7  * $Log: flash.c,v $
   8  * Revision 1.39  2004/04/20 07:57:57  jonashg
   9  * Clear flash_status fields to make it possible to flash several images
  10  * sequentially.
  11  *
  12  * Revision 1.38  2003/12/16 09:04:07  magnusmn
  13  * Removed FLASHFILL command
  14  *
  15  * Revision 1.37  2003/12/16 08:49:01  magnusmn
  16  * Merging change_branch--fast_flash
  17  *
  18  * Revision 1.36.2.6  2003/12/15 17:21:27  magnusmn
  19  * Reset counter when continuing with operations the next sector.
  20  *
  21  * Revision 1.36.2.5  2003/12/15 11:35:57  magnusmn
  22  * Bail out if we try to erase the same sector more that 10 times
  23  *
  24  * Revision 1.36.2.4  2003/12/12 12:07:10  magnusmn
  25  * FIX for ST M29W320DT
  26  * Some chip need a reset to bring them back to read mode again.
  27  *
  28  * Revision 1.36.2.3  2003/11/10 16:38:04  orjanf
  29  * Unified Erasing/Writing messages
  30  *
  31  * Revision 1.36.2.2  2003/11/10 15:52:34  magnusmn
  32  * More info on a sector basis
  33  *
  34  * Revision 1.36.2.1  2003/11/07 16:23:20  magnusmn
  35  * o Only erase a flash sector if we need to, that is if the source content isn't already is in place.
  36  * o Don't erase a flash sector that already contain ones.
  37  * o Don't write ones to a (d)word that already contain ones.
  38  * o If there are two flashes, switch flash after an erase operation is started on one of them.
  39  * o Flash fill doesn't work yet.
  40  * o No timeout implemented, we will continue to erase/program until we succeed.
  41  * o Interleave not tested.
  42  *
  43  * Revision 1.36  2003/10/16 17:08:51  jonashg
  44  * Bugfix: reversed CFI-tables wasn't handled correctly since regions support was
  45  * merged.
  46  *
  47  * Revision 1.35  2003/10/14 13:43:41  pkj
  48  * Fixed compiler warnings.
  49  *
  50  * Revision 1.34  2003/10/14 10:48:13  magnusmn
  51  * No need to write ones to a (d)word where there already are ones. This will save time during flash programming.
  52  *
  53  * Revision 1.33  2003/10/10 11:46:25  jonashg
  54  * Merged change_branch--regions_support.
  55  *
  56  * Revision 1.32.2.3  2003/10/10 09:38:13  jonashg
  57  * Corrected calculation of current region and sector before erase.
  58  *
  59  * Revision 1.32.2.2  2003/10/09 16:31:26  jonashg
  60  * Regions support in JEDEC probe.
  61  *
  62  * Revision 1.32.2.1  2003/09/19 15:28:22  jonashg
  63  * Support for unusual region layouts. It only works for CFI compliant chips (yet).
  64  *
  65  * Revision 1.32  2002/12/13 15:55:54  jonashg
  66  * Fix for ST M29W160ET. It seems to need a reset before erase (even though the
  67  * probe functions did reset it).
  68  *
  69  * Revision 1.31  2002/07/01 14:37:25  pkj
  70  * Merged with the ASIC version of e100boot. Main difference is that
  71  * information about the executed commands are sent back to e100boot
  72  * instead of being sent to the debug port. This means there is no
  73  * longer any need to use different boot loaders for different
  74  * debug ports.
  75  *
  76  * Revision 1.30  2002/06/26 13:28:29  pkj
  77  * flash_write() can now be used to erase an area (by specifying
  78  * source as NULL), and to fill an area with the first udword of
  79  * source by setting do_fill to TRUE).
  80  *
  81  * Revision 1.29  2002/06/26 13:19:37  pkj
  82  * * flash_write() now returns a status code.
  83  * * timeout is now decremented correctly in flash_write_part() to
  84  *   actually be able to trigger the timeout message.
  85  * * Fixed all compiler warnings.
  86  *
  87  * Revision 1.28  2002/06/20 12:58:18  pkj
  88  * Changed svinto_boot.h to e100boot.h
  89  *
  90  * Revision 1.27  2002/06/19 14:00:29  pkj
  91  * * Broke out the probing of the flash chips from  flash_write()
  92  *   into flash_probe_chips().
  93  * * flash_probe_chips() is not limited to two chips or that the
  94  *   first chip exists.
  95  *
  96  * Revision 1.26  2002/02/21 14:37:52  jonashg
  97  * Optimized away my sanity. It's back now I think.
  98  *
  99  * Revision 1.25  2002/02/21 14:28:24  jonashg
 100  * Added support for Atmel AT49?V16?T (had to optimize a bit to make room).
 101  *
 102  * Revision 1.24  2002/01/31 14:36:14  jonashg
 103  * * Added support for Atmel AT49[BL]V16[01] (the chip used in the ETRAX MCM).
 104  * * Replaced concurrent sector erase with sequential (we have found three
 105  *   different chips that cannot erase multiple sectors at the same time,
 106  *   one of the is the chip in the MCM). I haven't noticed any performance
 107  *   loss on chips (CFI and non-CFI) that can erase all sectors at the same
 108  *   time either (maybe they don't really erase them at the same time in
 109  *   hardware).
 110  * * Added check for manufacturer id as well as device id (should have been
 111  *   done a long time ago).
 112  *
 113  * Revision 1.23  2001/11/21 15:52:44  jonashg
 114  * Almost readable.
 115  *
 116  * Revision 1.22  2001/11/21 15:24:38  jonashg
 117  * Increased readability and decreased size some 40bytes.
 118  *
 119  * Revision 1.21  2001/11/20 13:40:12  starvik
 120  * Corrected handling for CFI capable bottom boot flashes
 121  * Shorted some strings to make more space available
 122  *
 123  * Revision 1.20  2001/08/08 17:51:28  pkj
 124  * Made it possible to flash at a start offset other than zero when
 125  * there are more than one physical flash chip available. Previously
 126  * it always started flashing from the start of the first flash if
 127  * there were more than one, even though the start offset was set to
 128  * something else...
 129  *
 130  * Revision 1.19  2001/06/19 14:51:17  jonashg
 131  * Added support for non-CFI flash Toshiba TC58FVT800.
 132  *
 133  * Revision 1.18  2001/04/05 06:32:39  starvik
 134  * Works with flashes with multiple banks
 135  *
 136  * Revision 1.17  2001/03/06 15:21:16  jonashg
 137  * More output to user.
 138  *
 139  * Revision 1.16  2001/03/06 14:11:16  jonashg
 140  * * Switch to second device correctly when flashing images that extend past the
 141  *   first device.
 142  * * Only enter autoselect mode once saves a few bytes (not needed before reading
 143  *   device id, since it was done before reading manufacturer id).
 144  * * A few unnecessary resets removed to save another few bytes.
 145  *
 146  * Revision 1.15  2001/02/28 14:52:43  jonashg
 147  * * Reverted to old sector erase sequence (that was correct).
 148  * * A bit of executable size optimization (a few hundred bytes).
 149  * * Cleanup.
 150  *
 151  * Revision 1.14  2001/02/27 14:18:59  jonashg
 152  * * Write full erase command sequence to all sectors that should be erased.
 153  * * Write 16bit erase command to non-interleaved chips.
 154  *
 155  * Revision 1.13  2001/02/23 11:03:41  jonashg
 156  * Added support for 2 x 16Mb flashes (32-bits buswidth).
 157  * The CFI probe does not detect two parallel flash devices, but the normal
 158  * probe does (it should be easy to add that in the CFI-probe, but I didn't
 159  * have any hardware to try it on and the size of the executable is getting
 160  * pretty close to the size of the ETRAX cache).
 161  *
 162  * Revision 1.12  2001/02/12 13:59:00  jonashg
 163  * Bugfix: pointer arithmetics made bootsector calculation go wrong.
 164  *
 165  * Revision 1.11  2000/11/10 08:02:23  starvik
 166  * Added CFI support
 167  *
 168  * Revision 1.10  2000/10/26 13:47:32  johana
 169  * Added support for Fujitsu flash 16MBit (2MByte) MBM29LV160BE and MBM29LV160TE.
 170  * NOT VERIFIED YET!
 171  *
 172  * Revision 1.9  2000/06/28 13:02:50  bjornw
 173  * * Added support for SST39LF800 and SST39LF160 flashes
 174  * * Fixed some indentation issues
 175  *
 176  * Revision 1.8  2000/06/13 11:51:11  starvik
 177  * Support for two flashes. Second flash is erased and programmed if program
 178  * is larger than first flash.
 179  *
 180  * Revision 1.7  2000/04/13 16:06:15  macce
 181  * See if flash is empty before erasing it. Might save some production time.
 182  *
 183  * Revision 1.6  2000/01/27 17:52:07  bjornw
 184  * * Added Toshiba flashes
 185  * * Added proper bootblock erase for the different flashes
 186  *   (this caused the verify errors when trying to do ./flashitall before)
 187  *
 188  * Revision 1.5  2000/01/20 11:41:28  finn
 189  * Improved the verify error printouts in flash_write.
 190  *
 191  * Revision 1.4  1999/12/21 19:32:53  bjornw
 192  * Dont choke on full chip erases even though we dont implement it efficiently.
 193  *
 194  * Revision 1.3  1999/11/12 01:30:04  bjornw
 195  * Added wait for busy to be ready. Removed some warnings.
 196  *
 197  * Revision 1.2  1999/10/27 07:42:42  johana
 198  * Added support for ST M29W800T flash used in 5600
 199  *
 200  * Revision 1.1  1999/10/27 01:37:12  bjornw
 201  * Wrote routines to erase and flash data into a flash ROM.
 202  *
 203  */
 204
 205 #include "e100boot.h"
 206
 207 //#define DEBUG
 208
 209 #ifdef DEBUG
 210 #define FDEBUG(x) x
 211 #else
 212 #define FDEBUG(x)
 213 #endif
 214
 215 /* Try turning of some of these if you run into space problems. */
 216 #define CFI_PROBE
 217 #define JEDEC_PROBE
 218 #define INTERLEAVE
 219
 220 #define TYPE_X16        (16 / 8)
 221
 222 #define nop() __asm__("nop")
 223
 224 #define safe_printk send_string
 225
 226 static char *message_bottom_boot_8 = "8Mb BB";
 227 static char *message_top_boot_8 = "8Mb TB";
 228 static char *message_bottom_boot_16 = "16Mb BB";
 229 static char *message_top_boot_16 = "16Mb TB";
 230 static char *message_top_boot_32 = "32Mb TB";
 231
 232 enum {
 233         /* Addresses */
 234         ADDR_UNLOCK_1                   = 0x0555,
 235         ADDR_UNLOCK_2                   = 0x02AA,
 236         ADDR_MANUFACTURER               = 0x0000,
 237         ADDR_DEVICE_ID                  = 0x0001,
 238         ADDR_CFI_QUERY                  = 0x0055,
 239
 240         /* Commands */
 241         CMD_UNLOCK_DATA_1               = 0x00AA,
 242         CMD_UNLOCK_DATA_2               = 0x0055,
 243         CMD_MANUFACTURER_UNLOCK_DATA    = 0x0090,
 244         CMD_PROGRAM_UNLOCK_DATA         = 0x00A0,
 245         CMD_RESET_DATA                  = 0x00F0,
 246         CMD_SECTOR_ERASE_UNLOCK_DATA_1  = 0x0080,
 247         CMD_SECTOR_ERASE_UNLOCK_DATA_2  = 0x0030,
 248         CMD_CFI_QUERY_DATA              = 0x0098,
 249
 250         /* Offsets */
 251         OFFSET_CFI_ID                   = 0x10,
 252         OFFSET_CFI_SIZE                 = 0x27,
 253         OFFSET_CFI_BLOCK_COUNT          = 0x2C,
 254         OFFSET_CFI_BLOCK                = 0x2D,
 255
 256         /* Manufacturers */
 257         MANUFACTURER_AMD                = 0x01,
 258         MANUFACTURER_ATMEL              = 0x1F,
 259         MANUFACTURER_FUJITSU            = 0x04,
 260         MANUFACTURER_SST                = 0xBF,
 261         MANUFACTURER_ST                 = 0x20,
 262         MANUFACTURER_TOSHIBA            = 0x98,
 263
 264
 265         /* To save precious space we store mfr and dev id together */
 266
 267         /* AMD devices */
 268         AM29F800BB                      = 0x00012258,
 269         AM29F800BT                      = 0x000122D6,
 270         AM29LV800BB                     = 0x0001225B,
 271         AM29LV800BT                     = 0x000122DA,
 272         AM29LV160BT                     = 0x000122C4,
 273
 274         /* Atmel devices */
 275         AT49xV16x                       = 0x001F00C0,
 276         AT49xV16xT                      = 0x001F00C2,
 277         AT49BV32xAT                     = 0x001F00C9,
 278
 279         /* Fujitsu devices */
 280         MBM29LV160TE                    = 0x000422C4,
 281         MBM29LV160BE                    = 0x00042249,
 282
 283         /* SST devices */
 284         SST39LF800                      = 0x00BF2781,
 285         SST39LF160                      = 0x00BF2782,
 286
 287         /* ST devices */
 288         M29W800T                        = 0x002000D7, /* Used in 5600, similar
 289                                                        * to AM29LV800, but no
 290                                                        * unlock bypass
 291                                                        */
 292         /* Toshiba devices */
 293         TC58FVT160                      = 0x009800C2,
 294         TC58FVB160                      = 0x00980043,
 295         TC58FVT800                      = 0x0098004F,
 296
 297         /* Toggle bit mask */
 298         D6_MASK                         = 0x40
 299 };
 300
 301 struct region {
 302         unsigned long offset;
 303         unsigned int sector_size;
 304         unsigned int numsectors;
 305 };
 306
 307 #define MAXREGIONS 8
 308
 309 struct chip {
 310         volatile unsigned char *base;
 311 #ifdef INTERLEAVE
 312         byte interleave;
 313         byte buswidth;
 314 #endif
 315         unsigned int size;
 316         unsigned short numregions;
 317         struct region regions[MAXREGIONS];
 318 };
 319
 320 /* Allocate flash structures and initialize base. */
 321 static struct chip chips[2] = {
 322         { (unsigned char *)0x80000000,
 323 #ifdef INTERLEAVE
 324                 0, 0,
 325 #endif
 326                 0, 0, { } },
 327         { (unsigned char *)0x84000000,
 328 #ifdef INTERLEAVE
 329                 0, 0,
 330 #endif
 331                 0, 0, { } }
 332 };
 333
 334
 335
 336 static unsigned int
 337 wide_read(struct chip *flash, unsigned long offset)
 338 {
 339 #ifdef INTERLEAVE
 340         switch (flash->buswidth) {
 341         case 2:
 342 #endif
 343                 return *((uword *)(flash->base + offset));
 344
 345 #ifdef INTERLEAVE
 346         case 4:
 347                 return *((udword *)(flash->base + offset));
 348         }
 349
 350         return 0;
 351 #endif
 352 }
 353
 354 static int
 355 wide_write_chunk(struct chip *flash, unsigned long offset, const void *chunk)
 356 {
 357 #ifdef INTERLEAVE
 358         switch (flash->buswidth) {
 359         case 2:
 360 #endif
 361                 *((uword *)(flash->base + offset)) = *((uword *)chunk);
 362                 return 2;
 363
 364 #ifdef INTERLEAVE
 365         case 4:
 366                 *((udword *)(flash->base + offset)) = *((udword *)chunk);
 367                 return 4;
 368         }
 369
 370         return 0;
 371 #endif
 372 }
 373
 374 static void
 375 wide_cmd(struct chip *flash, udword cmd, unsigned long offset)
 376 {
 377 #ifdef INTERLEAVE
 378         if (flash->interleave == 1) {
 379 #endif
 380                 offset <<= 1;
 381 #ifdef INTERLEAVE
 382         } else if (flash->interleave == 2) {
 383                 cmd |= (cmd << 16);
 384                 offset <<= 2;
 385         } else {
 386                 safe_printk("Unsupported interleave!\n");
 387                 return;
 388         }
 389 #endif
 390
 391         wide_write_chunk(flash, offset, &cmd);
 392 }
 393
 394 static void
 395 flash_unlock(struct chip *flash)
 396 {
 397         wide_cmd(flash, CMD_UNLOCK_DATA_1, ADDR_UNLOCK_1);
 398         wide_cmd(flash, CMD_UNLOCK_DATA_2, ADDR_UNLOCK_2);
 399 }
 400
 401 static int
 402 flash_is_busy(struct chip *flash, unsigned long offset)
 403 {
 404 #ifdef INTERLEAVE
 405         if (flash->interleave == 2) {
 406                 udword read1, read2;
 407
 408                 read1 = wide_read(flash, offset);
 409                 read2 = wide_read(flash, offset);
 410                 return (((read1 >> 16) & D6_MASK) !=
 411                         ((read2 >> 16) & D6_MASK)) ||
 412                        (((read1 & 0xffff) & D6_MASK) !=
 413                         ((read2 & 0xffff) & D6_MASK));
 414         }
 415 #endif
 416
 417         return ((wide_read(flash, offset) & D6_MASK) !=
 418                 (wide_read(flash, offset) & D6_MASK));
 419 }
 420
 421
 422
 423 #ifdef CFI_PROBE
 424 static int
 425 try_cfi(struct chip *flash)
 426 {
 427         int offset_shift = 1;
 428
 429 #ifdef INTERLEAVE
 430         if (flash->interleave == 2) {
 431                 offset_shift = 2;
 432         }
 433 #endif
 434
 435         /* Enter CFI mode */
 436         wide_cmd(flash, CMD_CFI_QUERY_DATA, ADDR_CFI_QUERY);
 437
 438         /* Check if flash responds correctly */
 439         if ((byte)wide_read(flash, (OFFSET_CFI_ID+0) << offset_shift) == 'Q' &&
 440             (byte)wide_read(flash, (OFFSET_CFI_ID+1) << offset_shift) == 'R' &&
 441             (byte)wide_read(flash, (OFFSET_CFI_ID+2) << offset_shift) == 'Y') {
 442                 int block;               /* Current block */
 443                 int block_count;         /* Number of blocks */
 444                 unsigned int offset = 0; /* Offset into flash */
 445                 int reverse = 0;         /* Reverse block table */
 446                 int primary;             /* Offset to vendor specific table */
 447
 448                 safe_printk("Found 1 x CFI at ");
 449                 send_hex((udword)flash->base, NL);
 450
 451                 flash->size =
 452                         1 << wide_read(flash, OFFSET_CFI_SIZE << offset_shift);
 453
 454                 /* CFI stores flash organization in blocks. Each block contains
 455                  * a number of sectors with the same size
 456                  */
 457                 block_count = wide_read(flash, OFFSET_CFI_BLOCK_COUNT <<
 458                                                offset_shift);
 459
 460                 /* Check if table is reversed */
 461                 primary = wide_read(flash, (OFFSET_CFI_ID+5) << offset_shift);
 462                 /* For CFI version 1.0 we don't know. Assume that id & 0x80 */
 463                 /* indicates top boot */
 464                 if ((byte)wide_read(flash, (primary+4) << offset_shift) == 0x30)
 465                 {
 466                         /* read device id */
 467                         wide_cmd(flash, CMD_RESET_DATA, ADDR_UNLOCK_1);
 468                         flash_unlock(flash);
 469                         wide_cmd(flash, CMD_MANUFACTURER_UNLOCK_DATA,
 470                                  ADDR_UNLOCK_1);
 471                         reverse = wide_read(flash, ADDR_DEVICE_ID * TYPE_X16
 472 #ifdef INTERLEAVE
 473                                             * flash->interleave
 474 #endif
 475                                            ) & 0x80;
 476                         wide_cmd(flash, CMD_CFI_QUERY_DATA, ADDR_CFI_QUERY);
 477                 } else {
 478                         reverse = ((byte)wide_read(flash,
 479                                         (primary+15) << offset_shift) == 3);
 480                 }
 481
 482                 flash->numregions = block_count;
 483                 if (block_count > MAXREGIONS) {
 484                         safe_printk("Too many regions on chip!\n");
 485                         return 0;
 486                 }
 487
 488                 /* Blocks are stored backwards compared to flash organization */
 489                 for (block = reverse ? block_count - 1 : 0;
 490                      reverse ? block >= 0 : block < block_count;
 491                      reverse ? block-- : block++) {
 492                         int region;
 493
 494                         /* Size of each sector in block. Size is stored as
 495                          * sector_size / 256.
 496                          */
 497                         int sector_size =
 498                             (wide_read(flash, (OFFSET_CFI_BLOCK+block * 4+2) <<
 499                                               offset_shift)
 500                                 |
 501                             (wide_read(flash, (OFFSET_CFI_BLOCK+block * 4+3) <<
 502                                               offset_shift) << 8)
 503                             ) << 8;
 504
 505                         /* Number of sectors */
 506                         int sector_count =
 507                             (wide_read(flash, (OFFSET_CFI_BLOCK+block * 4+0) <<
 508                                               offset_shift)
 509                                 |
 510                             (wide_read(flash, (OFFSET_CFI_BLOCK+block * 4+1) <<
 511                                               offset_shift) << 8)
 512                             ) + 1;
 513
 514                         region = reverse? block_count - 1 - block : block;
 515                         flash->regions[region].offset = offset;
 516                         flash->regions[region].sector_size = sector_size;
 517                         flash->regions[region].numsectors = sector_count;
 518
 519                         /* Can't use multiplication (we have no lib). */
 520                         {
 521                                 int temp;
 522                                 for (temp = 0 ; temp < sector_count ; temp++) {
 523                                         offset += sector_size;
 524                                 }
 525                         }
 526
 527 FDEBUG(
 528         if (reverse) {
 529                 safe_printk("NOTE! reversed table:\n");
 530         }
 531         safe_printk("region: ");
 532         send_hex((udword)region, NL);
 533         safe_printk("   offset: ");
 534         send_hex((udword)flash->regions[region].offset, NL);
 535         safe_printk("   sector_size: ");
 536         send_hex((udword)flash->regions[region].sector_size, NL);
 537         safe_printk("   numsectors: ");
 538         send_hex((udword)flash->regions[region].numsectors, NL);
 539 )
 540
 541                 /* Some flashes (SST) store information about alternate
 542                          * block sizes. Ignore those by breaking when the sum
 543                          * of the sector sizes == flash size.
 544                          */
 545                         if (offset == flash->size) {
 546                                 break;
 547                         }
 548                 }
 549
 550                 /* reset */
 551                 wide_cmd(flash, CMD_RESET_DATA, ADDR_UNLOCK_1);
 552
 553                 return 1;
 554         }
 555
 556         /* reset */
 557         wide_cmd(flash, CMD_RESET_DATA, ADDR_UNLOCK_1);
 558
 559         return 0;
 560 }
 561 #endif
 562
 563
 564
 565 static int
 566 flash_probe(struct chip *flash)
 567 {
 568         char *message;
 569         udword dev_id;
 570         udword mfr_id;
 571         udword id;
 572
 573         if (flash->size
 574 #ifdef CFI_PROBE
 575             || try_cfi(flash)
 576 #endif
 577            ) {
 578                 return 1;
 579         }
 580
 581 #ifdef JEDEC_PROBE
 582         /* Read manufacturer ID. */
 583         flash_unlock(flash);
 584         wide_cmd(flash, CMD_MANUFACTURER_UNLOCK_DATA, ADDR_UNLOCK_1);
 585         mfr_id = wide_read(flash, ADDR_MANUFACTURER * TYPE_X16
 586 #ifdef INTERLEAVE
 587                            * flash->interleave
 588 #endif
 589                           );
 590         /* Read device ID. */
 591         dev_id = wide_read(flash, ADDR_DEVICE_ID * TYPE_X16
 592 #ifdef INTERLEAVE
 593                            * flash->interleave
 594 #endif
 595                           );
 596 FDEBUG(
 597         safe_printk("mfr_id: ");
 598         send_hex(mfr_id, NL);
 599         safe_printk("dev_id: ");
 600         send_hex(dev_id, NL);
 601 )
 602
 603 #ifdef INTERLEAVE
 604         if ((flash->interleave == 2) &&
 605             ((mfr_id >> 16) == (mfr_id & 0xffff)) &&
 606             ((dev_id >> 16) == (dev_id & 0xffff))) {
 607                 mfr_id &= 0xffff;
 608                 dev_id &= 0xffff;
 609         }
 610 #endif
 611
 612         id = (mfr_id << 16) | dev_id;
 613
 614         /* reset */
 615         wide_cmd(flash, CMD_RESET_DATA, ADDR_UNLOCK_1);
 616
 617         /* Check device type and fill in correct sizes. */
 618         switch (id) {
 619                 case AM29LV160BT:
 620                 case TC58FVT160:
 621                 // case MBM29LV160TE: /* This is same id as AM29LV160BT */
 622                         message = message_top_boot_16;
 623
 624                         flash->size = 0x00200000;
 625
 626                         flash->regions[0].offset = 0x00000000;
 627                         flash->regions[0].sector_size = 0x10000;
 628                         flash->regions[0].numsectors = 31;
 629
 630                         flash->regions[1].offset = 0x001F0000;
 631                         flash->regions[1].sector_size = 0x08000;
 632                         flash->regions[1].numsectors = 1;
 633
 634                         flash->regions[2].offset = 0x001F8000;
 635                         flash->regions[2].sector_size = 0x02000;
 636                         flash->regions[2].numsectors = 2;
 637
 638                         flash->regions[3].offset = 0x001FC000;
 639                         flash->regions[3].sector_size = 0x04000;
 640                         flash->regions[3].numsectors = 1;
 641                                 break;
 642
 643                 // case AM29LV160BB:
 644                 case TC58FVB160:
 645                 case MBM29LV160BE:
 646                         message = message_bottom_boot_16;
 647
 648                         flash->size = 0x00200000;
 649
 650                         flash->regions[0].offset = 0x00000000;
 651                         flash->regions[0].sector_size = 0x04000;
 652                         flash->regions[0].numsectors = 1;
 653
 654                         flash->regions[1].offset = 0x00004000;
 655                         flash->regions[1].sector_size = 0x02000;
 656                         flash->regions[1].numsectors = 2;
 657
 658                         flash->regions[2].offset = 0x00008000;
 659                         flash->regions[2].sector_size = 0x08000;
 660                         flash->regions[2].numsectors = 1;
 661
 662                         flash->regions[3].offset = 0x00010000;
 663                         flash->regions[3].sector_size = 0x10000;
 664                         flash->regions[3].numsectors = 31;
 665                         break;
 666
 667                 case AM29LV800BB:
 668                 case AM29F800BB:
 669                         message = message_bottom_boot_8;
 670
 671                         flash->size = 0x00100000;
 672
 673                         flash->regions[0].offset = 0x00000000;
 674                         flash->regions[0].sector_size = 0x04000;
 675                         flash->regions[0].numsectors = 1;
 676
 677                         flash->regions[1].offset = 0x00004000;
 678                         flash->regions[1].sector_size = 0x02000;
 679                         flash->regions[1].numsectors = 2;
 680
 681                         flash->regions[2].offset = 0x00008000;
 682                         flash->regions[2].sector_size = 0x08000;
 683                         flash->regions[2].numsectors = 1;
 684
 685                         flash->regions[3].offset = 0x00010000;
 686                         flash->regions[3].sector_size = 0x10000;
 687                         flash->regions[3].numsectors = 15;
 688                         break;
 689
 690                 case M29W800T:
 691                 case AM29LV800BT:
 692                 case AM29F800BT:
 693                 case TC58FVT800:
 694                         message = message_top_boot_8;
 695
 696                         flash->size = 0x00100000;
 697
 698                         flash->regions[0].offset = 0x00000000;
 699                         flash->regions[0].sector_size = 0x10000;
 700                         flash->regions[0].numsectors = 15;
 701
 702                         flash->regions[1].offset = 0x000F0000;
 703                         flash->regions[1].sector_size = 0x08000;
 704                         flash->regions[1].numsectors = 1;
 705
 706                         flash->regions[2].offset = 0x000F8000;
 707                         flash->regions[2].sector_size = 0x02000;
 708                         flash->regions[2].numsectors = 2;
 709
 710                         flash->regions[3].offset = 0x000FC000;
 711                         flash->regions[3].sector_size = 0x04000;
 712                         flash->regions[3].numsectors = 1;
 713
 714                         break;
 715
 716                 case AT49xV16x:
 717                         message = message_bottom_boot_16;
 718
 719                         flash->size = 0x00200000;
 720
 721                         flash->regions[0].offset = 0x00000000;
 722                         flash->regions[0].sector_size = 0x02000;
 723                         flash->regions[0].numsectors = 8;
 724
 725                         flash->regions[1].offset = 0x00010000;
 726                         flash->regions[1].sector_size = 0x10000;
 727                         flash->regions[1].numsectors = 31;
 728
 729                         break;
 730
 731                 case AT49xV16xT:
 732                         message = message_top_boot_16;
 733
 734                         flash->size = 0x00200000;
 735
 736                         flash->regions[0].offset = 0x00000000;
 737                         flash->regions[0].sector_size = 0x10000;
 738                         flash->regions[0].numsectors = 31;
 739
 740                         flash->regions[1].offset = 0x001F0000;
 741                         flash->regions[1].sector_size = 0x02000;
 742                         flash->regions[1].numsectors = 8;
 743
 744                         break;
 745
 746                 case AT49BV32xAT:
 747                         message = message_top_boot_32;
 748
 749                         flash->size = 0x00400000;
 750
 751                         flash->regions[0].offset = 0x00000000;
 752                         flash->regions[0].sector_size = 0x10000;
 753                         flash->regions[0].numsectors = 63;
 754
 755                         flash->regions[1].offset = 0x001F0000;
 756                         flash->regions[1].sector_size = 0x02000;
 757                         flash->regions[1].numsectors = 8;
 758
 759                         break;
 760
 761                 default:
 762 #endif
 763 #ifdef INTERLEAVE
 764                         if (flash->interleave == 1) {
 765 #endif
 766                                 safe_printk("No single x16 at ");
 767 #ifdef INTERLEAVE
 768                         } else {
 769                                 safe_printk("No interleaved x16 at ");
 770                         }
 771 #endif
 772                         send_hex((udword)flash->base, NL);
 773
 774                         return 0;
 775 #ifdef JEDEC_PROBE
 776         }
 777
 778         safe_printk("Found ");
 779 #ifdef INTERLEAVE
 780         if (flash->interleave == 1) {
 781 #endif
 782                 safe_printk("1");
 783 #ifdef INTERLEAVE
 784         }
 785         if (flash->interleave == 2) {
 786         int count = 0;
 787
 788                 flash->size <<= 1;
 789         while (count < MAXREGIONS) {
 790                 flash->regions[count].offset <<= 1;
 791                 flash->regions[count].sector_size <<= 1;
 792                 count++;
 793         }
 794                 safe_printk("2");
 795         }
 796 #endif
 797         safe_printk(" x ");
 798         safe_printk(message);
 799         safe_printk(" at ");
 800         send_hex((udword)flash->base, NL);
 801
 802         return 1;
 803 #endif
 804 }
 805
 806 /* Start erase of a sector but do no wait for completion */
 807 static void
 808 start_sector_erase(struct chip *flash, unsigned long offset)
 809 {
 810         flash_unlock(flash);
 811         wide_cmd(flash, CMD_SECTOR_ERASE_UNLOCK_DATA_1, ADDR_UNLOCK_1);
 812         flash_unlock(flash);
 813
 814 #ifdef INTERLEAVE
 815         if (flash->interleave == 2) {
 816                 *(udword *)(flash->base+offset) = (CMD_SECTOR_ERASE_UNLOCK_DATA_2 << 16) |
 817                                                    CMD_SECTOR_ERASE_UNLOCK_DATA_2;
 818         } else {
 819 #endif
 820                 *(uword *)(flash->base+offset) = CMD_SECTOR_ERASE_UNLOCK_DATA_2;
 821 #ifdef INTERLEAVE
 822         }
 823 #endif
 824 }
 825
 826 /* Return the size of the sector at the given offset */
 827 static int
 828 find_sector_size(struct chip *flash, unsigned long offset)
 829 {
 830         unsigned int i, j;
 831         int region_size;
 832         /* Sanity check */
 833         if (offset >= flash->size)
 834                 return 0;
 835
 836         for(i=0; i < MAXREGIONS; i++)
 837                 if (offset >= flash->regions[i].offset) {
 838                         region_size=0;
 839                         for (j=0; j < flash->regions[i].numsectors; j++)
 840                                 region_size += flash->regions[i].sector_size;
 841                         if (offset < flash->regions[i].offset + region_size)
 842                                 return flash->regions[i].sector_size;
 843                 }
 844
 845         /* Should not happen */
 846         return 0;
 847 }
 848
 849 /* Check and see if we need to erase the sector  */
 850 /* The return values mean */
 851 /* 0: The source and destination are the same. */
 852 /* 1: The source and destination are not the same, but flash sector already contains only ones. */
 853 /* 2: The source and destination are not the same and the flash sector is tainted by some zeroes. */
 854 static char
 855 need_to_erase(struct chip *flash, unsigned long offset, const unsigned char *source, int size)
 856 {
 857         int i;
 858         unsigned long j;
 859
 860         for (i = 0; i < size; i+=2)
 861                 if (*(uword*)(flash->base + i + offset) != *(uword*)(source + i)) {
 862                         /* Check if the sector only contain zeroes */
 863                         for (j = offset; j < (size + offset); j+=2) {
 864                                 if (*(uword*)(flash->base + j) != 0xffff)
 865                                         return 2;
 866                         }
 867                         return 1;
 868                 }
 869
 870         /* The source is equal to the destination */
 871         return 0;
 872 }
 873
 874 static unsigned int
 875 flash_probe_chips(void)
 876 {
 877         unsigned int tot_size = 0;
 878         unsigned int i = 0;
 879
 880         for (; i < sizeof chips/sizeof *chips; i++) {
 881 #ifdef INTERLEAVE
 882                 byte interleave;
 883
 884                 for (interleave = 1; interleave < 4; interleave *= 2) {
 885                         chips[i].interleave = interleave;
 886                         if (interleave == 1) {
 887                                 chips[i].buswidth = sizeof(uword);
 888                         } else {
 889                                 chips[i].buswidth = sizeof(udword);
 890                         }
 891
 892                         if (flash_probe(&chips[i])) {
 893                                 break;
 894                         }
 895                 }
 896 #else
 897                 flash_probe(&chips[i]);
 898 #endif
 899
 900                 tot_size += chips[i].size;
 901         }
 902
 903         return tot_size;
 904 }
 905
 906 /* Program a sector (given by size) at the given offset. Do not write only ones. */
 907 static void
 908 program_sector(struct chip *flash, unsigned long offset, const unsigned char *source, int size)
 909 {
 910         int chunk_size = 0;
 911         int bytes_written = 0;
 912
 913
 914         while (bytes_written < size) {
 915                 if (
 916 #ifdef INTERLEAVE
 917                     (flash->buswidth == 2) &&
 918 #endif
 919                     *(uword*)(source + bytes_written) == 0xffff) {
 920                         chunk_size=2;
 921                 }
 922 #ifdef INTERLEAVE
 923                 else if ((flash->buswidth == 4) && *(udword*)(source + bytes_written) == 0xffffffff) {
 924                         chunk_size=4;
 925                 }
 926 #endif
 927                 else {
 928                         flash_unlock(flash);
 929                         wide_cmd(flash, CMD_PROGRAM_UNLOCK_DATA, ADDR_UNLOCK_1);
 930                         chunk_size = wide_write_chunk(flash, offset + bytes_written, source + bytes_written);
 931                         while(flash_is_busy(flash, offset + bytes_written))
 932                         /* Nothing */
 933                         ;
 934                 }
 935
 936                 bytes_written += chunk_size;
 937         }
 938 }
 939
 940 int
 941 flash_write(const unsigned char *source, unsigned int offset, unsigned int size)
 942 {
 943         struct flash_status {
 944                 unsigned char busy;             /* Indicates if the flash is busy */
 945                 const unsigned char *src;       /* From where to get the source info */
 946                 unsigned long offset;           /* Start operations in flash at this offset */
 947                 unsigned int size;              /* Size to erase/program (if needed) */
 948                 unsigned int bytes_done;        /* Bytes written (if needed) */
 949                 unsigned int erase_attempts;    /* Keep track how many times we try to erase the same sector */
 950         };
 951
 952         unsigned int tot_size = flash_probe_chips();
 953         unsigned int i, j;
 954         unsigned int current_sector_size;
 955         unsigned long current_offset;
 956         const unsigned char *current_src;
 957         char need_erase;
 958         struct flash_status *current_flash = NULL;
 959
 960         static struct flash_status flash_status[2] = {
 961                 { 0, NULL, 0, 0, 0, 0 },
 962                 { 0, NULL, 0, 0, 0, 0 }
 963         };
 964
 965         if (!tot_size) {
 966                 /* No chips found, bail out. */
 967                 return ERR_FLASH_NONE;
 968         }
 969
 970         if (offset + size > tot_size) {
 971                 safe_printk("Fatal: flash is too small.\n");
 972                 return ERR_FLASH_TOO_SMALL;
 973         }
 974
 975         /* Initiate the flash_status structs so that we can keep track of what needs to be done
 976            on the different flash chips */
 977
 978         /* Operations only on flash chip 1 */
 979         if (offset >= (&chips[0])->size) {
 980                 flash_status[0].size = 0;
 981                 flash_status[1].src = source;
 982                 flash_status[1].offset = offset - (&chips[0])->size;
 983                 flash_status[1].size = size;
 984         }
 985         /* Operations on both flash chips */
 986         else if ((offset < (&chips[0])->size) && ((offset+size) > (&chips[0])->size)) {
 987                 flash_status[0].src = source;
 988                 flash_status[0].offset = offset;
 989                 flash_status[0].size = (&chips[0])->size - offset;
 990                 flash_status[1].src = source + flash_status[0].size;
 991                 flash_status[1].offset = 0;
 992                 flash_status[1].size = size - flash_status[0].size;
 993         }
 994         /* Operations only on flash chip 0 */
 995         else {
 996                 flash_status[0].src = source;
 997                 flash_status[0].offset = offset;
 998                 flash_status[0].size = size;
 999                 flash_status[1].size = 0;
1000         }
1001         flash_status[0].busy = 0;
1002         flash_status[0].bytes_done = 0;
1003         flash_status[0].erase_attempts = 0;
1004         flash_status[1].busy = 0;
1005         flash_status[1].bytes_done = 0;
1006         flash_status[1].erase_attempts = 0;
1007 #if 0
1008         for (i = 0; i < 2; i++) {
1009                 safe_printk("\nFlash ");
1010                 send_hex(i, NL);
1011                 safe_printk("src:\t");
1012                 send_hex((int)flash_status[i].src, NL);
1013                 safe_printk("offset:\t");
1014                 send_hex(flash_status[i].offset, NL);
1015                 safe_printk("size:\t");
1016                 send_hex(flash_status[i].size, NL);
1017                 safe_printk("\n");
1018         }
1019 #endif
1020
1021         /* Erase and write */
1022
1023         i = 0;  /* Start operations on flash 0 */
1024
1025 #define CHANGE_FLASH
1026
1027         while (((&flash_status[0])->bytes_done + (&flash_status[1])->bytes_done) < size) {
1028
1029                 struct flash_status *previous_flash = &flash_status[i ? 0 : 1];
1030                 current_flash = &flash_status[i];
1031
1032 #ifdef CHANGE_FLASH
1033                 /* Change flash only if:
1034                    - There is a flash to change to and operations should be made on that flash *AND*
1035                    - There is more to write to the previous flash *AND*
1036                    - Operations should be made on the current flash *OR*
1037                    - The current flash is busy *OR*
1038                    - All has been written to the current flash */
1039
1040                 if (previous_flash->size && (previous_flash->bytes_done < previous_flash->size) &&
1041                         (!current_flash->size || current_flash->busy ||
1042                           current_flash->bytes_done == current_flash->size))
1043                                 i = i ? 0 : 1;  /* Change flash chip */
1044 #else
1045                 /* Finish one flash chip before continuing on the next one */
1046
1047                 if ((&flash_status[i])->bytes_done == (&flash_status[i])->size)
1048                         i = i ? 0 : 1;  /* Change flash chip */
1049 #endif
1050                 /* Bail out if we have tried to erase the same sector more that 10 times. */
1051                 if(current_flash->erase_attempts > 10) {
1052                         safe_printk("Sector erase error\n");
1053                         return ERR_FLASH_ERASE;
1054                 }
1055
1056                 /* Get the current status from the chip we are about to access */
1057                 current_flash = &flash_status[i];
1058                 current_offset = current_flash->offset + current_flash->bytes_done;
1059                 current_src = current_flash->src + current_flash->bytes_done;
1060                 current_sector_size = find_sector_size(&chips[i], current_offset);
1061
1062                 /* Make sure that the chip we are about to access has finished erasing */
1063                 if (current_flash->busy) {
1064                         while (flash_is_busy(&chips[i], current_offset))
1065                                 /* nothing */
1066                                 ;
1067                         current_flash->busy = 0;
1068                 }
1069
1070                 /* Some flash chip need a reset to bring them back to read mode again. */
1071                 wide_cmd(&chips[i], CMD_RESET_DATA, ADDR_UNLOCK_1);
1072
1073                 /* Find out if we need to erase the sector or not */
1074                 need_erase = need_to_erase(&chips[i], current_offset, current_src, current_sector_size);
1075
1076                 if (need_erase == 0) {
1077                         current_flash->bytes_done += current_sector_size;
1078                         current_flash->erase_attempts = 0;
1079                         send_hex((int)(&chips[i])->base + current_offset, 0);
1080                         safe_printk(": No need to write\n");
1081                         continue;
1082                 } else if (need_erase == 1) {
1083                         /* Erased, not worth printing. */
1084                 }
1085                 else if (need_erase == 2) {
1086                         send_hex((int)(&chips[i])->base + current_offset, 0);
1087                         safe_printk(": Erasing ");
1088                         send_hex(current_sector_size, 0);
1089                         safe_printk(" bytes\n");
1090                         start_sector_erase(&chips[i], current_offset);
1091                         current_flash->busy=1;
1092                         current_flash->erase_attempts++;
1093                         continue;
1094                 }
1095
1096                 /* The sector is ready to be programmed */
1097                 send_hex((int)(&chips[i])->base + current_offset, 0);
1098                 safe_printk(": Writing ");
1099                 send_hex(current_sector_size, 0);
1100                 safe_printk(" bytes\n");
1101                 program_sector(&chips[i], current_offset, current_src, current_sector_size);
1102                 current_flash->bytes_done += current_sector_size;
1103                 current_flash->erase_attempts = 0;
1104         }
1105
1106         /* Verify that the flash chip(s) have the correct content */
1107         for (i = 0; i < 2; i++) {
1108                 current_flash = &flash_status[i];
1109                 if (!current_flash->size)
1110                         continue;
1111                 send_hex((int)(&chips[i])->base, 0);
1112                 safe_printk(": Verifying...");
1113                 for (j = 0; j < current_flash->size; j+=2) {
1114                         if (*(uword*)(current_flash->offset + j + (&chips[i])->base) !=
1115                             *(uword*)(current_flash->src + j)) {
1116                                 safe_printk("Error at ");
1117                                 send_hex(j, NL);
1118                                 return ERR_FLASH_VERIFY;
1119                         }
1120                 }
1121                 safe_printk("OK\n");
1122         }
1123
1124         return ERR_FLASH_OK;
1125 }