board/ep8260/flash.c

   1 /*
   2  * (C) Copyright 2001, 2002
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * (C) Copyright 2002
   6  * Frank Panno <fpanno@delphintech.com>, Delphin Technology AG
   7  *
   8  * Flash Routines for AMD device AM29DL323DB on the EP8260 board.
   9  *
  10  * This file is based on board/tqm8260/flash.c.
  11  *--------------------------------------------------------------------
  12  * SPDX-License-Identifier:     GPL-2.0+
  13  */
  14
  15 #include <common.h>
  16 #include <mpc8xx.h>
  17
  18 #define V_ULONG(a)      (*(volatile unsigned long *)( a ))
  19 #define V_BYTE(a)       (*(volatile unsigned char *)( a ))
  20
  21
  22 flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];
  23
  24
  25 /*-----------------------------------------------------------------------
  26  */
  27 void flash_reset(void)
  28 {
  29         if( flash_info[0].flash_id != FLASH_UNKNOWN ) {
  30                 V_ULONG( flash_info[0].start[0] ) = 0x00F000F0;
  31                 V_ULONG( flash_info[0].start[0] + 4 ) = 0x00F000F0;
  32         }
  33 }
  34
  35 /*-----------------------------------------------------------------------
  36  */
  37 ulong flash_get_size( ulong baseaddr, flash_info_t *info )
  38 {
  39         short i;
  40         unsigned long flashtest_h, flashtest_l;
  41
  42         /* Write auto select command sequence and test FLASH answer */
  43         V_ULONG(baseaddr + ((ulong)0x0555 << 3)) = 0x00AA00AA;
  44         V_ULONG(baseaddr + ((ulong)0x02AA << 3)) = 0x00550055;
  45         V_ULONG(baseaddr + ((ulong)0x0555 << 3)) = 0x00900090;
  46         V_ULONG(baseaddr + 4 + ((ulong)0x0555 << 3)) = 0x00AA00AA;
  47         V_ULONG(baseaddr + 4 + ((ulong)0x02AA << 3)) = 0x00550055;
  48         V_ULONG(baseaddr + 4 + ((ulong)0x0555 << 3)) = 0x00900090;
  49
  50         flashtest_h = V_ULONG(baseaddr);                /* manufacturer ID         */
  51         flashtest_l = V_ULONG(baseaddr + 4);
  52
  53         if ((int)flashtest_h == AMD_MANUFACT) {
  54                 info->flash_id = FLASH_MAN_AMD;
  55         } else {
  56                 info->flash_id = FLASH_UNKNOWN;
  57                 info->sector_count = 0;
  58                 info->size = 0;
  59                 return (0);                             /* no or unknown flash     */
  60         }
  61
  62         flashtest_h = V_ULONG(baseaddr + 8);            /* device ID               */
  63         flashtest_l = V_ULONG(baseaddr + 12);
  64         if (flashtest_h != flashtest_l) {
  65                 info->flash_id = FLASH_UNKNOWN;
  66                 return(0);
  67         }
  68
  69         switch((int)flashtest_h) {
  70         case AMD_ID_DL323B:
  71                 info->flash_id += FLASH_AMDL323B;
  72                 info->sector_count = 71;
  73                 info->size = 0x01000000;         /* 4 * 4 MB = 16 MB    */
  74                 break;
  75         case AMD_ID_LV640U:     /* AMDLV640 and AMDLV641 have same ID */
  76                 info->flash_id += FLASH_AMLV640U;
  77                 info->sector_count = 128;
  78                 info->size = 0x02000000;        /* 4 * 8 MB = 32 MB     */
  79                 break;
  80         default:
  81                 info->flash_id = FLASH_UNKNOWN;
  82                 return(0);                              /* no or unknown flash     */
  83         }
  84
  85         if(flashtest_h == AMD_ID_LV640U) {
  86                 /* set up sector start adress table (uniform sector type) */
  87                 for (i = 0; i < info->sector_count; i++)
  88                         info->start[i] = baseaddr + (i * 0x00040000);
  89         } else {
  90                 /* set up sector start adress table (bottom sector type) */
  91                 for (i = 0; i < 8; i++) {
  92                         info->start[i] = baseaddr + (i * 0x00008000);
  93                 }
  94                 for (i = 8; i < info->sector_count; i++) {
  95                         info->start[i] = baseaddr + (i * 0x00040000) - 0x001C0000;
  96                 }
  97         }
  98         /* check for protected sectors */
  99         for (i = 0; i < info->sector_count; i++) {
 100                 /* read sector protection at sector address, (A7 .. A0) = 0x02 */
 101                 if ((V_ULONG( info->start[i] + 16 ) & 0x00010001) ||
 102                     (V_ULONG( info->start[i] + 20 ) & 0x00010001)) {
 103                         info->protect[i] = 1;           /* D0 = 1 if protected */
 104                 } else {
 105                         info->protect[i] = 0;
 106                 }
 107         }
 108
 109         flash_reset();
 110         return(info->size);
 111 }
 112
 113 /*-----------------------------------------------------------------------
 114  */
 115 unsigned long flash_init (void)
 116 {
 117         unsigned long size_b0 = 0;
 118         int i;
 119
 120         /* Init: no FLASHes known */
 121         for (i=0; i<CONFIG_SYS_MAX_FLASH_BANKS; ++i) {
 122                 flash_info[i].flash_id = FLASH_UNKNOWN;
 123         }
 124
 125         /* Static FLASH Bank configuration here (only one bank) */
 126
 127         size_b0 = flash_get_size(CONFIG_SYS_FLASH0_BASE, &flash_info[0]);
 128         if (flash_info[0].flash_id == FLASH_UNKNOWN || size_b0 == 0) {
 129                 printf ("## Unknown FLASH on Bank 0 - Size = 0x%08lx = %ld MB\n",
 130                         size_b0, size_b0>>20);
 131         }
 132
 133         /*
 134          * protect monitor and environment sectors
 135          */
 136
 137 #if CONFIG_SYS_MONITOR_BASE >= CONFIG_SYS_FLASH0_BASE
 138         flash_protect(FLAG_PROTECT_SET,
 139                       CONFIG_SYS_MONITOR_BASE,
 140                       CONFIG_SYS_MONITOR_BASE+monitor_flash_len-1,
 141                       &flash_info[0]);
 142 #endif
 143
 144 #if defined(CONFIG_ENV_IS_IN_FLASH) && defined(CONFIG_ENV_ADDR)
 145 # ifndef  CONFIG_ENV_SIZE
 146 #  define CONFIG_ENV_SIZE       CONFIG_ENV_SECT_SIZE
 147 # endif
 148         flash_protect(FLAG_PROTECT_SET,
 149                       CONFIG_ENV_ADDR,
 150                       CONFIG_ENV_ADDR + CONFIG_ENV_SIZE - 1,
 151                       &flash_info[0]);
 152 #endif
 153
 154         return (size_b0);
 155 }
 156
 157 /*-----------------------------------------------------------------------
 158  */
 159 void flash_print_info  (flash_info_t *info)
 160 {
 161         int i;
 162
 163         if (info->flash_id == FLASH_UNKNOWN) {
 164                 printf ("missing or unknown FLASH type\n");
 165                 return;
 166         }
 167
 168         switch ((info->flash_id >> 16) & 0xff) {
 169         case FLASH_MAN_AMD:         printf ("AMD ");                break;
 170         default:                    printf ("Unknown Vendor ");     break;
 171         }
 172
 173         switch (info->flash_id & FLASH_TYPEMASK) {
 174         case FLASH_AMDL323B:    printf ("29DL323B (32 M, bottom sector)\n");
 175                                 break;
 176         case FLASH_AMLV640U:    printf ("29LV640U (64 M, uniform sector)\n");
 177                                 break;
 178         default:                printf ("Unknown Chip Type\n");
 179                                 break;
 180         }
 181
 182         printf ("  Size: %ld MB in %d Sectors\n",
 183                 info->size >> 20, info->sector_count);
 184
 185         printf ("  Sector Start Addresses:");
 186         for (i=0; i<info->sector_count; ++i) {
 187                 if ((i % 5) == 0)
 188                         printf ("\n   ");
 189                 printf (" %08lX%s",
 190                         info->start[i],
 191                         info->protect[i] ? " (RO)" : "     "
 192                         );
 193         }
 194         printf ("\n");
 195         return;
 196 }
 197
 198 /*-----------------------------------------------------------------------
 199  */
 200 int flash_erase (flash_info_t *info, int s_first, int s_last)
 201 {
 202         int flag, prot, sect, l_sect;
 203         ulong start, now, last;
 204
 205         if ((s_first < 0) || (s_first > s_last)) {
 206                 if (info->flash_id == FLASH_UNKNOWN) {
 207                         printf ("- missing\n");
 208                 } else {
 209                         printf ("- no sectors to erase\n");
 210                 }
 211                 return 1;
 212         }
 213
 214         prot = 0;
 215         for (sect = s_first; sect <= s_last; sect++) {
 216                 if (info->protect[sect])
 217                         prot++;
 218         }
 219
 220         if (prot) {
 221                 printf ("- Warning: %d protected sectors will not be erased!\n",
 222                         prot);
 223         } else {
 224                 printf ("\n");
 225         }
 226
 227         l_sect = -1;
 228
 229         /* Disable interrupts which might cause a timeout here */
 230         flag = disable_interrupts();
 231
 232         V_ULONG( info->start[0] + (0x0555 << 3) ) = 0x00AA00AA;
 233         V_ULONG( info->start[0] + (0x02AA << 3) ) = 0x00550055;
 234         V_ULONG( info->start[0] + (0x0555 << 3) ) = 0x00800080;
 235         V_ULONG( info->start[0] + (0x0555 << 3) ) = 0x00AA00AA;
 236         V_ULONG( info->start[0] + (0x02AA << 3) ) = 0x00550055;
 237         V_ULONG( info->start[0] + 4 + (0x0555 << 3) ) = 0x00AA00AA;
 238         V_ULONG( info->start[0] + 4 + (0x02AA << 3) ) = 0x00550055;
 239         V_ULONG( info->start[0] + 4 + (0x0555 << 3) ) = 0x00800080;
 240         V_ULONG( info->start[0] + 4 + (0x0555 << 3) ) = 0x00AA00AA;
 241         V_ULONG( info->start[0] + 4 + (0x02AA << 3) ) = 0x00550055;
 242         udelay (1000);
 243
 244         /* Start erase on unprotected sectors */
 245         for (sect = s_first; sect<=s_last; sect++) {
 246                 if (info->protect[sect] == 0) { /* not protected */
 247                         V_ULONG( info->start[sect] ) = 0x00300030;
 248                         V_ULONG( info->start[sect] + 4 ) = 0x00300030;
 249                         l_sect = sect;
 250                 }
 251         }
 252
 253         /* re-enable interrupts if necessary */
 254         if (flag)
 255                 enable_interrupts();
 256
 257         /* wait at least 80us - let's wait 1 ms */
 258         udelay (1000);
 259
 260         /*
 261          * We wait for the last triggered sector
 262          */
 263         if (l_sect < 0)
 264                 goto DONE;
 265
 266         start = get_timer (0);
 267         last  = start;
 268         while ((V_ULONG( info->start[l_sect] ) & 0x00800080) != 0x00800080 ||
 269                (V_ULONG( info->start[l_sect] + 4 ) & 0x00800080) != 0x00800080)
 270         {
 271                 if ((now = get_timer(start)) > CONFIG_SYS_FLASH_ERASE_TOUT) {
 272                         printf ("Timeout\n");
 273                         return 1;
 274                 }
 275                 /* show that we're waiting */
 276                 if ((now - last) > 1000) {      /* every second */
 277                         serial_putc ('.');
 278                         last = now;
 279                 }
 280         }
 281
 282  DONE:
 283         /* reset to read mode */
 284         flash_reset ();
 285
 286         printf (" done\n");
 287         return 0;
 288 }
 289
 290 static int write_dword (flash_info_t *, ulong, unsigned char *);
 291
 292 /*-----------------------------------------------------------------------
 293  * Copy memory to flash, returns:
 294  * 0 - OK
 295  * 1 - write timeout
 296  * 2 - Flash not erased
 297  */
 298
 299 int write_buff (flash_info_t *info, uchar *src, ulong addr, ulong cnt)
 300 {
 301         ulong dp;
 302         static unsigned char bb[8];
 303         int i, l, rc, cc = cnt;
 304
 305         dp = (addr & ~7);       /* get lower dword aligned address */
 306
 307         /*
 308          * handle unaligned start bytes
 309          */
 310         if ((l = addr - dp) != 0) {
 311                 for (i = 0; i < 8; i++)
 312                         bb[i] = (i < l || (i-l) >= cc) ? V_BYTE(dp+i) : *src++;
 313                 if ((rc = write_dword(info, dp, bb)) != 0)
 314                 {
 315                         return (rc);
 316                 }
 317                 dp += 8;
 318                 cc -= 8 - l;
 319         }
 320
 321         /*
 322          * handle word aligned part
 323          */
 324         while (cc >= 8) {
 325                 if ((rc = write_dword(info, dp, src)) != 0) {
 326                         return (rc);
 327                 }
 328                 dp  += 8;
 329                 src += 8;
 330                 cc -= 8;
 331         }
 332
 333         if (cc <= 0) {
 334                 return (0);
 335         }
 336
 337         /*
 338          * handle unaligned tail bytes
 339          */
 340         for (i = 0; i < 8; i++) {
 341                 bb[i] = (i < cc) ? *src++ : V_BYTE(dp+i);
 342         }
 343         return (write_dword(info, dp, bb));
 344 }
 345
 346 /*-----------------------------------------------------------------------
 347  * Write a dword to Flash, returns:
 348  * 0 - OK
 349  * 1 - write timeout
 350  * 2 - Flash not erased
 351  */
 352 static int write_dword (flash_info_t *info, ulong dest, unsigned char * pdata)
 353 {
 354         ulong start;
 355         ulong cl = 0, ch =0;
 356         int flag, i;
 357
 358         for (ch=0, i=0; i < 4; i++)
 359                 ch = (ch << 8) + *pdata++;      /* high word    */
 360         for (cl=0, i=0; i < 4; i++)
 361                 cl = (cl << 8) + *pdata++;      /* low word     */
 362
 363         /* Check if Flash is (sufficiently) erased */
 364         if ((*((vu_long *)dest) & ch)   != ch
 365             ||(*((vu_long *)(dest + 4)) & cl)   != cl)
 366         {
 367                 return (2);
 368         }
 369
 370         /* Disable interrupts which might cause a timeout here */
 371         flag = disable_interrupts();
 372
 373         V_ULONG( info->start[0] + (0x0555 << 3) ) = 0x00AA00AA;
 374         V_ULONG( info->start[0] + (0x02AA << 3) ) = 0x00550055;
 375         V_ULONG( info->start[0] + (0x0555 << 3) ) = 0x00A000A0;
 376         V_ULONG( dest ) = ch;
 377         V_ULONG( info->start[0] + 4 + (0x0555 << 3) ) = 0x00AA00AA;
 378         V_ULONG( info->start[0] + 4 + (0x02AA << 3) ) = 0x00550055;
 379         V_ULONG( info->start[0] + 4 + (0x0555 << 3) ) = 0x00A000A0;
 380         V_ULONG( dest + 4 ) = cl;
 381
 382         /* re-enable interrupts if necessary */
 383         if (flag)
 384                 enable_interrupts();
 385
 386         /* data polling for D7 */
 387         start = get_timer (0);
 388         while (((V_ULONG( dest ) & 0x00800080) != (ch & 0x00800080)) ||
 389                ((V_ULONG( dest + 4 ) & 0x00800080) != (cl & 0x00800080))) {
 390                 if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
 391                         return (1);
 392                 }
 393         }
 394         return (0);
 395 }