board/atmel/at91rm9200dk/flash.c

   1 /*
   2  * (C) Copyright 2002
   3  * Lineo, Inc. <www.lineo.com>
   4  * Bernhard Kuhn <bkuhn@lineo.com>
   5  *
   6  * (C) Copyright 2002
   7  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   8  * Alex Zuepke <azu@sysgo.de>
   9  *
  10  * See file CREDITS for list of people who contributed to this
  11  * project.
  12  *
  13  * This program is free software; you can redistribute it and/or
  14  * modify it under the terms of the GNU General Public License as
  15  * published by the Free Software Foundation; either version 2 of
  16  * the License, or (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  26  * MA 02111-1307 USA
  27  */
  28
  29 #include <common.h>
  30
  31 ulong myflush(void);
  32
  33
  34 /* Flash Organization Structure */
  35 typedef struct OrgDef
  36 {
  37         unsigned int sector_number;
  38         unsigned int sector_size;
  39 } OrgDef;
  40
  41
  42 /* Flash Organizations */
  43 OrgDef OrgAT49BV16x4[] =
  44 {
  45         {  8,  8*1024 },        /*   8 *  8 kBytes sectors */
  46         {  2, 32*1024 },        /*   2 * 32 kBytes sectors */
  47         { 30, 64*1024 },        /*  30 * 64 kBytes sectors */
  48 };
  49
  50 OrgDef OrgAT49BV16x4A[] =
  51 {
  52         {  8,  8*1024 },        /*   8 *  8 kBytes sectors */
  53         { 31, 64*1024 },        /*  31 * 64 kBytes sectors */
  54 };
  55
  56 OrgDef OrgAT49BV6416[] =
  57 {
  58         {   8,  8*1024 },       /*   8 *  8 kBytes sectors */
  59         { 127, 64*1024 },       /* 127 * 64 kBytes sectors */
  60 };
  61
  62 flash_info_t    flash_info[CONFIG_SYS_MAX_FLASH_BANKS];
  63
  64 /* AT49BV1614A Codes */
  65 #define FLASH_CODE1             0xAA
  66 #define FLASH_CODE2             0x55
  67 #define ID_IN_CODE              0x90
  68 #define ID_OUT_CODE             0xF0
  69
  70
  71 #define CMD_READ_ARRAY          0x00F0
  72 #define CMD_UNLOCK1             0x00AA
  73 #define CMD_UNLOCK2             0x0055
  74 #define CMD_ERASE_SETUP         0x0080
  75 #define CMD_ERASE_CONFIRM       0x0030
  76 #define CMD_PROGRAM             0x00A0
  77 #define CMD_UNLOCK_BYPASS       0x0020
  78 #define CMD_SECTOR_UNLOCK       0x0070
  79
  80 #define MEM_FLASH_ADDR1         (*(volatile u16 *)(CONFIG_SYS_FLASH_BASE + (0x00005555<<1)))
  81 #define MEM_FLASH_ADDR2         (*(volatile u16 *)(CONFIG_SYS_FLASH_BASE + (0x00002AAA<<1)))
  82
  83 #define BIT_ERASE_DONE          0x0080
  84 #define BIT_RDY_MASK            0x0080
  85 #define BIT_PROGRAM_ERROR       0x0020
  86 #define BIT_TIMEOUT             0x80000000 /* our flag */
  87
  88 #define READY 1
  89 #define ERR   2
  90 #define TMO   4
  91
  92 /*-----------------------------------------------------------------------
  93  */
  94 void flash_identification (flash_info_t * info)
  95 {
  96         volatile u16 manuf_code, device_code, add_device_code;
  97
  98         MEM_FLASH_ADDR1 = FLASH_CODE1;
  99         MEM_FLASH_ADDR2 = FLASH_CODE2;
 100         MEM_FLASH_ADDR1 = ID_IN_CODE;
 101
 102         manuf_code = *(volatile u16 *) CONFIG_SYS_FLASH_BASE;
 103         device_code = *(volatile u16 *) (CONFIG_SYS_FLASH_BASE + 2);
 104         add_device_code = *(volatile u16 *) (CONFIG_SYS_FLASH_BASE + (3 << 1));
 105
 106         MEM_FLASH_ADDR1 = FLASH_CODE1;
 107         MEM_FLASH_ADDR2 = FLASH_CODE2;
 108         MEM_FLASH_ADDR1 = ID_OUT_CODE;
 109
 110         /* Vendor type */
 111         info->flash_id = ATM_MANUFACT & FLASH_VENDMASK;
 112         printf ("Atmel: ");
 113
 114         if ((device_code & FLASH_TYPEMASK) == (ATM_ID_BV1614 & FLASH_TYPEMASK)) {
 115
 116                 if ((add_device_code & FLASH_TYPEMASK) ==
 117                         (ATM_ID_BV1614A & FLASH_TYPEMASK)) {
 118                         info->flash_id |= ATM_ID_BV1614A & FLASH_TYPEMASK;
 119                         printf ("AT49BV1614A (16Mbit)\n");
 120                 } else {                                /* AT49BV1614 Flash */
 121                         info->flash_id |= ATM_ID_BV1614 & FLASH_TYPEMASK;
 122                         printf ("AT49BV1614 (16Mbit)\n");
 123                 }
 124
 125         } else if ((device_code & FLASH_TYPEMASK) == (ATM_ID_BV6416 & FLASH_TYPEMASK)) {
 126                 info->flash_id |= ATM_ID_BV6416 & FLASH_TYPEMASK;
 127                 printf ("AT49BV6416 (64Mbit)\n");
 128         }
 129 }
 130
 131 ushort flash_number_sector(OrgDef *pOrgDef, unsigned int nb_blocks)
 132 {
 133         int i, nb_sectors = 0;
 134
 135         for (i=0; i<nb_blocks; i++){
 136                 nb_sectors += pOrgDef[i].sector_number;
 137         }
 138
 139         return nb_sectors;
 140 }
 141
 142 void flash_unlock_sector(flash_info_t * info, unsigned int sector)
 143 {
 144         volatile u16 *addr = (volatile u16 *) (info->start[sector]);
 145
 146         MEM_FLASH_ADDR1 = CMD_UNLOCK1;
 147         *addr = CMD_SECTOR_UNLOCK;
 148 }
 149
 150
 151 ulong flash_init (void)
 152 {
 153         int i, j, k;
 154         unsigned int flash_nb_blocks, sector;
 155         unsigned int start_address;
 156         OrgDef *pOrgDef;
 157
 158         ulong size = 0;
 159
 160         for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
 161                 ulong flashbase = 0;
 162
 163                 flash_identification (&flash_info[i]);
 164
 165                 if ((flash_info[i].flash_id & FLASH_TYPEMASK) ==
 166                         (ATM_ID_BV1614 & FLASH_TYPEMASK)) {
 167
 168                         pOrgDef = OrgAT49BV16x4;
 169                         flash_nb_blocks = sizeof (OrgAT49BV16x4) / sizeof (OrgDef);
 170                 } else if ((flash_info[i].flash_id & FLASH_TYPEMASK) ==
 171                         (ATM_ID_BV1614A & FLASH_TYPEMASK)){     /* AT49BV1614A Flash */
 172
 173                         pOrgDef = OrgAT49BV16x4A;
 174                         flash_nb_blocks = sizeof (OrgAT49BV16x4A) / sizeof (OrgDef);
 175                 } else if ((flash_info[i].flash_id & FLASH_TYPEMASK) ==
 176                         (ATM_ID_BV6416 & FLASH_TYPEMASK)){      /* AT49BV6416 Flash */
 177
 178                         pOrgDef = OrgAT49BV6416;
 179                         flash_nb_blocks = sizeof (OrgAT49BV6416) / sizeof (OrgDef);
 180                 } else {
 181                         flash_nb_blocks = 0;
 182                         pOrgDef = OrgAT49BV16x4;
 183                 }
 184
 185                 flash_info[i].sector_count = flash_number_sector(pOrgDef, flash_nb_blocks);
 186                 memset (flash_info[i].protect, 0, flash_info[i].sector_count);
 187
 188                 if (i == 0)
 189                         flashbase = PHYS_FLASH_1;
 190                 else
 191                         panic ("configured too many flash banks!\n");
 192
 193                 sector = 0;
 194                 start_address = flashbase;
 195                 flash_info[i].size = 0;
 196
 197                 for (j = 0; j < flash_nb_blocks; j++) {
 198                         for (k = 0; k < pOrgDef[j].sector_number; k++) {
 199                                 flash_info[i].start[sector++] = start_address;
 200                                 start_address += pOrgDef[j].sector_size;
 201                                 flash_info[i].size += pOrgDef[j].sector_size;
 202                         }
 203                 }
 204
 205                 size += flash_info[i].size;
 206
 207                 if ((flash_info[i].flash_id & FLASH_TYPEMASK) ==
 208                         (ATM_ID_BV6416 & FLASH_TYPEMASK)){      /* AT49BV6416 Flash */
 209
 210                         /* Unlock all sectors at reset */
 211                         for (j=0; j<flash_info[i].sector_count; j++){
 212                                 flash_unlock_sector(&flash_info[i], j);
 213                         }
 214                 }
 215         }
 216
 217         /* Protect binary boot image */
 218         flash_protect (FLAG_PROTECT_SET,
 219                        CONFIG_SYS_FLASH_BASE,
 220                        CONFIG_SYS_FLASH_BASE + CONFIG_SYS_BOOT_SIZE - 1, &flash_info[0]);
 221
 222         /* Protect environment variables */
 223         flash_protect (FLAG_PROTECT_SET,
 224                        CONFIG_ENV_ADDR,
 225                        CONFIG_ENV_ADDR + CONFIG_ENV_SIZE - 1, &flash_info[0]);
 226
 227         /* Protect U-Boot gzipped image */
 228         flash_protect (FLAG_PROTECT_SET,
 229                        CONFIG_SYS_U_BOOT_BASE,
 230                        CONFIG_SYS_U_BOOT_BASE + CONFIG_SYS_U_BOOT_SIZE - 1, &flash_info[0]);
 231
 232         return size;
 233 }
 234
 235 /*-----------------------------------------------------------------------
 236  */
 237 void flash_print_info (flash_info_t * info)
 238 {
 239         int i;
 240
 241         switch (info->flash_id & FLASH_VENDMASK) {
 242         case (ATM_MANUFACT & FLASH_VENDMASK):
 243                 printf ("Atmel: ");
 244                 break;
 245         default:
 246                 printf ("Unknown Vendor ");
 247                 break;
 248         }
 249
 250         switch (info->flash_id & FLASH_TYPEMASK) {
 251         case (ATM_ID_BV1614 & FLASH_TYPEMASK):
 252                 printf ("AT49BV1614 (16Mbit)\n");
 253                 break;
 254         case (ATM_ID_BV1614A & FLASH_TYPEMASK):
 255                 printf ("AT49BV1614A (16Mbit)\n");
 256                 break;
 257         case (ATM_ID_BV6416 & FLASH_TYPEMASK):
 258                 printf ("AT49BV6416 (64Mbit)\n");
 259                 break;
 260         default:
 261                 printf ("Unknown Chip Type\n");
 262                 return;
 263         }
 264
 265         printf ("  Size: %ld MB in %d Sectors\n",
 266                 info->size >> 20, info->sector_count);
 267
 268         printf ("  Sector Start Addresses:");
 269         for (i = 0; i < info->sector_count; i++) {
 270                 if ((i % 5) == 0) {
 271                         printf ("\n   ");
 272                 }
 273                 printf (" %08lX%s", info->start[i],
 274                         info->protect[i] ? " (RO)" : "     ");
 275         }
 276         printf ("\n");
 277 }
 278
 279 /*-----------------------------------------------------------------------
 280  */
 281
 282 int flash_erase (flash_info_t * info, int s_first, int s_last)
 283 {
 284         ulong result;
 285         int iflag, cflag, prot, sect;
 286         int rc = ERR_OK;
 287         int chip1;
 288         ulong start;
 289
 290         /* first look for protection bits */
 291
 292         if (info->flash_id == FLASH_UNKNOWN)
 293                 return ERR_UNKNOWN_FLASH_TYPE;
 294
 295         if ((s_first < 0) || (s_first > s_last)) {
 296                 return ERR_INVAL;
 297         }
 298
 299         if ((info->flash_id & FLASH_VENDMASK) !=
 300                 (ATM_MANUFACT & FLASH_VENDMASK)) {
 301                 return ERR_UNKNOWN_FLASH_VENDOR;
 302         }
 303
 304         prot = 0;
 305         for (sect = s_first; sect <= s_last; ++sect) {
 306                 if (info->protect[sect]) {
 307                         prot++;
 308                 }
 309         }
 310         if (prot)
 311                 return ERR_PROTECTED;
 312
 313         /*
 314          * Disable interrupts which might cause a timeout
 315          * here. Remember that our exception vectors are
 316          * at address 0 in the flash, and we don't want a
 317          * (ticker) exception to happen while the flash
 318          * chip is in programming mode.
 319          */
 320         cflag = icache_status ();
 321         icache_disable ();
 322         iflag = disable_interrupts ();
 323
 324         /* Start erase on unprotected sectors */
 325         for (sect = s_first; sect <= s_last && !ctrlc (); sect++) {
 326                 printf ("Erasing sector %2d ... ", sect);
 327
 328                 /* arm simple, non interrupt dependent timer */
 329                 start = get_timer(0);
 330
 331                 if (info->protect[sect] == 0) { /* not protected */
 332                         volatile u16 *addr = (volatile u16 *) (info->start[sect]);
 333
 334                         MEM_FLASH_ADDR1 = CMD_UNLOCK1;
 335                         MEM_FLASH_ADDR2 = CMD_UNLOCK2;
 336                         MEM_FLASH_ADDR1 = CMD_ERASE_SETUP;
 337
 338                         MEM_FLASH_ADDR1 = CMD_UNLOCK1;
 339                         MEM_FLASH_ADDR2 = CMD_UNLOCK2;
 340                         *addr = CMD_ERASE_CONFIRM;
 341
 342                         /* wait until flash is ready */
 343                         chip1 = 0;
 344
 345                         do {
 346                                 result = *addr;
 347
 348                                 /* check timeout */
 349                                 if (get_timer(start) > CONFIG_SYS_FLASH_ERASE_TOUT) {
 350                                         MEM_FLASH_ADDR1 = CMD_READ_ARRAY;
 351                                         chip1 = TMO;
 352                                         break;
 353                                 }
 354
 355                                 if (!chip1 && (result & 0xFFFF) & BIT_ERASE_DONE)
 356                                         chip1 = READY;
 357
 358                         } while (!chip1);
 359
 360                         MEM_FLASH_ADDR1 = CMD_READ_ARRAY;
 361
 362                         if (chip1 == ERR) {
 363                                 rc = ERR_PROG_ERROR;
 364                                 goto outahere;
 365                         }
 366                         if (chip1 == TMO) {
 367                                 rc = ERR_TIMOUT;
 368                                 goto outahere;
 369                         }
 370
 371                         printf ("ok.\n");
 372                 } else {                        /* it was protected */
 373                         printf ("protected!\n");
 374                 }
 375         }
 376
 377         if (ctrlc ())
 378                 printf ("User Interrupt!\n");
 379
 380 outahere:
 381         /* allow flash to settle - wait 10 ms */
 382         udelay_masked (10000);
 383
 384         if (iflag)
 385                 enable_interrupts ();
 386
 387         if (cflag)
 388                 icache_enable ();
 389
 390         return rc;
 391 }
 392
 393 /*-----------------------------------------------------------------------
 394  * Copy memory to flash
 395  */
 396
 397 static int write_word (flash_info_t * info, ulong dest, ulong data)
 398 {
 399         volatile u16 *addr = (volatile u16 *) dest;
 400         ulong result;
 401         int rc = ERR_OK;
 402         int cflag, iflag;
 403         int chip1;
 404         ulong start;
 405
 406         /*
 407          * Check if Flash is (sufficiently) erased
 408          */
 409         result = *addr;
 410         if ((result & data) != data)
 411                 return ERR_NOT_ERASED;
 412
 413         /*
 414          * Disable interrupts which might cause a timeout
 415          * here. Remember that our exception vectors are
 416          * at address 0 in the flash, and we don't want a
 417          * (ticker) exception to happen while the flash
 418          * chip is in programming mode.
 419          */
 420         cflag = icache_status ();
 421         icache_disable ();
 422         iflag = disable_interrupts ();
 423
 424         MEM_FLASH_ADDR1 = CMD_UNLOCK1;
 425         MEM_FLASH_ADDR2 = CMD_UNLOCK2;
 426         MEM_FLASH_ADDR1 = CMD_PROGRAM;
 427         *addr = data;
 428
 429         /* arm simple, non interrupt dependent timer */
 430         start = get_timer(0);
 431
 432         /* wait until flash is ready */
 433         chip1 = 0;
 434         do {
 435                 result = *addr;
 436
 437                 /* check timeout */
 438                 if (get_timer(start) > CONFIG_SYS_FLASH_ERASE_TOUT) {
 439                         chip1 = ERR | TMO;
 440                         break;
 441                 }
 442                 if (!chip1 && ((result & 0x80) == (data & 0x80)))
 443                         chip1 = READY;
 444
 445         } while (!chip1);
 446
 447         *addr = CMD_READ_ARRAY;
 448
 449         if (chip1 == ERR || *addr != data)
 450                 rc = ERR_PROG_ERROR;
 451
 452         if (iflag)
 453                 enable_interrupts ();
 454
 455         if (cflag)
 456                 icache_enable ();
 457
 458         return rc;
 459 }
 460
 461 /*-----------------------------------------------------------------------
 462  * Copy memory to flash.
 463  */
 464
 465 int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
 466 {
 467         ulong wp, data;
 468         int rc;
 469
 470         if (addr & 1) {
 471                 printf ("unaligned destination not supported\n");
 472                 return ERR_ALIGN;
 473         };
 474
 475         if ((int) src & 1) {
 476                 printf ("unaligned source not supported\n");
 477                 return ERR_ALIGN;
 478         };
 479
 480         wp = addr;
 481
 482         while (cnt >= 2) {
 483                 data = *((volatile u16 *) src);
 484                 if ((rc = write_word (info, wp, data)) != 0) {
 485                         return (rc);
 486                 }
 487                 src += 2;
 488                 wp += 2;
 489                 cnt -= 2;
 490         }
 491
 492         if (cnt == 1) {
 493                 data = (*((volatile u8 *) src)) | (*((volatile u8 *) (wp + 1)) <<
 494                                                                                    8);
 495                 if ((rc = write_word (info, wp, data)) != 0) {
 496                         return (rc);
 497                 }
 498                 src += 1;
 499                 wp += 1;
 500                 cnt -= 1;
 501         };
 502
 503         return ERR_OK;
 504 }