git.sur5r.net Git - u-boot/blob - board/armadillo/flash.c

   1 /*
   2  * (C) Copyright 2002
   3  * Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   4  * Marius Groeger <mgroeger@sysgo.de>
   5  *
   6  * (C) Copyright 2005 Rowel Atienza <rowel@diwalabs.com>
   7  * Flash driver for armadillo board HT1070
   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
  32 /*value used by hermit is 0x200*/
  33 /*document says sector size is either 64k in low mem reg and 8k in high mem reg*/
  34 #define MAIN_SECT_SIZE  0x10000
  35
  36 #define UNALIGNED_MASK (3)
  37 #define FL_WORD(addr) (*(volatile unsigned short*)(addr))
  38 #define FLASH_TIMEOUT 20000000
  39
  40 flash_info_t flash_info[CFG_MAX_FLASH_BANKS];
  41
  42 /*-----------------------------------------------------------------------
  43  */
  44
  45 ulong flash_init (void)
  46 {
  47         int i, j;
  48         ulong size = 0;
  49
  50         for (i = 0; i < CFG_MAX_FLASH_BANKS; i++) {
  51                 ulong flashbase = 0;
  52
  53                 flash_info[i].flash_id = (FUJ_MANUFACT & FLASH_VENDMASK);
  54                 /*(INTEL_ID_28F128J3 & FLASH_TYPEMASK); */
  55                 flash_info[i].size = FLASH_BANK_SIZE;
  56                 flash_info[i].sector_count = CFG_MAX_FLASH_SECT;
  57                 memset (flash_info[i].protect, 0, CFG_MAX_FLASH_SECT);
  58                 if (i == 0)
  59                         flashbase = PHYS_FLASH_1;
  60                 else
  61                         panic ("configured too many flash banks!\n");
  62                 for (j = 0; j < flash_info[i].sector_count; j++) {
  63                         flash_info[i].start[j] =
  64                                 flashbase + j * MAIN_SECT_SIZE;
  65                 }
  66                 size += flash_info[i].size;
  67         }
  68
  69         /* Protect monitor and environment sectors
  70          */
  71         flash_protect (FLAG_PROTECT_SET,
  72                        CFG_FLASH_BASE,
  73                        CFG_FLASH_BASE + monitor_flash_len - 1,
  74                        &flash_info[0]);
  75
  76         flash_protect (FLAG_PROTECT_SET,
  77                        CFG_ENV_ADDR,
  78                        CFG_ENV_ADDR + CFG_ENV_SIZE - 1, &flash_info[0]);
  79
  80         return size;
  81 }
  82
  83 /*-----------------------------------------------------------------------
  84  */
  85 void flash_print_info (flash_info_t * info)
  86 {
  87         int i;
  88
  89         switch (info->flash_id & FLASH_VENDMASK) {
  90         case (FUJ_MANUFACT & FLASH_VENDMASK):
  91                 printf ("Fujitsu: ");
  92                 break;
  93         default:
  94                 printf ("Unknown Vendor ");
  95                 break;
  96         }
  97 /*
  98         switch (info->flash_id & FLASH_TYPEMASK) {
  99         case (INTEL_ID_28F128J3 & FLASH_TYPEMASK):
 100                 printf ("28F128J3 (128Mbit)\n");
 101                 break;
 102         default:
 103                 printf ("Unknown Chip Type\n");
 104                 goto Done;
 105                 break;
 106         }
 107 */
 108         printf ("  Size: %ld MB in %d Sectors\n",
 109                 info->size >> 20, info->sector_count);
 110
 111         printf ("  Sector Start Addresses:");
 112         for (i = 0; i < info->sector_count; i++) {
 113                 if ((i % 5) == 0) {
 114                         printf ("\n   ");
 115                 }
 116                 printf (" %08lX%s", info->start[i],
 117                         info->protect[i] ? " (RO)" : "     ");
 118         }
 119         printf ("\n");
 120
 121       Done:
 122 }
 123
 124 /*
 125  *  * Loop until both write state machines complete.
 126  *   */
 127 static unsigned short flash_status_wait (unsigned long addr,
 128                                          unsigned short value)
 129 {
 130         unsigned short status;
 131         long timeout = FLASH_TIMEOUT;
 132
 133         while (((status = (FL_WORD (addr))) != value) && timeout > 0) {
 134                 timeout--;
 135         }
 136         return status;
 137 }
 138
 139 /*
 140  * Loop until the Write State machine is ready, then do a full error
 141  * check.  Clear status and leave the flash in Read Array mode; return
 142  * 0 for no error, -1 for error.
 143  */
 144 static int flash_status_full_check (unsigned long addr, unsigned short value1,
 145                                     unsigned short value2)
 146 {
 147         unsigned short status1, status2;
 148
 149         status1 = flash_status_wait (addr, value1);
 150         status2 = flash_status_wait (addr + 2, value2);
 151         return (status1 != value1 || status2 != value2) ? -1 : 0;
 152 }
 153
 154 /*-----------------------------------------------------------------------
 155  */
 156
 157 int flash_erase (flash_info_t * info, int s_first, int s_last)
 158 {
 159         int flag, prot, sect;
 160         int rc = ERR_OK;
 161         unsigned long base;
 162         unsigned long addr;
 163
 164         if ((info->flash_id & FLASH_VENDMASK) !=
 165             (FUJ_MANUFACT & FLASH_VENDMASK)) {
 166                 return ERR_UNKNOWN_FLASH_VENDOR;
 167         }
 168
 169         prot = 0;
 170         for (sect = s_first; sect <= s_last; ++sect) {
 171                 if (info->protect[sect]) {
 172                         prot++;
 173                 }
 174         }
 175         if (prot)
 176                 return ERR_PROTECTED;
 177
 178         /*
 179          * Disable interrupts which might cause a timeout
 180          * here. Remember that our exception vectors are
 181          * at address 0 in the flash, and we don't want a
 182          * (ticker) exception to happen while the flash
 183          * chip is in programming mode.
 184          */
 185         flag = disable_interrupts ();
 186
 187         printf ("Erasing %d sectors starting at sector %2d.\n"
 188                 "This make take some time ... ",
 189                 s_last - s_first, sect);
 190         /* Start erase on unprotected sectors */
 191         for (sect = s_first; sect <= s_last && !ctrlc (); sect++) {
 192                 /* ARM simple, non interrupt dependent timer */
 193                 reset_timer_masked ();
 194
 195                 if (info->protect[sect] == 0) { /* not protected */
 196
 197                         addr = sect * MAIN_SECT_SIZE;
 198                         addr &= ~(unsigned long) UNALIGNED_MASK;        /* word align */
 199                         base = addr & 0xF0000000;
 200
 201                         FL_WORD (base + (0x555 << 1)) = 0xAA;
 202                         FL_WORD (base + (0x2AA << 1)) = 0x55;
 203                         FL_WORD (base + (0x555 << 1)) = 0x80;
 204                         FL_WORD (base + (0x555 << 1)) = 0xAA;
 205                         FL_WORD (base + (0x2AA << 1)) = 0x55;
 206                         FL_WORD (addr) = 0x30;
 207                         if (flash_status_full_check (addr, 0xFFFF, 0xFFFF))
 208                                 return ERR_PROTECTED;
 209                 }
 210         }
 211         printf ("\nDone.\n");
 212         if (ctrlc ())
 213                 printf ("User Interrupt!\n");
 214
 215         /* allow flash to settle - wait 10 ms */
 216         udelay_masked (10000);
 217
 218         if (flag)
 219                 enable_interrupts ();
 220
 221         return rc;
 222 }
 223
 224
 225 /*-----------------------------------------------------------------------
 226  * Copy memory to flash
 227  */
 228
 229 static int write_word (flash_info_t * info, ulong dest, ushort data)
 230 {
 231         int flag;
 232         unsigned long base;
 233
 234         /* Check if Flash is (sufficiently) erased
 235          */
 236         if ((FL_WORD (dest) & data) != data)
 237                 return ERR_NOT_ERASED;
 238
 239         /*if(dest & UNALIGNED_MASK) return ERR_ALIGN; */
 240
 241         /*
 242          * Disable interrupts which might cause a timeout
 243          * here. Remember that our exception vectors are
 244          * at address 0 in the flash, and we don't want a
 245          * (ticker) exception to happen while the flash
 246          * chip is in programming mode.
 247          */
 248         flag = disable_interrupts ();
 249
 250         /* arm simple, non interrupt dependent timer */
 251         reset_timer_masked ();
 252
 253         base = dest & 0xF0000000;
 254         FL_WORD (base + (0x555 << 1)) = 0xAA;
 255         FL_WORD (base + (0x2AA << 1)) = 0x55;
 256         FL_WORD (base + (0x555 << 1)) = 0xA0;
 257         FL_WORD (dest) = data;
 258         /*printf("writing 0x%p = 0x%x\n",dest,data); */
 259         if (flash_status_wait (dest, data) != data)
 260                 return ERR_PROG_ERROR;
 261
 262         if (flag)
 263                 enable_interrupts ();
 264
 265         return ERR_OK;
 266 }
 267
 268 /*-----------------------------------------------------------------------
 269  * Copy memory to flash.
 270  */
 271
 272 int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
 273 {
 274         ulong cp, wp;
 275         ushort data;
 276         int l;
 277         int i, rc;
 278
 279         wp = (addr & ~1);       /* get lower word aligned address */
 280         printf ("Writing %d short data to 0x%p from 0x%p.\n ", cnt, wp, src);
 281
 282         /*
 283          * handle unaligned start bytes
 284          */
 285         if ((l = addr - wp) != 0) {
 286                 data = 0;
 287                 for (i = 0, cp = wp; i < l; ++i, ++cp) {
 288                         data = (data >> 8) | (*(uchar *) cp << 8);
 289                 }
 290                 for (; i < 2 && cnt > 0; ++i) {
 291                         data = (data >> 8) | (*src++ << 8);
 292                         --cnt;
 293                         ++cp;
 294                 }
 295                 for (; cnt == 0 && i < 2; ++i, ++cp) {
 296                         data = (data >> 8) | (*(uchar *) cp << 8);
 297                 }
 298
 299                 if ((rc = write_word (info, wp, data)) != 0) {
 300                         return (rc);
 301                 }
 302                 wp += 2;
 303         }
 304
 305         /*
 306          * handle word aligned part
 307          */
 308         while (cnt >= 2) {
 309                 data = *((vu_short *) src);
 310                 if ((rc = write_word (info, wp, data)) != 0) {
 311                         return (rc);
 312                 }
 313                 src += 2;
 314                 wp += 2;
 315                 cnt -= 2;
 316         }
 317
 318         if (cnt == 0) {
 319                 printf ("\nDone.\n");
 320                 return ERR_OK;
 321         }
 322
 323         /*
 324          * handle unaligned tail bytes
 325          */
 326         data = 0;
 327         for (i = 0, cp = wp; i < 2 && cnt > 0; ++i, ++cp) {
 328                 data = (data >> 8) | (*src++ << 8);
 329                 --cnt;
 330         }
 331         for (; i < 2; ++i, ++cp) {
 332                 data = (data >> 8) | (*(uchar *) cp << 8);
 333         }
 334
 335         return write_word (info, wp, data);
 336 }