Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
add support for naming flash banks
[openocd.git] / src / flash / flash.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
20 * *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29
30 #include "flash.h"
31 #include "common.h"
32 #include "image.h"
33 #include "time_support.h"
34
35 static int flash_write_unlock(struct target *target, struct image *image, uint32_t *written, int erase, bool unlock);
36
37 /* flash drivers
38 */
39 extern struct flash_driver lpc2000_flash;
40 extern struct flash_driver lpc288x_flash;
41 extern struct flash_driver lpc2900_flash;
42 extern struct flash_driver cfi_flash;
43 extern struct flash_driver at91sam3_flash;
44 extern struct flash_driver at91sam7_flash;
45 extern struct flash_driver str7x_flash;
46 extern struct flash_driver str9x_flash;
47 extern struct flash_driver aduc702x_flash;
48 extern struct flash_driver stellaris_flash;
49 extern struct flash_driver str9xpec_flash;
50 extern struct flash_driver stm32x_flash;
51 extern struct flash_driver tms470_flash;
52 extern struct flash_driver ecosflash_flash;
53 extern struct flash_driver ocl_flash;
54 extern struct flash_driver pic32mx_flash;
55 extern struct flash_driver avr_flash;
56 extern struct flash_driver faux_flash;
57
58 struct flash_driver *flash_drivers[] = {
59 &lpc2000_flash,
60 &lpc288x_flash,
61 &lpc2900_flash,
62 &cfi_flash,
63 &at91sam7_flash,
64 &at91sam3_flash,
65 &str7x_flash,
66 &str9x_flash,
67 &aduc702x_flash,
68 &stellaris_flash,
69 &str9xpec_flash,
70 &stm32x_flash,
71 &tms470_flash,
72 &ecosflash_flash,
73 &ocl_flash,
74 &pic32mx_flash,
75 &avr_flash,
76 &faux_flash,
77 NULL,
78 };
79
80 struct flash_bank *flash_banks;
81 static struct command *flash_cmd;
82
83 /* wafer thin wrapper for invoking the flash driver */
84 static int flash_driver_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
85 {
86 int retval;
87
88 retval = bank->driver->write(bank, buffer, offset, count);
89 if (retval != ERROR_OK)
90 {
91 LOG_ERROR("error writing to flash at address 0x%08" PRIx32 " at offset 0x%8.8" PRIx32 " (%d)",
92 bank->base, offset, retval);
93 }
94
95 return retval;
96 }
97
98 static int flash_driver_erase(struct flash_bank *bank, int first, int last)
99 {
100 int retval;
101
102 retval = bank->driver->erase(bank, first, last);
103 if (retval != ERROR_OK)
104 {
105 LOG_ERROR("failed erasing sectors %d to %d (%d)", first, last, retval);
106 }
107
108 return retval;
109 }
110
111 int flash_driver_protect(struct flash_bank *bank, int set, int first, int last)
112 {
113 int retval;
114
115 retval = bank->driver->protect(bank, set, first, last);
116 if (retval != ERROR_OK)
117 {
118 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first, last, retval);
119 }
120
121 return retval;
122 }
123
124 static int jim_flash_banks(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
125 {
126 struct flash_bank *p;
127
128 if (argc != 1) {
129 Jim_WrongNumArgs(interp, 1, argv, "no arguments to flash_banks command");
130 return JIM_ERR;
131 }
132
133 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
134 for (p = flash_banks; p; p = p->next)
135 {
136 Jim_Obj *elem = Jim_NewListObj(interp, NULL, 0);
137
138 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "name", -1));
139 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, p->driver->name, -1));
140 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "base", -1));
141 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->base));
142 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "size", -1));
143 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->size));
144 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "bus_width", -1));
145 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->bus_width));
146 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "chip_width", -1));
147 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->chip_width));
148
149 Jim_ListAppendElement(interp, list, elem);
150 }
151
152 Jim_SetResult(interp, list);
153
154 return JIM_OK;
155 }
156
157 struct flash_bank *get_flash_bank_by_num_noprobe(int num)
158 {
159 struct flash_bank *p;
160 int i = 0;
161
162 for (p = flash_banks; p; p = p->next)
163 {
164 if (i++ == num)
165 {
166 return p;
167 }
168 }
169 LOG_ERROR("flash bank %d does not exist", num);
170 return NULL;
171 }
172
173 int flash_get_bank_count(void)
174 {
175 struct flash_bank *p;
176 int i = 0;
177 for (p = flash_banks; p; p = p->next)
178 {
179 i++;
180 }
181 return i;
182 }
183
184 struct flash_bank *get_flash_bank_by_name(const char *name)
185 {
186 unsigned requested = get_flash_name_index(name);
187 unsigned found = 0;
188
189 struct flash_bank *bank;
190 for (bank = flash_banks; NULL != bank; bank = bank->next)
191 {
192 if (strcmp(bank->name, name) == 0)
193 return bank;
194 if (!flash_driver_name_matches(bank->driver->name, name))
195 continue;
196 if (++found < requested)
197 continue;
198 return bank;
199 }
200 return NULL;
201 }
202
203 struct flash_bank *get_flash_bank_by_num(int num)
204 {
205 struct flash_bank *p = get_flash_bank_by_num_noprobe(num);
206 int retval;
207
208 if (p == NULL)
209 return NULL;
210
211 retval = p->driver->auto_probe(p);
212
213 if (retval != ERROR_OK)
214 {
215 LOG_ERROR("auto_probe failed %d\n", retval);
216 return NULL;
217 }
218 return p;
219 }
220
221 COMMAND_HELPER(flash_command_get_bank, unsigned name_index,
222 struct flash_bank **bank)
223 {
224 const char *name = CMD_ARGV[name_index];
225 *bank = get_flash_bank_by_name(name);
226 if (*bank)
227 return ERROR_OK;
228
229 unsigned bank_num;
230 COMMAND_PARSE_NUMBER(uint, name, bank_num);
231
232 *bank = get_flash_bank_by_num(bank_num);
233 if (!*bank)
234 {
235 command_print(CMD_CTX, "flash bank '%s' not found", name);
236 return ERROR_INVALID_ARGUMENTS;
237 }
238 return ERROR_OK;
239 }
240
241
242 COMMAND_HANDLER(handle_flash_bank_command)
243 {
244 if (CMD_ARGC < 7)
245 {
246 LOG_ERROR("usage: flash bank <name> <driver> "
247 "<base> <size> <chip_width> <bus_width>");
248 return ERROR_COMMAND_SYNTAX_ERROR;
249 }
250 // save bank name and advance arguments for compatibility
251 const char *bank_name = *CMD_ARGV++;
252 CMD_ARGC--;
253
254 struct target *target;
255 if ((target = get_target(CMD_ARGV[5])) == NULL)
256 {
257 LOG_ERROR("target '%s' not defined", CMD_ARGV[5]);
258 return ERROR_FAIL;
259 }
260
261 const char *driver_name = CMD_ARGV[0];
262 for (unsigned i = 0; flash_drivers[i]; i++)
263 {
264 if (strcmp(driver_name, flash_drivers[i]->name) != 0)
265 continue;
266
267 struct flash_bank *p, *c;
268
269 /* register flash specific commands */
270 if (flash_drivers[i]->register_commands(CMD_CTX) != ERROR_OK)
271 {
272 LOG_ERROR("couldn't register '%s' commands", driver_name);
273 return ERROR_FAIL;
274 }
275
276 c = malloc(sizeof(struct flash_bank));
277 c->name = strdup(bank_name);
278 c->target = target;
279 c->driver = flash_drivers[i];
280 c->driver_priv = NULL;
281 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], c->base);
282 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], c->size);
283 COMMAND_PARSE_NUMBER(int, CMD_ARGV[3], c->chip_width);
284 COMMAND_PARSE_NUMBER(int, CMD_ARGV[4], c->bus_width);
285 c->num_sectors = 0;
286 c->sectors = NULL;
287 c->next = NULL;
288
289 int retval;
290 retval = CALL_COMMAND_HANDLER(flash_drivers[i]->flash_bank_command, c);
291 if (ERROR_OK != retval)
292 {
293 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32,
294 driver_name, c->base);
295 free(c);
296 return retval;
297 }
298
299 /* put flash bank in linked list */
300 if (flash_banks)
301 {
302 int bank_num = 0;
303 /* find last flash bank */
304 for (p = flash_banks; p && p->next; p = p->next) bank_num++;
305 if (p)
306 p->next = c;
307 c->bank_number = bank_num + 1;
308 }
309 else
310 {
311 flash_banks = c;
312 c->bank_number = 0;
313 }
314
315 return ERROR_OK;
316 }
317
318 /* no matching flash driver found */
319 LOG_ERROR("flash driver '%s' not found", driver_name);
320 return ERROR_FAIL;
321 }
322
323 COMMAND_HANDLER(handle_flash_info_command)
324 {
325 struct flash_bank *p;
326 uint32_t i = 0;
327 int j = 0;
328 int retval;
329
330 if (CMD_ARGC != 1)
331 return ERROR_COMMAND_SYNTAX_ERROR;
332
333 unsigned bank_nr;
334 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], bank_nr);
335
336 for (p = flash_banks; p; p = p->next, i++)
337 {
338 if (i != bank_nr)
339 continue;
340
341 char buf[1024];
342
343 /* attempt auto probe */
344 if ((retval = p->driver->auto_probe(p)) != ERROR_OK)
345 return retval;
346
347 command_print(CMD_CTX,
348 "#%" PRIi32 " : %s at 0x%8.8" PRIx32 ", size 0x%8.8" PRIx32 ", buswidth %i, chipwidth %i",
349 i,
350 p->driver->name,
351 p->base,
352 p->size,
353 p->bus_width,
354 p->chip_width);
355 for (j = 0; j < p->num_sectors; j++)
356 {
357 char *protect_state;
358
359 if (p->sectors[j].is_protected == 0)
360 protect_state = "not protected";
361 else if (p->sectors[j].is_protected == 1)
362 protect_state = "protected";
363 else
364 protect_state = "protection state unknown";
365
366 command_print(CMD_CTX,
367 "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
368 j,
369 p->sectors[j].offset,
370 p->sectors[j].size,
371 p->sectors[j].size >> 10,
372 protect_state);
373 }
374
375 *buf = '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
376 retval = p->driver->info(p, buf, sizeof(buf));
377 command_print(CMD_CTX, "%s", buf);
378 if (retval != ERROR_OK)
379 LOG_ERROR("error retrieving flash info (%d)", retval);
380 }
381
382 return ERROR_OK;
383 }
384
385 COMMAND_HANDLER(handle_flash_probe_command)
386 {
387 int retval;
388
389 if (CMD_ARGC != 1)
390 {
391 return ERROR_COMMAND_SYNTAX_ERROR;
392 }
393
394 unsigned bank_nr;
395 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], bank_nr);
396 struct flash_bank *p = get_flash_bank_by_num_noprobe(bank_nr);
397 if (p)
398 {
399 if ((retval = p->driver->probe(p)) == ERROR_OK)
400 {
401 command_print(CMD_CTX, "flash '%s' found at 0x%8.8" PRIx32, p->driver->name, p->base);
402 }
403 else if (retval == ERROR_FLASH_BANK_INVALID)
404 {
405 command_print(CMD_CTX, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32,
406 CMD_ARGV[0], p->base);
407 }
408 else
409 {
410 command_print(CMD_CTX, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32,
411 CMD_ARGV[0], p->base);
412 }
413 }
414 else
415 {
416 command_print(CMD_CTX, "flash bank '#%s' is out of bounds", CMD_ARGV[0]);
417 }
418
419 return ERROR_OK;
420 }
421
422 COMMAND_HANDLER(handle_flash_erase_check_command)
423 {
424 if (CMD_ARGC != 1)
425 {
426 return ERROR_COMMAND_SYNTAX_ERROR;
427 }
428
429 struct flash_bank *p;
430 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
431 if (ERROR_OK != retval)
432 return retval;
433
434 int j;
435 if ((retval = p->driver->erase_check(p)) == ERROR_OK)
436 {
437 command_print(CMD_CTX, "successfully checked erase state");
438 }
439 else
440 {
441 command_print(CMD_CTX, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32,
442 CMD_ARGV[0], p->base);
443 }
444
445 for (j = 0; j < p->num_sectors; j++)
446 {
447 char *erase_state;
448
449 if (p->sectors[j].is_erased == 0)
450 erase_state = "not erased";
451 else if (p->sectors[j].is_erased == 1)
452 erase_state = "erased";
453 else
454 erase_state = "erase state unknown";
455
456 command_print(CMD_CTX,
457 "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
458 j,
459 p->sectors[j].offset,
460 p->sectors[j].size,
461 p->sectors[j].size >> 10,
462 erase_state);
463 }
464
465 return ERROR_OK;
466 }
467
468 COMMAND_HANDLER(handle_flash_erase_address_command)
469 {
470 struct flash_bank *p;
471 int retval;
472 int address;
473 int length;
474
475 struct target *target = get_current_target(CMD_CTX);
476
477 if (CMD_ARGC != 2)
478 return ERROR_COMMAND_SYNTAX_ERROR;
479
480 COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], address);
481 COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], length);
482 if (length <= 0)
483 {
484 command_print(CMD_CTX, "Length must be >0");
485 return ERROR_COMMAND_SYNTAX_ERROR;
486 }
487
488 p = get_flash_bank_by_addr(target, address);
489 if (p == NULL)
490 {
491 return ERROR_FAIL;
492 }
493
494 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
495 flash_set_dirty();
496
497 struct duration bench;
498 duration_start(&bench);
499
500 retval = flash_erase_address_range(target, address, length);
501
502 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
503 {
504 command_print(CMD_CTX, "erased address 0x%8.8x (length %i)"
505 " in %fs (%0.3f kb/s)", address, length,
506 duration_elapsed(&bench), duration_kbps(&bench, length));
507 }
508
509 return retval;
510 }
511
512 COMMAND_HANDLER(handle_flash_protect_check_command)
513 {
514 if (CMD_ARGC != 1)
515 return ERROR_COMMAND_SYNTAX_ERROR;
516
517 struct flash_bank *p;
518 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
519 if (ERROR_OK != retval)
520 return retval;
521
522 if ((retval = p->driver->protect_check(p)) == ERROR_OK)
523 {
524 command_print(CMD_CTX, "successfully checked protect state");
525 }
526 else if (retval == ERROR_FLASH_OPERATION_FAILED)
527 {
528 command_print(CMD_CTX, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32, CMD_ARGV[0], p->base);
529 }
530 else
531 {
532 command_print(CMD_CTX, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32, CMD_ARGV[0], p->base);
533 }
534
535 return ERROR_OK;
536 }
537
538 static int flash_check_sector_parameters(struct command_context *cmd_ctx,
539 uint32_t first, uint32_t last, uint32_t num_sectors)
540 {
541 if (!(first <= last)) {
542 command_print(cmd_ctx, "ERROR: "
543 "first sector must be <= last sector");
544 return ERROR_FAIL;
545 }
546
547 if (!(last <= (num_sectors - 1))) {
548 command_print(cmd_ctx, "ERROR: last sector must be <= %d",
549 (int) num_sectors - 1);
550 return ERROR_FAIL;
551 }
552
553 return ERROR_OK;
554 }
555
556 COMMAND_HANDLER(handle_flash_erase_command)
557 {
558 if (CMD_ARGC != 2)
559 return ERROR_COMMAND_SYNTAX_ERROR;
560
561 uint32_t bank_nr;
562 uint32_t first;
563 uint32_t last;
564
565 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], bank_nr);
566 struct flash_bank *p = get_flash_bank_by_num(bank_nr);
567 if (!p)
568 return ERROR_OK;
569
570 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first);
571 if (strcmp(CMD_ARGV[2], "last") == 0)
572 last = p->num_sectors - 1;
573 else
574 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
575
576 int retval;
577 if ((retval = flash_check_sector_parameters(CMD_CTX,
578 first, last, p->num_sectors)) != ERROR_OK)
579 return retval;
580
581 struct duration bench;
582 duration_start(&bench);
583
584 retval = flash_driver_erase(p, first, last);
585
586 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
587 {
588 command_print(CMD_CTX, "erased sectors %" PRIu32 " "
589 "through %" PRIu32" on flash bank %" PRIu32 " "
590 "in %fs", first, last, bank_nr, duration_elapsed(&bench));
591 }
592
593 return ERROR_OK;
594 }
595
596 COMMAND_HANDLER(handle_flash_protect_command)
597 {
598 if (CMD_ARGC != 3)
599 return ERROR_COMMAND_SYNTAX_ERROR;
600
601 uint32_t bank_nr;
602 uint32_t first;
603 uint32_t last;
604
605 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], bank_nr);
606 struct flash_bank *p = get_flash_bank_by_num(bank_nr);
607 if (!p)
608 return ERROR_OK;
609
610 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first);
611 if (strcmp(CMD_ARGV[2], "last") == 0)
612 last = p->num_sectors - 1;
613 else
614 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
615
616 bool set;
617 COMMAND_PARSE_ON_OFF(CMD_ARGV[3], set);
618
619 int retval;
620 if ((retval = flash_check_sector_parameters(CMD_CTX,
621 first, last, p->num_sectors)) != ERROR_OK)
622 return retval;
623
624 retval = flash_driver_protect(p, set, first, last);
625 if (retval == ERROR_OK) {
626 command_print(CMD_CTX, "%s protection for sectors %i "
627 "through %i on flash bank %i",
628 (set) ? "set" : "cleared", (int) first,
629 (int) last, (int) bank_nr);
630 }
631
632 return ERROR_OK;
633 }
634
635 COMMAND_HANDLER(handle_flash_write_image_command)
636 {
637 struct target *target = get_current_target(CMD_CTX);
638
639 struct image image;
640 uint32_t written;
641
642 int retval;
643
644 if (CMD_ARGC < 1)
645 {
646 return ERROR_COMMAND_SYNTAX_ERROR;
647 }
648
649 /* flash auto-erase is disabled by default*/
650 int auto_erase = 0;
651 bool auto_unlock = false;
652
653 for (;;)
654 {
655 if (strcmp(CMD_ARGV[0], "erase") == 0)
656 {
657 auto_erase = 1;
658 CMD_ARGV++;
659 CMD_ARGC--;
660 command_print(CMD_CTX, "auto erase enabled");
661 } else if (strcmp(CMD_ARGV[0], "unlock") == 0)
662 {
663 auto_unlock = true;
664 CMD_ARGV++;
665 CMD_ARGC--;
666 command_print(CMD_CTX, "auto unlock enabled");
667 } else
668 {
669 break;
670 }
671 }
672
673 if (CMD_ARGC < 1)
674 {
675 return ERROR_COMMAND_SYNTAX_ERROR;
676 }
677
678 if (!target)
679 {
680 LOG_ERROR("no target selected");
681 return ERROR_FAIL;
682 }
683
684 struct duration bench;
685 duration_start(&bench);
686
687 if (CMD_ARGC >= 2)
688 {
689 image.base_address_set = 1;
690 COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], image.base_address);
691 }
692 else
693 {
694 image.base_address_set = 0;
695 image.base_address = 0x0;
696 }
697
698 image.start_address_set = 0;
699
700 retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL);
701 if (retval != ERROR_OK)
702 {
703 return retval;
704 }
705
706 retval = flash_write_unlock(target, &image, &written, auto_erase, auto_unlock);
707 if (retval != ERROR_OK)
708 {
709 image_close(&image);
710 return retval;
711 }
712
713 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
714 {
715 command_print(CMD_CTX, "wrote %" PRIu32 " byte from file %s "
716 "in %fs (%0.3f kb/s)", written, CMD_ARGV[0],
717 duration_elapsed(&bench), duration_kbps(&bench, written));
718 }
719
720 image_close(&image);
721
722 return retval;
723 }
724
725 COMMAND_HANDLER(handle_flash_fill_command)
726 {
727 int err = ERROR_OK;
728 uint32_t address;
729 uint32_t pattern;
730 uint32_t count;
731 uint8_t chunk[1024];
732 uint8_t readback[1024];
733 uint32_t wrote = 0;
734 uint32_t cur_size = 0;
735 uint32_t chunk_count;
736 struct target *target = get_current_target(CMD_CTX);
737 uint32_t i;
738 uint32_t wordsize;
739
740 if (CMD_ARGC != 3)
741 return ERROR_COMMAND_SYNTAX_ERROR;
742
743 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
744 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], pattern);
745 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], count);
746
747 if (count == 0)
748 return ERROR_OK;
749
750 switch (CMD_NAME[4])
751 {
752 case 'w':
753 wordsize = 4;
754 break;
755 case 'h':
756 wordsize = 2;
757 break;
758 case 'b':
759 wordsize = 1;
760 break;
761 default:
762 return ERROR_COMMAND_SYNTAX_ERROR;
763 }
764
765 chunk_count = MIN(count, (1024 / wordsize));
766 switch (wordsize)
767 {
768 case 4:
769 for (i = 0; i < chunk_count; i++)
770 {
771 target_buffer_set_u32(target, chunk + i * wordsize, pattern);
772 }
773 break;
774 case 2:
775 for (i = 0; i < chunk_count; i++)
776 {
777 target_buffer_set_u16(target, chunk + i * wordsize, pattern);
778 }
779 break;
780 case 1:
781 memset(chunk, pattern, chunk_count);
782 break;
783 default:
784 LOG_ERROR("BUG: can't happen");
785 exit(-1);
786 }
787
788 struct duration bench;
789 duration_start(&bench);
790
791 for (wrote = 0; wrote < (count*wordsize); wrote += cur_size)
792 {
793 cur_size = MIN((count*wordsize - wrote), sizeof(chunk));
794 struct flash_bank *bank;
795 bank = get_flash_bank_by_addr(target, address);
796 if (bank == NULL)
797 {
798 return ERROR_FAIL;
799 }
800 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
801 if (err != ERROR_OK)
802 return err;
803
804 err = target_read_buffer(target, address + wrote, cur_size, readback);
805 if (err != ERROR_OK)
806 return err;
807
808 unsigned i;
809 for (i = 0; i < cur_size; i++)
810 {
811 if (readback[i]!=chunk[i])
812 {
813 LOG_ERROR("Verfication error address 0x%08" PRIx32 ", read back 0x%02x, expected 0x%02x",
814 address + wrote + i, readback[i], chunk[i]);
815 return ERROR_FAIL;
816 }
817 }
818 }
819
820 if (duration_measure(&bench) == ERROR_OK)
821 {
822 command_print(CMD_CTX, "wrote %" PRIu32 " bytes to 0x%8.8" PRIx32
823 " in %fs (%0.3f kb/s)", wrote, address,
824 duration_elapsed(&bench), duration_kbps(&bench, wrote));
825 }
826 return ERROR_OK;
827 }
828
829 COMMAND_HANDLER(handle_flash_write_bank_command)
830 {
831 uint32_t offset;
832 uint8_t *buffer;
833 struct fileio fileio;
834
835 if (CMD_ARGC != 3)
836 return ERROR_COMMAND_SYNTAX_ERROR;
837
838 struct duration bench;
839 duration_start(&bench);
840
841 struct flash_bank *p;
842 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
843 if (ERROR_OK != retval)
844 return retval;
845
846 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], offset);
847
848 if (fileio_open(&fileio, CMD_ARGV[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
849 {
850 return ERROR_OK;
851 }
852
853 buffer = malloc(fileio.size);
854 size_t buf_cnt;
855 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
856 {
857 free(buffer);
858 fileio_close(&fileio);
859 return ERROR_OK;
860 }
861
862 retval = flash_driver_write(p, buffer, offset, buf_cnt);
863
864 free(buffer);
865 buffer = NULL;
866
867 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
868 {
869 command_print(CMD_CTX, "wrote %zu byte from file %s to flash bank %u"
870 " at offset 0x%8.8" PRIx32 " in %fs (%0.3f kb/s)",
871 fileio.size, CMD_ARGV[1], p->bank_number, offset,
872 duration_elapsed(&bench), duration_kbps(&bench, fileio.size));
873 }
874
875 fileio_close(&fileio);
876
877 return retval;
878 }
879
880 void flash_set_dirty(void)
881 {
882 struct flash_bank *c;
883 int i;
884
885 /* set all flash to require erasing */
886 for (c = flash_banks; c; c = c->next)
887 {
888 for (i = 0; i < c->num_sectors; i++)
889 {
890 c->sectors[i].is_erased = 0;
891 }
892 }
893 }
894
895 /* lookup flash bank by address */
896 struct flash_bank *get_flash_bank_by_addr(struct target *target, uint32_t addr)
897 {
898 struct flash_bank *c;
899
900 /* cycle through bank list */
901 for (c = flash_banks; c; c = c->next)
902 {
903 int retval;
904 retval = c->driver->auto_probe(c);
905
906 if (retval != ERROR_OK)
907 {
908 LOG_ERROR("auto_probe failed %d\n", retval);
909 return NULL;
910 }
911 /* check whether address belongs to this flash bank */
912 if ((addr >= c->base) && (addr <= c->base + (c->size - 1)) && target == c->target)
913 return c;
914 }
915 LOG_ERROR("No flash at address 0x%08" PRIx32 "\n", addr);
916 return NULL;
917 }
918
919 /* erase given flash region, selects proper bank according to target and address */
920 static int flash_iterate_address_range(struct target *target, uint32_t addr, uint32_t length,
921 int (*callback)(struct flash_bank *bank, int first, int last))
922 {
923 struct flash_bank *c;
924 int first = -1;
925 int last = -1;
926 int i;
927
928 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
929 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
930
931 if (c->size == 0 || c->num_sectors == 0)
932 {
933 LOG_ERROR("Bank is invalid");
934 return ERROR_FLASH_BANK_INVALID;
935 }
936
937 if (length == 0)
938 {
939 /* special case, erase whole bank when length is zero */
940 if (addr != c->base)
941 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
942
943 return callback(c, 0, c->num_sectors - 1);
944 }
945
946 /* check whether it fits */
947 if (addr + length - 1 > c->base + c->size - 1)
948 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
949
950 addr -= c->base;
951
952 for (i = 0; i < c->num_sectors; i++)
953 {
954 /* check whether sector overlaps with the given range and is not yet erased */
955 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
956 /* if first is not set yet then this is the first sector */
957 if (first == -1)
958 first = i;
959 last = i; /* and it is the last one so far in any case */
960 }
961 }
962
963 if (first == -1 || last == -1)
964 return ERROR_OK;
965
966 return callback(c, first, last);
967 }
968
969
970
971 int flash_erase_address_range(struct target *target, uint32_t addr, uint32_t length)
972 {
973 return flash_iterate_address_range(target, addr, length, &flash_driver_erase);
974 }
975
976 static int flash_driver_unprotect(struct flash_bank *bank, int first, int last)
977 {
978 return flash_driver_protect(bank, 0, first, last);
979 }
980
981 static int flash_unlock_address_range(struct target *target, uint32_t addr, uint32_t length)
982 {
983 return flash_iterate_address_range(target, addr, length, &flash_driver_unprotect);
984 }
985
986
987 /* write (optional verify) an image to flash memory of the given target */
988 static int flash_write_unlock(struct target *target, struct image *image, uint32_t *written, int erase, bool unlock)
989 {
990 int retval = ERROR_OK;
991
992 int section;
993 uint32_t section_offset;
994 struct flash_bank *c;
995 int *padding;
996
997 section = 0;
998 section_offset = 0;
999
1000 if (written)
1001 *written = 0;
1002
1003 if (erase)
1004 {
1005 /* assume all sectors need erasing - stops any problems
1006 * when flash_write is called multiple times */
1007
1008 flash_set_dirty();
1009 }
1010
1011 /* allocate padding array */
1012 padding = malloc(image->num_sections * sizeof(padding));
1013
1014 /* loop until we reach end of the image */
1015 while (section < image->num_sections)
1016 {
1017 uint32_t buffer_size;
1018 uint8_t *buffer;
1019 int section_first;
1020 int section_last;
1021 uint32_t run_address = image->sections[section].base_address + section_offset;
1022 uint32_t run_size = image->sections[section].size - section_offset;
1023 int pad_bytes = 0;
1024
1025 if (image->sections[section].size == 0)
1026 {
1027 LOG_WARNING("empty section %d", section);
1028 section++;
1029 section_offset = 0;
1030 continue;
1031 }
1032
1033 /* find the corresponding flash bank */
1034 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
1035 {
1036 section++; /* and skip it */
1037 section_offset = 0;
1038 continue;
1039 }
1040
1041 /* collect consecutive sections which fall into the same bank */
1042 section_first = section;
1043 section_last = section;
1044 padding[section] = 0;
1045 while ((run_address + run_size - 1 < c->base + c->size - 1)
1046 && (section_last + 1 < image->num_sections))
1047 {
1048 if (image->sections[section_last + 1].base_address < (run_address + run_size))
1049 {
1050 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
1051 break;
1052 }
1053 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1054 * attempt to rebuild a consecutive buffer for the flash loader */
1055 pad_bytes = (image->sections[section_last + 1].base_address) - (run_address + run_size);
1056 if ((run_address + run_size + pad_bytes) > (c->base + c->size))
1057 break;
1058 padding[section_last] = pad_bytes;
1059 run_size += image->sections[++section_last].size;
1060 run_size += pad_bytes;
1061 padding[section_last] = 0;
1062
1063 LOG_INFO("Padding image section %d with %d bytes", section_last-1, pad_bytes);
1064 }
1065
1066 /* fit the run into bank constraints */
1067 if (run_address + run_size - 1 > c->base + c->size - 1)
1068 {
1069 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1070 (int)(c->base + c->size - run_address), (int)(run_size), (int)(c->size));
1071 run_size = c->base + c->size - run_address;
1072 }
1073
1074 /* allocate buffer */
1075 buffer = malloc(run_size);
1076 buffer_size = 0;
1077
1078 /* read sections to the buffer */
1079 while (buffer_size < run_size)
1080 {
1081 size_t size_read;
1082
1083 size_read = run_size - buffer_size;
1084 if (size_read > image->sections[section].size - section_offset)
1085 size_read = image->sections[section].size - section_offset;
1086
1087 if ((retval = image_read_section(image, section, section_offset,
1088 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
1089 {
1090 free(buffer);
1091 free(padding);
1092 return retval;
1093 }
1094
1095 /* see if we need to pad the section */
1096 while (padding[section]--)
1097 (buffer + buffer_size)[size_read++] = 0xff;
1098
1099 buffer_size += size_read;
1100 section_offset += size_read;
1101
1102 if (section_offset >= image->sections[section].size)
1103 {
1104 section++;
1105 section_offset = 0;
1106 }
1107 }
1108
1109 retval = ERROR_OK;
1110
1111 if (unlock)
1112 {
1113 retval = flash_unlock_address_range(target, run_address, run_size);
1114 }
1115 if (retval == ERROR_OK)
1116 {
1117 if (erase)
1118 {
1119 /* calculate and erase sectors */
1120 retval = flash_erase_address_range(target, run_address, run_size);
1121 }
1122 }
1123
1124 if (retval == ERROR_OK)
1125 {
1126 /* write flash sectors */
1127 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
1128 }
1129
1130 free(buffer);
1131
1132 if (retval != ERROR_OK)
1133 {
1134 free(padding);
1135 return retval; /* abort operation */
1136 }
1137
1138 if (written != NULL)
1139 *written += run_size; /* add run size to total written counter */
1140 }
1141
1142 free(padding);
1143
1144 return retval;
1145 }
1146
1147 int flash_write(struct target *target, struct image *image, uint32_t *written, int erase)
1148 {
1149 return flash_write_unlock(target, image, written, erase, false);
1150 }
1151
1152 int default_flash_mem_blank_check(struct flash_bank *bank)
1153 {
1154 struct target *target = bank->target;
1155 uint8_t buffer[1024];
1156 int buffer_size = sizeof(buffer);
1157 int i;
1158 uint32_t nBytes;
1159
1160 if (bank->target->state != TARGET_HALTED)
1161 {
1162 LOG_ERROR("Target not halted");
1163 return ERROR_TARGET_NOT_HALTED;
1164 }
1165
1166 for (i = 0; i < bank->num_sectors; i++)
1167 {
1168 uint32_t j;
1169 bank->sectors[i].is_erased = 1;
1170
1171 for (j = 0; j < bank->sectors[i].size; j += buffer_size)
1172 {
1173 uint32_t chunk;
1174 int retval;
1175 chunk = buffer_size;
1176 if (chunk > (j - bank->sectors[i].size))
1177 {
1178 chunk = (j - bank->sectors[i].size);
1179 }
1180
1181 retval = target_read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
1182 if (retval != ERROR_OK)
1183 return retval;
1184
1185 for (nBytes = 0; nBytes < chunk; nBytes++)
1186 {
1187 if (buffer[nBytes] != 0xFF)
1188 {
1189 bank->sectors[i].is_erased = 0;
1190 break;
1191 }
1192 }
1193 }
1194 }
1195
1196 return ERROR_OK;
1197 }
1198
1199 int default_flash_blank_check(struct flash_bank *bank)
1200 {
1201 struct target *target = bank->target;
1202 int i;
1203 int retval;
1204 int fast_check = 0;
1205 uint32_t blank;
1206
1207 if (bank->target->state != TARGET_HALTED)
1208 {
1209 LOG_ERROR("Target not halted");
1210 return ERROR_TARGET_NOT_HALTED;
1211 }
1212
1213 for (i = 0; i < bank->num_sectors; i++)
1214 {
1215 uint32_t address = bank->base + bank->sectors[i].offset;
1216 uint32_t size = bank->sectors[i].size;
1217
1218 if ((retval = target_blank_check_memory(target, address, size, &blank)) != ERROR_OK)
1219 {
1220 fast_check = 0;
1221 break;
1222 }
1223 if (blank == 0xFF)
1224 bank->sectors[i].is_erased = 1;
1225 else
1226 bank->sectors[i].is_erased = 0;
1227 fast_check = 1;
1228 }
1229
1230 if (!fast_check)
1231 {
1232 LOG_USER("Running slow fallback erase check - add working memory");
1233 return default_flash_mem_blank_check(bank);
1234 }
1235
1236 return ERROR_OK;
1237 }
1238
1239 int flash_init_drivers(struct command_context *cmd_ctx)
1240 {
1241 register_jim(cmd_ctx, "ocd_flash_banks",
1242 jim_flash_banks, "return information about the flash banks");
1243
1244 if (!flash_banks)
1245 return ERROR_OK;
1246
1247 register_command(cmd_ctx, flash_cmd, "info",
1248 handle_flash_info_command, COMMAND_EXEC,
1249 "print info about flash bank <num>");
1250 register_command(cmd_ctx, flash_cmd, "probe",
1251 handle_flash_probe_command, COMMAND_EXEC,
1252 "identify flash bank <num>");
1253 register_command(cmd_ctx, flash_cmd, "erase_check",
1254 handle_flash_erase_check_command, COMMAND_EXEC,
1255 "check erase state of sectors in flash bank <num>");
1256 register_command(cmd_ctx, flash_cmd, "protect_check",
1257 handle_flash_protect_check_command, COMMAND_EXEC,
1258 "check protection state of sectors in flash bank <num>");
1259 register_command(cmd_ctx, flash_cmd, "erase_sector",
1260 handle_flash_erase_command, COMMAND_EXEC,
1261 "erase sectors at <bank> <first> <last>");
1262 register_command(cmd_ctx, flash_cmd, "erase_address",
1263 handle_flash_erase_address_command, COMMAND_EXEC,
1264 "erase address range <address> <length>");
1265
1266 register_command(cmd_ctx, flash_cmd, "fillw",
1267 handle_flash_fill_command, COMMAND_EXEC,
1268 "fill with pattern (no autoerase) <address> <word_pattern> <count>");
1269 register_command(cmd_ctx, flash_cmd, "fillh",
1270 handle_flash_fill_command, COMMAND_EXEC,
1271 "fill with pattern <address> <halfword_pattern> <count>");
1272 register_command(cmd_ctx, flash_cmd, "fillb",
1273 handle_flash_fill_command, COMMAND_EXEC,
1274 "fill with pattern <address> <byte_pattern> <count>");
1275
1276 register_command(cmd_ctx, flash_cmd, "write_bank",
1277 handle_flash_write_bank_command, COMMAND_EXEC,
1278 "write binary data to <bank> <file> <offset>");
1279 register_command(cmd_ctx, flash_cmd, "write_image",
1280 handle_flash_write_image_command, COMMAND_EXEC,
1281 "write_image [erase] [unlock] <file> [offset] [type]");
1282 register_command(cmd_ctx, flash_cmd, "protect",
1283 handle_flash_protect_command, COMMAND_EXEC,
1284 "set protection of sectors at <bank> <first> <last> <on | off>");
1285
1286 return ERROR_OK;
1287 }
1288
1289 int flash_register_commands(struct command_context *cmd_ctx)
1290 {
1291 flash_cmd = register_command(cmd_ctx, NULL, "flash",
1292 NULL, COMMAND_ANY, NULL);
1293
1294 register_command(cmd_ctx, flash_cmd, "bank",
1295 handle_flash_bank_command, COMMAND_CONFIG,
1296 "flash bank <driver> <base> <size> "
1297 "<chip_width> <bus_width> <target> [driver_options ...]");
1298 return ERROR_OK;
1299 }
Open On-Chip Debugger

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)