board/cradle/flash.c

   1 /*
   2  * (C) Copyright 2002
   3  * Kyle Harris, Nexus Technologies, Inc. kharris@nexus-tech.net
   4  *
   5  * (C) Copyright 2002
   6  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   7  * Marius Groeger <mgroeger@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
  30 #define FLASH_BANK_SIZE 0x400000
  31 #define MAIN_SECT_SIZE  0x20000
  32
  33 flash_info_t flash_info[CONFIG_SYS_MAX_FLASH_BANKS];
  34
  35
  36 /*-----------------------------------------------------------------------
  37  */
  38
  39 ulong flash_init (void)
  40 {
  41         int i, j;
  42         ulong size = 0;
  43
  44         for (i = 0; i < CONFIG_SYS_MAX_FLASH_BANKS; i++) {
  45                 ulong flashbase = 0;
  46
  47                 flash_info[i].flash_id =
  48                         (INTEL_MANUFACT & FLASH_VENDMASK) |
  49                         (INTEL_ID_28F128J3 & FLASH_TYPEMASK);
  50                 flash_info[i].size = FLASH_BANK_SIZE;
  51                 flash_info[i].sector_count = CONFIG_SYS_MAX_FLASH_SECT;
  52                 memset (flash_info[i].protect, 0, CONFIG_SYS_MAX_FLASH_SECT);
  53                 switch (i) {
  54                 case 0:
  55                         flashbase = PHYS_FLASH_1;
  56                         break;
  57                 case 1:
  58                         flashbase = PHYS_FLASH_2;
  59                         break;
  60                 default:
  61                         panic ("configured too many flash banks!\n");
  62                         break;
  63                 }
  64                 for (j = 0; j < flash_info[i].sector_count; j++) {
  65                         flash_info[i].start[j] =
  66                                 flashbase + j * MAIN_SECT_SIZE;
  67                 }
  68                 size += flash_info[i].size;
  69         }
  70
  71         /* Protect monitor and environment sectors
  72          */
  73         flash_protect (FLAG_PROTECT_SET,
  74                        CONFIG_SYS_FLASH_BASE,
  75                        CONFIG_SYS_FLASH_BASE + monitor_flash_len - 1,
  76                        &flash_info[0]);
  77
  78         flash_protect (FLAG_PROTECT_SET,
  79                        CONFIG_ENV_ADDR,
  80                        CONFIG_ENV_ADDR + CONFIG_ENV_SIZE - 1, &flash_info[0]);
  81
  82         return size;
  83 }
  84
  85 /*-----------------------------------------------------------------------
  86  */
  87 void flash_print_info (flash_info_t * info)
  88 {
  89         int i, j;
  90
  91         for (j = 0; j < CONFIG_SYS_MAX_FLASH_BANKS; j++) {
  92                 switch (info->flash_id & FLASH_VENDMASK) {
  93                 case (INTEL_MANUFACT & FLASH_VENDMASK):
  94                         printf ("Intel: ");
  95                         break;
  96                 default:
  97                         printf ("Unknown Vendor ");
  98                         break;
  99                 }
 100
 101                 switch (info->flash_id & FLASH_TYPEMASK) {
 102                 case (INTEL_ID_28F320J3A & FLASH_TYPEMASK):
 103                         printf ("28F320J3A (32Mbit)\n");
 104                         break;
 105                 case (INTEL_ID_28F128J3 & FLASH_TYPEMASK):
 106                         printf ("28F128J3 (128Mbit)\n");
 107                         break;
 108                 default:
 109                         printf ("Unknown Chip Type\n");
 110                         goto Done;
 111                         break;
 112                 }
 113
 114                 printf ("  Size: %ld MB in %d Sectors\n",
 115                         info->size >> 20, info->sector_count);
 116
 117                 printf ("  Sector Start Addresses:");
 118                 for (i = 0; i < info->sector_count; i++) {
 119                         if ((i % 5) == 0) {
 120                                 printf ("\n   ");
 121                         }
 122                         printf (" %08lX%s", info->start[i],
 123                                 info->protect[i] ? " (RO)" : "     ");
 124                 }
 125                 printf ("\n");
 126                 info++;
 127         }
 128
 129 Done:   ;
 130 }
 131
 132 /*-----------------------------------------------------------------------
 133  */
 134
 135 int flash_erase (flash_info_t * info, int s_first, int s_last)
 136 {
 137         int flag, prot, sect;
 138         int rc = ERR_OK;
 139         ulong start;
 140
 141         if (info->flash_id == FLASH_UNKNOWN)
 142                 return ERR_UNKNOWN_FLASH_TYPE;
 143
 144         if ((s_first < 0) || (s_first > s_last)) {
 145                 return ERR_INVAL;
 146         }
 147
 148         if ((info->flash_id & FLASH_VENDMASK) !=
 149             (INTEL_MANUFACT & FLASH_VENDMASK)) {
 150                 return ERR_UNKNOWN_FLASH_VENDOR;
 151         }
 152
 153         prot = 0;
 154         for (sect = s_first; sect <= s_last; ++sect) {
 155                 if (info->protect[sect]) {
 156                         prot++;
 157                 }
 158         }
 159         if (prot)
 160                 return ERR_PROTECTED;
 161
 162         /*
 163          * Disable interrupts which might cause a timeout
 164          * here. Remember that our exception vectors are
 165          * at address 0 in the flash, and we don't want a
 166          * (ticker) exception to happen while the flash
 167          * chip is in programming mode.
 168          */
 169         flag = disable_interrupts ();
 170
 171         /* Start erase on unprotected sectors */
 172         for (sect = s_first; sect <= s_last && !ctrlc (); sect++) {
 173
 174                 printf ("Erasing sector %2d ... ", sect);
 175
 176                 /* arm simple, non interrupt dependent timer */
 177                 start = get_timer(0);
 178
 179                 if (info->protect[sect] == 0) { /* not protected */
 180                         vu_short *addr = (vu_short *) (info->start[sect]);
 181
 182                         *addr = 0x20;   /* erase setup */
 183                         *addr = 0xD0;   /* erase confirm */
 184
 185                         while ((*addr & 0x80) != 0x80) {
 186                                 if (get_timer(start) >
 187                                     CONFIG_SYS_FLASH_ERASE_TOUT) {
 188                                         *addr = 0xB0;   /* suspend erase */
 189                                         *addr = 0xFF;   /* reset to read mode */
 190                                         rc = ERR_TIMOUT;
 191                                         goto outahere;
 192                                 }
 193                         }
 194
 195                         /* clear status register command */
 196                         *addr = 0x50;
 197                         /* reset to read mode */
 198                         *addr = 0xFF;
 199                 }
 200                 printf ("ok.\n");
 201         }
 202         if (ctrlc ())
 203                 printf ("User Interrupt!\n");
 204
 205 outahere:
 206
 207         /* allow flash to settle - wait 10 ms */
 208         udelay_masked (10000);
 209
 210         if (flag)
 211                 enable_interrupts ();
 212
 213         return rc;
 214 }
 215
 216 /*-----------------------------------------------------------------------
 217  * Copy memory to flash
 218  */
 219
 220 static int write_word (flash_info_t * info, ulong dest, ushort data)
 221 {
 222         vu_short *addr = (vu_short *) dest, val;
 223         int rc = ERR_OK;
 224         int flag;
 225         ulong start;
 226
 227         /* Check if Flash is (sufficiently) erased
 228          */
 229         if ((*addr & data) != data)
 230                 return ERR_NOT_ERASED;
 231
 232         /*
 233          * Disable interrupts which might cause a timeout
 234          * here. Remember that our exception vectors are
 235          * at address 0 in the flash, and we don't want a
 236          * (ticker) exception to happen while the flash
 237          * chip is in programming mode.
 238          */
 239         flag = disable_interrupts ();
 240
 241         /* clear status register command */
 242         *addr = 0x50;
 243
 244         /* program set-up command */
 245         *addr = 0x40;
 246
 247         /* latch address/data */
 248         *addr = data;
 249
 250         /* arm simple, non interrupt dependent timer */
 251         start = get_timer(0);
 252
 253         /* wait while polling the status register */
 254         while (((val = *addr) & 0x80) != 0x80) {
 255                 if (get_timer(start) > CONFIG_SYS_FLASH_WRITE_TOUT) {
 256                         rc = ERR_TIMOUT;
 257                         /* suspend program command */
 258                         *addr = 0xB0;
 259                         goto outahere;
 260                 }
 261         }
 262
 263         if (val & 0x1A) {       /* check for error */
 264                 printf ("\nFlash write error %02x at address %08lx\n",
 265                         (int) val, (unsigned long) dest);
 266                 if (val & (1 << 3)) {
 267                         printf ("Voltage range error.\n");
 268                         rc = ERR_PROG_ERROR;
 269                         goto outahere;
 270                 }
 271                 if (val & (1 << 1)) {
 272                         printf ("Device protect error.\n");
 273                         rc = ERR_PROTECTED;
 274                         goto outahere;
 275                 }
 276                 if (val & (1 << 4)) {
 277                         printf ("Programming error.\n");
 278                         rc = ERR_PROG_ERROR;
 279                         goto outahere;
 280                 }
 281                 rc = ERR_PROG_ERROR;
 282                 goto outahere;
 283         }
 284
 285 outahere:
 286         /* read array command */
 287         *addr = 0xFF;
 288
 289         if (flag)
 290                 enable_interrupts ();
 291
 292         return rc;
 293 }
 294
 295 /*-----------------------------------------------------------------------
 296  * Copy memory to flash.
 297  */
 298
 299 int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
 300 {
 301         ulong cp, wp;
 302         ushort data;
 303         int l;
 304         int i, rc;
 305
 306         wp = (addr & ~1);       /* get lower word aligned address */
 307
 308         /*
 309          * handle unaligned start bytes
 310          */
 311         if ((l = addr - wp) != 0) {
 312                 data = 0;
 313                 for (i = 0, cp = wp; i < l; ++i, ++cp) {
 314                         data = (data >> 8) | (*(uchar *) cp << 8);
 315                 }
 316                 for (; i < 2 && cnt > 0; ++i) {
 317                         data = (data >> 8) | (*src++ << 8);
 318                         --cnt;
 319                         ++cp;
 320                 }
 321                 for (; cnt == 0 && i < 2; ++i, ++cp) {
 322                         data = (data >> 8) | (*(uchar *) cp << 8);
 323                 }
 324
 325                 if ((rc = write_word (info, wp, data)) != 0) {
 326                         return (rc);
 327                 }
 328                 wp += 2;
 329         }
 330
 331         /*
 332          * handle word aligned part
 333          */
 334         while (cnt >= 2) {
 335                 data = *((vu_short *) src);
 336                 if ((rc = write_word (info, wp, data)) != 0) {
 337                         return (rc);
 338                 }
 339                 src += 2;
 340                 wp += 2;
 341                 cnt -= 2;
 342         }
 343
 344         if (cnt == 0) {
 345                 return ERR_OK;
 346         }
 347
 348         /*
 349          * handle unaligned tail bytes
 350          */
 351         data = 0;
 352         for (i = 0, cp = wp; i < 2 && cnt > 0; ++i, ++cp) {
 353                 data = (data >> 8) | (*src++ << 8);
 354                 --cnt;
 355         }
 356         for (; i < 2; ++i, ++cp) {
 357                 data = (data >> 8) | (*(uchar *) cp << 8);
 358         }
 359
 360         return write_word (info, wp, data);
 361 }