Merge with /home/wd/git/u-boot/custodian/u-boot-mpc83xx
[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 defined(CONFIG_CMD_FLASH)
35
36 #if defined(CONFIG_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 *ep;
129         char len_used; /* indicates if the "start +length" form used */
130         char found;
131         ulong bank;
132
133         *addr_first = simple_strtoul(arg1, &ep, 16);
134         if (ep == arg1 || *ep != '\0')
135                 return -1;
136
137         len_used = 0;
138         if (arg2 && *arg2 == '+'){
139                 len_used = 1;
140                 ++arg2;
141         }
142
143         *addr_last = simple_strtoul(arg2, &ep, 16);
144         if (ep == arg2 || *ep != '\0')
145                 return -1;
146
147         if (len_used){
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                 found = 0;
163                 for (bank = 0; bank < CFG_MAX_FLASH_BANKS && !found; ++bank){
164                         int i;
165                         flash_info_t *info = &flash_info[bank];
166                         for (i = 0; i < info->sector_count && !found; ++i){
167                                 /* get the end address of the sector */
168                                 ulong sector_end_addr;
169                                 if (i == info->sector_count - 1){
170                                         sector_end_addr =
171                                                 info->start[0] + info->size - 1;
172                                 } else {
173                                         sector_end_addr =
174                                                 info->start[i+1] - 1;
175                                 }
176                                 if (*addr_last <= sector_end_addr &&
177                                                 *addr_last >= info->start[i]){
178                                         /* sector found */
179                                         found = 1;
180                                         /* adjust *addr_last if necessary */
181                                         if (*addr_last < sector_end_addr){
182                                                 *addr_last = sector_end_addr;
183                                         }
184                                 }
185                         } /* sector */
186                 } /* bank */
187                 if (!found){
188                         /* error, addres not in flash */
189                         printf("Error: end address (0x%08lx) not in flash!\n",
190                                                                 *addr_last);
191                         return -1;
192                 }
193         } /* "start +length" from used */
194
195         return 1;
196 }
197
198 static int
199 flash_fill_sect_ranges (ulong addr_first, ulong addr_last,
200                         int *s_first, int *s_last,
201                         int *s_count )
202 {
203         flash_info_t *info;
204         ulong bank;
205         int rcode = 0;
206
207         *s_count = 0;
208
209         for (bank=0; bank < CFG_MAX_FLASH_BANKS; ++bank) {
210                 s_first[bank] = -1;     /* first sector to erase        */
211                 s_last [bank] = -1;     /* last  sector to erase        */
212         }
213
214         for (bank=0,info=&flash_info[0];
215              (bank < CFG_MAX_FLASH_BANKS) && (addr_first <= addr_last);
216              ++bank, ++info) {
217                 ulong b_end;
218                 int sect;
219                 short s_end;
220
221                 if (info->flash_id == FLASH_UNKNOWN) {
222                         continue;
223                 }
224
225                 b_end = info->start[0] + info->size - 1;        /* bank end addr */
226                 s_end = info->sector_count - 1;                 /* last sector   */
227
228
229                 for (sect=0; sect < info->sector_count; ++sect) {
230                         ulong end;      /* last address in current sect */
231
232                         end = (sect == s_end) ? b_end : info->start[sect + 1] - 1;
233
234                         if (addr_first > end)
235                                 continue;
236                         if (addr_last < info->start[sect])
237                                 continue;
238
239                         if (addr_first == info->start[sect]) {
240                                 s_first[bank] = sect;
241                         }
242                         if (addr_last  == end) {
243                                 s_last[bank]  = sect;
244                         }
245                 }
246                 if (s_first[bank] >= 0) {
247                         if (s_last[bank] < 0) {
248                                 if (addr_last > b_end) {
249                                         s_last[bank] = s_end;
250                                 } else {
251                                         puts ("Error: end address"
252                                                 " not on sector boundary\n");
253                                         rcode = 1;
254                                         break;
255                                 }
256                         }
257                         if (s_last[bank] < s_first[bank]) {
258                                 puts ("Error: end sector"
259                                         " precedes start sector\n");
260                                 rcode = 1;
261                                 break;
262                         }
263                         sect = s_last[bank];
264                         addr_first = (sect == s_end) ? b_end + 1: info->start[sect + 1];
265                         (*s_count) += s_last[bank] - s_first[bank] + 1;
266                 } else if (addr_first >= info->start[0] && addr_first < b_end) {
267                         puts ("Error: start address not on sector boundary\n");
268                         rcode = 1;
269                         break;
270                 } else if (s_last[bank] >= 0) {
271                         puts ("Error: cannot span across banks when they are"
272                                " mapped in reverse order\n");
273                         rcode = 1;
274                         break;
275                 }
276         }
277
278         return rcode;
279 }
280
281 int do_flinfo ( cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
282 {
283         ulong bank;
284
285 #ifdef CONFIG_HAS_DATAFLASH
286         dataflash_print_info();
287 #endif
288
289         if (argc == 1) {        /* print info for all FLASH banks */
290                 for (bank=0; bank <CFG_MAX_FLASH_BANKS; ++bank) {
291                         printf ("\nBank # %ld: ", bank+1);
292
293                         flash_print_info (&flash_info[bank]);
294                 }
295                 return 0;
296         }
297
298         bank = simple_strtoul(argv[1], NULL, 16);
299         if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS)) {
300                 printf ("Only FLASH Banks # 1 ... # %d supported\n",
301                         CFG_MAX_FLASH_BANKS);
302                 return 1;
303         }
304         printf ("\nBank # %ld: ", bank);
305         flash_print_info (&flash_info[bank-1]);
306         return 0;
307 }
308
309 int do_flerase (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
310 {
311         flash_info_t *info;
312         ulong bank, addr_first, addr_last;
313         int n, sect_first, sect_last;
314 #if defined(CONFIG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
315         struct mtd_device *dev;
316         struct part_info *part;
317         u8 dev_type, dev_num, pnum;
318 #endif
319         int rcode = 0;
320
321         if (argc < 2) {
322                 printf ("Usage:\n%s\n", cmdtp->usage);
323                 return 1;
324         }
325
326         if (strcmp(argv[1], "all") == 0) {
327                 for (bank=1; bank<=CFG_MAX_FLASH_BANKS; ++bank) {
328                         printf ("Erase Flash Bank # %ld ", bank);
329                         info = &flash_info[bank-1];
330                         rcode = flash_erase (info, 0, info->sector_count-1);
331                 }
332                 return rcode;
333         }
334
335         if ((n = abbrev_spec(argv[1], &info, &sect_first, &sect_last)) != 0) {
336                 if (n < 0) {
337                         puts ("Bad sector specification\n");
338                         return 1;
339                 }
340                 printf ("Erase Flash Sectors %d-%d in Bank # %d ",
341                         sect_first, sect_last, (info-flash_info)+1);
342                 rcode = flash_erase(info, sect_first, sect_last);
343                 return rcode;
344         }
345
346 #if defined(CONFIG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
347         /* erase <part-id> - erase partition */
348         if ((argc == 2) && (id_parse(argv[1], NULL, &dev_type, &dev_num) == 0)) {
349                 mtdparts_init();
350                 if (find_dev_and_part(argv[1], &dev, &pnum, &part) == 0) {
351                         if (dev->id->type == MTD_DEV_TYPE_NOR) {
352                                 bank = dev->id->num;
353                                 info = &flash_info[bank];
354                                 addr_first = part->offset + info->start[0];
355                                 addr_last = addr_first + part->size - 1;
356
357                                 printf ("Erase Flash Parition %s, "
358                                                 "bank %d, 0x%08lx - 0x%08lx ",
359                                                 argv[1], bank, addr_first,
360                                                 addr_last);
361
362                                 rcode = flash_sect_erase(addr_first, addr_last);
363                                 return rcode;
364                         }
365
366                         printf("cannot erase, not a NOR device\n");
367                         return 1;
368                 }
369         }
370 #endif
371
372         if (argc != 3) {
373                 printf ("Usage:\n%s\n", cmdtp->usage);
374                 return 1;
375         }
376
377         if (strcmp(argv[1], "bank") == 0) {
378                 bank = simple_strtoul(argv[2], NULL, 16);
379                 if ((bank < 1) || (bank > CFG_MAX_FLASH_BANKS)) {
380                         printf ("Only FLASH Banks # 1 ... # %d supported\n",
381                                 CFG_MAX_FLASH_BANKS);
382                         return 1;
383                 }
384                 printf ("Erase Flash Bank # %ld ", bank);
385                 info = &flash_info[bank-1];
386                 rcode = flash_erase (info, 0, info->sector_count-1);
387                 return rcode;
388         }
389
390         if (addr_spec(argv[1], argv[2], &addr_first, &addr_last) < 0){
391                 printf ("Bad address format\n");
392                 return 1;
393         }
394
395         if (addr_first >= addr_last) {
396                 printf ("Usage:\n%s\n", cmdtp->usage);
397                 return 1;
398         }
399
400         rcode = flash_sect_erase(addr_first, addr_last);
401         return rcode;
402 }
403
404 int flash_sect_erase (ulong addr_first, ulong addr_last)
405 {
406         flash_info_t *info;
407         ulong bank;
408 #ifdef CFG_MAX_FLASH_BANKS_DETECT
409         int s_first[CFG_MAX_FLASH_BANKS_DETECT], s_last[CFG_MAX_FLASH_BANKS_DETECT];
410 #else
411         int s_first[CFG_MAX_FLASH_BANKS], s_last[CFG_MAX_FLASH_BANKS];
412 #endif
413         int erased = 0;
414         int planned;
415         int rcode = 0;
416
417         rcode = flash_fill_sect_ranges (addr_first, addr_last,
418                                         s_first, s_last, &planned );
419
420         if (planned && (rcode == 0)) {
421                 for (bank=0,info=&flash_info[0];
422                      (bank < CFG_MAX_FLASH_BANKS) && (rcode == 0);
423                      ++bank, ++info) {
424                         if (s_first[bank]>=0) {
425                                 erased += s_last[bank] - s_first[bank] + 1;
426                                 debug ("Erase Flash from 0x%08lx to 0x%08lx "
427                                         "in Bank # %ld ",
428                                         info->start[s_first[bank]],
429                                         (s_last[bank] == info->sector_count) ?
430                                                 info->start[0] + info->size - 1:
431                                                 info->start[s_last[bank]+1] - 1,
432                                         bank+1);
433                                 rcode = flash_erase (info, s_first[bank], s_last[bank]);
434                         }
435                 }
436                 printf ("Erased %d sectors\n", erased);
437         } else if (rcode == 0) {
438                 puts ("Error: start and/or end address"
439                         " not on sector boundary\n");
440                 rcode = 1;
441         }
442         return rcode;
443 }
444
445 int do_protect (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
446 {
447         flash_info_t *info;
448         ulong bank, addr_first, addr_last;
449         int i, p, n, sect_first, sect_last;
450 #if defined(CONFIG_CMD_JFFS2) && defined(CONFIG_JFFS2_CMDLINE)
451         struct mtd_device *dev;
452         struct part_info *part;
453         u8 dev_type, dev_num, pnum;
454 #endif
455         int rcode = 0;
456 #ifdef CONFIG_HAS_DATAFLASH
457         int status;
458 #endif
459
460         if (argc < 3) {
461                 printf ("Usage:\n%s\n", cmdtp->usage);
462                 return 1;
463         }
464
465         if (strcmp(argv[1], "off") == 0) {
466                 p = 0;
467         } else if (strcmp(argv[1], "on") == 0) {
468                 p = 1;
469         } else {
470                 printf ("Usage:\n%s\n", cmdtp->usage);
471                 return 1;
472         }
473
474 #ifdef CONFIG_HAS_DATAFLASH
475         if ((strcmp(argv[2], "all") != 0) && (strcmp(argv[2], "bank") != 0)) {
476                 addr_first = simple_strtoul(argv[2], NULL, 16);
477                 addr_last  = simple_strtoul(argv[3], NULL, 16);
478
479                 if (addr_dataflash(addr_first) && addr_dataflash(addr_last)) {
480                         status = dataflash_real_protect(p,addr_first,addr_last);
481                         if (status < 0){
482                                 puts ("Bad DataFlash sector specification\n");
483                                 return 1;
484                         }
485                         printf("%sProtect %d DataFlash Sectors\n",
486                                 p ? "" : "Un-", status);
487                         return 0;
488                 }
489         }
490 #endif
491
492         if (strcmp(argv[2], "all") == 0) {
493                 for (bank=1; bank<=CFG_MAX_FLASH_BANKS; ++bank) {
494                         info = &flash_info[bank-1];
495                         if (info->flash_id == FLASH_UNKNOWN) {
496                                 continue;
497                         }
498                         printf ("%sProtect Flash Bank # %ld\n",
499                                 p ? "" : "Un-", bank);
500
501                         for (i=0; i<info->sector_count; ++i) {
502 #if defined(CFG_FLASH_PROTECTION)
503                                 if (flash_real_protect(info, i, p))
504                                         rcode = 1;
505                                 putc ('.');
506 #else
507                                 info->protect[i] = p;
508 #endif  /* CFG_FLASH_PROTECTION */
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 defined(CONFIG_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                 }
659 #if defined(CFG_FLASH_PROTECTION)
660                 puts (" done\n");
661 #endif  /* CFG_FLASH_PROTECTION */
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 defined(CONFIG_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,   0,  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,  0,   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