9628684ed6bac7eb680bf977df2aa51d24640b15
[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 * *
7 * This program is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation; either version 2 of the License, or *
10 * (at your option) any later version. *
11 * *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
16 * *
17 * You should have received a copy of the GNU General Public License *
18 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
19 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23 #include "imp.h"
24 #include <helper/time_support.h>
25 #include <target/image.h>
26
27 /**
28 * @file
29 * Implements Tcl commands used to access NOR flash facilities.
30 */
31
32 COMMAND_HELPER(flash_command_get_bank_maybe_probe, unsigned name_index,
33 struct flash_bank **bank, bool do_probe)
34 {
35 const char *name = CMD_ARGV[name_index];
36 int retval;
37 if (do_probe) {
38 retval = get_flash_bank_by_name(name, bank);
39 } else {
40 *bank = get_flash_bank_by_name_noprobe(name);
41 retval = ERROR_OK;
42 }
43
44 if (retval != ERROR_OK)
45 return retval;
46 if (*bank)
47 return ERROR_OK;
48
49 unsigned bank_num;
50 COMMAND_PARSE_NUMBER(uint, name, bank_num);
51
52 if (do_probe) {
53 return get_flash_bank_by_num(bank_num, bank);
54 } else {
55 *bank = get_flash_bank_by_num_noprobe(bank_num);
56 retval = (bank) ? ERROR_OK : ERROR_FAIL;
57 return retval;
58 }
59 }
60
61 COMMAND_HELPER(flash_command_get_bank, unsigned name_index,
62 struct flash_bank **bank)
63 {
64 return CALL_COMMAND_HANDLER(flash_command_get_bank_maybe_probe,
65 name_index, bank, true);
66 }
67
68 COMMAND_HANDLER(handle_flash_info_command)
69 {
70 struct flash_bank *p;
71 int j = 0;
72 int retval;
73
74 if (CMD_ARGC != 1)
75 return ERROR_COMMAND_SYNTAX_ERROR;
76
77 retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
78 if (retval != ERROR_OK)
79 return retval;
80
81 if (p != NULL) {
82 char buf[1024];
83
84 /* attempt auto probe */
85 retval = p->driver->auto_probe(p);
86 if (retval != ERROR_OK)
87 return retval;
88
89 /* We must query the hardware to avoid printing stale information! */
90 retval = p->driver->protect_check(p);
91 if (retval != ERROR_OK)
92 return retval;
93
94 command_print(CMD_CTX,
95 "#%d : %s at 0x%8.8" PRIx32 ", size 0x%8.8" PRIx32
96 ", buswidth %i, chipwidth %i",
97 p->bank_number,
98 p->driver->name,
99 p->base,
100 p->size,
101 p->bus_width,
102 p->chip_width);
103 for (j = 0; j < p->num_sectors; j++) {
104 char *protect_state;
105
106 if (p->sectors[j].is_protected == 0)
107 protect_state = "not protected";
108 else if (p->sectors[j].is_protected == 1)
109 protect_state = "protected";
110 else
111 protect_state = "protection state unknown";
112
113 command_print(CMD_CTX,
114 "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
115 j,
116 p->sectors[j].offset,
117 p->sectors[j].size,
118 p->sectors[j].size >> 10,
119 protect_state);
120 }
121
122 if (p->driver->info != NULL) {
123 retval = p->driver->info(p, buf, sizeof(buf));
124 if (retval == ERROR_OK)
125 command_print(CMD_CTX, "%s", buf);
126 else
127 LOG_ERROR("error retrieving flash info");
128 }
129 }
130
131 return retval;
132 }
133
134 COMMAND_HANDLER(handle_flash_probe_command)
135 {
136 struct flash_bank *p;
137 int retval;
138
139 if (CMD_ARGC != 1)
140 return ERROR_COMMAND_SYNTAX_ERROR;
141
142 retval = CALL_COMMAND_HANDLER(flash_command_get_bank_maybe_probe, 0, &p, false);
143 if (retval != ERROR_OK)
144 return retval;
145
146 if (p) {
147 retval = p->driver->probe(p);
148 if (retval == ERROR_OK)
149 command_print(CMD_CTX,
150 "flash '%s' found at 0x%8.8" PRIx32,
151 p->driver->name,
152 p->base);
153 } else {
154 command_print(CMD_CTX, "flash bank '#%s' is out of bounds", CMD_ARGV[0]);
155 retval = ERROR_FAIL;
156 }
157
158 return retval;
159 }
160
161 COMMAND_HANDLER(handle_flash_erase_check_command)
162 {
163 bool blank = true;
164 if (CMD_ARGC != 1)
165 return ERROR_COMMAND_SYNTAX_ERROR;
166
167 struct flash_bank *p;
168 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
169 if (ERROR_OK != retval)
170 return retval;
171
172 int j;
173 retval = p->driver->erase_check(p);
174 if (retval == ERROR_OK)
175 command_print(CMD_CTX, "successfully checked erase state");
176 else {
177 command_print(CMD_CTX,
178 "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32,
179 CMD_ARGV[0],
180 p->base);
181 }
182
183 for (j = 0; j < p->num_sectors; j++) {
184 char *erase_state;
185
186 if (p->sectors[j].is_erased == 0)
187 erase_state = "not erased";
188 else if (p->sectors[j].is_erased == 1)
189 continue;
190 else
191 erase_state = "erase state unknown";
192
193 blank = false;
194 command_print(CMD_CTX,
195 "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
196 j,
197 p->sectors[j].offset,
198 p->sectors[j].size,
199 p->sectors[j].size >> 10,
200 erase_state);
201 }
202
203 if (blank)
204 command_print(CMD_CTX, "\tBank is erased");
205 return retval;
206 }
207
208 COMMAND_HANDLER(handle_flash_erase_address_command)
209 {
210 struct flash_bank *p;
211 int retval = ERROR_OK;
212 uint32_t address;
213 uint32_t length;
214 bool do_pad = false;
215 bool do_unlock = false;
216 struct target *target = get_current_target(CMD_CTX);
217
218 while (CMD_ARGC >= 3) {
219 /* Optionally pad out the address range to block/sector
220 * boundaries. We can't know if there's data in that part
221 * of the flash; only do padding if we're told to.
222 */
223 if (strcmp("pad", CMD_ARGV[0]) == 0)
224 do_pad = true;
225 else if (strcmp("unlock", CMD_ARGV[0]) == 0)
226 do_unlock = true;
227 else
228 return ERROR_COMMAND_SYNTAX_ERROR;
229 CMD_ARGC--;
230 CMD_ARGV++;
231 }
232 if (CMD_ARGC != 2)
233 return ERROR_COMMAND_SYNTAX_ERROR;
234
235 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
236 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], length);
237
238 if (length <= 0) {
239 command_print(CMD_CTX, "Length must be >0");
240 return ERROR_COMMAND_SYNTAX_ERROR;
241 }
242
243 retval = get_flash_bank_by_addr(target, address, true, &p);
244 if (retval != ERROR_OK)
245 return retval;
246
247 /* We can't know if we did a resume + halt, in which case we no longer know the erased state
248 **/
249 flash_set_dirty();
250
251 struct duration bench;
252 duration_start(&bench);
253
254 if (do_unlock)
255 retval = flash_unlock_address_range(target, address, length);
256
257 if (retval == ERROR_OK)
258 retval = flash_erase_address_range(target, do_pad, address, length);
259
260 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
261 command_print(CMD_CTX, "erased address 0x%8.8" PRIx32 " (length %" PRIi32 ")"
262 " in %fs (%0.3f KiB/s)", address, length,
263 duration_elapsed(&bench), duration_kbps(&bench, length));
264 }
265
266 return retval;
267 }
268
269 static int flash_check_sector_parameters(struct command_context *cmd_ctx,
270 uint32_t first, uint32_t last, uint32_t num_sectors)
271 {
272 if (!(first <= last)) {
273 command_print(cmd_ctx, "ERROR: "
274 "first sector must be <= last sector");
275 return ERROR_FAIL;
276 }
277
278 if (!(last <= (num_sectors - 1))) {
279 command_print(cmd_ctx, "ERROR: last sector must be <= %d",
280 (int) num_sectors - 1);
281 return ERROR_FAIL;
282 }
283
284 return ERROR_OK;
285 }
286
287 COMMAND_HANDLER(handle_flash_erase_command)
288 {
289 if (CMD_ARGC != 3)
290 return ERROR_COMMAND_SYNTAX_ERROR;
291
292 uint32_t first;
293 uint32_t last;
294
295 struct flash_bank *p;
296 int retval;
297
298 retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
299 if (retval != ERROR_OK)
300 return retval;
301
302 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first);
303 if (strcmp(CMD_ARGV[2], "last") == 0)
304 last = p->num_sectors - 1;
305 else
306 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
307
308 retval = flash_check_sector_parameters(CMD_CTX, first, last, p->num_sectors);
309 if (retval != ERROR_OK)
310 return retval;
311
312 struct duration bench;
313 duration_start(&bench);
314
315 retval = flash_driver_erase(p, first, last);
316
317 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
318 command_print(CMD_CTX, "erased sectors %" PRIu32 " "
319 "through %" PRIu32 " on flash bank %d "
320 "in %fs", first, last, p->bank_number, duration_elapsed(&bench));
321 }
322
323 return ERROR_OK;
324 }
325
326 COMMAND_HANDLER(handle_flash_protect_command)
327 {
328 if (CMD_ARGC != 4)
329 return ERROR_COMMAND_SYNTAX_ERROR;
330
331 uint32_t first;
332 uint32_t last;
333
334 struct flash_bank *p;
335 int retval;
336
337 retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
338 if (retval != ERROR_OK)
339 return retval;
340
341 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first);
342 if (strcmp(CMD_ARGV[2], "last") == 0)
343 last = p->num_sectors - 1;
344 else
345 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
346
347 bool set;
348 COMMAND_PARSE_ON_OFF(CMD_ARGV[3], set);
349
350 retval = flash_check_sector_parameters(CMD_CTX, first, last, p->num_sectors);
351 if (retval != ERROR_OK)
352 return retval;
353
354 retval = flash_driver_protect(p, set, first, last);
355 if (retval == ERROR_OK) {
356 command_print(CMD_CTX, "%s protection for sectors %i "
357 "through %i on flash bank %d",
358 (set) ? "set" : "cleared", (int) first,
359 (int) last, p->bank_number);
360 }
361
362 return retval;
363 }
364
365 COMMAND_HANDLER(handle_flash_write_image_command)
366 {
367 struct target *target = get_current_target(CMD_CTX);
368
369 struct image image;
370 uint32_t written;
371
372 int retval;
373
374 /* flash auto-erase is disabled by default*/
375 int auto_erase = 0;
376 bool auto_unlock = false;
377
378 while (CMD_ARGC) {
379 if (strcmp(CMD_ARGV[0], "erase") == 0) {
380 auto_erase = 1;
381 CMD_ARGV++;
382 CMD_ARGC--;
383 command_print(CMD_CTX, "auto erase enabled");
384 } else if (strcmp(CMD_ARGV[0], "unlock") == 0) {
385 auto_unlock = true;
386 CMD_ARGV++;
387 CMD_ARGC--;
388 command_print(CMD_CTX, "auto unlock enabled");
389 } else
390 break;
391 }
392
393 if (CMD_ARGC < 1)
394 return ERROR_COMMAND_SYNTAX_ERROR;
395
396 if (!target) {
397 LOG_ERROR("no target selected");
398 return ERROR_FAIL;
399 }
400
401 struct duration bench;
402 duration_start(&bench);
403
404 if (CMD_ARGC >= 2) {
405 image.base_address_set = 1;
406 COMMAND_PARSE_NUMBER(llong, CMD_ARGV[1], image.base_address);
407 } else {
408 image.base_address_set = 0;
409 image.base_address = 0x0;
410 }
411
412 image.start_address_set = 0;
413
414 retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL);
415 if (retval != ERROR_OK)
416 return retval;
417
418 retval = flash_write_unlock(target, &image, &written, auto_erase, auto_unlock);
419 if (retval != ERROR_OK) {
420 image_close(&image);
421 return retval;
422 }
423
424 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
425 command_print(CMD_CTX, "wrote %" PRIu32 " bytes from file %s "
426 "in %fs (%0.3f KiB/s)", written, CMD_ARGV[0],
427 duration_elapsed(&bench), duration_kbps(&bench, written));
428 }
429
430 image_close(&image);
431
432 return retval;
433 }
434
435 COMMAND_HANDLER(handle_flash_fill_command)
436 {
437 int err = ERROR_OK;
438 uint32_t address;
439 uint32_t pattern;
440 uint32_t count;
441 uint32_t wrote = 0;
442 uint32_t cur_size = 0;
443 uint32_t chunk_count;
444 struct target *target = get_current_target(CMD_CTX);
445 unsigned i;
446 uint32_t wordsize;
447 int retval = ERROR_OK;
448
449 static size_t const chunksize = 1024;
450 uint8_t *chunk = NULL, *readback = NULL;
451
452 if (CMD_ARGC != 3) {
453 retval = ERROR_COMMAND_SYNTAX_ERROR;
454 goto done;
455 }
456
457 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
458 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], pattern);
459 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], count);
460
461 chunk = malloc(chunksize);
462 if (chunk == NULL)
463 return ERROR_FAIL;
464
465 readback = malloc(chunksize);
466 if (readback == NULL) {
467 free(chunk);
468 return ERROR_FAIL;
469 }
470
471 if (count == 0)
472 goto done;
473
474 switch (CMD_NAME[4]) {
475 case 'w':
476 wordsize = 4;
477 break;
478 case 'h':
479 wordsize = 2;
480 break;
481 case 'b':
482 wordsize = 1;
483 break;
484 default:
485 retval = ERROR_COMMAND_SYNTAX_ERROR;
486 goto done;
487 }
488
489 chunk_count = MIN(count, (chunksize / wordsize));
490 switch (wordsize) {
491 case 4:
492 for (i = 0; i < chunk_count; i++)
493 target_buffer_set_u32(target, chunk + i * wordsize, pattern);
494 break;
495 case 2:
496 for (i = 0; i < chunk_count; i++)
497 target_buffer_set_u16(target, chunk + i * wordsize, pattern);
498 break;
499 case 1:
500 memset(chunk, pattern, chunk_count);
501 break;
502 default:
503 LOG_ERROR("BUG: can't happen");
504 exit(-1);
505 }
506
507 struct duration bench;
508 duration_start(&bench);
509
510 for (wrote = 0; wrote < (count*wordsize); wrote += cur_size) {
511 struct flash_bank *bank;
512
513 retval = get_flash_bank_by_addr(target, address, true, &bank);
514 if (retval != ERROR_OK)
515 goto done;
516
517 cur_size = MIN((count * wordsize - wrote), chunksize);
518 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
519 if (err != ERROR_OK) {
520 retval = err;
521 goto done;
522 }
523
524 err = flash_driver_read(bank, readback, address - bank->base + wrote, cur_size);
525 if (err != ERROR_OK) {
526 retval = err;
527 goto done;
528 }
529
530 for (i = 0; i < cur_size; i++) {
531 if (readback[i] != chunk[i]) {
532 LOG_ERROR(
533 "Verification error address 0x%08" PRIx32 ", read back 0x%02x, expected 0x%02x",
534 address + wrote + i,
535 readback[i],
536 chunk[i]);
537 retval = ERROR_FAIL;
538 goto done;
539 }
540 }
541 }
542
543 if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
544 command_print(CMD_CTX, "wrote %" PRIu32 " bytes to 0x%8.8" PRIx32
545 " in %fs (%0.3f KiB/s)", wrote, address,
546 duration_elapsed(&bench), duration_kbps(&bench, wrote));
547 }
548
549 done:
550 free(readback);
551 free(chunk);
552
553 return retval;
554 }
555
556 COMMAND_HANDLER(handle_flash_write_bank_command)
557 {
558 uint32_t offset;
559 uint8_t *buffer;
560 struct fileio *fileio;
561
562 if (CMD_ARGC != 3)
563 return ERROR_COMMAND_SYNTAX_ERROR;
564
565 struct duration bench;
566 duration_start(&bench);
567
568 struct flash_bank *p;
569 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
570 if (ERROR_OK != retval)
571 return retval;
572
573 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], offset);
574
575 if (fileio_open(&fileio, CMD_ARGV[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
576 return ERROR_OK;
577
578 size_t filesize;
579 retval = fileio_size(fileio, &filesize);
580 if (retval != ERROR_OK) {
581 fileio_close(fileio);
582 return retval;
583 }
584
585 buffer = malloc(filesize);
586 if (buffer == NULL) {
587 fileio_close(fileio);
588 LOG_ERROR("Out of memory");
589 return ERROR_FAIL;
590 }
591 size_t buf_cnt;
592 if (fileio_read(fileio, filesize, buffer, &buf_cnt) != ERROR_OK) {
593 free(buffer);
594 fileio_close(fileio);
595 return ERROR_OK;
596 }
597
598 retval = flash_driver_write(p, buffer, offset, buf_cnt);
599
600 free(buffer);
601 buffer = NULL;
602
603 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK)) {
604 command_print(CMD_CTX, "wrote %zu bytes from file %s to flash bank %u"
605 " at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
606 filesize, CMD_ARGV[1], p->bank_number, offset,
607 duration_elapsed(&bench), duration_kbps(&bench, filesize));
608 }
609
610 fileio_close(fileio);
611
612 return retval;
613 }
614
615 COMMAND_HANDLER(handle_flash_read_bank_command)
616 {
617 uint32_t offset;
618 uint8_t *buffer;
619 struct fileio *fileio;
620 uint32_t length;
621 size_t written;
622
623 if (CMD_ARGC != 4)
624 return ERROR_COMMAND_SYNTAX_ERROR;
625
626 struct duration bench;
627 duration_start(&bench);
628
629 struct flash_bank *p;
630 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
631 if (ERROR_OK != retval)
632 return retval;
633
634 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], offset);
635 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[3], length);
636
637 buffer = malloc(length);
638 if (buffer == NULL) {
639 LOG_ERROR("Out of memory");
640 return ERROR_FAIL;
641 }
642
643 retval = flash_driver_read(p, buffer, offset, length);
644 if (retval != ERROR_OK) {
645 LOG_ERROR("Read error");
646 free(buffer);
647 return retval;
648 }
649
650 retval = fileio_open(&fileio, CMD_ARGV[1], FILEIO_WRITE, FILEIO_BINARY);
651 if (retval != ERROR_OK) {
652 LOG_ERROR("Could not open file");
653 free(buffer);
654 return retval;
655 }
656
657 retval = fileio_write(fileio, length, buffer, &written);
658 fileio_close(fileio);
659 free(buffer);
660 if (retval != ERROR_OK) {
661 LOG_ERROR("Could not write file");
662 return ERROR_FAIL;
663 }
664
665 if (duration_measure(&bench) == ERROR_OK)
666 command_print(CMD_CTX, "wrote %ld bytes to file %s from flash bank %u"
667 " at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
668 (long)written, CMD_ARGV[1], p->bank_number, offset,
669 duration_elapsed(&bench), duration_kbps(&bench, written));
670
671 return retval;
672 }
673
674
675 COMMAND_HANDLER(handle_flash_verify_bank_command)
676 {
677 uint32_t offset;
678 uint8_t *buffer_file, *buffer_flash;
679 struct fileio *fileio;
680 size_t read_cnt;
681 size_t filesize;
682 int differ;
683
684 if (CMD_ARGC != 3)
685 return ERROR_COMMAND_SYNTAX_ERROR;
686
687 struct duration bench;
688 duration_start(&bench);
689
690 struct flash_bank *p;
691 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
692 if (ERROR_OK != retval)
693 return retval;
694
695 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], offset);
696
697 retval = fileio_open(&fileio, CMD_ARGV[1], FILEIO_READ, FILEIO_BINARY);
698 if (retval != ERROR_OK) {
699 LOG_ERROR("Could not open file");
700 return retval;
701 }
702
703 retval = fileio_size(fileio, &filesize);
704 if (retval != ERROR_OK) {
705 fileio_close(fileio);
706 return retval;
707 }
708
709 buffer_file = malloc(filesize);
710 if (buffer_file == NULL) {
711 LOG_ERROR("Out of memory");
712 fileio_close(fileio);
713 return ERROR_FAIL;
714 }
715
716 retval = fileio_read(fileio, filesize, buffer_file, &read_cnt);
717 fileio_close(fileio);
718 if (retval != ERROR_OK) {
719 LOG_ERROR("File read failure");
720 free(buffer_file);
721 return retval;
722 }
723
724 if (read_cnt != filesize) {
725 LOG_ERROR("Short read");
726 free(buffer_file);
727 return ERROR_FAIL;
728 }
729
730 buffer_flash = malloc(filesize);
731 if (buffer_flash == NULL) {
732 LOG_ERROR("Out of memory");
733 free(buffer_file);
734 return ERROR_FAIL;
735 }
736
737 retval = flash_driver_read(p, buffer_flash, offset, read_cnt);
738 if (retval != ERROR_OK) {
739 LOG_ERROR("Flash read error");
740 free(buffer_flash);
741 free(buffer_file);
742 return retval;
743 }
744
745 if (duration_measure(&bench) == ERROR_OK)
746 command_print(CMD_CTX, "read %ld bytes from file %s and flash bank %u"
747 " at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
748 (long)read_cnt, CMD_ARGV[1], p->bank_number, offset,
749 duration_elapsed(&bench), duration_kbps(&bench, read_cnt));
750
751 differ = memcmp(buffer_file, buffer_flash, read_cnt);
752 command_print(CMD_CTX, "contents %s", differ ? "differ" : "match");
753 if (differ) {
754 uint32_t t;
755 int diffs = 0;
756 for (t = 0; t < read_cnt; t++) {
757 if (buffer_flash[t] == buffer_file[t])
758 continue;
759 command_print(CMD_CTX, "diff %d address 0x%08x. Was 0x%02x instead of 0x%02x",
760 diffs, t + offset, buffer_flash[t], buffer_file[t]);
761 if (diffs++ >= 127) {
762 command_print(CMD_CTX, "More than 128 errors, the rest are not printed.");
763 break;
764 }
765 keep_alive();
766 }
767 }
768 free(buffer_flash);
769 free(buffer_file);
770
771 return differ ? ERROR_FAIL : ERROR_OK;
772 }
773
774 void flash_set_dirty(void)
775 {
776 struct flash_bank *c;
777 int i;
778
779 /* set all flash to require erasing */
780 for (c = flash_bank_list(); c; c = c->next) {
781 for (i = 0; i < c->num_sectors; i++)
782 c->sectors[i].is_erased = 0;
783 }
784 }
785
786 COMMAND_HANDLER(handle_flash_padded_value_command)
787 {
788 if (CMD_ARGC != 2)
789 return ERROR_COMMAND_SYNTAX_ERROR;
790
791 struct flash_bank *p;
792 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
793 if (ERROR_OK != retval)
794 return retval;
795
796 COMMAND_PARSE_NUMBER(u8, CMD_ARGV[1], p->default_padded_value);
797
798 command_print(CMD_CTX, "Default padded value set to 0x%" PRIx8 " for flash bank %u", \
799 p->default_padded_value, p->bank_number);
800
801 return retval;
802 }
803
804 static const struct command_registration flash_exec_command_handlers[] = {
805 {
806 .name = "probe",
807 .handler = handle_flash_probe_command,
808 .mode = COMMAND_EXEC,
809 .usage = "bank_id",
810 .help = "Identify a flash bank.",
811 },
812 {
813 .name = "info",
814 .handler = handle_flash_info_command,
815 .mode = COMMAND_EXEC,
816 .usage = "bank_id",
817 .help = "Print information about a flash bank.",
818 },
819 {
820 .name = "erase_check",
821 .handler = handle_flash_erase_check_command,
822 .mode = COMMAND_EXEC,
823 .usage = "bank_id",
824 .help = "Check erase state of all blocks in a "
825 "flash bank.",
826 },
827 {
828 .name = "erase_sector",
829 .handler = handle_flash_erase_command,
830 .mode = COMMAND_EXEC,
831 .usage = "bank_id first_sector_num last_sector_num",
832 .help = "Erase a range of sectors in a flash bank.",
833 },
834 {
835 .name = "erase_address",
836 .handler = handle_flash_erase_address_command,
837 .mode = COMMAND_EXEC,
838 .usage = "['pad'] ['unlock'] address length",
839 .help = "Erase flash sectors starting at address and "
840 "continuing for length bytes. If 'pad' is specified, "
841 "data outside that range may also be erased: the start "
842 "address may be decreased, and length increased, so "
843 "that all of the first and last sectors are erased. "
844 "If 'unlock' is specified, then the flash is unprotected "
845 "before erasing.",
846
847 },
848 {
849 .name = "fillw",
850 .handler = handle_flash_fill_command,
851 .mode = COMMAND_EXEC,
852 .usage = "address value n",
853 .help = "Fill n words with 32-bit value, starting at "
854 "word address. (No autoerase.)",
855 },
856 {
857 .name = "fillh",
858 .handler = handle_flash_fill_command,
859 .mode = COMMAND_EXEC,
860 .usage = "address value n",
861 .help = "Fill n halfwords with 16-bit value, starting at "
862 "word address. (No autoerase.)",
863 },
864 {
865 .name = "fillb",
866 .handler = handle_flash_fill_command,
867 .mode = COMMAND_EXEC,
868 .usage = "address value n",
869 .help = "Fill n bytes with 8-bit value, starting at "
870 "word address. (No autoerase.)",
871 },
872 {
873 .name = "write_bank",
874 .handler = handle_flash_write_bank_command,
875 .mode = COMMAND_EXEC,
876 .usage = "bank_id filename offset",
877 .help = "Write binary data from file to flash bank, "
878 "starting at specified byte offset from the "
879 "beginning of the bank.",
880 },
881 {
882 .name = "write_image",
883 .handler = handle_flash_write_image_command,
884 .mode = COMMAND_EXEC,
885 .usage = "[erase] [unlock] filename [offset [file_type]]",
886 .help = "Write an image to flash. Optionally first unprotect "
887 "and/or erase the region to be used. Allow optional "
888 "offset from beginning of bank (defaults to zero)",
889 },
890 {
891 .name = "read_bank",
892 .handler = handle_flash_read_bank_command,
893 .mode = COMMAND_EXEC,
894 .usage = "bank_id filename offset length",
895 .help = "Read binary data from flash bank to file, "
896 "starting at specified byte offset from the "
897 "beginning of the bank.",
898 },
899 {
900 .name = "verify_bank",
901 .handler = handle_flash_verify_bank_command,
902 .mode = COMMAND_EXEC,
903 .usage = "bank_id filename offset",
904 .help = "Read binary data from flash bank and file, "
905 "starting at specified byte offset from the "
906 "beginning of the bank. Compare the contents.",
907 },
908 {
909 .name = "protect",
910 .handler = handle_flash_protect_command,
911 .mode = COMMAND_EXEC,
912 .usage = "bank_id first_sector [last_sector|'last'] "
913 "('on'|'off')",
914 .help = "Turn protection on or off for a range of sectors "
915 "in a given flash bank.",
916 },
917 {
918 .name = "padded_value",
919 .handler = handle_flash_padded_value_command,
920 .mode = COMMAND_EXEC,
921 .usage = "bank_id value",
922 .help = "Set default flash padded value",
923 },
924 COMMAND_REGISTRATION_DONE
925 };
926
927 static int flash_init_drivers(struct command_context *cmd_ctx)
928 {
929 if (!flash_bank_list())
930 return ERROR_OK;
931
932 struct command *parent = command_find_in_context(cmd_ctx, "flash");
933 return register_commands(cmd_ctx, parent, flash_exec_command_handlers);
934 }
935
936 COMMAND_HANDLER(handle_flash_bank_command)
937 {
938 if (CMD_ARGC < 7) {
939 LOG_ERROR("usage: flash bank <name> <driver> "
940 "<base> <size> <chip_width> <bus_width> <target>");
941 return ERROR_COMMAND_SYNTAX_ERROR;
942 }
943 /* save bank name and advance arguments for compatibility */
944 const char *bank_name = *CMD_ARGV++;
945 CMD_ARGC--;
946
947 struct target *target = get_target(CMD_ARGV[5]);
948 if (target == NULL) {
949 LOG_ERROR("target '%s' not defined", CMD_ARGV[5]);
950 return ERROR_FAIL;
951 }
952
953 const char *driver_name = CMD_ARGV[0];
954 struct flash_driver *driver = flash_driver_find_by_name(driver_name);
955 if (NULL == driver) {
956 /* no matching flash driver found */
957 LOG_ERROR("flash driver '%s' not found", driver_name);
958 return ERROR_FAIL;
959 }
960
961 /* check the flash bank name is unique */
962 if (get_flash_bank_by_name_noprobe(bank_name) != NULL) {
963 /* flash bank name already exists */
964 LOG_ERROR("flash bank name '%s' already exists", bank_name);
965 return ERROR_FAIL;
966 }
967
968 /* register flash specific commands */
969 if (NULL != driver->commands) {
970 int retval = register_commands(CMD_CTX, NULL,
971 driver->commands);
972 if (ERROR_OK != retval) {
973 LOG_ERROR("couldn't register '%s' commands",
974 driver_name);
975 return ERROR_FAIL;
976 }
977 }
978
979 struct flash_bank *c = malloc(sizeof(*c));
980 c->name = strdup(bank_name);
981 c->target = target;
982 c->driver = driver;
983 c->driver_priv = NULL;
984 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], c->base);
985 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], c->size);
986 COMMAND_PARSE_NUMBER(int, CMD_ARGV[3], c->chip_width);
987 COMMAND_PARSE_NUMBER(int, CMD_ARGV[4], c->bus_width);
988 c->default_padded_value = 0xff;
989 c->num_sectors = 0;
990 c->sectors = NULL;
991 c->next = NULL;
992
993 int retval;
994 retval = CALL_COMMAND_HANDLER(driver->flash_bank_command, c);
995 if (ERROR_OK != retval) {
996 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32 "; usage: %s",
997 driver_name, c->base, driver->usage);
998 free(c);
999 return retval;
1000 }
1001
1002 if (driver->usage == NULL)
1003 LOG_DEBUG("'%s' driver usage field missing", driver_name);
1004
1005 flash_bank_add(c);
1006
1007 return ERROR_OK;
1008 }
1009
1010 COMMAND_HANDLER(handle_flash_banks_command)
1011 {
1012 if (CMD_ARGC != 0)
1013 return ERROR_COMMAND_SYNTAX_ERROR;
1014
1015 unsigned n = 0;
1016 for (struct flash_bank *p = flash_bank_list(); p; p = p->next, n++) {
1017 LOG_USER("#%d : %s (%s) at 0x%8.8" PRIx32 ", size 0x%8.8" PRIx32 ", "
1018 "buswidth %u, chipwidth %u", p->bank_number,
1019 p->name, p->driver->name, p->base, p->size,
1020 p->bus_width, p->chip_width);
1021 }
1022 return ERROR_OK;
1023 }
1024
1025 static int jim_flash_list(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
1026 {
1027 if (argc != 1) {
1028 Jim_WrongNumArgs(interp, 1, argv,
1029 "no arguments to 'flash list' command");
1030 return JIM_ERR;
1031 }
1032
1033 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
1034
1035 for (struct flash_bank *p = flash_bank_list(); p; p = p->next) {
1036 Jim_Obj *elem = Jim_NewListObj(interp, NULL, 0);
1037
1038 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "name", -1));
1039 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, p->driver->name, -1));
1040 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "base", -1));
1041 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->base));
1042 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "size", -1));
1043 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->size));
1044 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "bus_width", -1));
1045 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->bus_width));
1046 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "chip_width", -1));
1047 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->chip_width));
1048
1049 Jim_ListAppendElement(interp, list, elem);
1050 }
1051
1052 Jim_SetResult(interp, list);
1053
1054 return JIM_OK;
1055 }
1056
1057 COMMAND_HANDLER(handle_flash_init_command)
1058 {
1059 if (CMD_ARGC != 0)
1060 return ERROR_COMMAND_SYNTAX_ERROR;
1061
1062 static bool flash_initialized;
1063 if (flash_initialized) {
1064 LOG_INFO("'flash init' has already been called");
1065 return ERROR_OK;
1066 }
1067 flash_initialized = true;
1068
1069 LOG_DEBUG("Initializing flash devices...");
1070 return flash_init_drivers(CMD_CTX);
1071 }
1072
1073 static const struct command_registration flash_config_command_handlers[] = {
1074 {
1075 .name = "bank",
1076 .handler = handle_flash_bank_command,
1077 .mode = COMMAND_CONFIG,
1078 .usage = "bank_id driver_name base_address size_bytes "
1079 "chip_width_bytes bus_width_bytes target "
1080 "[driver_options ...]",
1081 .help = "Define a new bank with the given name, "
1082 "using the specified NOR flash driver.",
1083 },
1084 {
1085 .name = "init",
1086 .mode = COMMAND_CONFIG,
1087 .handler = handle_flash_init_command,
1088 .help = "Initialize flash devices.",
1089 },
1090 {
1091 .name = "banks",
1092 .mode = COMMAND_ANY,
1093 .handler = handle_flash_banks_command,
1094 .help = "Display table with information about flash banks.",
1095 },
1096 {
1097 .name = "list",
1098 .mode = COMMAND_ANY,
1099 .jim_handler = jim_flash_list,
1100 .help = "Returns a list of details about the flash banks.",
1101 },
1102 COMMAND_REGISTRATION_DONE
1103 };
1104 static const struct command_registration flash_command_handlers[] = {
1105 {
1106 .name = "flash",
1107 .mode = COMMAND_ANY,
1108 .help = "NOR flash command group",
1109 .chain = flash_config_command_handlers,
1110 },
1111 COMMAND_REGISTRATION_DONE
1112 };
1113
1114 int flash_register_commands(struct command_context *cmd_ctx)
1115 {
1116 return register_commands(cmd_ctx, NULL, flash_command_handlers);
1117 }