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