Merge with pollux.denx.org:/home/git/u-boot/.git
[platform/kernel/u-boot.git] / 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         int s_first[CFG_MAX_FLASH_BANKS], s_last[CFG_MAX_FLASH_BANKS];
408         int erased = 0;
409         int planned;
410         int rcode = 0;
411
412         rcode = flash_fill_sect_ranges (addr_first, addr_last,
413                                         s_first, s_last, &planned );
414
415         if (planned && (rcode == 0)) {
416                 for (bank=0,info=&flash_info[0];
417                      (bank < CFG_MAX_FLASH_BANKS) && (rcode == 0);
418                      ++bank, ++info) {
419                         if (s_first[bank]>=0) {
420                                 erased += s_last[bank] - s_first[bank] + 1;
421                                 debug ("Erase Flash from 0x%08lx to 0x%08lx "
422                                         "in Bank # %ld ",
423                                         info->start[s_first[bank]],
424                                         (s_last[bank] == info->sector_count) ?
425                                                 info->start[0] + info->size - 1:
426                                                 info->start[s_last[bank]+1] - 1,
427                                         bank+1);
428                                 rcode = flash_erase (info, s_first[bank], s_last[bank]);
429                         }
430                 }
431                 printf ("Erased %d sectors\n", erased);
432         } else if (rcode == 0) {
433                 puts ("Error: start and/or end address"
434                         " not on sector boundary\n");
435                 rcode = 1;
436         }
437         return rcode;
438 }
439
440 int do_protect (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
441 {
442         flash_info_t *info;
443         ulong bank, addr_first, addr_last;
444         int i, p, n, sect_first, sect_last;
445 #if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
446         struct mtd_device *dev;
447         struct part_info *part;
448         u8 dev_type, dev_num, pnum;
449 #endif
450         int rcode = 0;
451 #ifdef CONFIG_HAS_DATAFLASH
452         int status;
453 #endif
454         if (argc < 3) {
455                 printf ("Usage:\n%s\n", cmdtp->usage);
456                 return 1;
457         }
458
459         if (strcmp(argv[1], "off") == 0) {
460                 p = 0;
461         } else if (strcmp(argv[1], "on") == 0) {
462                 p = 1;
463         } else {
464                 printf ("Usage:\n%s\n", cmdtp->usage);
465                 return 1;
466         }
467
468 #ifdef CONFIG_HAS_DATAFLASH
469         if ((strcmp(argv[2], "all") != 0) && (strcmp(argv[2], "bank") != 0)) {
470                 addr_first = simple_strtoul(argv[2], NULL, 16);
471                 addr_last  = simple_strtoul(argv[3], NULL, 16);
472
473                 if (addr_dataflash(addr_first) && addr_dataflash(addr_last)) {
474                         status = dataflash_real_protect(p,addr_first,addr_last);
475                         if (status < 0){
476                                 puts ("Bad DataFlash sector specification\n");
477                                 return 1;
478                         }
479                         printf("%sProtect %d DataFlash Sectors\n",
480                                 p ? "" : "Un-", status);
481                         return 0;
482                 }
483         }
484 #endif
485
486         if (strcmp(argv[2], "all") == 0) {
487                 for (bank=1; bank<=CFG_MAX_FLASH_BANKS; ++bank) {
488                         info = &flash_info[bank-1];
489                         if (info->flash_id == FLASH_UNKNOWN) {
490                                 continue;
491                         }
492                         printf ("%sProtect Flash Bank # %ld\n",
493                                 p ? "" : "Un-", bank);
494
495                         for (i=0; i<info->sector_count; ++i) {
496 #if defined(CFG_FLASH_PROTECTION)
497                                 if (flash_real_protect(info, i, p))
498                                         rcode = 1;
499                                 putc ('.');
500 #else
501                                 info->protect[i] = p;
502 #endif  /* CFG_FLASH_PROTECTION */
503                         }
504                 }
505
506 #if defined(CFG_FLASH_PROTECTION)
507                 if (!rcode) puts (" done\n");
508 #endif  /* CFG_FLASH_PROTECTION */
509
510                 return rcode;
511         }
512
513         if ((n = abbrev_spec(argv[2], &info, &sect_first, &sect_last)) != 0) {
514                 if (n < 0) {
515                         puts ("Bad sector specification\n");
516                         return 1;
517                 }
518                 printf("%sProtect Flash Sectors %d-%d in Bank # %d\n",
519                         p ? "" : "Un-", sect_first, sect_last,
520                         (info-flash_info)+1);
521                 for (i = sect_first; i <= sect_last; i++) {
522 #if defined(CFG_FLASH_PROTECTION)
523                         if (flash_real_protect(info, i, p))
524                                 rcode =  1;
525                         putc ('.');
526 #else
527                         info->protect[i] = p;
528 #endif  /* CFG_FLASH_PROTECTION */
529                 }
530
531 #if defined(CFG_FLASH_PROTECTION)
532                 if (!rcode) puts (" done\n");
533 #endif  /* CFG_FLASH_PROTECTION */
534
535                 return rcode;
536         }
537
538 #if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
539         /* protect on/off <part-id> */
540         if ((argc == 3) && (id_parse(argv[2], NULL, &dev_type, &dev_num) == 0)) {
541                 mtdparts_init();
542                 if (find_dev_and_part(argv[2], &dev, &pnum, &part) == 0) {
543                         if (dev->id->type == MTD_DEV_TYPE_NOR) {
544                                 bank = dev->id->num;
545                                 info = &flash_info[bank];
546                                 addr_first = part->offset + info->start[0];
547                                 addr_last = addr_first + part->size - 1;
548
549                                 printf ("%sProtect Flash Parition %s, "
550                                                 "bank %d, 0x%08lx - 0x%08lx\n",
551                                                 p ? "" : "Un", argv[1],
552                                                 bank, addr_first, addr_last);
553
554                                 rcode = flash_sect_protect (p, addr_first, addr_last);
555                                 return rcode;
556                         }
557
558                         printf("cannot %sprotect, not a NOR device\n",
559                                         p ? "" : "un");
560                         return 1;
561                 }
562         }
563 #endif
564
565         if (argc != 4) {
566                 printf ("Usage:\n%s\n", cmdtp->usage);
567                 return 1;
568         }
569
570         if (strcmp(argv[2], "bank") == 0) {
571                 bank = simple_strtoul(argv[3], NULL, 16);
572                 if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS)) {
573                         printf ("Only FLASH Banks # 1 ... # %d supported\n",
574                                 CFG_MAX_FLASH_BANKS);
575                         return 1;
576                 }
577                 printf ("%sProtect Flash Bank # %ld\n",
578                         p ? "" : "Un-", bank);
579                 info = &flash_info[bank-1];
580
581                 if (info->flash_id == FLASH_UNKNOWN) {
582                         puts ("missing or unknown FLASH type\n");
583                         return 1;
584                 }
585                 for (i=0; i<info->sector_count; ++i) {
586 #if defined(CFG_FLASH_PROTECTION)
587                         if (flash_real_protect(info, i, p))
588                                 rcode =  1;
589                         putc ('.');
590 #else
591                         info->protect[i] = p;
592 #endif  /* CFG_FLASH_PROTECTION */
593                 }
594
595 #if defined(CFG_FLASH_PROTECTION)
596                 if (!rcode) puts (" done\n");
597 #endif  /* CFG_FLASH_PROTECTION */
598
599                 return rcode;
600         }
601
602         if (addr_spec(argv[2], argv[3], &addr_first, &addr_last) < 0){
603                 printf("Bad address format\n");
604                 return 1;
605         }
606
607         if (addr_first >= addr_last) {
608                 printf ("Usage:\n%s\n", cmdtp->usage);
609                 return 1;
610         }
611         rcode = flash_sect_protect (p, addr_first, addr_last);
612         return rcode;
613 }
614
615
616 int flash_sect_protect (int p, ulong addr_first, ulong addr_last)
617 {
618         flash_info_t *info;
619         ulong bank;
620         int s_first[CFG_MAX_FLASH_BANKS], s_last[CFG_MAX_FLASH_BANKS];
621         int protected, i;
622         int planned;
623         int rcode;
624
625         rcode = flash_fill_sect_ranges( addr_first, addr_last, s_first, s_last, &planned );
626
627         protected = 0;
628
629         if (planned && (rcode == 0)) {
630                 for (bank=0,info=&flash_info[0]; bank < CFG_MAX_FLASH_BANKS; ++bank, ++info) {
631                         if (info->flash_id == FLASH_UNKNOWN) {
632                                 continue;
633                         }
634
635                         if (s_first[bank]>=0 && s_first[bank]<=s_last[bank]) {
636                                 debug ("%sProtecting sectors %d..%d in bank %ld\n",
637                                         p ? "" : "Un-",
638                                         s_first[bank], s_last[bank], bank+1);
639                                 protected += s_last[bank] - s_first[bank] + 1;
640                                 for (i=s_first[bank]; i<=s_last[bank]; ++i) {
641 #if defined(CFG_FLASH_PROTECTION)
642                                         if (flash_real_protect(info, i, p))
643                                                 rcode = 1;
644                                         putc ('.');
645 #else
646                                         info->protect[i] = p;
647 #endif  /* CFG_FLASH_PROTECTION */
648                                 }
649                         }
650 #if defined(CFG_FLASH_PROTECTION)
651                         if (!rcode) putc ('\n');
652 #endif  /* CFG_FLASH_PROTECTION */
653                 }
654
655                 printf ("%sProtected %d sectors\n",
656                         p ? "" : "Un-", protected);
657         } else if (rcode == 0) {
658                 puts ("Error: start and/or end address"
659                         " not on sector boundary\n");
660                 rcode = 1;
661         }
662         return rcode;
663 }
664
665
666 /**************************************************/
667 #if (CONFIG_COMMANDS & CFG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
668 # define TMP_ERASE      "erase <part-id>\n    - erase partition\n"
669 # define TMP_PROT_ON    "protect on <part-id>\n    - protect partition\n"
670 # define TMP_PROT_OFF   "protect off <part-id>\n    - make partition writable\n"
671 #else
672 # define TMP_ERASE      /* empty */
673 # define TMP_PROT_ON    /* empty */
674 # define TMP_PROT_OFF   /* empty */
675 #endif
676
677 U_BOOT_CMD(
678         flinfo,    2,    1,    do_flinfo,
679         "flinfo  - print FLASH memory information\n",
680         "\n    - print information for all FLASH memory banks\n"
681         "flinfo N\n    - print information for FLASH memory bank # N\n"
682 );
683
684 U_BOOT_CMD(
685         erase,   3,   1,  do_flerase,
686         "erase   - erase FLASH memory\n",
687         "start end\n"
688         "    - erase FLASH from addr 'start' to addr 'end'\n"
689         "erase start +len\n"
690         "    - erase FLASH from addr 'start' to the end of sect "
691         "w/addr 'start'+'len'-1\n"
692         "erase N:SF[-SL]\n    - erase sectors SF-SL in FLASH bank # N\n"
693         "erase bank N\n    - erase FLASH bank # N\n"
694         TMP_ERASE
695         "erase all\n    - erase all FLASH banks\n"
696 );
697
698 U_BOOT_CMD(
699         protect,  4,  1,   do_protect,
700         "protect - enable or disable FLASH write protection\n",
701         "on  start end\n"
702         "    - protect FLASH from addr 'start' to addr 'end'\n"
703         "protect on start +len\n"
704         "    - protect FLASH from addr 'start' to end of sect "
705         "w/addr 'start'+'len'-1\n"
706         "protect on  N:SF[-SL]\n"
707         "    - protect sectors SF-SL in FLASH bank # N\n"
708         "protect on  bank N\n    - protect FLASH bank # N\n"
709         TMP_PROT_ON
710         "protect on  all\n    - protect all FLASH banks\n"
711         "protect off start end\n"
712         "    - make FLASH from addr 'start' to addr 'end' writable\n"
713         "protect off start +len\n"
714         "    - make FLASH from addr 'start' to end of sect "
715         "w/addr 'start'+'len'-1 wrtable\n"
716         "protect off N:SF[-SL]\n"
717         "    - make sectors SF-SL writable in FLASH bank # N\n"
718         "protect off bank N\n    - make FLASH bank # N writable\n"
719         TMP_PROT_OFF
720         "protect off all\n    - make all FLASH banks writable\n"
721 );
722
723 #undef  TMP_ERASE
724 #undef  TMP_PROT_ON
725 #undef  TMP_PROT_OFF
726
727 #endif  /* CFG_CMD_FLASH */