?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
flash/nor/tcl: fix the flash name returned by 'flash list' command
[openocd.git] / src / flash / nor / tcl.c
blob613012b7b84b95e6135413ba532fb9b934444b3a
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath <Dominic.Rath@gmx.de> *
3 * Copyright (C) 2007,2008 Øyvind Harboe <oyvind.harboe@zylin.com> *
4 * Copyright (C) 2008 by Spencer Oliver <spen@spen-soft.co.uk> *
5 * Copyright (C) 2009 Zachary T Welch <zw@superlucidity.net> *
6 * Copyright (C) 2017-2018 Tomas Vanek <vanekt@fbl.cz> *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (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, see <http://www.gnu.org/licenses/>. *
20 ***************************************************************************/
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif
24 #include "imp.h"
25 #include <helper/time_support.h>
26 #include <target/image.h>
27
28 /**
29 * @file
30 * Implements Tcl commands used to access NOR flash facilities.
31 */
32
33 static COMMAND_HELPER(flash_command_get_bank_maybe_probe, unsigned name_index,
34 struct flash_bank **bank, bool do_probe)
35 {
36 const char *name = CMD_ARGV[name_index];
37 int retval;
38 if (do_probe) {
39 retval = get_flash_bank_by_name(name, bank);
40 } else {
41 *bank = get_flash_bank_by_name_noprobe(name);
42 retval = ERROR_OK;
43 }
44
45 if (retval != ERROR_OK)
46 return retval;
47 if (*bank)
48 return ERROR_OK;
49
50 unsigned bank_num;
51 COMMAND_PARSE_NUMBER(uint, name, bank_num);
52
53 if (do_probe) {
54 return get_flash_bank_by_num(bank_num, bank);
55 } else {
56 *bank = get_flash_bank_by_num_noprobe(bank_num);
57 retval = (bank) ? ERROR_OK : ERROR_FAIL;
58 return retval;
59 }
60 }
61
62 COMMAND_HELPER(flash_command_get_bank, unsigned name_index,
63 struct flash_bank **bank)
64 {
65 return CALL_COMMAND_HANDLER(flash_command_get_bank_maybe_probe,
66 name_index, bank, true);
67 }
68
69 COMMAND_HANDLER(handle_flash_info_command)
70 {
71 struct flash_bank *p;
72 int j = 0;
73 int retval;
74 bool show_sectors = false;
75 bool prot_block_available;
76
77 if (CMD_ARGC < 1 || CMD_ARGC > 2)
78 return ERROR_COMMAND_SYNTAX_ERROR;
79
80 if (CMD_ARGC == 2) {
81 if (strcmp("sectors", CMD_ARGV[1]) == 0)
82 show_sectors = true;
83 else
84 return ERROR_COMMAND_SYNTAX_ERROR;
85 }
86
87 retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
88 if (retval != ERROR_OK)
89 return retval;
90
91 if (p) {
92 int num_blocks;
93 struct flash_sector *block_array;
94
95 /* attempt auto probe */
96 retval = p->driver->auto_probe(p);
97 if (retval != ERROR_OK)
98 return retval;
99
100 /* If the driver does not implement protection, we show the default
101 * state of is_protected array - usually protection state unknown */
102 if (!p->driver->protect_check) {
103 retval = ERROR_FLASH_OPER_UNSUPPORTED;
104 } else {
105 /* We must query the hardware to avoid printing stale information! */
106 retval = p->driver->protect_check(p);
107 if (retval != ERROR_OK && retval != ERROR_FLASH_OPER_UNSUPPORTED)
108 return retval;
109 }
110 if (retval == ERROR_FLASH_OPER_UNSUPPORTED)
111 LOG_INFO("Flash protection check is not implemented.");
112
113 command_print(CMD,
114 "#%u : %s at " TARGET_ADDR_FMT ", size 0x%8.8" PRIx32
115 ", buswidth %u, chipwidth %u",
116 p->bank_number,
117 p->driver->name,
118 p->base,
119 p->size,
120 p->bus_width,
121 p->chip_width);
122
123 prot_block_available = p->num_prot_blocks && p->prot_blocks;
124 if (!show_sectors && prot_block_available) {
125 block_array = p->prot_blocks;
126 num_blocks = p->num_prot_blocks;
127 } else {
128 block_array = p->sectors;
129 num_blocks = p->num_sectors;
130 }
131
132 for (j = 0; j < num_blocks; j++) {
133 char *protect_state = "";
134
135 if (block_array[j].is_protected == 0)
136 protect_state = "not protected";
137 else if (block_array[j].is_protected == 1)
138 protect_state = "protected";
139 else if (!show_sectors || !prot_block_available)
140 protect_state = "protection state unknown";
141
142 command_print(CMD,
143 "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIu32 "kB) %s",
144 j,
145 block_array[j].offset,
146 block_array[j].size,
147 block_array[j].size >> 10,
148 protect_state);
149 }
150
151 if (p->driver->info) {
152 /* Let the flash driver print extra custom info */
153 retval = p->driver->info(p, CMD);
154 command_print_sameline(CMD, "\n");
155 if (retval != ERROR_OK)
156 LOG_ERROR("error retrieving flash info");
157 }
158 }
159
160 return retval;
161 }
162
163 COMMAND_HANDLER(handle_flash_probe_command)
164 {
165 struct flash_bank *p;
166 int retval;
167
168 if (CMD_ARGC != 1)
169 return ERROR_COMMAND_SYNTAX_ERROR;
170
171 retval = CALL_COMMAND_HANDLER(flash_command_get_bank_maybe_probe, 0, &p, false);
172 if (retval != ERROR_OK)
173 return retval;
174
175 if (p) {
176 retval = p->driver->probe(p);
177 if (retval == ERROR_OK)
178 command_print(CMD,
179 "flash '%s' found at " TARGET_ADDR_FMT,
180 p->driver->name,
181 p->base);
182 } else {
183 command_print(CMD, "flash bank '#%s' is out of bounds", CMD_ARGV[0]);
184 retval = ERROR_FAIL;
185 }
186
187 return retval;
188 }
189
190 COMMAND_HANDLER(handle_flash_erase_check_command)
191 {
192 bool blank = true;
193 if (CMD_ARGC != 1)
194 return ERROR_COMMAND_SYNTAX_ERROR;
195
196 struct flash_bank *p;
197 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
198 if (retval != ERROR_OK)
199 return retval;
200
201 retval = p->driver->erase_check(p);
202 if (retval == ERROR_OK)
203 command_print(CMD, "successfully checked erase state");
204 else {
205 command_print(CMD,
206 "unknown error when checking erase state of flash bank #%s at "
207 TARGET_ADDR_FMT,
208 CMD_ARGV[0],
209 p->base);
210 }
211
212 for (unsigned int j = 0; j < p->num_sectors; j++) {
213 char *erase_state;
214
215 if (p->sectors[j].is_erased == 0)
216 erase_state = "not erased";
217 else if (p->sectors[j].is_erased == 1)
218 continue;
219 else
220 erase_state = "erase state unknown";
221
222 blank = false;
223 command_print(CMD,
224 "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIu32 "kB) %s",
225 j,
226 p->sectors[j].offset,
227 p->sectors[j].size,
228 p->sectors[j].size >> 10,
229 erase_state);
230 }
231
232 if (blank)
233 command_print(CMD, "\tBank is erased");
234 return retval;
235 }
236
237 COMMAND_HANDLER(handle_flash_erase_address_command)
238 {
239 struct flash_bank *p;
240 int retval = ERROR_OK;
241 target_addr_t address;
242 uint32_t length;
243 bool do_pad = false;
244 bool do_unlock = false;
245 struct target *target = get_current_target(CMD_CTX);
246
247 while (CMD_ARGC >= 3) {
248 /* Optionally pad out the address range to block/sector
249 * boundaries. We can't know if there's data in that part
250 * of the flash; only do padding if we're told to.
251 */
252 if (strcmp("pad", CMD_ARGV[0]) == 0)
253 do_pad = true;
254 else if (strcmp("unlock", CMD_ARGV[0]) == 0)
255 do_unlock = true;
256 else
257 return ERROR_COMMAND_SYNTAX_ERROR;
258 CMD_ARGC--;
259 CMD_ARGV++;
260 }
261 if (CMD_ARGC != 2)
262 return ERROR_COMMAND_SYNTAX_ERROR;
263
264 COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);
265 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
266
267 if (length <= 0) {
268 command_print(CMD, "Length must be >0");
269 return ERROR_COMMAND_SYNTAX_ERROR;
270 }
271
272 retval = get_flash_bank_by_addr(target, address, true, &p);
273 if (retval != ERROR_OK)
274 return retval;
275
276 /* We can't know if we did a resume + halt, in which case we no longer know the erased state
277 **/
278 flash_set_dirty();
279
280 struct duration bench;
281 duration_start(&bench);
282
283 if (do_unlock)
284 retval = flash_unlock_address_range(target, address, length);
285
286 if (retval == ERROR_OK)
287 retval = flash_erase_address_range(target, do_pad, address, length);
288
289 if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
290 command_print(CMD, "erased address " TARGET_ADDR_FMT " (length %" PRIu32 ")"
291 " in %fs (%0.3f KiB/s)", address, length,
292 duration_elapsed(&bench), duration_kbps(&bench, length));
293 }
294
295 return retval;
296 }
297
298 COMMAND_HANDLER(handle_flash_erase_command)
299 {
300 if (CMD_ARGC != 3)
301 return ERROR_COMMAND_SYNTAX_ERROR;
302
303 uint32_t first;
304 uint32_t last;
305
306 struct flash_bank *p;
307 int retval;
308
309 retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
310 if (retval != ERROR_OK)
311 return retval;
312
313 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first);
314 if (strcmp(CMD_ARGV[2], "last") == 0)
315 last = p->num_sectors - 1;
316 else
317 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
318
319 if (!(first <= last)) {
320 command_print(CMD, "ERROR: "
321 "first sector must be <= last");
322 return ERROR_FAIL;
323 }
324
325 if (!(last <= (p->num_sectors - 1))) {
326 command_print(CMD, "ERROR: "
327 "last sector must be <= %u",
328 p->num_sectors - 1);
329 return ERROR_FAIL;
330 }
331
332 struct duration bench;
333 duration_start(&bench);
334
335 retval = flash_driver_erase(p, first, last);
336
337 if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
338 command_print(CMD, "erased sectors %" PRIu32 " "
339 "through %" PRIu32 " on flash bank %u "
340 "in %fs", first, last, p->bank_number, duration_elapsed(&bench));
341 }
342
343 return retval;
344 }
345
346 COMMAND_HANDLER(handle_flash_protect_command)
347 {
348 if (CMD_ARGC != 4)
349 return ERROR_COMMAND_SYNTAX_ERROR;
350
351 uint32_t first;
352 uint32_t last;
353
354 struct flash_bank *p;
355 int retval;
356 int num_blocks;
357
358 retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
359 if (retval != ERROR_OK)
360 return retval;
361
362 if (p->num_prot_blocks)
363 num_blocks = p->num_prot_blocks;
364 else
365 num_blocks = p->num_sectors;
366
367 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first);
368 if (strcmp(CMD_ARGV[2], "last") == 0)
369 last = num_blocks - 1;
370 else
371 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
372
373 bool set;
374 COMMAND_PARSE_ON_OFF(CMD_ARGV[3], set);
375
376 if (!(first <= last)) {
377 command_print(CMD, "ERROR: "
378 "first %s must be <= last",
379 (p->num_prot_blocks) ? "block" : "sector");
380 return ERROR_FAIL;
381 }
382
383 if (!(last <= (uint32_t)(num_blocks - 1))) {
384 command_print(CMD, "ERROR: "
385 "last %s must be <= %d",
386 (p->num_prot_blocks) ? "block" : "sector",
387 num_blocks - 1);
388 return ERROR_FAIL;
389 }
390
391 retval = flash_driver_protect(p, set, first, last);
392 if (retval == ERROR_OK) {
393 command_print(CMD, "%s protection for %s %" PRIu32
394 " through %" PRIu32 " on flash bank %d",
395 (set) ? "set" : "cleared",
396 (p->num_prot_blocks) ? "blocks" : "sectors",
397 first, last, p->bank_number);
398 }
399
400 return retval;
401 }
402
403 COMMAND_HANDLER(handle_flash_write_image_command)
404 {
405 struct target *target = get_current_target(CMD_CTX);
406
407 struct image image;
408 uint32_t written;
409
410 int retval;
411
412 /* flash auto-erase is disabled by default*/
413 int auto_erase = 0;
414 bool auto_unlock = false;
415
416 while (CMD_ARGC) {
417 if (strcmp(CMD_ARGV[0], "erase") == 0) {
418 auto_erase = 1;
419 CMD_ARGV++;
420 CMD_ARGC--;
421 command_print(CMD, "auto erase enabled");
422 } else if (strcmp(CMD_ARGV[0], "unlock") == 0) {
423 auto_unlock = true;
424 CMD_ARGV++;
425 CMD_ARGC--;
426 command_print(CMD, "auto unlock enabled");
427 } else
428 break;
429 }
430
431 if (CMD_ARGC < 1)
432 return ERROR_COMMAND_SYNTAX_ERROR;
433
434 if (!target) {
435 LOG_ERROR("no target selected");
436 return ERROR_FAIL;
437 }
438
439 struct duration bench;
440 duration_start(&bench);
441
442 if (CMD_ARGC >= 2) {
443 image.base_address_set = true;
444 COMMAND_PARSE_NUMBER(llong, CMD_ARGV[1], image.base_address);
445 } else {
446 image.base_address_set = false;
447 image.base_address = 0x0;
448 }
449
450 image.start_address_set = false;
451
452 retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL);
453 if (retval != ERROR_OK)
454 return retval;
455
456 retval = flash_write_unlock_verify(target, &image, &written, auto_erase,
457 auto_unlock, true, false);
458 if (retval != ERROR_OK) {
459 image_close(&image);
460 return retval;
461 }
462
463 if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
464 command_print(CMD, "wrote %" PRIu32 " bytes from file %s "
465 "in %fs (%0.3f KiB/s)", written, CMD_ARGV[0],
466 duration_elapsed(&bench), duration_kbps(&bench, written));
467 }
468
469 image_close(&image);
470
471 return retval;
472 }
473
474 COMMAND_HANDLER(handle_flash_verify_image_command)
475 {
476 struct target *target = get_current_target(CMD_CTX);
477
478 struct image image;
479 uint32_t verified;
480
481 int retval;
482
483 if (CMD_ARGC < 1)
484 return ERROR_COMMAND_SYNTAX_ERROR;
485
486 if (!target) {
487 LOG_ERROR("no target selected");
488 return ERROR_FAIL;
489 }
490
491 struct duration bench;
492 duration_start(&bench);
493
494 if (CMD_ARGC >= 2) {
495 image.base_address_set = 1;
496 COMMAND_PARSE_NUMBER(llong, CMD_ARGV[1], image.base_address);
497 } else {
498 image.base_address_set = 0;
499 image.base_address = 0x0;
500 }
501
502 image.start_address_set = 0;
503
504 retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL);
505 if (retval != ERROR_OK)
506 return retval;
507
508 retval = flash_write_unlock_verify(target, &image, &verified, false,
509 false, false, true);
510 if (retval != ERROR_OK) {
511 image_close(&image);
512 return retval;
513 }
514
515 if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
516 command_print(CMD, "verified %" PRIu32 " bytes from file %s "
517 "in %fs (%0.3f KiB/s)", verified, CMD_ARGV[0],
518 duration_elapsed(&bench), duration_kbps(&bench, verified));
519 }
520
521 image_close(&image);
522
523 return retval;
524 }
525
526 COMMAND_HANDLER(handle_flash_fill_command)
527 {
528 target_addr_t address;
529 uint64_t pattern;
530 uint32_t count;
531 struct target *target = get_current_target(CMD_CTX);
532 unsigned i;
533 uint32_t wordsize;
534 int retval;
535
536 if (CMD_ARGC != 3)
537 return ERROR_COMMAND_SYNTAX_ERROR;
538
539 COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);
540 COMMAND_PARSE_NUMBER(u64, CMD_ARGV[1], pattern);
541 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], count);
542
543 struct flash_bank *bank;
544 retval = get_flash_bank_by_addr(target, address, true, &bank);
545 if (retval != ERROR_OK)
546 return retval;
547
548 switch (CMD_NAME[4]) {
549 case 'd':
550 wordsize = 8;
551 break;
552 case 'w':
553 wordsize = 4;
554 break;
555 case 'h':
556 wordsize = 2;
557 break;
558 case 'b':
559 wordsize = 1;
560 break;
561 default:
562 return ERROR_COMMAND_SYNTAX_ERROR;
563 }
564
565 if ((wordsize < sizeof(pattern)) && (pattern >> (8 * wordsize) != 0)) {
566 command_print(CMD, "Fill pattern 0x%" PRIx64 " does not fit within %" PRIu32 "-byte word", pattern, wordsize);
567 return ERROR_FAIL;
568 }
569
570 if (count == 0)
571 return ERROR_OK;
572
573 if (address + count * wordsize > bank->base + bank->size) {
574 LOG_ERROR("Cannot cross flash bank borders");
575 return ERROR_FAIL;
576 }
577
578 uint32_t size_bytes = count * wordsize;
579 target_addr_t aligned_start = flash_write_align_start(bank, address);
580 target_addr_t end_addr = address + size_bytes - 1;
581 target_addr_t aligned_end = flash_write_align_end(bank, end_addr);
582 uint32_t aligned_size = aligned_end + 1 - aligned_start;
583 uint32_t padding_at_start = address - aligned_start;
584 uint32_t padding_at_end = aligned_end - end_addr;
585
586 uint8_t *buffer = malloc(aligned_size);
587 if (!buffer)
588 return ERROR_FAIL;
589
590 if (padding_at_start) {
591 memset(buffer, bank->default_padded_value, padding_at_start);
592 LOG_WARNING("Start address " TARGET_ADDR_FMT
593 " breaks the required alignment of flash bank %s",
594 address, bank->name);
595 LOG_WARNING("Padding %" PRIu32 " bytes from " TARGET_ADDR_FMT,
596 padding_at_start, aligned_start);
597 }
598
599 uint8_t *ptr = buffer + padding_at_start;
600
601 switch (wordsize) {
602 case 8:
603 for (i = 0; i < count; i++, ptr += wordsize)
604 target_buffer_set_u64(target, ptr, pattern);
605 break;
606 case 4:
607 for (i = 0; i < count; i++, ptr += wordsize)
608 target_buffer_set_u32(target, ptr, pattern);
609 break;
610 case 2:
611 for (i = 0; i < count; i++, ptr += wordsize)
612 target_buffer_set_u16(target, ptr, pattern);
613 break;
614 case 1:
615 memset(ptr, pattern, count);
616 ptr += count;
617 break;
618 default:
619 LOG_ERROR("BUG: can't happen");
620 exit(-1);
621 }
622
623 if (padding_at_end) {
624 memset(ptr, bank->default_padded_value, padding_at_end);
625 LOG_INFO("Padding at " TARGET_ADDR_FMT " with %" PRIu32
626 " bytes (bank write end alignment)",
627 end_addr + 1, padding_at_end);
628 }
629
630 struct duration bench;
631 duration_start(&bench);
632
633 retval = flash_driver_write(bank, buffer, aligned_start - bank->base, aligned_size);
634 if (retval != ERROR_OK)
635 goto done;
636
637 retval = flash_driver_read(bank, buffer, address - bank->base, size_bytes);
638 if (retval != ERROR_OK)
639 goto done;
640
641 for (i = 0, ptr = buffer; i < count; i++) {
642 uint64_t readback = 0;
643
644 switch (wordsize) {
645 case 8:
646 readback = target_buffer_get_u64(target, ptr);
647 break;
648 case 4:
649 readback = target_buffer_get_u32(target, ptr);
650 break;
651 case 2:
652 readback = target_buffer_get_u16(target, ptr);
653 break;
654 case 1:
655 readback = *ptr;
656 break;
657 }
658 if (readback != pattern) {
659 LOG_ERROR(
660 "Verification error address " TARGET_ADDR_FMT
661 ", read back 0x%02" PRIx64 ", expected 0x%02" PRIx64,
662 address + i * wordsize, readback, pattern);
663 retval = ERROR_FAIL;
664 goto done;
665 }
666 ptr += wordsize;
667 }
668
669 if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
670 command_print(CMD, "wrote %" PRIu32 " bytes to " TARGET_ADDR_FMT
671 " in %fs (%0.3f KiB/s)", size_bytes, address,
672 duration_elapsed(&bench), duration_kbps(&bench, size_bytes));
673 }
674
675 done:
676 free(buffer);
677
678 return retval;
679 }
680
681 COMMAND_HANDLER(handle_flash_md_command)
682 {
683 int retval;
684
685 if (CMD_ARGC < 1 || CMD_ARGC > 2)
686 return ERROR_COMMAND_SYNTAX_ERROR;
687
688 target_addr_t address;
689 COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);
690
691 uint32_t count = 1;
692 if (CMD_ARGC == 2)
693 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], count);
694
695 unsigned int wordsize;
696 switch (CMD_NAME[2]) {
697 case 'w':
698 wordsize = 4;
699 break;
700 case 'h':
701 wordsize = 2;
702 break;
703 case 'b':
704 wordsize = 1;
705 break;
706 default:
707 return ERROR_COMMAND_SYNTAX_ERROR;
708 }
709
710 if (count == 0)
711 return ERROR_OK;
712
713 struct target *target = get_current_target(CMD_CTX);
714 struct flash_bank *bank;
715 retval = get_flash_bank_by_addr(target, address, true, &bank);
716 if (retval != ERROR_OK)
717 return retval;
718
719 uint32_t offset = address - bank->base;
720 uint32_t sizebytes = count * wordsize;
721 if (offset + sizebytes > bank->size) {
722 command_print(CMD, "Cannot cross flash bank borders");
723 return ERROR_FAIL;
724 }
725
726 uint8_t *buffer = calloc(count, wordsize);
727 if (!buffer) {
728 command_print(CMD, "No memory for flash read buffer");
729 return ERROR_FAIL;
730 }
731
732 retval = flash_driver_read(bank, buffer, offset, sizebytes);
733 if (retval == ERROR_OK)
734 target_handle_md_output(CMD, target, address, wordsize, count, buffer);
735
736 free(buffer);
737
738 return retval;
739 }
740
741
742 COMMAND_HANDLER(handle_flash_write_bank_command)
743 {
744 uint32_t offset;
745 uint8_t *buffer;
746 size_t length;
747 struct fileio *fileio;
748
749 if (CMD_ARGC < 2 || CMD_ARGC > 3)
750 return ERROR_COMMAND_SYNTAX_ERROR;
751
752 struct duration bench;
753 duration_start(&bench);
754
755 struct flash_bank *bank;
756 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
757 if (retval != ERROR_OK)
758 return retval;
759
760 offset = 0;
761
762 if (CMD_ARGC > 2)
763 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], offset);
764
765 if (offset > bank->size) {
766 LOG_ERROR("Offset 0x%8.8" PRIx32 " is out of range of the flash bank",
767 offset);
768 return ERROR_COMMAND_ARGUMENT_INVALID;
769 }
770
771 if (fileio_open(&fileio, CMD_ARGV[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
772 return ERROR_FAIL;
773
774 size_t filesize;
775 retval = fileio_size(fileio, &filesize);
776 if (retval != ERROR_OK) {
777 fileio_close(fileio);
778 return retval;
779 }
780
781 length = MIN(filesize, bank->size - offset);
782
783 if (!length) {
784 LOG_INFO("Nothing to write to flash bank");
785 fileio_close(fileio);
786 return ERROR_OK;
787 }
788
789 if (length != filesize)
790 LOG_INFO("File content exceeds flash bank size. Only writing the "
791 "first %zu bytes of the file", length);
792
793 target_addr_t start_addr = bank->base + offset;
794 target_addr_t aligned_start = flash_write_align_start(bank, start_addr);
795 target_addr_t end_addr = start_addr + length - 1;
796 target_addr_t aligned_end = flash_write_align_end(bank, end_addr);
797 uint32_t aligned_size = aligned_end + 1 - aligned_start;
798 uint32_t padding_at_start = start_addr - aligned_start;
799 uint32_t padding_at_end = aligned_end - end_addr;
800
801 buffer = malloc(aligned_size);
802 if (!buffer) {
803 fileio_close(fileio);
804 LOG_ERROR("Out of memory");
805 return ERROR_FAIL;
806 }
807
808 if (padding_at_start) {
809 memset(buffer, bank->default_padded_value, padding_at_start);
810 LOG_WARNING("Start offset 0x%08" PRIx32
811 " breaks the required alignment of flash bank %s",
812 offset, bank->name);
813 LOG_WARNING("Padding %" PRIu32 " bytes from " TARGET_ADDR_FMT,
814 padding_at_start, aligned_start);
815 }
816
817 uint8_t *ptr = buffer + padding_at_start;
818 size_t buf_cnt;
819 if (fileio_read(fileio, length, ptr, &buf_cnt) != ERROR_OK) {
820 free(buffer);
821 fileio_close(fileio);
822 return ERROR_FAIL;
823 }
824
825 if (buf_cnt != length) {
826 LOG_ERROR("Short read");
827 free(buffer);
828 return ERROR_FAIL;
829 }
830
831 ptr += length;
832
833 if (padding_at_end) {
834 memset(ptr, bank->default_padded_value, padding_at_end);
835 LOG_INFO("Padding at " TARGET_ADDR_FMT " with %" PRIu32
836 " bytes (bank write end alignment)",
837 end_addr + 1, padding_at_end);
838 }
839
840 retval = flash_driver_write(bank, buffer, aligned_start - bank->base, aligned_size);
841
842 free(buffer);
843
844 if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
845 command_print(CMD, "wrote %zu bytes from file %s to flash bank %u"
846 " at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
847 length, CMD_ARGV[1], bank->bank_number, offset,
848 duration_elapsed(&bench), duration_kbps(&bench, length));
849 }
850
851 fileio_close(fileio);
852
853 return retval;
854 }
855
856 COMMAND_HANDLER(handle_flash_read_bank_command)
857 {
858 uint32_t offset;
859 uint8_t *buffer;
860 struct fileio *fileio;
861 uint32_t length;
862 size_t written;
863
864 if (CMD_ARGC < 2 || CMD_ARGC > 4)
865 return ERROR_COMMAND_SYNTAX_ERROR;
866
867 struct duration bench;
868 duration_start(&bench);
869
870 struct flash_bank *p;
871 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
872
873 if (retval != ERROR_OK)
874 return retval;
875
876 offset = 0;
877
878 if (CMD_ARGC > 2)
879 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], offset);
880
881 if (offset > p->size) {
882 LOG_ERROR("Offset 0x%8.8" PRIx32 " is out of range of the flash bank",
883 offset);
884 return ERROR_COMMAND_ARGUMENT_INVALID;
885 }
886
887 length = p->size - offset;
888
889 if (CMD_ARGC > 3)
890 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], length);
891
892 if (offset + length > p->size) {
893 LOG_ERROR("Length of %" PRIu32 " bytes with offset 0x%8.8" PRIx32
894 " is out of range of the flash bank", length, offset);
895 return ERROR_COMMAND_ARGUMENT_INVALID;
896 }
897
898 buffer = malloc(length);
899 if (!buffer) {
900 LOG_ERROR("Out of memory");
901 return ERROR_FAIL;
902 }
903
904 retval = flash_driver_read(p, buffer, offset, length);
905 if (retval != ERROR_OK) {
906 LOG_ERROR("Read error");
907 free(buffer);
908 return retval;
909 }
910
911 retval = fileio_open(&fileio, CMD_ARGV[1], FILEIO_WRITE, FILEIO_BINARY);
912 if (retval != ERROR_OK) {
913 LOG_ERROR("Could not open file");
914 free(buffer);
915 return retval;
916 }
917
918 retval = fileio_write(fileio, length, buffer, &written);
919 fileio_close(fileio);
920 free(buffer);
921 if (retval != ERROR_OK) {
922 LOG_ERROR("Could not write file");
923 return ERROR_FAIL;
924 }
925
926 if (duration_measure(&bench) == ERROR_OK)
927 command_print(CMD, "wrote %zd bytes to file %s from flash bank %u"
928 " at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
929 written, CMD_ARGV[1], p->bank_number, offset,
930 duration_elapsed(&bench), duration_kbps(&bench, written));
931
932 return retval;
933 }
934
935
936 COMMAND_HANDLER(handle_flash_verify_bank_command)
937 {
938 uint32_t offset;
939 uint8_t *buffer_file, *buffer_flash;
940 struct fileio *fileio;
941 size_t read_cnt;
942 size_t filesize;
943 size_t length;
944 int differ;
945
946 if (CMD_ARGC < 2 || CMD_ARGC > 3)
947 return ERROR_COMMAND_SYNTAX_ERROR;
948
949 struct duration bench;
950 duration_start(&bench);
951
952 struct flash_bank *p;
953 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
954 if (retval != ERROR_OK)
955 return retval;
956
957 offset = 0;
958
959 if (CMD_ARGC > 2)
960 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], offset);
961
962 if (offset > p->size) {
963 LOG_ERROR("Offset 0x%8.8" PRIx32 " is out of range of the flash bank",
964 offset);
965 return ERROR_COMMAND_ARGUMENT_INVALID;
966 }
967
968 retval = fileio_open(&fileio, CMD_ARGV[1], FILEIO_READ, FILEIO_BINARY);
969 if (retval != ERROR_OK) {
970 LOG_ERROR("Could not open file");
971 return retval;
972 }
973
974 retval = fileio_size(fileio, &filesize);
975 if (retval != ERROR_OK) {
976 fileio_close(fileio);
977 return retval;
978 }
979
980 length = MIN(filesize, p->size - offset);
981
982 if (!length) {
983 LOG_INFO("Nothing to compare with flash bank");
984 fileio_close(fileio);
985 return ERROR_OK;
986 }
987
988 if (length != filesize)
989 LOG_INFO("File content exceeds flash bank size. Only comparing the "
990 "first %zu bytes of the file", length);
991
992 buffer_file = malloc(length);
993 if (!buffer_file) {
994 LOG_ERROR("Out of memory");
995 fileio_close(fileio);
996 return ERROR_FAIL;
997 }
998
999 retval = fileio_read(fileio, length, buffer_file, &read_cnt);
1000 fileio_close(fileio);
1001 if (retval != ERROR_OK) {
1002 LOG_ERROR("File read failure");
1003 free(buffer_file);
1004 return retval;
1005 }
1006
1007 if (read_cnt != length) {
1008 LOG_ERROR("Short read");
1009 free(buffer_file);
1010 return ERROR_FAIL;
1011 }
1012
1013 buffer_flash = malloc(length);
1014 if (!buffer_flash) {
1015 LOG_ERROR("Out of memory");
1016 free(buffer_file);
1017 return ERROR_FAIL;
1018 }
1019
1020 retval = flash_driver_read(p, buffer_flash, offset, length);
1021 if (retval != ERROR_OK) {
1022 LOG_ERROR("Flash read error");
1023 free(buffer_flash);
1024 free(buffer_file);
1025 return retval;
1026 }
1027
1028 if (duration_measure(&bench) == ERROR_OK)
1029 command_print(CMD, "read %zd bytes from file %s and flash bank %u"
1030 " at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
1031 length, CMD_ARGV[1], p->bank_number, offset,
1032 duration_elapsed(&bench), duration_kbps(&bench, length));
1033
1034 differ = memcmp(buffer_file, buffer_flash, length);
1035 command_print(CMD, "contents %s", differ ? "differ" : "match");
1036 if (differ) {
1037 uint32_t t;
1038 int diffs = 0;
1039 for (t = 0; t < length; t++) {
1040 if (buffer_flash[t] == buffer_file[t])
1041 continue;
1042 command_print(CMD, "diff %d address 0x%08" PRIx32 ". Was 0x%02x instead of 0x%02x",
1043 diffs, t + offset, buffer_flash[t], buffer_file[t]);
1044 if (diffs++ >= 127) {
1045 command_print(CMD, "More than 128 errors, the rest are not printed.");
1046 break;
1047 }
1048 keep_alive();
1049 }
1050 }
1051 free(buffer_flash);
1052 free(buffer_file);
1053
1054 return differ ? ERROR_FAIL : ERROR_OK;
1055 }
1056
1057 void flash_set_dirty(void)
1058 {
1059 struct flash_bank *c;
1060
1061 /* set all flash to require erasing */
1062 for (c = flash_bank_list(); c; c = c->next) {
1063 for (unsigned int i = 0; i < c->num_sectors; i++)
1064 c->sectors[i].is_erased = 0;
1065 }
1066 }
1067
1068 COMMAND_HANDLER(handle_flash_padded_value_command)
1069 {
1070 if (CMD_ARGC != 2)
1071 return ERROR_COMMAND_SYNTAX_ERROR;
1072
1073 struct flash_bank *p;
1074 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
1075 if (retval != ERROR_OK)
1076 return retval;
1077
1078 COMMAND_PARSE_NUMBER(u8, CMD_ARGV[1], p->default_padded_value);
1079
1080 command_print(CMD, "Default padded value set to 0x%" PRIx8 " for flash bank %u",
1081 p->default_padded_value, p->bank_number);
1082
1083 return retval;
1084 }
1085
1086 static const struct command_registration flash_exec_command_handlers[] = {
1087 {
1088 .name = "probe",
1089 .handler = handle_flash_probe_command,
1090 .mode = COMMAND_EXEC,
1091 .usage = "bank_id",
1092 .help = "Identify a flash bank.",
1093 },
1094 {
1095 .name = "info",
1096 .handler = handle_flash_info_command,
1097 .mode = COMMAND_EXEC,
1098 .usage = "bank_id ['sectors']",
1099 .help = "Print information about a flash bank.",
1100 },
1101 {
1102 .name = "erase_check",
1103 .handler = handle_flash_erase_check_command,
1104 .mode = COMMAND_EXEC,
1105 .usage = "bank_id",
1106 .help = "Check erase state of all blocks in a "
1107 "flash bank.",
1108 },
1109 {
1110 .name = "erase_sector",
1111 .handler = handle_flash_erase_command,
1112 .mode = COMMAND_EXEC,
1113 .usage = "bank_id first_sector_num (last_sector_num|'last')",
1114 .help = "Erase a range of sectors in a flash bank.",
1115 },
1116 {
1117 .name = "erase_address",
1118 .handler = handle_flash_erase_address_command,
1119 .mode = COMMAND_EXEC,
1120 .usage = "['pad'] ['unlock'] address length",
1121 .help = "Erase flash sectors starting at address and "
1122 "continuing for length bytes. If 'pad' is specified, "
1123 "data outside that range may also be erased: the start "
1124 "address may be decreased, and length increased, so "
1125 "that all of the first and last sectors are erased. "
1126 "If 'unlock' is specified, then the flash is unprotected "
1127 "before erasing.",
1128
1129 },
1130 {
1131 .name = "filld",
1132 .handler = handle_flash_fill_command,
1133 .mode = COMMAND_EXEC,
1134 .usage = "address value n",
1135 .help = "Fill n double-words with 64-bit value, starting at "
1136 "word address. (No autoerase.)",
1137 },
1138 {
1139 .name = "fillw",
1140 .handler = handle_flash_fill_command,
1141 .mode = COMMAND_EXEC,
1142 .usage = "address value n",
1143 .help = "Fill n words with 32-bit value, starting at "
1144 "word address. (No autoerase.)",
1145 },
1146 {
1147 .name = "fillh",
1148 .handler = handle_flash_fill_command,
1149 .mode = COMMAND_EXEC,
1150 .usage = "address value n",
1151 .help = "Fill n halfwords with 16-bit value, starting at "
1152 "word address. (No autoerase.)",
1153 },
1154 {
1155 .name = "fillb",
1156 .handler = handle_flash_fill_command,
1157 .mode = COMMAND_EXEC,
1158 .usage = "address value n",
1159 .help = "Fill n bytes with 8-bit value, starting at "
1160 "word address. (No autoerase.)",
1161 },
1162 {
1163 .name = "mdb",
1164 .handler = handle_flash_md_command,
1165 .mode = COMMAND_EXEC,
1166 .usage = "address [count]",
1167 .help = "Display bytes from flash.",
1168 },
1169 {
1170 .name = "mdh",
1171 .handler = handle_flash_md_command,
1172 .mode = COMMAND_EXEC,
1173 .usage = "address [count]",
1174 .help = "Display half-words from flash.",
1175 },
1176 {
1177 .name = "mdw",
1178 .handler = handle_flash_md_command,
1179 .mode = COMMAND_EXEC,
1180 .usage = "address [count]",
1181 .help = "Display words from flash.",
1182 },
1183 {
1184 .name = "write_bank",
1185 .handler = handle_flash_write_bank_command,
1186 .mode = COMMAND_EXEC,
1187 .usage = "bank_id filename [offset]",
1188 .help = "Write binary data from file to flash bank. Allow optional "
1189 "offset from beginning of the bank (defaults to zero).",
1190 },
1191 {
1192 .name = "write_image",
1193 .handler = handle_flash_write_image_command,
1194 .mode = COMMAND_EXEC,
1195 .usage = "[erase] [unlock] filename [offset [file_type]]",
1196 .help = "Write an image to flash. Optionally first unprotect "
1197 "and/or erase the region to be used. Allow optional "
1198 "offset from beginning of bank (defaults to zero)",
1199 },
1200 {
1201 .name = "verify_image",
1202 .handler = handle_flash_verify_image_command,
1203 .mode = COMMAND_EXEC,
1204 .usage = "filename [offset [file_type]]",
1205 .help = "Verify an image against flash. Allow optional "
1206 "offset from beginning of bank (defaults to zero)",
1207 },
1208 {
1209 .name = "read_bank",
1210 .handler = handle_flash_read_bank_command,
1211 .mode = COMMAND_EXEC,
1212 .usage = "bank_id filename [offset [length]]",
1213 .help = "Read binary data from flash bank to file. Allow optional "
1214 "offset from beginning of the bank (defaults to zero).",
1215 },
1216 {
1217 .name = "verify_bank",
1218 .handler = handle_flash_verify_bank_command,
1219 .mode = COMMAND_EXEC,
1220 .usage = "bank_id filename [offset]",
1221 .help = "Compare the contents of a file with the contents of the "
1222 "flash bank. Allow optional offset from beginning of the bank "
1223 "(defaults to zero).",
1224 },
1225 {
1226 .name = "protect",
1227 .handler = handle_flash_protect_command,
1228 .mode = COMMAND_EXEC,
1229 .usage = "bank_id first_block [last_block|'last'] "
1230 "('on'|'off')",
1231 .help = "Turn protection on or off for a range of protection "
1232 "blocks or sectors in a given flash bank. "
1233 "See 'flash info' output for a list of blocks.",
1234 },
1235 {
1236 .name = "padded_value",
1237 .handler = handle_flash_padded_value_command,
1238 .mode = COMMAND_EXEC,
1239 .usage = "bank_id value",
1240 .help = "Set default flash padded value",
1241 },
1242 COMMAND_REGISTRATION_DONE
1243 };
1244
1245 static int flash_init_drivers(struct command_context *cmd_ctx)
1246 {
1247 if (!flash_bank_list())
1248 return ERROR_OK;
1249
1250 return register_commands(cmd_ctx, "flash", flash_exec_command_handlers);
1251 }
1252
1253 COMMAND_HANDLER(handle_flash_bank_command)
1254 {
1255 if (CMD_ARGC < 7) {
1256 LOG_ERROR("usage: flash bank <name> <driver> "
1257 "<base> <size> <chip_width> <bus_width> <target>");
1258 return ERROR_COMMAND_SYNTAX_ERROR;
1259 }
1260 /* save bank name and advance arguments for compatibility */
1261 const char *bank_name = *CMD_ARGV++;
1262 CMD_ARGC--;
1263
1264 struct target *target = get_target(CMD_ARGV[5]);
1265 if (!target) {
1266 LOG_ERROR("target '%s' not defined", CMD_ARGV[5]);
1267 return ERROR_FAIL;
1268 }
1269
1270 const char *driver_name = CMD_ARGV[0];
1271 const struct flash_driver *driver = flash_driver_find_by_name(driver_name);
1272 if (!driver) {
1273 /* no matching flash driver found */
1274 LOG_ERROR("flash driver '%s' not found", driver_name);
1275 return ERROR_FAIL;
1276 }
1277
1278 /* check the flash bank name is unique */
1279 if (get_flash_bank_by_name_noprobe(bank_name)) {
1280 /* flash bank name already exists */
1281 LOG_ERROR("flash bank name '%s' already exists", bank_name);
1282 return ERROR_FAIL;
1283 }
1284
1285 /* register flash specific commands */
1286 if (driver->commands) {
1287 int retval = register_commands(CMD_CTX, NULL,
1288 driver->commands);
1289 if (retval != ERROR_OK) {
1290 LOG_ERROR("couldn't register '%s' commands",
1291 driver_name);
1292 return ERROR_FAIL;
1293 }
1294 }
1295
1296 struct flash_bank *c = calloc(1, sizeof(*c));
1297 c->name = strdup(bank_name);
1298 c->target = target;
1299 c->driver = driver;
1300 COMMAND_PARSE_NUMBER(target_addr, CMD_ARGV[1], c->base);
1301 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], c->size);
1302 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[3], c->chip_width);
1303 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[4], c->bus_width);
1304 c->default_padded_value = c->erased_value = 0xff;
1305 c->minimal_write_gap = FLASH_WRITE_GAP_SECTOR;
1306
1307 int retval;
1308 retval = CALL_COMMAND_HANDLER(driver->flash_bank_command, c);
1309 if (retval != ERROR_OK) {
1310 LOG_ERROR("'%s' driver rejected flash bank at " TARGET_ADDR_FMT
1311 "; usage: %s", driver_name, c->base, driver->usage);
1312 free(c);
1313 return retval;
1314 }
1315
1316 if (!driver->usage)
1317 LOG_DEBUG("'%s' driver usage field missing", driver_name);
1318
1319 flash_bank_add(c);
1320
1321 return ERROR_OK;
1322 }
1323
1324 COMMAND_HANDLER(handle_flash_banks_command)
1325 {
1326 if (CMD_ARGC != 0)
1327 return ERROR_COMMAND_SYNTAX_ERROR;
1328
1329 unsigned n = 0;
1330 for (struct flash_bank *p = flash_bank_list(); p; p = p->next, n++) {
1331 command_print(CMD, "#%d : %s (%s) at " TARGET_ADDR_FMT ", size 0x%8.8" PRIx32 ", "
1332 "buswidth %u, chipwidth %u", p->bank_number,
1333 p->name, p->driver->name, p->base, p->size,
1334 p->bus_width, p->chip_width);
1335 }
1336 return ERROR_OK;
1337 }
1338
1339 static int jim_flash_list(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
1340 {
1341 if (argc != 1) {
1342 Jim_WrongNumArgs(interp, 1, argv,
1343 "no arguments to 'flash list' command");
1344 return JIM_ERR;
1345 }
1346
1347 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
1348
1349 for (struct flash_bank *p = flash_bank_list(); p; p = p->next) {
1350 Jim_Obj *elem = Jim_NewListObj(interp, NULL, 0);
1351
1352 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "name", -1));
1353 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, p->name, -1));
1354 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "driver", -1));
1355 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, p->driver->name, -1));
1356 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "base", -1));
1357 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->base));
1358 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "size", -1));
1359 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->size));
1360 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "bus_width", -1));
1361 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->bus_width));
1362 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "chip_width", -1));
1363 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->chip_width));
1364
1365 Jim_ListAppendElement(interp, list, elem);
1366 }
1367
1368 Jim_SetResult(interp, list);
1369
1370 return JIM_OK;
1371 }
1372
1373 COMMAND_HANDLER(handle_flash_init_command)
1374 {
1375 if (CMD_ARGC != 0)
1376 return ERROR_COMMAND_SYNTAX_ERROR;
1377
1378 static bool flash_initialized;
1379 if (flash_initialized) {
1380 LOG_INFO("'flash init' has already been called");
1381 return ERROR_OK;
1382 }
1383 flash_initialized = true;
1384
1385 LOG_DEBUG("Initializing flash devices...");
1386 return flash_init_drivers(CMD_CTX);
1387 }
1388
1389 static const struct command_registration flash_config_command_handlers[] = {
1390 {
1391 .name = "bank",
1392 .handler = handle_flash_bank_command,
1393 .mode = COMMAND_CONFIG,
1394 .usage = "bank_id driver_name base_address size_bytes "
1395 "chip_width_bytes bus_width_bytes target "
1396 "[driver_options ...]",
1397 .help = "Define a new bank with the given name, "
1398 "using the specified NOR flash driver.",
1399 },
1400 {
1401 .name = "init",
1402 .mode = COMMAND_CONFIG,
1403 .handler = handle_flash_init_command,
1404 .help = "Initialize flash devices.",
1405 .usage = "",
1406 },
1407 {
1408 .name = "banks",
1409 .mode = COMMAND_ANY,
1410 .handler = handle_flash_banks_command,
1411 .help = "Display table with information about flash banks.",
1412 .usage = "",
1413 },
1414 {
1415 .name = "list",
1416 .mode = COMMAND_ANY,
1417 .jim_handler = jim_flash_list,
1418 .help = "Returns a list of details about the flash banks.",
1419 },
1420 COMMAND_REGISTRATION_DONE
1421 };
1422 static const struct command_registration flash_command_handlers[] = {
1423 {
1424 .name = "flash",
1425 .mode = COMMAND_ANY,
1426 .help = "NOR flash command group",
1427 .chain = flash_config_command_handlers,
1428 .usage = "",
1429 },
1430 COMMAND_REGISTRATION_DONE
1431 };
1432
1433 int flash_register_commands(struct command_context *cmd_ctx)
1434 {
1435 return register_commands(cmd_ctx, NULL, flash_command_handlers);
1436 }
Official OpenOCD Mirror