common/cmd_flash.c

   1 /*
   2  * (C) Copyright 2000
   3  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
   4  *
   5  * See file CREDITS for list of people who contributed to this
   6  * project.
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU General Public License as
  10  * published by the Free Software Foundation; either version 2 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21  * MA 02111-1307 USA
  22  */
  23
  24 /*
  25  * FLASH support
  26  */
  27 #include <common.h>
  28 #include <command.h>
  29
  30
  31 #ifdef CONFIG_HAS_DATAFLASH
  32 #include <dataflash.h>
  33 #endif
  34
  35 #if (CONFIG_COMMANDS & CFG_CMD_FLASH)
  36
  37 extern flash_info_t flash_info[];       /* info for FLASH chips */
  38
  39 /*
  40  * The user interface starts numbering for Flash banks with 1
  41  * for historical reasons.
  42  */
  43
  44 /*
  45  * this routine looks for an abbreviated flash range specification.
  46  * the syntax is B:SF[-SL], where B is the bank number, SF is the first
  47  * sector to erase, and SL is the last sector to erase (defaults to SF).
  48  * bank numbers start at 1 to be consistent with other specs, sector numbers
  49  * start at zero.
  50  *
  51  * returns:     1       - correct spec; *pinfo, *psf and *psl are
  52  *                        set appropriately
  53  *              0       - doesn't look like an abbreviated spec
  54  *              -1      - looks like an abbreviated spec, but got
  55  *                        a parsing error, a number out of range,
  56  *                        or an invalid flash bank.
  57  */
  58 static int
  59 abbrev_spec (char *str, flash_info_t ** pinfo, int *psf, int *psl)
  60 {
  61         flash_info_t *fp;
  62         int bank, first, last;
  63         char *p, *ep;
  64
  65         if ((p = strchr (str, ':')) == NULL)
  66                 return 0;
  67         *p++ = '\0';
  68
  69         bank = simple_strtoul (str, &ep, 10);
  70         if (ep == str || *ep != '\0' ||
  71                 bank < 1 || bank > CFG_MAX_FLASH_BANKS ||
  72                 (fp = &flash_info[bank - 1])->flash_id == FLASH_UNKNOWN)
  73                 return -1;
  74
  75         str = p;
  76         if ((p = strchr (str, '-')) != NULL)
  77                 *p++ = '\0';
  78
  79         first = simple_strtoul (str, &ep, 10);
  80         if (ep == str || *ep != '\0' || first >= fp->sector_count)
  81                 return -1;
  82
  83         if (p != NULL) {
  84                 last = simple_strtoul (p, &ep, 10);
  85                 if (ep == p || *ep != '\0' ||
  86                         last < first || last >= fp->sector_count)
  87                         return -1;
  88         } else {
  89                 last = first;
  90         }
  91
  92         *pinfo = fp;
  93         *psf = first;
  94         *psl = last;
  95
  96         return 1;
  97 }
  98
  99 static int
 100 flash_fill_sect_ranges (ulong addr_first, ulong addr_last,
 101                         int *s_first, int *s_last,
 102                         int *s_count )
 103 {
 104         flash_info_t *info;
 105         ulong bank;
 106         int rcode = 0;
 107
 108         *s_count = 0;
 109
 110         for (bank=0; bank < CFG_MAX_FLASH_BANKS; ++bank) {
 111                 s_first[bank] = -1;     /* first sector to erase        */
 112                 s_last [bank] = -1;     /* last  sector to erase        */
 113         }
 114
 115         for (bank=0,info=&flash_info[0];
 116              (bank < CFG_MAX_FLASH_BANKS) && (addr_first <= addr_last);
 117              ++bank, ++info) {
 118                 ulong b_end;
 119                 int sect;
 120                 short s_end;
 121
 122                 if (info->flash_id == FLASH_UNKNOWN) {
 123                         continue;
 124                 }
 125
 126                 b_end = info->start[0] + info->size - 1;        /* bank end addr */
 127                 s_end = info->sector_count - 1;                 /* last sector   */
 128
 129
 130                 for (sect=0; sect < info->sector_count; ++sect) {
 131                         ulong end;      /* last address in current sect */
 132
 133                         end = (sect == s_end) ? b_end : info->start[sect + 1] - 1;
 134
 135                         if (addr_first > end)
 136                                 continue;
 137                         if (addr_last < info->start[sect])
 138                                 continue;
 139
 140                         if (addr_first == info->start[sect]) {
 141                                 s_first[bank] = sect;
 142                         }
 143                         if (addr_last  == end) {
 144                                 s_last[bank]  = sect;
 145                         }
 146                 }
 147                 if (s_first[bank] >= 0) {
 148                         if (s_last[bank] < 0) {
 149                                 if (addr_last > b_end) {
 150                                         s_last[bank] = s_end;
 151                                 } else {
 152                                         printf ("Error: end address"
 153                                                 " not on sector boundary\n");
 154                                         rcode = 1;
 155                                         break;
 156                                 }
 157                         }
 158                         if (s_last[bank] < s_first[bank]) {
 159                                 printf ("Error: end sector"
 160                                         " precedes start sector\n");
 161                                 rcode = 1;
 162                                 break;
 163                         }
 164                         sect = s_last[bank];
 165                         addr_first = (sect == s_end) ? b_end + 1: info->start[sect + 1];
 166                         (*s_count) += s_last[bank] - s_first[bank] + 1;
 167                 } else if (s_last[bank] >= 0) {
 168                         printf("Error: cannot span across banks when they are"
 169                                " mapped in reverse order\n");
 170                         rcode = 1;
 171                         break;
 172                 }
 173         }
 174
 175         return rcode;
 176 }
 177
 178 int do_flinfo ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 179 {
 180         ulong bank;
 181
 182 #ifdef CONFIG_HAS_DATAFLASH
 183         dataflash_print_info();
 184 #endif
 185
 186         if (argc == 1) {        /* print info for all FLASH banks */
 187                 for (bank=0; bank <CFG_MAX_FLASH_BANKS; ++bank) {
 188                         printf ("\nBank # %ld: ", bank+1);
 189
 190                         flash_print_info (&flash_info[bank]);
 191                 }
 192                 return 0;
 193         }
 194
 195         bank = simple_strtoul(argv[1], NULL, 16);
 196         if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS)) {
 197                 printf ("Only FLASH Banks # 1 ... # %d supported\n",
 198                         CFG_MAX_FLASH_BANKS);
 199                 return 1;
 200         }
 201         printf ("\nBank # %ld: ", bank);
 202         flash_print_info (&flash_info[bank-1]);
 203         return 0;
 204 }
 205 int do_flerase (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 206 {
 207         flash_info_t *info;
 208         ulong bank, addr_first, addr_last;
 209         int n, sect_first, sect_last;
 210         int rcode = 0;
 211
 212         if (argc < 2) {
 213                 printf ("Usage:\n%s\n", cmdtp->usage);
 214                 return 1;
 215         }
 216
 217         if (strcmp(argv[1], "all") == 0) {
 218                 for (bank=1; bank<=CFG_MAX_FLASH_BANKS; ++bank) {
 219                         printf ("Erase Flash Bank # %ld ", bank);
 220                         info = &flash_info[bank-1];
 221                         rcode = flash_erase (info, 0, info->sector_count-1);
 222                 }
 223                 return rcode;
 224         }
 225
 226         if ((n = abbrev_spec(argv[1], &info, &sect_first, &sect_last)) != 0) {
 227                 if (n < 0) {
 228                         printf("Bad sector specification\n");
 229                         return 1;
 230                 }
 231                 printf ("Erase Flash Sectors %d-%d in Bank # %d ",
 232                         sect_first, sect_last, (info-flash_info)+1);
 233                 rcode = flash_erase(info, sect_first, sect_last);
 234                 return rcode;
 235         }
 236
 237         if (argc != 3) {
 238                 printf ("Usage:\n%s\n", cmdtp->usage);
 239                 return 1;
 240         }
 241
 242         if (strcmp(argv[1], "bank") == 0) {
 243                 bank = simple_strtoul(argv[2], NULL, 16);
 244                 if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS)) {
 245                         printf ("Only FLASH Banks # 1 ... # %d supported\n",
 246                                 CFG_MAX_FLASH_BANKS);
 247                         return 1;
 248                 }
 249                 printf ("Erase Flash Bank # %ld ", bank);
 250                 info = &flash_info[bank-1];
 251                 rcode = flash_erase (info, 0, info->sector_count-1);
 252                 return rcode;
 253         }
 254
 255         addr_first = simple_strtoul(argv[1], NULL, 16);
 256         addr_last  = simple_strtoul(argv[2], NULL, 16);
 257
 258         if (addr_first >= addr_last) {
 259                 printf ("Usage:\n%s\n", cmdtp->usage);
 260                 return 1;
 261         }
 262
 263         rcode = flash_sect_erase(addr_first, addr_last);
 264         return rcode;
 265 }
 266
 267 int flash_sect_erase (ulong addr_first, ulong addr_last)
 268 {
 269         flash_info_t *info;
 270         ulong bank;
 271         int s_first[CFG_MAX_FLASH_BANKS], s_last[CFG_MAX_FLASH_BANKS];
 272         int erased = 0;
 273         int planned;
 274         int rcode = 0;
 275
 276         rcode = flash_fill_sect_ranges (addr_first, addr_last,
 277                                         s_first, s_last, &planned );
 278
 279         if (planned && (rcode == 0)) {
 280                 for (bank=0,info=&flash_info[0];
 281                      (bank < CFG_MAX_FLASH_BANKS) && (rcode == 0);
 282                      ++bank, ++info) {
 283                         if (s_first[bank]>=0) {
 284                                 erased += s_last[bank] - s_first[bank] + 1;
 285                                 debug ("Erase Flash from 0x%08lx to 0x%08lx "
 286                                         "in Bank # %ld ",
 287                                         info->start[s_first[bank]],
 288                                         (s_last[bank] == info->sector_count) ?
 289                                                 info->start[0] + info->size - 1:
 290                                                 info->start[s_last[bank]+1] - 1,
 291                                         bank+1);
 292                                 rcode = flash_erase (info, s_first[bank], s_last[bank]);
 293                         }
 294                 }
 295                 printf ("Erased %d sectors\n", erased);
 296         } else if (rcode == 0) {
 297                 printf ("Error: start and/or end address"
 298                         " not on sector boundary\n");
 299                 rcode = 1;
 300         }
 301         return rcode;
 302 }
 303
 304 int do_protect (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 305 {
 306         flash_info_t *info;
 307         ulong bank, addr_first, addr_last;
 308         int i, p, n, sect_first, sect_last;
 309         int rcode = 0;
 310
 311         if (argc < 3) {
 312                 printf ("Usage:\n%s\n", cmdtp->usage);
 313                 return 1;
 314         }
 315
 316         if (strcmp(argv[1], "off") == 0) {
 317                 p = 0;
 318         } else if (strcmp(argv[1], "on") == 0) {
 319                 p = 1;
 320         } else {
 321                 printf ("Usage:\n%s\n", cmdtp->usage);
 322                 return 1;
 323         }
 324
 325         if (strcmp(argv[2], "all") == 0) {
 326                 for (bank=1; bank<=CFG_MAX_FLASH_BANKS; ++bank) {
 327                         info = &flash_info[bank-1];
 328                         if (info->flash_id == FLASH_UNKNOWN) {
 329                                 continue;
 330                         }
 331                         printf ("%sProtect Flash Bank # %ld\n",
 332                                 p ? "" : "Un-", bank);
 333
 334                         for (i=0; i<info->sector_count; ++i) {
 335 #if defined(CFG_FLASH_PROTECTION)
 336                                 if (flash_real_protect(info, i, p))
 337                                         rcode = 1;
 338                                 putc ('.');
 339 #else
 340                                 info->protect[i] = p;
 341 #endif  /* CFG_FLASH_PROTECTION */
 342                         }
 343                 }
 344
 345 #if defined(CFG_FLASH_PROTECTION)
 346                 if (!rcode) puts (" done\n");
 347 #endif  /* CFG_FLASH_PROTECTION */
 348
 349                 return rcode;
 350         }
 351
 352         if ((n = abbrev_spec(argv[2], &info, &sect_first, &sect_last)) != 0) {
 353                 if (n < 0) {
 354                         printf("Bad sector specification\n");
 355                         return 1;
 356                 }
 357                 printf("%sProtect Flash Sectors %d-%d in Bank # %d\n",
 358                         p ? "" : "Un-", sect_first, sect_last,
 359                         (info-flash_info)+1);
 360                 for (i = sect_first; i <= sect_last; i++) {
 361 #if defined(CFG_FLASH_PROTECTION)
 362                         if (flash_real_protect(info, i, p))
 363                                 rcode =  1;
 364                         putc ('.');
 365 #else
 366                         info->protect[i] = p;
 367 #endif  /* CFG_FLASH_PROTECTION */
 368                 }
 369
 370 #if defined(CFG_FLASH_PROTECTION)
 371                 if (!rcode) puts (" done\n");
 372 #endif  /* CFG_FLASH_PROTECTION */
 373
 374                 return rcode;
 375         }
 376
 377         if (argc != 4) {
 378                 printf ("Usage:\n%s\n", cmdtp->usage);
 379                 return 1;
 380         }
 381
 382         if (strcmp(argv[2], "bank") == 0) {
 383                 bank = simple_strtoul(argv[3], NULL, 16);
 384                 if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS)) {
 385                         printf ("Only FLASH Banks # 1 ... # %d supported\n",
 386                                 CFG_MAX_FLASH_BANKS);
 387                         return 1;
 388                 }
 389                 printf ("%sProtect Flash Bank # %ld\n",
 390                         p ? "" : "Un-", bank);
 391                 info = &flash_info[bank-1];
 392
 393                 if (info->flash_id == FLASH_UNKNOWN) {
 394                         printf ("missing or unknown FLASH type\n");
 395                         return 1;
 396                 }
 397                 for (i=0; i<info->sector_count; ++i) {
 398 #if defined(CFG_FLASH_PROTECTION)
 399                         if (flash_real_protect(info, i, p))
 400                                 rcode =  1;
 401                         putc ('.');
 402 #else
 403                         info->protect[i] = p;
 404 #endif  /* CFG_FLASH_PROTECTION */
 405                 }
 406
 407 #if defined(CFG_FLASH_PROTECTION)
 408                 if (!rcode) puts (" done\n");
 409 #endif  /* CFG_FLASH_PROTECTION */
 410
 411                 return rcode;
 412         }
 413
 414         addr_first = simple_strtoul(argv[2], NULL, 16);
 415         addr_last  = simple_strtoul(argv[3], NULL, 16);
 416
 417         if (addr_first >= addr_last) {
 418                 printf ("Usage:\n%s\n", cmdtp->usage);
 419                 return 1;
 420         }
 421         rcode = flash_sect_protect (p, addr_first, addr_last);
 422         return rcode;
 423 }
 424
 425
 426 int flash_sect_protect (int p, ulong addr_first, ulong addr_last)
 427 {
 428         flash_info_t *info;
 429         ulong bank;
 430         int s_first[CFG_MAX_FLASH_BANKS], s_last[CFG_MAX_FLASH_BANKS];
 431         int protected, i;
 432         int planned;
 433         int rcode;
 434
 435         rcode = flash_fill_sect_ranges( addr_first, addr_last, s_first, s_last, &planned );
 436
 437         protected = 0;
 438
 439         if (planned && (rcode == 0)) {
 440                 for (bank=0,info=&flash_info[0]; bank < CFG_MAX_FLASH_BANKS; ++bank, ++info) {
 441                         if (info->flash_id == FLASH_UNKNOWN) {
 442                                 continue;
 443                         }
 444
 445                         if (s_first[bank]>=0 && s_first[bank]<=s_last[bank]) {
 446                                 debug ("Protecting sectors %d..%d in bank %ld\n",
 447                                         s_first[bank], s_last[bank], bank+1);
 448                                 protected += s_last[bank] - s_first[bank] + 1;
 449                                 for (i=s_first[bank]; i<=s_last[bank]; ++i) {
 450 #if defined(CFG_FLASH_PROTECTION)
 451                                         if (flash_real_protect(info, i, p))
 452                                                 rcode = 1;
 453                                         putc ('.');
 454 #else
 455                                         info->protect[i] = p;
 456 #endif  /* CFG_FLASH_PROTECTION */
 457                                 }
 458                         }
 459 #if defined(CFG_FLASH_PROTECTION)
 460                         if (!rcode) putc ('\n');
 461 #endif  /* CFG_FLASH_PROTECTION */
 462                 }
 463
 464                 printf ("%sProtected %d sectors\n",
 465                         p ? "" : "Un-", protected);
 466         } else if (rcode == 0) {
 467                 printf ("Error: start and/or end address"
 468                         " not on sector boundary\n");
 469                 rcode = 1;
 470         }
 471         return rcode;
 472 }
 473
 474
 475 /**************************************************/
 476
 477 U_BOOT_CMD(
 478         flinfo,    2,    1,    do_flinfo,
 479         "flinfo  - print FLASH memory information\n",
 480         "\n    - print information for all FLASH memory banks\n"
 481         "flinfo N\n    - print information for FLASH memory bank # N\n"
 482 );
 483
 484 U_BOOT_CMD(
 485         erase,   3,   1,  do_flerase,
 486         "erase   - erase FLASH memory\n",
 487         "start end\n"
 488         "    - erase FLASH from addr 'start' to addr 'end'\n"
 489         "erase N:SF[-SL]\n    - erase sectors SF-SL in FLASH bank # N\n"
 490         "erase bank N\n    - erase FLASH bank # N\n"
 491         "erase all\n    - erase all FLASH banks\n"
 492 );
 493
 494 U_BOOT_CMD(
 495         protect,  4,  1,   do_protect,
 496         "protect - enable or disable FLASH write protection\n",
 497         "on  start end\n"
 498         "    - protect FLASH from addr 'start' to addr 'end'\n"
 499         "protect on  N:SF[-SL]\n"
 500         "    - protect sectors SF-SL in FLASH bank # N\n"
 501         "protect on  bank N\n    - protect FLASH bank # N\n"
 502         "protect on  all\n    - protect all FLASH banks\n"
 503         "protect off start end\n"
 504         "    - make FLASH from addr 'start' to addr 'end' writable\n"
 505         "protect off N:SF[-SL]\n"
 506         "    - make sectors SF-SL writable in FLASH bank # N\n"
 507         "protect off bank N\n    - make FLASH bank # N writable\n"
 508         "protect off all\n    - make all FLASH banks writable\n"
 509 );
 510
 511 #endif  /* CFG_CMD_FLASH */