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