board/sc520_cdp/flash.c

   1 /*
   2  * (C) Copyright 2002, 2003
   3  * Daniel Engström, Omicron Ceti AB, daniel@omicron.se
   4  *
   5  * (C) Copyright 2002
   6  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   7  * Alex Zuepke <azu@sysgo.de>
   8  *
   9  * See file CREDITS for list of people who contributed to this
  10  * project.
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License as
  14  * published by the Free Software Foundation; either version 2 of
  15  * the License, or (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  25  * MA 02111-1307 USA
  26  */
  27
  28 #include <common.h>
  29 #include <asm/io.h>
  30 #include <pci.h>
  31 #include <asm/ic/sc520.h>
  32
  33 #define PROBE_BUFFER_SIZE 1024
  34 static unsigned char buffer[PROBE_BUFFER_SIZE];
  35
  36 #define SC520_MAX_FLASH_BANKS  3
  37 #define SC520_FLASH_BANK0_BASE 0x38000000  /* BOOTCS */
  38 #define SC520_FLASH_BANK1_BASE 0x30000000  /* ROMCS0 */
  39 #define SC520_FLASH_BANK2_BASE 0x28000000  /* ROMCS1 */
  40 #define SC520_FLASH_BANKSIZE   0x8000000
  41
  42 #define AMD29LV016B_SIZE        0x200000
  43 #define AMD29LV016B_SECTORS     32
  44
  45 flash_info_t    flash_info[SC520_MAX_FLASH_BANKS];
  46
  47 #define READY 1
  48 #define ERR   2
  49 #define TMO   4
  50
  51 /*-----------------------------------------------------------------------
  52  */
  53
  54
  55 static u32 _probe_flash(u32 addr, u32 bw, int il)
  56 {
  57         u32 result=0;
  58
  59         /* First do an unlock cycle for the benefit of
  60          * devices that need it */
  61
  62         switch (bw) {
  63
  64         case 1:
  65                 *(volatile u8*)(addr+0x5555) = 0xaa;
  66                 *(volatile u8*)(addr+0x2aaa) = 0x55;
  67                 *(volatile u8*)(addr+0x5555) = 0x90;
  68
  69                 /* Read vendor */
  70                 result = *(volatile u8*)addr;
  71                 result <<= 16;
  72
  73                 /* Read device */
  74                 result |= *(volatile u8*)(addr+2);
  75
  76                 /* Return device to data mode */
  77                 *(volatile u8*)addr = 0xff;
  78                 *(volatile u8*)(addr+0x5555), 0xf0;
  79                 break;
  80
  81         case 2:
  82                 *(volatile u16*)(addr+0xaaaa) = 0xaaaa;
  83                 *(volatile u16*)(addr+0x5554) = 0x5555;
  84
  85                 /* Issue identification command */
  86                 if (il == 2) {
  87                         *(volatile u16*)(addr+0xaaaa) = 0x9090;
  88
  89                         /* Read vendor */
  90                         result = *(volatile u8*)addr;
  91                         result <<= 16;
  92
  93                         /* Read device */
  94                         result |= *(volatile u8*)(addr+2);
  95
  96                         /* Return device to data mode */
  97                         *(volatile u16*)addr =  0xffff;
  98                         *(volatile u16*)(addr+0xaaaa), 0xf0f0;
  99
 100                 } else {
 101                         *(volatile u8*)(addr+0xaaaa) = 0x90;
 102                         /* Read vendor */
 103                         result = *(volatile u16*)addr;
 104                         result <<= 16;
 105
 106                         /* Read device */
 107                         result |= *(volatile u16*)(addr+2);
 108
 109                         /* Return device to data mode */
 110                         *(volatile u8*)addr = 0xff;
 111                         *(volatile u8*)(addr+0xaaaa), 0xf0;
 112                 }
 113
 114                 break;
 115
 116          case 4:
 117                 *(volatile u32*)(addr+0x5554) = 0xaaaaaaaa;
 118                 *(volatile u32*)(addr+0xaaa8) = 0x55555555;
 119
 120                 switch (il) {
 121                 case 1:
 122                         /* Issue identification command */
 123                         *(volatile u8*)(addr+0x5554) = 0x90;
 124
 125                         /* Read vendor */
 126                         result = *(volatile u16*)addr;
 127                         result <<= 16;
 128
 129                         /* Read device */
 130                         result |= *(volatile u16*)(addr+4);
 131
 132                         /* Return device to data mode */
 133                         *(volatile u8*)addr =  0xff;
 134                         *(volatile u8*)(addr+0x5554), 0xf0;
 135                         break;
 136
 137                 case 2:
 138                         /* Issue identification command */
 139                         *(volatile u32*)(addr + 0x5554) = 0x00900090;
 140
 141                         /* Read vendor */
 142                         result = *(volatile u16*)addr;
 143                         result <<= 16;
 144
 145                         /* Read device */
 146                         result |= *(volatile u16*)(addr+4);
 147
 148                         /* Return device to data mode */
 149                         *(volatile u32*)addr =  0x00ff00ff;
 150                         *(volatile u32*)(addr+0x5554), 0x00f000f0;
 151                         break;
 152
 153                 case 4:
 154                         /* Issue identification command */
 155                         *(volatile u32*)(addr+0x5554) = 0x90909090;
 156
 157                         /* Read vendor */
 158                         result = *(volatile u8*)addr;
 159                         result <<= 16;
 160
 161                         /* Read device */
 162                         result |= *(volatile u8*)(addr+4);
 163
 164                         /* Return device to data mode */
 165                         *(volatile u32*)addr =  0xffffffff;
 166                         *(volatile u32*)(addr+0x5554), 0xf0f0f0f0;
 167                         break;
 168                 }
 169                 break;
 170         }
 171
 172
 173         return result;
 174 }
 175
 176 extern int _probe_flash_end;
 177 asm ("_probe_flash_end:\n"
 178      ".long 0\n");
 179
 180 static int identify_flash(unsigned address, int width)
 181 {
 182         int is;
 183         int device;
 184         int vendor;
 185         int size;
 186         unsigned res;
 187
 188         u32 (*_probe_flash_ptr)(u32 a, u32 bw, int il);
 189
 190         size = (unsigned)&_probe_flash_end - (unsigned)_probe_flash;
 191
 192         if (size > PROBE_BUFFER_SIZE) {
 193                 printf("_probe_flash() routine too large (%d) %p - %p\n",
 194                        size, &_probe_flash_end, _probe_flash);
 195                 return 0;
 196         }
 197
 198         memcpy(buffer, _probe_flash, size);
 199         _probe_flash_ptr = (void*)buffer;
 200
 201         is = disable_interrupts();
 202         res = _probe_flash_ptr(address, width, 1);
 203         if (is) {
 204                 enable_interrupts();
 205         }
 206
 207
 208         vendor = res >> 16;
 209         device = res & 0xffff;
 210
 211
 212         return res;
 213 }
 214
 215 ulong flash_init(void)
 216 {
 217         int i, j;
 218         ulong size = 0;
 219
 220         for (i = 0; i < SC520_MAX_FLASH_BANKS; i++) {
 221                 unsigned id;
 222                 ulong flashbase = 0;
 223                 int sectsize = 0;
 224
 225                 memset(flash_info[i].protect, 0, CFG_MAX_FLASH_SECT);
 226                 switch (i) {
 227                 case 0:
 228                         flashbase = SC520_FLASH_BANK0_BASE;
 229                         break;
 230                 case 1:
 231                         flashbase = SC520_FLASH_BANK1_BASE;
 232                         break;
 233                 case 2:
 234                         flashbase = SC520_FLASH_BANK2_BASE;
 235                         break;
 236                 default:
 237                         panic("configured too many flash banks!\n");
 238                 }
 239
 240                 id = identify_flash(flashbase, 4);
 241                 switch (id & 0x00ff00ff) {
 242                 case 0x000100c8:
 243                         /* 29LV016B/29LV017B */
 244                         flash_info[i].flash_id =
 245                                 (AMD_MANUFACT & FLASH_VENDMASK) |
 246                                 (AMD_ID_LV016B & FLASH_TYPEMASK);
 247
 248                         flash_info[i].size = AMD29LV016B_SIZE*4;
 249                         flash_info[i].sector_count = AMD29LV016B_SECTORS;
 250                         sectsize = (AMD29LV016B_SIZE*4)/AMD29LV016B_SECTORS;
 251                         printf("Bank %d: 4 x AMD 29LV017B\n", i);
 252                         break;
 253
 254
 255                 default:
 256                         printf("Bank %d have unknown flash %08x\n", i, id);
 257                         flash_info[i].flash_id = FLASH_UNKNOWN;
 258                         continue;
 259                 }
 260
 261                 for (j = 0; j < flash_info[i].sector_count; j++) {
 262                         flash_info[i].start[j] = flashbase + j * sectsize;
 263                 }
 264                 size += flash_info[i].size;
 265
 266                 flash_protect(FLAG_PROTECT_CLEAR,
 267                               flash_info[i].start[0],
 268                                flash_info[i].start[0] + flash_info[i].size - 1,
 269                               &flash_info[i]);
 270         }
 271
 272         /*
 273          * Protect monitor and environment sectors
 274          */
 275         flash_protect(FLAG_PROTECT_SET,
 276                       i386boot_start,
 277                       i386boot_end,
 278                       &flash_info[0]);
 279 #ifdef CFG_ENV_ADDR
 280         flash_protect(FLAG_PROTECT_SET,
 281                       CFG_ENV_ADDR,
 282                       CFG_ENV_ADDR + CFG_ENV_SIZE - 1,
 283                       &flash_info[0]);
 284 #endif
 285         return size;
 286 }
 287
 288 /*-----------------------------------------------------------------------
 289  */
 290 void flash_print_info(flash_info_t *info)
 291 {
 292         int i;
 293
 294         switch (info->flash_id & FLASH_VENDMASK) {
 295
 296         case (AMD_MANUFACT & FLASH_VENDMASK):
 297                 printf("AMD:   ");
 298                 switch (info->flash_id & FLASH_TYPEMASK) {
 299                 case (AMD_ID_LV016B & FLASH_TYPEMASK):
 300                         printf("4x AMD29LV017B (4x16Mbit)\n");
 301                         break;
 302                 default:
 303                         printf("Unknown Chip Type\n");
 304                         goto done;
 305                         break;
 306                 }
 307
 308                 break;
 309         default:
 310                 printf("Unknown Vendor ");
 311                 break;
 312         }
 313
 314
 315         printf("  Size: %ld MB in %d Sectors\n",
 316                info->size >> 20, info->sector_count);
 317
 318         printf("  Sector Start Addresses:");
 319         for (i = 0; i < info->sector_count; i++) {
 320                 if ((i % 5) == 0) {
 321                         printf ("\n   ");
 322                 }
 323                 printf (" %08lX%s", info->start[i],
 324                         info->protect[i] ? " (RO)" : "     ");
 325         }
 326         printf ("\n");
 327
 328 done:   ;
 329 }
 330
 331 /*-----------------------------------------------------------------------
 332  */
 333
 334 /* this needs to be inlined, the SWTMRMMILLI register is reset by each read */
 335 #define __udelay(delay) \
 336 {       \
 337         unsigned micro; \
 338         unsigned milli=0; \
 339         \
 340         micro = *(volatile u16*)(0xfffef000+SC520_SWTMRMILLI); \
 341          \
 342         for (;;) { \
 343                 \
 344                 milli += *(volatile u16*)(0xfffef000+SC520_SWTMRMILLI); \
 345                 micro = *(volatile u16*)(0xfffef000+SC520_SWTMRMICRO); \
 346                 \
 347                 if ((delay) <= (micro + (milli * 1000))) { \
 348                         break; \
 349                 } \
 350         } \
 351 } while (0)
 352
 353 static u32 _amd_erase_flash(u32 addr, u32 sector)
 354 {
 355         unsigned elapsed;
 356
 357         /* Issue erase */
 358         *(volatile u32*)(addr + 0x5554) = 0xAAAAAAAA;
 359         *(volatile u32*)(addr + 0xaaa8) = 0x55555555;
 360         *(volatile u32*)(addr + 0x5554) = 0x80808080;
 361         /* And one unlock */
 362         *(volatile u32*)(addr + 0x5554) = 0xAAAAAAAA;
 363         *(volatile u32*)(addr + 0xaaa8) = 0x55555555;
 364         /* Sector erase command comes last */
 365         *(volatile u32*)(addr + sector) = 0x30303030;
 366
 367         elapsed = *(volatile u16*)(0xfffef000+SC520_SWTMRMILLI); /* dummy read */
 368         elapsed = 0;
 369         __udelay(50);
 370         while (((*(volatile u32*)(addr + sector)) & 0x80808080) != 0x80808080) {
 371
 372                 elapsed += *(volatile u16*)(0xfffef000+SC520_SWTMRMILLI);
 373                 if (elapsed > ((CFG_FLASH_ERASE_TOUT/CFG_HZ) * 1000)) {
 374                         *(volatile u32*)(addr) = 0xf0f0f0f0;
 375                         return 1;
 376                 }
 377         }
 378
 379         *(volatile u32*)(addr) = 0xf0f0f0f0;
 380
 381         return 0;
 382 }
 383
 384 extern int _amd_erase_flash_end;
 385 asm ("_amd_erase_flash_end:\n"
 386      ".long 0\n");
 387
 388 int flash_erase(flash_info_t *info, int s_first, int s_last)
 389 {
 390         u32 (*_erase_flash_ptr)(u32 a, u32 so);
 391         int prot;
 392         int sect;
 393         unsigned size;
 394
 395         if ((s_first < 0) || (s_first > s_last)) {
 396                 if (info->flash_id == FLASH_UNKNOWN) {
 397                         printf("- missing\n");
 398                 } else {
 399                         printf("- no sectors to erase\n");
 400                 }
 401                 return 1;
 402         }
 403
 404         if ((info->flash_id & FLASH_VENDMASK) == (AMD_MANUFACT & FLASH_VENDMASK)) {
 405                 size = (unsigned)&_amd_erase_flash_end - (unsigned)_amd_erase_flash;
 406
 407                 if (size > PROBE_BUFFER_SIZE) {
 408                         printf("_amd_erase_flash() routine too large (%d) %p - %p\n",
 409                                size, &_amd_erase_flash_end, _amd_erase_flash);
 410                         return 0;
 411                 }
 412
 413                 memcpy(buffer, _amd_erase_flash, size);
 414                 _erase_flash_ptr = (void*)buffer;
 415
 416         }  else {
 417                 printf ("Can't erase unknown flash type - aborted\n");
 418                 return 1;
 419         }
 420
 421         prot = 0;
 422         for (sect=s_first; sect<=s_last; ++sect) {
 423                 if (info->protect[sect]) {
 424                         prot++;
 425                 }
 426         }
 427
 428         if (prot) {
 429                 printf ("- Warning: %d protected sectors will not be erased!\n", prot);
 430         } else {
 431                 printf ("\n");
 432         }
 433
 434
 435         /* Start erase on unprotected sectors */
 436         for (sect = s_first; sect<=s_last; sect++) {
 437
 438                 if (info->protect[sect] == 0) { /* not protected */
 439                         int res;
 440                         int flag;
 441
 442                         /* Disable interrupts which might cause a timeout here */
 443                         flag = disable_interrupts();
 444
 445                         res = _erase_flash_ptr(info->start[0], info->start[sect]-info->start[0]);
 446
 447                         /* re-enable interrupts if necessary */
 448                         if (flag) {
 449                                 enable_interrupts();
 450                         }
 451
 452
 453                         if (res) {
 454                                 printf("Erase timed out, sector %d\n", sect);
 455                                 return res;
 456                         }
 457
 458                         putc('.');
 459                 }
 460         }
 461
 462
 463         return 0;
 464 }
 465
 466 /*-----------------------------------------------------------------------
 467  * Write a word to Flash, returns:
 468  * 0 - OK
 469  * 1 - write timeout
 470  * 2 - Flash not erased
 471  */
 472 static int _amd_write_word(unsigned start, unsigned dest, unsigned data)
 473 {
 474         volatile u32 *addr2 = (u32*)start;
 475         volatile u32 *dest2 = (u32*)dest;
 476         volatile u32 *data2 = (u32*)&data;
 477         unsigned elapsed;
 478
 479         /* Check if Flash is (sufficiently) erased */
 480         if ((*((volatile u32*)dest) & (u32)data) != (u32)data) {
 481                 return 2;
 482         }
 483
 484         addr2[0x5554] = 0xAAAAAAAA;
 485         addr2[0xaaa8] = 0x55555555;
 486         addr2[0x5554] = 0xA0A0A0A0;
 487
 488         dest2[0] = data;
 489
 490         elapsed = *(volatile u16*)(0xfffef000+SC520_SWTMRMILLI); /* dummy read */
 491         elapsed = 0;
 492
 493         /* data polling for D7 */
 494         while ((dest2[0] & 0x80808080) != (data2[0] & 0x80808080)) {
 495                 elapsed += *(volatile u16*)(0xfffef000+SC520_SWTMRMILLI);
 496                 if (elapsed > ((CFG_FLASH_WRITE_TOUT/CFG_HZ) * 1000)) {
 497                         addr2[0] = 0xf0f0f0f0;
 498                         return 1;
 499                 }
 500         }
 501
 502
 503         addr2[0] = 0xf0f0f0f0;
 504
 505         return 0;
 506 }
 507
 508 extern int _amd_write_word_end;
 509 asm ("_amd_write_word_end:\n"
 510      ".long 0\n");
 511
 512
 513 /*-----------------------------------------------------------------------
 514  * Copy memory to flash, returns:
 515  * 0 - OK
 516  * 1 - write timeout
 517  * 2 - Flash not erased
 518  * 3 - Unsupported flash type
 519  */
 520
 521 int write_buff(flash_info_t *info, uchar *src, ulong addr, ulong cnt)
 522 {
 523         ulong cp, wp, data;
 524         int i, l, rc;
 525         int flag;
 526         u32 (*_write_word_ptr)(unsigned start, unsigned dest, unsigned data);
 527         unsigned size;
 528
 529         if ((info->flash_id & FLASH_VENDMASK) == (AMD_MANUFACT & FLASH_VENDMASK)) {
 530                 size = (unsigned)&_amd_write_word_end - (unsigned)_amd_write_word;
 531
 532                 if (size > PROBE_BUFFER_SIZE) {
 533                         printf("_amd_write_word() routine too large (%d) %p - %p\n",
 534                                size, &_amd_write_word_end, _amd_write_word);
 535                         return 0;
 536                 }
 537
 538                 memcpy(buffer, _amd_write_word, size);
 539                 _write_word_ptr = (void*)buffer;
 540
 541         } else {
 542                 printf ("Can't program unknown flash type - aborted\n");
 543                 return 3;
 544         }
 545
 546
 547         wp = (addr & ~3);       /* get lower word aligned address */
 548
 549
 550         /*
 551          * handle unaligned start bytes
 552          */
 553         if ((l = addr - wp) != 0) {
 554                 data = 0;
 555                 for (i=0, cp=wp; i<l; ++i, ++cp) {
 556                         data |= (*(uchar *)cp) << (8*i);
 557                 }
 558                 for (; i<4 && cnt>0; ++i) {
 559                         data |= *src++ << (8*i);
 560                         --cnt;
 561                         ++cp;
 562                 }
 563                 for (; cnt==0 && i<4; ++i, ++cp) {
 564                         data |= (*(uchar *)cp)  << (8*i);
 565                 }
 566
 567                 /* Disable interrupts which might cause a timeout here */
 568                 flag = disable_interrupts();
 569
 570                 rc = _write_word_ptr(info->start[0], wp, data);
 571
 572                 /* re-enable interrupts if necessary */
 573                 if (flag) {
 574                         enable_interrupts();
 575                 }
 576                 if (rc != 0) {
 577                         return rc;
 578                 }
 579                 wp += 4;
 580         }
 581
 582         /*
 583          * handle word aligned part
 584          */
 585         while (cnt >= 4) {
 586                 data = 0;
 587
 588                 for (i=0; i<4; ++i) {
 589                         data |= *src++ << (8*i);
 590                 }
 591
 592                 /* Disable interrupts which might cause a timeout here */
 593                 flag = disable_interrupts();
 594
 595                 rc = _write_word_ptr(info->start[0], wp, data);
 596
 597                 /* re-enable interrupts if necessary */
 598                 if (flag) {
 599                         enable_interrupts();
 600                 }
 601                 if (rc != 0) {
 602                         return rc;
 603                 }
 604                 wp  += 4;
 605                 cnt -= 4;
 606         }
 607
 608         if (cnt == 0) {
 609                 return 0;
 610         }
 611
 612         /*
 613          * handle unaligned tail bytes
 614          */
 615         data = 0;
 616         for (i=0, cp=wp; i<4 && cnt>0; ++i, ++cp) {
 617                 data |= *src++ << (8*i);
 618                 --cnt;
 619         }
 620
 621         for (; i<4; ++i, ++cp) {
 622                 data |= (*(uchar *)cp) << (8*i);
 623         }
 624
 625         /* Disable interrupts which might cause a timeout here */
 626         flag = disable_interrupts();
 627
 628         rc = _write_word_ptr(info->start[0], wp, data);
 629
 630         /* re-enable interrupts if necessary */
 631         if (flag) {
 632                 enable_interrupts();
 633         }
 634
 635         return rc;
 636
 637 }