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