board/trab/flash.c

   1 /*
   2  * (C) Copyright 2002
   3  * Gary Jennejohn, DENX Software Engineering, <gj@denx.de>
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24 /* #define DEBUG */
  25
  26 #include <common.h>
  27 #include <environment.h>
  28
  29 static ulong flash_get_size (vu_long *addr, flash_info_t *info);
  30
  31 flash_info_t flash_info[CFG_MAX_FLASH_BANKS];
  32
  33
  34 #define CMD_READ_ARRAY          0x00F000F0
  35 #define CMD_UNLOCK1             0x00AA00AA
  36 #define CMD_UNLOCK2             0x00550055
  37 #define CMD_ERASE_SETUP         0x00800080
  38 #define CMD_ERASE_CONFIRM       0x00300030
  39 #define CMD_PROGRAM             0x00A000A0
  40 #define CMD_UNLOCK_BYPASS       0x00200020
  41 #define CMD_READ_MANF_ID        0x00900090
  42 #define CMD_UNLOCK_BYPASS_RES1  0x00900090
  43 #define CMD_UNLOCK_BYPASS_RES2  0x00000000
  44
  45 #define MEM_FLASH_ADDR          (*(volatile u32 *)CFG_FLASH_BASE)
  46 #define MEM_FLASH_ADDR1         (*(volatile u32 *)(CFG_FLASH_BASE + (0x00000555 << 2)))
  47 #define MEM_FLASH_ADDR2         (*(volatile u32 *)(CFG_FLASH_BASE + (0x000002AA << 2)))
  48
  49 #define BIT_ERASE_DONE          0x00800080
  50 #define BIT_RDY_MASK            0x00800080
  51 #define BIT_PROGRAM_ERROR       0x00200020
  52 #define BIT_TIMEOUT             0x80000000      /* our flag */
  53
  54 #define READY 1
  55 #define ERR   2
  56 #define TMO   4
  57
  58 /*-----------------------------------------------------------------------
  59  */
  60
  61 ulong flash_init (void)
  62 {
  63         int i, j;
  64         ulong size = 0;
  65
  66         for (i=0; i<CFG_MAX_FLASH_BANKS; ++i) {
  67                 ulong flashbase = 0;
  68                 flash_info_t *info = &flash_info[i];
  69
  70                 /* Init: no FLASHes known */
  71                 info->flash_id = FLASH_UNKNOWN;
  72
  73                 size += flash_get_size (CFG_FLASH_BASE, info);
  74
  75                 if (i == 0)
  76                         flashbase = CFG_FLASH_BASE;
  77                 else
  78                         panic ("configured too many flash banks!\n");
  79                 for (j = 0; j < info->sector_count; j++) {
  80
  81                         info->protect[j] = 0;
  82                         info->start[j] = flashbase;
  83
  84                         switch (info->flash_id & FLASH_TYPEMASK) {
  85                         case (FLASH_AM320B & FLASH_TYPEMASK):
  86                         case (FLASH_MXLV320B & FLASH_TYPEMASK):
  87                                 /* Boot sector type: 8 x 8 + N x 128 kB */
  88                                 flashbase += (j < 8) ? 0x4000 : 0x20000;
  89                                 break;
  90                         case (FLASH_AM640U & FLASH_TYPEMASK):
  91                                 /* Uniform sector type: 128 kB */
  92                                 flashbase += 0x20000;
  93                                 break;
  94                         default:
  95                                 printf ("## Bad flash chip type 0x%04lX\n",
  96                                         info->flash_id & FLASH_TYPEMASK);
  97                         }
  98                 }
  99         }
 100
 101         /*
 102          * Protect monitor and environment sectors
 103          */
 104         flash_protect ( FLAG_PROTECT_SET,
 105                         CFG_FLASH_BASE,
 106                         CFG_FLASH_BASE + monitor_flash_len - 1,
 107                         &flash_info[0]);
 108
 109         flash_protect ( FLAG_PROTECT_SET,
 110                         CFG_ENV_ADDR,
 111                         CFG_ENV_ADDR + CFG_ENV_SIZE - 1, &flash_info[0]);
 112
 113 #ifdef CFG_ENV_ADDR_REDUND
 114         flash_protect ( FLAG_PROTECT_SET,
 115                         CFG_ENV_ADDR_REDUND,
 116                         CFG_ENV_ADDR_REDUND + CFG_ENV_SIZE_REDUND - 1,
 117                         &flash_info[0]);
 118 #endif
 119
 120         return size;
 121 }
 122
 123 /*-----------------------------------------------------------------------
 124  */
 125 void flash_print_info (flash_info_t * info)
 126 {
 127         int i;
 128
 129         switch (info->flash_id & FLASH_VENDMASK) {
 130         case (FLASH_MAN_AMD & FLASH_VENDMASK):
 131                         printf ("AMD ");                break;
 132         case (FLASH_MAN_FUJ & FLASH_VENDMASK):
 133                         printf ("FUJITSU ");            break;
 134         case (FLASH_MAN_MX  & FLASH_VENDMASK):
 135                         printf ("MACRONIX ");           break;
 136         default:        printf ("Unknown Vendor ");     break;
 137         }
 138
 139         switch (info->flash_id & FLASH_TYPEMASK) {
 140         case (FLASH_AM320B & FLASH_TYPEMASK):
 141                 printf ("2x Am29LV320DB (32Mbit)\n");
 142                 break;
 143         case (FLASH_MXLV320B & FLASH_TYPEMASK):
 144                 printf ("2x MX29LV320DB (32Mbit)\n");
 145                 break;
 146         case (FLASH_AM640U & FLASH_TYPEMASK):
 147                 printf ("2x Am29LV640D (64Mbit)\n");
 148                 break;
 149         default:
 150                 printf ("Unknown Chip Type\n");
 151                 goto Done;
 152                 break;
 153         }
 154
 155         printf ("  Size: %ld MB in %d Sectors\n",
 156                         info->size >> 20, info->sector_count);
 157
 158         printf ("  Sector Start Addresses:");
 159         for (i = 0; i < info->sector_count; i++) {
 160                 if ((i % 5) == 0) {
 161                         printf ("\n   ");
 162                 }
 163                 printf (" %08lX%s",
 164                         info->start[i],
 165                         info->protect[i] ? " (RO)" : "     ");
 166         }
 167         printf ("\n");
 168
 169 Done:   ;
 170 }
 171
 172 /*-----------------------------------------------------------------------
 173  */
 174
 175 int flash_erase (flash_info_t * info, int s_first, int s_last)
 176 {
 177         ulong result;
 178
 179 #if 0
 180         int cflag;
 181 #endif
 182         int iflag, prot, sect;
 183         int rc = ERR_OK;
 184         int chip1, chip2;
 185
 186         debug ("flash_erase: s_first %d  s_last %d\n", s_first, s_last);
 187
 188         /* first look for protection bits */
 189
 190         if (info->flash_id == FLASH_UNKNOWN)
 191                 return ERR_UNKNOWN_FLASH_TYPE;
 192
 193         if ((s_first < 0) || (s_first > s_last)) {
 194                 return ERR_INVAL;
 195         }
 196
 197         switch (info->flash_id & FLASH_VENDMASK) {
 198         case (FLASH_MAN_AMD & FLASH_VENDMASK):  break;  /* OK */
 199         case (FLASH_MAN_FUJ & FLASH_VENDMASK):  break;  /* OK */
 200         case (FLASH_MAN_MX  & FLASH_VENDMASK):  break;  /* OK */
 201         default:
 202                 debug ("## flash_erase: unknown manufacturer\n");
 203                 return (ERR_UNKNOWN_FLASH_VENDOR);
 204         }
 205
 206         prot = 0;
 207         for (sect = s_first; sect <= s_last; ++sect) {
 208                 if (info->protect[sect]) {
 209                         prot++;
 210                 }
 211         }
 212
 213         if (prot) {
 214                 printf ("- Warning: %d protected sectors will not be erased!\n",
 215                         prot);
 216         } else {
 217                 printf ("\n");
 218         }
 219
 220         /*
 221          * Disable interrupts which might cause a timeout
 222          * here. Remember that our exception vectors are
 223          * at address 0 in the flash, and we don't want a
 224          * (ticker) exception to happen while the flash
 225          * chip is in programming mode.
 226          */
 227 #if 0
 228         cflag = icache_status ();
 229         icache_disable ();
 230 #endif
 231         iflag = disable_interrupts ();
 232
 233         /* Start erase on unprotected sectors */
 234         for (sect = s_first; sect <= s_last && !ctrlc (); sect++) {
 235
 236                 debug ("Erasing sector %2d @ %08lX... ",
 237                         sect, info->start[sect]);
 238
 239                 /* arm simple, non interrupt dependent timer */
 240                 reset_timer_masked ();
 241
 242                 if (info->protect[sect] == 0) { /* not protected */
 243                         vu_long *addr = (vu_long *) (info->start[sect]);
 244
 245                         MEM_FLASH_ADDR1 = CMD_UNLOCK1;
 246                         MEM_FLASH_ADDR2 = CMD_UNLOCK2;
 247                         MEM_FLASH_ADDR1 = CMD_ERASE_SETUP;
 248
 249                         MEM_FLASH_ADDR1 = CMD_UNLOCK1;
 250                         MEM_FLASH_ADDR2 = CMD_UNLOCK2;
 251                         *addr = CMD_ERASE_CONFIRM;
 252
 253                         /* wait until flash is ready */
 254                         chip1 = chip2 = 0;
 255
 256                         do {
 257                                 result = *addr;
 258
 259                                 /* check timeout */
 260                                 if (get_timer_masked () > CFG_FLASH_ERASE_TOUT) {
 261                                         MEM_FLASH_ADDR1 = CMD_READ_ARRAY;
 262                                         chip1 = TMO;
 263                                         break;
 264                                 }
 265
 266                                 if (!chip1 && (result & 0xFFFF) & BIT_ERASE_DONE)
 267                                         chip1 = READY;
 268
 269                                 if (!chip1 && (result & 0xFFFF) & BIT_PROGRAM_ERROR)
 270                                         chip1 = ERR;
 271
 272                                 if (!chip2 && (result >> 16) & BIT_ERASE_DONE)
 273                                         chip2 = READY;
 274
 275                                 if (!chip2 && (result >> 16) & BIT_PROGRAM_ERROR)
 276                                         chip2 = ERR;
 277
 278                         } while (!chip1 || !chip2);
 279
 280                         MEM_FLASH_ADDR1 = CMD_READ_ARRAY;
 281
 282                         if (chip1 == ERR || chip2 == ERR) {
 283                                 rc = ERR_PROG_ERROR;
 284                                 goto outahere;
 285                         }
 286                         if (chip1 == TMO) {
 287                                 rc = ERR_TIMOUT;
 288                                 goto outahere;
 289                         }
 290                 }
 291         }
 292
 293 outahere:
 294         /* allow flash to settle - wait 10 ms */
 295         udelay_masked (10000);
 296
 297         if (iflag)
 298                 enable_interrupts ();
 299
 300 #if 0
 301         if (cflag)
 302                 icache_enable ();
 303 #endif
 304         return rc;
 305 }
 306
 307 /*-----------------------------------------------------------------------
 308  * Copy memory to flash
 309  */
 310
 311 static int write_word (flash_info_t * info, ulong dest, ulong data)
 312 {
 313         vu_long *addr = (vu_long *) dest;
 314         ulong result;
 315         int rc = ERR_OK;
 316
 317 #if 0
 318         int cflag;
 319 #endif
 320         int iflag;
 321         int chip1, chip2;
 322
 323         /*
 324          * Check if Flash is (sufficiently) erased
 325          */
 326         result = *addr;
 327         if ((result & data) != data)
 328                 return ERR_NOT_ERASED;
 329
 330         /*
 331          * Disable interrupts which might cause a timeout
 332          * here. Remember that our exception vectors are
 333          * at address 0 in the flash, and we don't want a
 334          * (ticker) exception to happen while the flash
 335          * chip is in programming mode.
 336          */
 337 #if 0
 338         cflag = icache_status ();
 339         icache_disable ();
 340 #endif
 341         iflag = disable_interrupts ();
 342
 343         *addr = CMD_PROGRAM;
 344         *addr = data;
 345
 346         /* arm simple, non interrupt dependent timer */
 347         reset_timer_masked ();
 348
 349         /* wait until flash is ready */
 350         chip1 = chip2 = 0;
 351         do {
 352                 result = *addr;
 353
 354                 /* check timeout */
 355                 if (get_timer_masked () > CFG_FLASH_ERASE_TOUT) {
 356                         chip1 = ERR | TMO;
 357                         break;
 358                 }
 359                 if (!chip1 && ((result & 0x80) == (data & 0x80)))
 360                         chip1 = READY;
 361
 362                 if (!chip1 && ((result & 0xFFFF) & BIT_PROGRAM_ERROR)) {
 363                         result = *addr;
 364
 365                         if ((result & 0x80) == (data & 0x80))
 366                                 chip1 = READY;
 367                         else
 368                                 chip1 = ERR;
 369                 }
 370
 371                 if (!chip2 && ((result & (0x80 << 16)) == (data & (0x80 << 16))))
 372                         chip2 = READY;
 373
 374                 if (!chip2 && ((result >> 16) & BIT_PROGRAM_ERROR)) {
 375                         result = *addr;
 376
 377                         if ((result & (0x80 << 16)) == (data & (0x80 << 16)))
 378                                 chip2 = READY;
 379                         else
 380                                 chip2 = ERR;
 381                 }
 382
 383         } while (!chip1 || !chip2);
 384
 385         *addr = CMD_READ_ARRAY;
 386
 387         if (chip1 == ERR || chip2 == ERR || *addr != data)
 388                 rc = ERR_PROG_ERROR;
 389
 390         if (iflag)
 391                 enable_interrupts ();
 392
 393 #if 0
 394         if (cflag)
 395                 icache_enable ();
 396 #endif
 397
 398         return rc;
 399 }
 400
 401 /*-----------------------------------------------------------------------
 402  * Copy memory to flash.
 403  */
 404
 405 int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
 406 {
 407         ulong cp, wp, data;
 408         int l;
 409         int i, rc;
 410
 411         MEM_FLASH_ADDR1 = CMD_UNLOCK1;
 412         MEM_FLASH_ADDR2 = CMD_UNLOCK2;
 413         MEM_FLASH_ADDR1 = CMD_UNLOCK_BYPASS;
 414
 415         wp = (addr & ~3);       /* get lower word aligned address */
 416
 417         /*
 418          * handle unaligned start bytes
 419          */
 420         if ((l = addr - wp) != 0) {
 421                 data = 0;
 422                 for (i = 0, cp = wp; i < l; ++i, ++cp) {
 423                         data = (data >> 8) | (*(uchar *) cp << 24);
 424                 }
 425                 for (; i < 4 && cnt > 0; ++i) {
 426                         data = (data >> 8) | (*src++ << 24);
 427                         --cnt;
 428                         ++cp;
 429                 }
 430                 for (; cnt == 0 && i < 4; ++i, ++cp) {
 431                         data = (data >> 8) | (*(uchar *) cp << 24);
 432                 }
 433
 434                 if ((rc = write_word (info, wp, data)) != 0) {
 435                         goto Done;
 436                 }
 437                 wp += 4;
 438         }
 439
 440         /*
 441          * handle word aligned part
 442          */
 443         while (cnt >= 4) {
 444                 if (((ulong)src) & 0x3) {
 445                         for (i = 0; i < 4; i++) {
 446                                 ((char *)&data)[i] = ((vu_char *)src)[i];
 447                         }
 448                 }
 449                 else {
 450                         data = *((vu_long *) src);
 451                 }
 452
 453                 if ((rc = write_word (info, wp, data)) != 0) {
 454                         goto Done;
 455                 }
 456                 src += 4;
 457                 wp += 4;
 458                 cnt -= 4;
 459         }
 460
 461         if (cnt == 0) {
 462                 rc = ERR_OK;
 463                 goto Done;
 464         }
 465
 466         /*
 467          * handle unaligned tail bytes
 468          */
 469         data = 0;
 470         for (i = 0, cp = wp; i < 4 && cnt > 0; ++i, ++cp) {
 471                 data = (data >> 8) | (*src++ << 24);
 472                 --cnt;
 473         }
 474         for (; i < 4; ++i, ++cp) {
 475                 data = (data >> 8) | (*(uchar *) cp << 24);
 476         }
 477
 478         rc = write_word (info, wp, data);
 479
 480         Done:
 481
 482         MEM_FLASH_ADDR = CMD_UNLOCK_BYPASS_RES1;
 483         MEM_FLASH_ADDR = CMD_UNLOCK_BYPASS_RES2;
 484
 485         return (rc);
 486 }
 487
 488 /*-----------------------------------------------------------------------
 489  */
 490
 491 static ulong flash_get_size (vu_long *addr, flash_info_t *info)
 492 {
 493         ulong value;
 494
 495         /* Write auto select command sequence and read Manufacturer ID */
 496         addr[0x0555] = CMD_UNLOCK1;
 497         addr[0x02AA] = CMD_UNLOCK2;
 498         addr[0x0555] = CMD_READ_MANF_ID;
 499
 500         value = addr[0];
 501
 502         debug ("Manuf. ID @ 0x%08lx: 0x%08lx\n", (ulong)addr, value);
 503
 504         switch (value) {
 505         case AMD_MANUFACT:
 506                 info->flash_id = FLASH_MAN_AMD;
 507                 break;
 508         case FUJ_MANUFACT:
 509                 info->flash_id = FLASH_MAN_FUJ;
 510                 break;
 511         case MX_MANUFACT:
 512                 info->flash_id = FLASH_MAN_MX;
 513                 break;
 514         default:
 515                 info->flash_id = FLASH_UNKNOWN;
 516                 info->sector_count = 0;
 517                 info->size = 0;
 518                 addr[0] = 0x00FF00FF;           /* restore read mode */
 519                 debug ("## flash_init: unknown manufacturer\n");
 520                 return (0);                     /* no or unknown flash  */
 521         }
 522
 523         value = addr[1];                        /* device ID            */
 524
 525         debug ("Device ID @ 0x%08lx: 0x%08lx\n", (ulong)(&addr[1]), value);
 526
 527         switch (value) {
 528         case AMD_ID_LV320B:
 529                 info->flash_id += FLASH_AM320B;
 530                 info->sector_count = 71;
 531                 info->size = 0x00800000;
 532
 533                 addr[0] = 0x00FF00FF;           /* restore read mode */
 534                 break;                          /* =>  8 MB             */
 535
 536         case AMD_ID_LV640U:
 537                 info->flash_id += FLASH_AM640U;
 538                 info->sector_count = 128;
 539                 info->size = 0x01000000;
 540
 541                 addr[0] = 0x00F000F0;           /* restore read mode */
 542                 break;                          /* => 16 MB             */
 543
 544         case MX_ID_LV320B:
 545                 info->flash_id += FLASH_MXLV320B;
 546                 info->sector_count = 71;
 547                 info->size = 0x00800000;
 548
 549                 addr[0] = 0x00FF00FF;           /* restore read mode */
 550                 break;                          /* =>  8 MB             */
 551
 552         default:
 553                 debug ("## flash_init: unknown flash chip\n");
 554                 info->flash_id = FLASH_UNKNOWN;
 555                 addr[0] = 0x00FF00FF;           /* restore read mode */
 556                 return (0);                     /* => no or unknown flash */
 557
 558         }
 559
 560         if (info->sector_count > CFG_MAX_FLASH_SECT) {
 561                 printf ("** ERROR: sector count %d > max (%d) **\n",
 562                         info->sector_count, CFG_MAX_FLASH_SECT);
 563                 info->sector_count = CFG_MAX_FLASH_SECT;
 564         }
 565
 566         return (info->size);
 567 }