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