git.sur5r.net Git - u-boot/blob - 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                                 printf ("Flash erase error\n");
 285                                 goto outahere;
 286                         }
 287                         if (chip1 == TMO) {
 288                                 rc = ERR_TIMOUT;
 289                                 printf ("Flash erase timeout error\n");
 290                                 goto outahere;
 291                         }
 292                 }
 293         }
 294
 295 outahere:
 296         /* allow flash to settle - wait 10 ms */
 297         udelay_masked (10000);
 298
 299         if (iflag)
 300                 enable_interrupts ();
 301
 302 #if 0
 303         if (cflag)
 304                 icache_enable ();
 305 #endif
 306         return rc;
 307 }
 308
 309 /*-----------------------------------------------------------------------
 310  * Copy memory to flash
 311  */
 312
 313 static int write_word (flash_info_t * info, ulong dest, ulong data)
 314 {
 315         vu_long *addr = (vu_long *) dest;
 316         ulong result;
 317         int rc = ERR_OK;
 318
 319 #if 0
 320         int cflag;
 321 #endif
 322         int iflag;
 323         int chip1, chip2;
 324
 325         /*
 326          * Check if Flash is (sufficiently) erased
 327          */
 328         result = *addr;
 329         if ((result & data) != data)
 330                 return ERR_NOT_ERASED;
 331
 332         /*
 333          * Disable interrupts which might cause a timeout
 334          * here. Remember that our exception vectors are
 335          * at address 0 in the flash, and we don't want a
 336          * (ticker) exception to happen while the flash
 337          * chip is in programming mode.
 338          */
 339 #if 0
 340         cflag = icache_status ();
 341         icache_disable ();
 342 #endif
 343         iflag = disable_interrupts ();
 344
 345         *addr = CMD_PROGRAM;
 346         *addr = data;
 347
 348         /* arm simple, non interrupt dependent timer */
 349         reset_timer_masked ();
 350
 351         /* wait until flash is ready */
 352         chip1 = chip2 = 0;
 353         do {
 354                 result = *addr;
 355
 356                 /* check timeout */
 357                 if (get_timer_masked () > CFG_FLASH_ERASE_TOUT) {
 358                         chip1 = ERR | TMO;
 359                         break;
 360                 }
 361                 if (!chip1 && ((result & 0x80) == (data & 0x80)))
 362                         chip1 = READY;
 363
 364                 if (!chip1 && ((result & 0xFFFF) & BIT_PROGRAM_ERROR)) {
 365                         result = *addr;
 366
 367                         if ((result & 0x80) == (data & 0x80))
 368                                 chip1 = READY;
 369                         else
 370                                 chip1 = ERR;
 371                 }
 372
 373                 if (!chip2 && ((result & (0x80 << 16)) == (data & (0x80 << 16))))
 374                         chip2 = READY;
 375
 376                 if (!chip2 && ((result >> 16) & BIT_PROGRAM_ERROR)) {
 377                         result = *addr;
 378
 379                         if ((result & (0x80 << 16)) == (data & (0x80 << 16)))
 380                                 chip2 = READY;
 381                         else
 382                                 chip2 = ERR;
 383                 }
 384
 385         } while (!chip1 || !chip2);
 386
 387         *addr = CMD_READ_ARRAY;
 388
 389         if (chip1 == ERR || chip2 == ERR || *addr != data) {
 390                 rc = ERR_PROG_ERROR;
 391                 printf ("Flash program error\n");
 392                 debug ("chip1: %#x, chip2: %#x, addr: %#lx *addr: %#lx, "
 393                        "data: %#lx\n",
 394                        chip1, chip2, addr, *addr, data);
 395         }
 396
 397         if (iflag)
 398                 enable_interrupts ();
 399
 400 #if 0
 401         if (cflag)
 402                 icache_enable ();
 403 #endif
 404
 405         return rc;
 406 }
 407
 408 /*-----------------------------------------------------------------------
 409  * Copy memory to flash.
 410  */
 411
 412 int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
 413 {
 414         ulong cp, wp, data;
 415         int l;
 416         int i, rc;
 417
 418         MEM_FLASH_ADDR1 = CMD_UNLOCK1;
 419         MEM_FLASH_ADDR2 = CMD_UNLOCK2;
 420         MEM_FLASH_ADDR1 = CMD_UNLOCK_BYPASS;
 421
 422         wp = (addr & ~3);       /* get lower word aligned address */
 423
 424         /*
 425          * handle unaligned start bytes
 426          */
 427         if ((l = addr - wp) != 0) {
 428                 data = 0;
 429                 for (i = 0, cp = wp; i < l; ++i, ++cp) {
 430                         data = (data >> 8) | (*(uchar *) cp << 24);
 431                 }
 432                 for (; i < 4 && cnt > 0; ++i) {
 433                         data = (data >> 8) | (*src++ << 24);
 434                         --cnt;
 435                         ++cp;
 436                 }
 437                 for (; cnt == 0 && i < 4; ++i, ++cp) {
 438                         data = (data >> 8) | (*(uchar *) cp << 24);
 439                 }
 440
 441                 if ((rc = write_word (info, wp, data)) != 0) {
 442                         goto Done;
 443                 }
 444                 wp += 4;
 445         }
 446
 447         /*
 448          * handle word aligned part
 449          */
 450         while (cnt >= 4) {
 451                 if (((ulong)src) & 0x3) {
 452                         for (i = 0; i < 4; i++) {
 453                                 ((char *)&data)[i] = ((vu_char *)src)[i];
 454                         }
 455                 }
 456                 else {
 457                         data = *((vu_long *) src);
 458                 }
 459
 460                 if ((rc = write_word (info, wp, data)) != 0) {
 461                         goto Done;
 462                 }
 463                 src += 4;
 464                 wp += 4;
 465                 cnt -= 4;
 466         }
 467
 468         if (cnt == 0) {
 469                 rc = ERR_OK;
 470                 goto Done;
 471         }
 472
 473         /*
 474          * handle unaligned tail bytes
 475          */
 476         data = 0;
 477         for (i = 0, cp = wp; i < 4 && cnt > 0; ++i, ++cp) {
 478                 data = (data >> 8) | (*src++ << 24);
 479                 --cnt;
 480         }
 481         for (; i < 4; ++i, ++cp) {
 482                 data = (data >> 8) | (*(uchar *) cp << 24);
 483         }
 484
 485         rc = write_word (info, wp, data);
 486
 487         Done:
 488
 489         MEM_FLASH_ADDR = CMD_UNLOCK_BYPASS_RES1;
 490         MEM_FLASH_ADDR = CMD_UNLOCK_BYPASS_RES2;
 491
 492         return (rc);
 493 }
 494
 495 /*-----------------------------------------------------------------------
 496  */
 497
 498 static ulong flash_get_size (vu_long *addr, flash_info_t *info)
 499 {
 500         ulong value;
 501
 502         /* Write auto select command sequence and read Manufacturer ID */
 503         addr[0x0555] = CMD_UNLOCK1;
 504         addr[0x02AA] = CMD_UNLOCK2;
 505         addr[0x0555] = CMD_READ_MANF_ID;
 506
 507         value = addr[0];
 508
 509         debug ("Manuf. ID @ 0x%08lx: 0x%08lx\n", (ulong)addr, value);
 510
 511         switch (value) {
 512         case AMD_MANUFACT:
 513                 info->flash_id = FLASH_MAN_AMD;
 514                 break;
 515         case FUJ_MANUFACT:
 516                 info->flash_id = FLASH_MAN_FUJ;
 517                 break;
 518         case MX_MANUFACT:
 519                 info->flash_id = FLASH_MAN_MX;
 520                 break;
 521         default:
 522                 info->flash_id = FLASH_UNKNOWN;
 523                 info->sector_count = 0;
 524                 info->size = 0;
 525                 addr[0] = 0x00FF00FF;           /* restore read mode */
 526                 debug ("## flash_init: unknown manufacturer\n");
 527                 return (0);                     /* no or unknown flash  */
 528         }
 529
 530         value = addr[1];                        /* device ID            */
 531
 532         debug ("Device ID @ 0x%08lx: 0x%08lx\n", (ulong)(&addr[1]), value);
 533
 534         switch (value) {
 535         case AMD_ID_LV320B:
 536                 info->flash_id += FLASH_AM320B;
 537                 info->sector_count = 71;
 538                 info->size = 0x00800000;
 539
 540                 addr[0] = 0x00FF00FF;           /* restore read mode */
 541                 break;                          /* =>  8 MB             */
 542
 543         case AMD_ID_LV640U:
 544                 info->flash_id += FLASH_AM640U;
 545                 info->sector_count = 128;
 546                 info->size = 0x01000000;
 547
 548                 addr[0] = 0x00F000F0;           /* restore read mode */
 549                 break;                          /* => 16 MB             */
 550
 551         case MX_ID_LV320B:
 552                 info->flash_id += FLASH_MXLV320B;
 553                 info->sector_count = 71;
 554                 info->size = 0x00800000;
 555
 556                 addr[0] = 0x00FF00FF;           /* restore read mode */
 557                 break;                          /* =>  8 MB             */
 558
 559         default:
 560                 debug ("## flash_init: unknown flash chip\n");
 561                 info->flash_id = FLASH_UNKNOWN;
 562                 addr[0] = 0x00FF00FF;           /* restore read mode */
 563                 return (0);                     /* => no or unknown flash */
 564
 565         }
 566
 567         if (info->sector_count > CFG_MAX_FLASH_SECT) {
 568                 printf ("** ERROR: sector count %d > max (%d) **\n",
 569                         info->sector_count, CFG_MAX_FLASH_SECT);
 570                 info->sector_count = CFG_MAX_FLASH_SECT;
 571         }
 572
 573         return (info->size);
 574 }