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

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)