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 #ifdef CONFIG_HAS_DATAFLASH
  31 #include <dataflash.h>
  32 #endif
  33
  34 #if (CONFIG_COMMANDS & CFG_CMD_FLASH)
  35
  36 #if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
  37 #include <jffs2/jffs2.h>
  38
  39 /* parition handling routines */
  40 int mtdparts_init(void);
  41 int id_parse(const char *id, const char **ret_id, u8 *dev_type, u8 *dev_num);
  42 int find_dev_and_part(const char *id, struct mtd_device **dev,
  43                 u8 *part_num, struct part_info **part);
  44 #endif
  45
  46 extern flash_info_t flash_info[];       /* info for FLASH chips */
  47
  48 /*
  49  * The user interface starts numbering for Flash banks with 1
  50  * for historical reasons.
  51  */
  52
  53 /*
  54  * this routine looks for an abbreviated flash range specification.
  55  * the syntax is B:SF[-SL], where B is the bank number, SF is the first
  56  * sector to erase, and SL is the last sector to erase (defaults to SF).
  57  * bank numbers start at 1 to be consistent with other specs, sector numbers
  58  * start at zero.
  59  *
  60  * returns:     1       - correct spec; *pinfo, *psf and *psl are
  61  *                        set appropriately
  62  *              0       - doesn't look like an abbreviated spec
  63  *              -1      - looks like an abbreviated spec, but got
  64  *                        a parsing error, a number out of range,
  65  *                        or an invalid flash bank.
  66  */
  67 static int
  68 abbrev_spec (char *str, flash_info_t ** pinfo, int *psf, int *psl)
  69 {
  70         flash_info_t *fp;
  71         int bank, first, last;
  72         char *p, *ep;
  73
  74         if ((p = strchr (str, ':')) == NULL)
  75                 return 0;
  76         *p++ = '\0';
  77
  78         bank = simple_strtoul (str, &ep, 10);
  79         if (ep == str || *ep != '\0' ||
  80                 bank < 1 || bank > CFG_MAX_FLASH_BANKS ||
  81                 (fp = &flash_info[bank - 1])->flash_id == FLASH_UNKNOWN)
  82                 return -1;
  83
  84         str = p;
  85         if ((p = strchr (str, '-')) != NULL)
  86                 *p++ = '\0';
  87
  88         first = simple_strtoul (str, &ep, 10);
  89         if (ep == str || *ep != '\0' || first >= fp->sector_count)
  90                 return -1;
  91
  92         if (p != NULL) {
  93                 last = simple_strtoul (p, &ep, 10);
  94                 if (ep == p || *ep != '\0' ||
  95                         last < first || last >= fp->sector_count)
  96                         return -1;
  97         } else {
  98                 last = first;
  99         }
 100
 101         *pinfo = fp;
 102         *psf = first;
 103         *psl = last;
 104
 105         return 1;
 106 }
 107
 108 /*
 109  * This function computes the start and end addresses for both
 110  * erase and protect commands. The range of the addresses on which
 111  * either of the commands is to operate can be given in two forms:
 112  * 1. <cmd> start end - operate on <'start',  'end')
 113  * 2. <cmd> start +length - operate on <'start', start + length)
 114  * If the second form is used and the end address doesn't fall on the
 115  * sector boundary, than it will be adjusted to the next sector boundary.
 116  * If it isn't in the flash, the function will fail (return -1).
 117  * Input:
 118  *    arg1, arg2: address specification (i.e. both command arguments)
 119  * Output:
 120  *    addr_first, addr_last: computed address range
 121  * Return:
 122  *    1: success
 123  *   -1: failure (bad format, bad address).
 124 */
 125 static int
 126 addr_spec(char *arg1, char *arg2, ulong *addr_first, ulong *addr_last)
 127 {
 128         char len_used = 0; /* indicates if the "start +length" form used */
 129         char *ep;
 130
 131         *addr_first = simple_strtoul(arg1, &ep, 16);
 132         if (ep == arg1 || *ep != '\0')
 133                 return -1;
 134
 135         if (arg2 && *arg2 == '+'){
 136                 len_used = 1;
 137                 ++arg2;
 138         }
 139
 140         *addr_last = simple_strtoul(arg2, &ep, 16);
 141         if (ep == arg2 || *ep != '\0')
 142                 return -1;
 143
 144         if (len_used){
 145                 char found = 0;
 146                 ulong bank;
 147
 148                 /*
 149                  * *addr_last has the length, compute correct *addr_last
 150                  * XXX watch out for the integer overflow! Right now it is
 151                  * checked for in both the callers.
 152                  */
 153                 *addr_last = *addr_first + *addr_last - 1;
 154
 155                 /*
 156                  * It may happen that *addr_last doesn't fall on the sector
 157                  * boundary. We want to round such an address to the next
 158                  * sector boundary, so that the commands don't fail later on.
 159                  */
 160
 161                 /* find the end addr of the sector where the *addr_last is */
 162                 for (bank = 0; bank < CFG_MAX_FLASH_BANKS && !found; ++bank){
 163                         int i;
 164                         flash_info_t *info = &flash_info[bank];
 165                         for (i = 0; i < info->sector_count && !found; ++i){
 166                                 /* get the end address of the sector */
 167                                 ulong sector_end_addr;
 168                                 if (i == info->sector_count - 1){
 169                                         sector_end_addr =
 170                                                 info->start[0] + info->size - 1;
 171                                 } else {
 172                                         sector_end_addr =
 173                                                 info->start[i+1] - 1;
 174                                 }
 175                                 if (*addr_last <= sector_end_addr &&
 176                                                 *addr_last >= info->start[i]){
 177                                         /* sector found */
 178                                         found = 1;
 179                                         /* adjust *addr_last if necessary */
 180                                         if (*addr_last < sector_end_addr){
 181                                                 *addr_last = sector_end_addr;
 182                                         }
 183                                 }
 184                         } /* sector */
 185                 } /* bank */
 186                 if (!found){
 187                         /* error, addres not in flash */
 188                         printf("Error: end address (0x%08lx) not in flash!\n",
 189                                                                 *addr_last);
 190                         return -1;
 191                 }
 192         } /* "start +length" from used */
 193
 194         return 1;
 195 }
 196
 197 static int
 198 flash_fill_sect_ranges (ulong addr_first, ulong addr_last,
 199                         int *s_first, int *s_last,
 200                         int *s_count )
 201 {
 202         flash_info_t *info;
 203         ulong bank;
 204         int rcode = 0;
 205
 206         *s_count = 0;
 207
 208         for (bank=0; bank < CFG_MAX_FLASH_BANKS; ++bank) {
 209                 s_first[bank] = -1;     /* first sector to erase        */
 210                 s_last [bank] = -1;     /* last  sector to erase        */
 211         }
 212
 213         for (bank=0,info=&flash_info[0];
 214              (bank < CFG_MAX_FLASH_BANKS) && (addr_first <= addr_last);
 215              ++bank, ++info) {
 216                 ulong b_end;
 217                 int sect;
 218                 short s_end;
 219
 220                 if (info->flash_id == FLASH_UNKNOWN) {
 221                         continue;
 222                 }
 223
 224                 b_end = info->start[0] + info->size - 1;        /* bank end addr */
 225                 s_end = info->sector_count - 1;                 /* last sector   */
 226
 227
 228                 for (sect=0; sect < info->sector_count; ++sect) {
 229                         ulong end;      /* last address in current sect */
 230
 231                         end = (sect == s_end) ? b_end : info->start[sect + 1] - 1;
 232
 233                         if (addr_first > end)
 234                                 continue;
 235                         if (addr_last < info->start[sect])
 236                                 continue;
 237
 238                         if (addr_first == info->start[sect]) {
 239                                 s_first[bank] = sect;
 240                         }
 241                         if (addr_last  == end) {
 242                                 s_last[bank]  = sect;
 243                         }
 244                 }
 245                 if (s_first[bank] >= 0) {
 246                         if (s_last[bank] < 0) {
 247                                 if (addr_last > b_end) {
 248                                         s_last[bank] = s_end;
 249                                 } else {
 250                                         puts ("Error: end address"
 251                                                 " not on sector boundary\n");
 252                                         rcode = 1;
 253                                         break;
 254                                 }
 255                         }
 256                         if (s_last[bank] < s_first[bank]) {
 257                                 puts ("Error: end sector"
 258                                         " precedes start sector\n");
 259                                 rcode = 1;
 260                                 break;
 261                         }
 262                         sect = s_last[bank];
 263                         addr_first = (sect == s_end) ? b_end + 1: info->start[sect + 1];
 264                         (*s_count) += s_last[bank] - s_first[bank] + 1;
 265                 } else if (addr_first >= info->start[0] && addr_first < b_end) {
 266                         puts ("Error: start address not on sector boundary\n");
 267                         rcode = 1;
 268                         break;
 269                 } else if (s_last[bank] >= 0) {
 270                         puts ("Error: cannot span across banks when they are"
 271                                " mapped in reverse order\n");
 272                         rcode = 1;
 273                         break;
 274                 }
 275         }
 276
 277         return rcode;
 278 }
 279
 280 int do_flinfo ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 281 {
 282         ulong bank;
 283
 284 #ifdef CONFIG_HAS_DATAFLASH
 285         dataflash_print_info();
 286 #endif
 287
 288         if (argc == 1) {        /* print info for all FLASH banks */
 289                 for (bank=0; bank <CFG_MAX_FLASH_BANKS; ++bank) {
 290                         printf ("\nBank # %ld: ", bank+1);
 291
 292                         flash_print_info (&flash_info[bank]);
 293                 }
 294                 return 0;
 295         }
 296
 297         bank = simple_strtoul(argv[1], NULL, 16);
 298         if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS)) {
 299                 printf ("Only FLASH Banks # 1 ... # %d supported\n",
 300                         CFG_MAX_FLASH_BANKS);
 301                 return 1;
 302         }
 303         printf ("\nBank # %ld: ", bank);
 304         flash_print_info (&flash_info[bank-1]);
 305         return 0;
 306 }
 307
 308 int do_flerase (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 309 {
 310         flash_info_t *info;
 311         ulong bank, addr_first, addr_last;
 312         int n, sect_first, sect_last;
 313 #if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
 314         struct mtd_device *dev;
 315         struct part_info *part;
 316         u8 dev_type, dev_num, pnum;
 317 #endif
 318         int rcode = 0;
 319
 320         if (argc < 2) {
 321                 printf ("Usage:\n%s\n", cmdtp->usage);
 322                 return 1;
 323         }
 324
 325         if (strcmp(argv[1], "all") == 0) {
 326                 for (bank=1; bank<=CFG_MAX_FLASH_BANKS; ++bank) {
 327                         printf ("Erase Flash Bank # %ld ", bank);
 328                         info = &flash_info[bank-1];
 329                         rcode = flash_erase (info, 0, info->sector_count-1);
 330                 }
 331                 return rcode;
 332         }
 333
 334         if ((n = abbrev_spec(argv[1], &info, &sect_first, &sect_last)) != 0) {
 335                 if (n < 0) {
 336                         puts ("Bad sector specification\n");
 337                         return 1;
 338                 }
 339                 printf ("Erase Flash Sectors %d-%d in Bank # %d ",
 340                         sect_first, sect_last, (info-flash_info)+1);
 341                 rcode = flash_erase(info, sect_first, sect_last);
 342                 return rcode;
 343         }
 344
 345 #if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
 346         /* erase <part-id> - erase partition */
 347         if ((argc == 2) && (id_parse(argv[1], NULL, &dev_type, &dev_num) == 0)) {
 348                 mtdparts_init();
 349                 if (find_dev_and_part(argv[1], &dev, &pnum, &part) == 0) {
 350                         if (dev->id->type == MTD_DEV_TYPE_NOR) {
 351                                 bank = dev->id->num;
 352                                 info = &flash_info[bank];
 353                                 addr_first = part->offset + info->start[0];
 354                                 addr_last = addr_first + part->size - 1;
 355
 356                                 printf ("Erase Flash Parition %s, "
 357                                                 "bank %d, 0x%08lx - 0x%08lx ",
 358                                                 argv[1], bank, addr_first,
 359                                                 addr_last);
 360
 361                                 rcode = flash_sect_erase(addr_first, addr_last);
 362                                 return rcode;
 363                         }
 364
 365                         printf("cannot erase, not a NOR device\n");
 366                         return 1;
 367                 }
 368         }
 369 #endif
 370
 371         if (argc != 3) {
 372                 printf ("Usage:\n%s\n", cmdtp->usage);
 373                 return 1;
 374         }
 375
 376         if (strcmp(argv[1], "bank") == 0) {
 377                 bank = simple_strtoul(argv[2], NULL, 16);
 378                 if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS)) {
 379                         printf ("Only FLASH Banks # 1 ... # %d supported\n",
 380                                 CFG_MAX_FLASH_BANKS);
 381                         return 1;
 382                 }
 383                 printf ("Erase Flash Bank # %ld ", bank);
 384                 info = &flash_info[bank-1];
 385                 rcode = flash_erase (info, 0, info->sector_count-1);
 386                 return rcode;
 387         }
 388
 389         if (addr_spec(argv[1], argv[2], &addr_first, &addr_last) < 0){
 390                 printf ("Bad address format\n");
 391                 return 1;
 392         }
 393
 394         if (addr_first >= addr_last) {
 395                 printf ("Usage:\n%s\n", cmdtp->usage);
 396                 return 1;
 397         }
 398
 399         rcode = flash_sect_erase(addr_first, addr_last);
 400         return rcode;
 401 }
 402
 403 int flash_sect_erase (ulong addr_first, ulong addr_last)
 404 {
 405         flash_info_t *info;
 406         ulong bank;
 407 #ifdef CFG_MAX_FLASH_BANKS_DETECT
 408         int s_first[CFG_MAX_FLASH_BANKS_DETECT], s_last[CFG_MAX_FLASH_BANKS_DETECT];
 409 #else
 410         int s_first[CFG_MAX_FLASH_BANKS], s_last[CFG_MAX_FLASH_BANKS];
 411 #endif
 412         int erased = 0;
 413         int planned;
 414         int rcode = 0;
 415
 416         rcode = flash_fill_sect_ranges (addr_first, addr_last,
 417                                         s_first, s_last, &planned );
 418
 419         if (planned && (rcode == 0)) {
 420                 for (bank=0,info=&flash_info[0];
 421                      (bank < CFG_MAX_FLASH_BANKS) && (rcode == 0);
 422                      ++bank, ++info) {
 423                         if (s_first[bank]>=0) {
 424                                 erased += s_last[bank] - s_first[bank] + 1;
 425                                 debug ("Erase Flash from 0x%08lx to 0x%08lx "
 426                                         "in Bank # %ld ",
 427                                         info->start[s_first[bank]],
 428                                         (s_last[bank] == info->sector_count) ?
 429                                                 info->start[0] + info->size - 1:
 430                                                 info->start[s_last[bank]+1] - 1,
 431                                         bank+1);
 432                                 rcode = flash_erase (info, s_first[bank], s_last[bank]);
 433                         }
 434                 }
 435                 printf ("Erased %d sectors\n", erased);
 436         } else if (rcode == 0) {
 437                 puts ("Error: start and/or end address"
 438                         " not on sector boundary\n");
 439                 rcode = 1;
 440         }
 441         return rcode;
 442 }
 443
 444 int do_protect (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
 445 {
 446         flash_info_t *info;
 447         ulong bank, addr_first, addr_last;
 448         int i, p, n, sect_first, sect_last;
 449 #if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
 450         struct mtd_device *dev;
 451         struct part_info *part;
 452         u8 dev_type, dev_num, pnum;
 453 #endif
 454         int rcode = 0;
 455 #ifdef CONFIG_HAS_DATAFLASH
 456         int status;
 457 #endif
 458         if (argc < 3) {
 459                 printf ("Usage:\n%s\n", cmdtp->usage);
 460                 return 1;
 461         }
 462
 463         if (strcmp(argv[1], "off") == 0) {
 464                 p = 0;
 465         } else if (strcmp(argv[1], "on") == 0) {
 466                 p = 1;
 467         } else {
 468                 printf ("Usage:\n%s\n", cmdtp->usage);
 469                 return 1;
 470         }
 471
 472 #ifdef CONFIG_HAS_DATAFLASH
 473         if ((strcmp(argv[2], "all") != 0) && (strcmp(argv[2], "bank") != 0)) {
 474                 addr_first = simple_strtoul(argv[2], NULL, 16);
 475                 addr_last  = simple_strtoul(argv[3], NULL, 16);
 476
 477                 if (addr_dataflash(addr_first) && addr_dataflash(addr_last)) {
 478                         status = dataflash_real_protect(p,addr_first,addr_last);
 479                         if (status < 0){
 480                                 puts ("Bad DataFlash sector specification\n");
 481                                 return 1;
 482                         }
 483                         printf("%sProtect %d DataFlash Sectors\n",
 484                                 p ? "" : "Un-", status);
 485                         return 0;
 486                 }
 487         }
 488 #endif
 489
 490         if (strcmp(argv[2], "all") == 0) {
 491                 for (bank=1; bank<=CFG_MAX_FLASH_BANKS; ++bank) {
 492                         info = &flash_info[bank-1];
 493                         if (info->flash_id == FLASH_UNKNOWN) {
 494                                 continue;
 495                         }
 496                         printf ("%sProtect Flash Bank # %ld\n",
 497                                 p ? "" : "Un-", bank);
 498
 499                         for (i=0; i<info->sector_count; ++i) {
 500 #if defined(CFG_FLASH_PROTECTION)
 501                                 if (flash_real_protect(info, i, p))
 502                                         rcode = 1;
 503                                 putc ('.');
 504 #else
 505                                 info->protect[i] = p;
 506 #endif  /* CFG_FLASH_PROTECTION */
 507                         }
 508                 }
 509
 510 #if defined(CFG_FLASH_PROTECTION)
 511                 if (!rcode) puts (" done\n");
 512 #endif  /* CFG_FLASH_PROTECTION */
 513
 514                 return rcode;
 515         }
 516
 517         if ((n = abbrev_spec(argv[2], &info, &sect_first, &sect_last)) != 0) {
 518                 if (n < 0) {
 519                         puts ("Bad sector specification\n");
 520                         return 1;
 521                 }
 522                 printf("%sProtect Flash Sectors %d-%d in Bank # %d\n",
 523                         p ? "" : "Un-", sect_first, sect_last,
 524                         (info-flash_info)+1);
 525                 for (i = sect_first; i <= sect_last; i++) {
 526 #if defined(CFG_FLASH_PROTECTION)
 527                         if (flash_real_protect(info, i, p))
 528                                 rcode =  1;
 529                         putc ('.');
 530 #else
 531                         info->protect[i] = p;
 532 #endif  /* CFG_FLASH_PROTECTION */
 533                 }
 534
 535 #if defined(CFG_FLASH_PROTECTION)
 536                 if (!rcode) puts (" done\n");
 537 #endif  /* CFG_FLASH_PROTECTION */
 538
 539                 return rcode;
 540         }
 541
 542 #if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
 543         /* protect on/off <part-id> */
 544         if ((argc == 3) && (id_parse(argv[2], NULL, &dev_type, &dev_num) == 0)) {
 545                 mtdparts_init();
 546                 if (find_dev_and_part(argv[2], &dev, &pnum, &part) == 0) {
 547                         if (dev->id->type == MTD_DEV_TYPE_NOR) {
 548                                 bank = dev->id->num;
 549                                 info = &flash_info[bank];
 550                                 addr_first = part->offset + info->start[0];
 551                                 addr_last = addr_first + part->size - 1;
 552
 553                                 printf ("%sProtect Flash Parition %s, "
 554                                                 "bank %d, 0x%08lx - 0x%08lx\n",
 555                                                 p ? "" : "Un", argv[1],
 556                                                 bank, addr_first, addr_last);
 557
 558                                 rcode = flash_sect_protect (p, addr_first, addr_last);
 559                                 return rcode;
 560                         }
 561
 562                         printf("cannot %sprotect, not a NOR device\n",
 563                                         p ? "" : "un");
 564                         return 1;
 565                 }
 566         }
 567 #endif
 568
 569         if (argc != 4) {
 570                 printf ("Usage:\n%s\n", cmdtp->usage);
 571                 return 1;
 572         }
 573
 574         if (strcmp(argv[2], "bank") == 0) {
 575                 bank = simple_strtoul(argv[3], NULL, 16);
 576                 if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS)) {
 577                         printf ("Only FLASH Banks # 1 ... # %d supported\n",
 578                                 CFG_MAX_FLASH_BANKS);
 579                         return 1;
 580                 }
 581                 printf ("%sProtect Flash Bank # %ld\n",
 582                         p ? "" : "Un-", bank);
 583                 info = &flash_info[bank-1];
 584
 585                 if (info->flash_id == FLASH_UNKNOWN) {
 586                         puts ("missing or unknown FLASH type\n");
 587                         return 1;
 588                 }
 589                 for (i=0; i<info->sector_count; ++i) {
 590 #if defined(CFG_FLASH_PROTECTION)
 591                         if (flash_real_protect(info, i, p))
 592                                 rcode =  1;
 593                         putc ('.');
 594 #else
 595                         info->protect[i] = p;
 596 #endif  /* CFG_FLASH_PROTECTION */
 597                 }
 598
 599 #if defined(CFG_FLASH_PROTECTION)
 600                 if (!rcode) puts (" done\n");
 601 #endif  /* CFG_FLASH_PROTECTION */
 602
 603                 return rcode;
 604         }
 605
 606         if (addr_spec(argv[2], argv[3], &addr_first, &addr_last) < 0){
 607                 printf("Bad address format\n");
 608                 return 1;
 609         }
 610
 611         if (addr_first >= addr_last) {
 612                 printf ("Usage:\n%s\n", cmdtp->usage);
 613                 return 1;
 614         }
 615         rcode = flash_sect_protect (p, addr_first, addr_last);
 616         return rcode;
 617 }
 618
 619
 620 int flash_sect_protect (int p, ulong addr_first, ulong addr_last)
 621 {
 622         flash_info_t *info;
 623         ulong bank;
 624 #ifdef CFG_MAX_FLASH_BANKS_DETECT
 625         int s_first[CFG_MAX_FLASH_BANKS_DETECT], s_last[CFG_MAX_FLASH_BANKS_DETECT];
 626 #else
 627         int s_first[CFG_MAX_FLASH_BANKS], s_last[CFG_MAX_FLASH_BANKS];
 628 #endif
 629         int protected, i;
 630         int planned;
 631         int rcode;
 632
 633         rcode = flash_fill_sect_ranges( addr_first, addr_last, s_first, s_last, &planned );
 634
 635         protected = 0;
 636
 637         if (planned && (rcode == 0)) {
 638                 for (bank=0,info=&flash_info[0]; bank < CFG_MAX_FLASH_BANKS; ++bank, ++info) {
 639                         if (info->flash_id == FLASH_UNKNOWN) {
 640                                 continue;
 641                         }
 642
 643                         if (s_first[bank]>=0 && s_first[bank]<=s_last[bank]) {
 644                                 debug ("%sProtecting sectors %d..%d in bank %ld\n",
 645                                         p ? "" : "Un-",
 646                                         s_first[bank], s_last[bank], bank+1);
 647                                 protected += s_last[bank] - s_first[bank] + 1;
 648                                 for (i=s_first[bank]; i<=s_last[bank]; ++i) {
 649 #if defined(CFG_FLASH_PROTECTION)
 650                                         if (flash_real_protect(info, i, p))
 651                                                 rcode = 1;
 652                                         putc ('.');
 653 #else
 654                                         info->protect[i] = p;
 655 #endif  /* CFG_FLASH_PROTECTION */
 656                                 }
 657                         }
 658 #if defined(CFG_FLASH_PROTECTION)
 659                         if (!rcode) putc ('\n');
 660 #endif  /* CFG_FLASH_PROTECTION */
 661                 }
 662
 663                 printf ("%sProtected %d sectors\n",
 664                         p ? "" : "Un-", protected);
 665         } else if (rcode == 0) {
 666                 puts ("Error: start and/or end address"
 667                         " not on sector boundary\n");
 668                 rcode = 1;
 669         }
 670         return rcode;
 671 }
 672
 673
 674 /**************************************************/
 675 #if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
 676 # define TMP_ERASE      "erase <part-id>\n    - erase partition\n"
 677 # define TMP_PROT_ON    "protect on <part-id>\n    - protect partition\n"
 678 # define TMP_PROT_OFF   "protect off <part-id>\n    - make partition writable\n"
 679 #else
 680 # define TMP_ERASE      /* empty */
 681 # define TMP_PROT_ON    /* empty */
 682 # define TMP_PROT_OFF   /* empty */
 683 #endif
 684
 685 U_BOOT_CMD(
 686         flinfo,    2,    1,    do_flinfo,
 687         "flinfo  - print FLASH memory information\n",
 688         "\n    - print information for all FLASH memory banks\n"
 689         "flinfo N\n    - print information for FLASH memory bank # N\n"
 690 );
 691
 692 U_BOOT_CMD(
 693         erase,   3,   1,  do_flerase,
 694         "erase   - erase FLASH memory\n",
 695         "start end\n"
 696         "    - erase FLASH from addr 'start' to addr 'end'\n"
 697         "erase start +len\n"
 698         "    - erase FLASH from addr 'start' to the end of sect "
 699         "w/addr 'start'+'len'-1\n"
 700         "erase N:SF[-SL]\n    - erase sectors SF-SL in FLASH bank # N\n"
 701         "erase bank N\n    - erase FLASH bank # N\n"
 702         TMP_ERASE
 703         "erase all\n    - erase all FLASH banks\n"
 704 );
 705
 706 U_BOOT_CMD(
 707         protect,  4,  1,   do_protect,
 708         "protect - enable or disable FLASH write protection\n",
 709         "on  start end\n"
 710         "    - protect FLASH from addr 'start' to addr 'end'\n"
 711         "protect on start +len\n"
 712         "    - protect FLASH from addr 'start' to end of sect "
 713         "w/addr 'start'+'len'-1\n"
 714         "protect on  N:SF[-SL]\n"
 715         "    - protect sectors SF-SL in FLASH bank # N\n"
 716         "protect on  bank N\n    - protect FLASH bank # N\n"
 717         TMP_PROT_ON
 718         "protect on  all\n    - protect all FLASH banks\n"
 719         "protect off start end\n"
 720         "    - make FLASH from addr 'start' to addr 'end' writable\n"
 721         "protect off start +len\n"
 722         "    - make FLASH from addr 'start' to end of sect "
 723         "w/addr 'start'+'len'-1 wrtable\n"
 724         "protect off N:SF[-SL]\n"
 725         "    - make sectors SF-SL writable in FLASH bank # N\n"
 726         "protect off bank N\n    - make FLASH bank # N writable\n"
 727         TMP_PROT_OFF
 728         "protect off all\n    - make all FLASH banks writable\n"
 729 );
 730
 731 #undef  TMP_ERASE
 732 #undef  TMP_PROT_ON
 733 #undef  TMP_PROT_OFF
 734
 735 #endif  /* CFG_CMD_FLASH */