Added support for TQM834x boards.
[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 #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 */