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[CONFIG_SYS_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 < CONFIG_SYS_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 = CONFIG_SYS_MAX_FLASH_SECT;
  57                 memset (flash_info[i].protect, 0, CONFIG_SYS_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                        CONFIG_SYS_FLASH_BASE,
  73                        CONFIG_SYS_FLASH_BASE + monitor_flash_len - 1,
  74                        &flash_info[0]);
  75
  76         flash_protect (FLAG_PROTECT_SET,
  77                        CONFIG_ENV_ADDR,
  78                        CONFIG_ENV_ADDR + CONFIG_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 /*
 122 Done:   ;
 123 */
 124 }
 125
 126 /*
 127  *  * Loop until both write state machines complete.
 128  *   */
 129 static unsigned short flash_status_wait (unsigned long addr,
 130                                          unsigned short value)
 131 {
 132         unsigned short status;
 133         long timeout = FLASH_TIMEOUT;
 134
 135         while (((status = (FL_WORD (addr))) != value) && timeout > 0) {
 136                 timeout--;
 137         }
 138         return status;
 139 }
 140
 141 /*
 142  * Loop until the Write State machine is ready, then do a full error
 143  * check.  Clear status and leave the flash in Read Array mode; return
 144  * 0 for no error, -1 for error.
 145  */
 146 static int flash_status_full_check (unsigned long addr, unsigned short value1,
 147                                     unsigned short value2)
 148 {
 149         unsigned short status1, status2;
 150
 151         status1 = flash_status_wait (addr, value1);
 152         status2 = flash_status_wait (addr + 2, value2);
 153         return (status1 != value1 || status2 != value2) ? -1 : 0;
 154 }
 155
 156 /*-----------------------------------------------------------------------
 157  */
 158
 159 int flash_erase (flash_info_t * info, int s_first, int s_last)
 160 {
 161         int flag, prot, sect;
 162         int rc = ERR_OK;
 163         unsigned long base;
 164         unsigned long addr;
 165         ulong start;
 166
 167         if ((info->flash_id & FLASH_VENDMASK) !=
 168             (FUJ_MANUFACT & FLASH_VENDMASK)) {
 169                 return ERR_UNKNOWN_FLASH_VENDOR;
 170         }
 171
 172         prot = 0;
 173         for (sect = s_first; sect <= s_last; ++sect) {
 174                 if (info->protect[sect]) {
 175                         prot++;
 176                 }
 177         }
 178         if (prot)
 179                 return ERR_PROTECTED;
 180
 181         /*
 182          * Disable interrupts which might cause a timeout
 183          * here. Remember that our exception vectors are
 184          * at address 0 in the flash, and we don't want a
 185          * (ticker) exception to happen while the flash
 186          * chip is in programming mode.
 187          */
 188         flag = disable_interrupts ();
 189
 190         printf ("Erasing %d sectors starting at sector %2d.\n"
 191                 "This make take some time ... ",
 192                 s_last - s_first, sect);
 193         /* Start erase on unprotected sectors */
 194         for (sect = s_first; sect <= s_last && !ctrlc (); sect++) {
 195                 /* ARM simple, non interrupt dependent timer */
 196                 start = get_timer(0);
 197
 198                 if (info->protect[sect] == 0) { /* not protected */
 199
 200                         addr = sect * MAIN_SECT_SIZE;
 201                         addr &= ~(unsigned long) UNALIGNED_MASK;        /* word align */
 202                         base = addr & 0xF0000000;
 203
 204                         FL_WORD (base + (0x555 << 1)) = 0xAA;
 205                         FL_WORD (base + (0x2AA << 1)) = 0x55;
 206                         FL_WORD (base + (0x555 << 1)) = 0x80;
 207                         FL_WORD (base + (0x555 << 1)) = 0xAA;
 208                         FL_WORD (base + (0x2AA << 1)) = 0x55;
 209                         FL_WORD (addr) = 0x30;
 210                         if (flash_status_full_check (addr, 0xFFFF, 0xFFFF))
 211                                 return ERR_PROTECTED;
 212                 }
 213         }
 214         printf ("\nDone.\n");
 215         if (ctrlc ())
 216                 printf ("User Interrupt!\n");
 217
 218         /* allow flash to settle - wait 10 ms */
 219         udelay_masked (10000);
 220
 221         if (flag)
 222                 enable_interrupts ();
 223
 224         return rc;
 225 }
 226
 227
 228 /*-----------------------------------------------------------------------
 229  * Copy memory to flash
 230  */
 231
 232 static int write_word (flash_info_t * info, ulong dest, ushort data)
 233 {
 234         int flag;
 235         unsigned long base;
 236         ulong start;
 237
 238         /* Check if Flash is (sufficiently) erased
 239          */
 240         if ((FL_WORD (dest) & data) != data)
 241                 return ERR_NOT_ERASED;
 242
 243         /*if(dest & UNALIGNED_MASK) return ERR_ALIGN; */
 244
 245         /*
 246          * Disable interrupts which might cause a timeout
 247          * here. Remember that our exception vectors are
 248          * at address 0 in the flash, and we don't want a
 249          * (ticker) exception to happen while the flash
 250          * chip is in programming mode.
 251          */
 252         flag = disable_interrupts ();
 253
 254         /* arm simple, non interrupt dependent timer */
 255         start = get_timer(0);
 256
 257         base = dest & 0xF0000000;
 258         FL_WORD (base + (0x555 << 1)) = 0xAA;
 259         FL_WORD (base + (0x2AA << 1)) = 0x55;
 260         FL_WORD (base + (0x555 << 1)) = 0xA0;
 261         FL_WORD (dest) = data;
 262         /*printf("writing 0x%p = 0x%x\n",dest,data); */
 263         if (flash_status_wait (dest, data) != data)
 264                 return ERR_PROG_ERROR;
 265
 266         if (flag)
 267                 enable_interrupts ();
 268
 269         return ERR_OK;
 270 }
 271
 272 /*-----------------------------------------------------------------------
 273  * Copy memory to flash.
 274  */
 275
 276 int write_buff (flash_info_t * info, uchar * src, ulong addr, ulong cnt)
 277 {
 278         ulong cp, wp;
 279         ushort data;
 280         int l;
 281         int i, rc;
 282
 283         wp = (addr & ~1);       /* get lower word aligned address */
 284         printf ("Writing %lu short data to 0x%lx from 0x%p.\n ", cnt, wp, src);
 285
 286         /*
 287          * handle unaligned start bytes
 288          */
 289         if ((l = addr - wp) != 0) {
 290                 data = 0;
 291                 for (i = 0, cp = wp; i < l; ++i, ++cp) {
 292                         data = (data >> 8) | (*(uchar *) cp << 8);
 293                 }
 294                 for (; i < 2 && cnt > 0; ++i) {
 295                         data = (data >> 8) | (*src++ << 8);
 296                         --cnt;
 297                         ++cp;
 298                 }
 299                 for (; cnt == 0 && i < 2; ++i, ++cp) {
 300                         data = (data >> 8) | (*(uchar *) cp << 8);
 301                 }
 302
 303                 if ((rc = write_word (info, wp, data)) != 0) {
 304                         return (rc);
 305                 }
 306                 wp += 2;
 307         }
 308
 309         /*
 310          * handle word aligned part
 311          */
 312         while (cnt >= 2) {
 313                 data = *((vu_short *) src);
 314                 if ((rc = write_word (info, wp, data)) != 0) {
 315                         return (rc);
 316                 }
 317                 src += 2;
 318                 wp += 2;
 319                 cnt -= 2;
 320         }
 321
 322         if (cnt == 0) {
 323                 printf ("\nDone.\n");
 324                 return ERR_OK;
 325         }
 326
 327         /*
 328          * handle unaligned tail bytes
 329          */
 330         data = 0;
 331         for (i = 0, cp = wp; i < 2 && cnt > 0; ++i, ++cp) {
 332                 data = (data >> 8) | (*src++ << 8);
 333                 --cnt;
 334         }
 335         for (; i < 2; ++i, ++cp) {
 336                 data = (data >> 8) | (*(uchar *) cp << 8);
 337         }
 338
 339         return write_word (info, wp, data);
 340 }