Code Review / openocd.git / blob
? search:


ce1dc4fe13d879293eeec4022b20552ef822b831
[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 cfi_flash;
51 extern flash_driver_t at91sam3_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
712 float speed;
713
714 speed = written / 1024.0;
715 speed /= ((float)duration.duration.tv_sec
716 + ((float)duration.duration.tv_usec / 1000000.0));
717 command_print(cmd_ctx,
718 "wrote %" PRIu32 " byte from file %s in %s (%f kb/s)",
719 written, args[0], duration_text, speed);
720
721 free(duration_text);
722
723 image_close(&image);
724
725 return retval;
726 }
727
728 static int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
729 {
730 int err = ERROR_OK, retval;
731 uint32_t address;
732 uint32_t pattern;
733 uint32_t count;
734 uint8_t chunk[1024];
735 uint8_t readback[1024];
736 uint32_t wrote = 0;
737 uint32_t cur_size = 0;
738 uint32_t chunk_count;
739 char *duration_text;
740 duration_t duration;
741 target_t *target = get_current_target(cmd_ctx);
742 uint32_t i;
743 uint32_t wordsize;
744
745 if (argc != 3)
746 {
747 return ERROR_COMMAND_SYNTAX_ERROR;
748 }
749
750 address = strtoul(args[0], NULL, 0);
751 pattern = strtoul(args[1], NULL, 0);
752 count = strtoul(args[2], NULL, 0);
753
754 if (count == 0)
755 return ERROR_OK;
756
757 switch (cmd[4])
758 {
759 case 'w':
760 wordsize = 4;
761 break;
762 case 'h':
763 wordsize = 2;
764 break;
765 case 'b':
766 wordsize = 1;
767 break;
768 default:
769 return ERROR_COMMAND_SYNTAX_ERROR;
770 }
771
772 chunk_count = MIN(count, (1024 / wordsize));
773 switch (wordsize)
774 {
775 case 4:
776 for (i = 0; i < chunk_count; i++)
777 {
778 target_buffer_set_u32(target, chunk + i * wordsize, pattern);
779 }
780 break;
781 case 2:
782 for (i = 0; i < chunk_count; i++)
783 {
784 target_buffer_set_u16(target, chunk + i * wordsize, pattern);
785 }
786 break;
787 case 1:
788 memset(chunk, pattern, chunk_count);
789 break;
790 default:
791 LOG_ERROR("BUG: can't happen");
792 exit(-1);
793 }
794
795 duration_start_measure(&duration);
796
797 for (wrote = 0; wrote < (count*wordsize); wrote += cur_size)
798 {
799 cur_size = MIN((count*wordsize - wrote), sizeof(chunk));
800 flash_bank_t *bank;
801 bank = get_flash_bank_by_addr(target, address);
802 if (bank == NULL)
803 {
804 return ERROR_FAIL;
805 }
806 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
807 if (err != ERROR_OK)
808 return err;
809
810 err = target_read_buffer(target, address + wrote, cur_size, readback);
811 if (err != ERROR_OK)
812 return err;
813
814 unsigned i;
815 for (i = 0; i < cur_size; i++)
816 {
817 if (readback[i]!=chunk[i])
818 {
819 LOG_ERROR("Verfication error address 0x%08" PRIx32 ", read back 0x%02x, expected 0x%02x",
820 address + wrote + i, readback[i], chunk[i]);
821 return ERROR_FAIL;
822 }
823 }
824
825 }
826
827 if ((retval = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
828 {
829 return retval;
830 }
831
832 float speed;
833
834 speed = wrote / 1024.0;
835 speed /= ((float)duration.duration.tv_sec
836 + ((float)duration.duration.tv_usec / 1000000.0));
837 command_print(cmd_ctx,
838 "wrote %" PRIu32 " bytes to 0x%8.8" PRIx32 " in %s (%f kb/s)",
839 wrote, address, duration_text, speed);
840
841 free(duration_text);
842 return ERROR_OK;
843 }
844
845 static int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
846 {
847 uint32_t offset;
848 uint8_t *buffer;
849 uint32_t buf_cnt;
850
851 fileio_t fileio;
852
853 duration_t duration;
854 char *duration_text;
855
856 int retval, retvaltemp;
857 flash_bank_t *p;
858
859 if (argc != 3)
860 {
861 return ERROR_COMMAND_SYNTAX_ERROR;
862 }
863
864 duration_start_measure(&duration);
865
866 offset = strtoul(args[2], NULL, 0);
867 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
868 if (!p)
869 {
870 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
871 return ERROR_OK;
872 }
873
874 if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
875 {
876 return ERROR_OK;
877 }
878
879 buffer = malloc(fileio.size);
880 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
881 {
882 free(buffer);
883 fileio_close(&fileio);
884 return ERROR_OK;
885 }
886
887 retval = flash_driver_write(p, buffer, offset, buf_cnt);
888
889 free(buffer);
890 buffer = NULL;
891
892 if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
893 {
894 fileio_close(&fileio);
895 return retvaltemp;
896 }
897 if (retval == ERROR_OK)
898 {
899 command_print(cmd_ctx,
900 "wrote %lld byte from file %s to flash bank %li at offset 0x%8.8" PRIx32 " in %s (%f kb/s)",
901 fileio.size,
902 args[1],
903 strtoul(args[0], NULL, 0),
904 offset,
905 duration_text,
906 (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
907 }
908 free(duration_text);
909
910 fileio_close(&fileio);
911
912 return retval;
913 }
914
915 void flash_set_dirty(void)
916 {
917 flash_bank_t *c;
918 int i;
919
920 /* set all flash to require erasing */
921 for (c = flash_banks; c; c = c->next)
922 {
923 for (i = 0; i < c->num_sectors; i++)
924 {
925 c->sectors[i].is_erased = 0;
926 }
927 }
928 }
929
930 /* lookup flash bank by address */
931 flash_bank_t *get_flash_bank_by_addr(target_t *target, uint32_t addr)
932 {
933 flash_bank_t *c;
934
935 /* cycle through bank list */
936 for (c = flash_banks; c; c = c->next)
937 {
938 int retval;
939 retval = c->driver->auto_probe(c);
940
941 if (retval != ERROR_OK)
942 {
943 LOG_ERROR("auto_probe failed %d\n", retval);
944 return NULL;
945 }
946 /* check whether address belongs to this flash bank */
947 if ((addr >= c->base) && (addr <= c->base + (c->size - 1)) && target == c->target)
948 return c;
949 }
950 LOG_ERROR("No flash at address 0x%08" PRIx32 "\n", addr);
951 return NULL;
952 }
953
954 /* erase given flash region, selects proper bank according to target and address */
955 int flash_erase_address_range(target_t *target, uint32_t addr, uint32_t length)
956 {
957 flash_bank_t *c;
958 int first = -1;
959 int last = -1;
960 int i;
961
962 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
963 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
964
965 if (c->size == 0 || c->num_sectors == 0)
966 {
967 LOG_ERROR("Bank is invalid");
968 return ERROR_FLASH_BANK_INVALID;
969 }
970
971 if (length == 0)
972 {
973 /* special case, erase whole bank when length is zero */
974 if (addr != c->base)
975 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
976
977 return flash_driver_erase(c, 0, c->num_sectors - 1);
978 }
979
980 /* check whether it fits */
981 if (addr + length - 1 > c->base + c->size - 1)
982 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
983
984 addr -= c->base;
985
986 for (i = 0; i < c->num_sectors; i++)
987 {
988 /* check whether sector overlaps with the given range and is not yet erased */
989 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
990 /* if first is not set yet then this is the first sector */
991 if (first == -1)
992 first = i;
993 last = i; /* and it is the last one so far in any case */
994 }
995 }
996
997 if (first == -1 || last == -1)
998 return ERROR_OK;
999
1000 return flash_driver_erase(c, first, last);
1001 }
1002
1003 /* write (optional verify) an image to flash memory of the given target */
1004 int flash_write(target_t *target, image_t *image, uint32_t *written, int erase)
1005 {
1006 int retval = ERROR_OK;
1007
1008 int section;
1009 uint32_t section_offset;
1010 flash_bank_t *c;
1011 int *padding;
1012
1013 section = 0;
1014 section_offset = 0;
1015
1016 if (written)
1017 *written = 0;
1018
1019 if (erase)
1020 {
1021 /* assume all sectors need erasing - stops any problems
1022 * when flash_write is called multiple times */
1023
1024 flash_set_dirty();
1025 }
1026
1027 /* allocate padding array */
1028 padding = malloc(image->num_sections * sizeof(padding));
1029
1030 /* loop until we reach end of the image */
1031 while (section < image->num_sections)
1032 {
1033 uint32_t buffer_size;
1034 uint8_t *buffer;
1035 int section_first;
1036 int section_last;
1037 uint32_t run_address = image->sections[section].base_address + section_offset;
1038 uint32_t run_size = image->sections[section].size - section_offset;
1039 int pad_bytes = 0;
1040
1041 if (image->sections[section].size == 0)
1042 {
1043 LOG_WARNING("empty section %d", section);
1044 section++;
1045 section_offset = 0;
1046 continue;
1047 }
1048
1049 /* find the corresponding flash bank */
1050 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
1051 {
1052 section++; /* and skip it */
1053 section_offset = 0;
1054 continue;
1055 }
1056
1057 /* collect consecutive sections which fall into the same bank */
1058 section_first = section;
1059 section_last = section;
1060 padding[section] = 0;
1061 while ((run_address + run_size - 1 < c->base + c->size - 1)
1062 && (section_last + 1 < image->num_sections))
1063 {
1064 if (image->sections[section_last + 1].base_address < (run_address + run_size))
1065 {
1066 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
1067 break;
1068 }
1069 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1070 * attempt to rebuild a consecutive buffer for the flash loader */
1071 pad_bytes = (image->sections[section_last + 1].base_address) - (run_address + run_size);
1072 if ((run_address + run_size + pad_bytes) > (c->base + c->size))
1073 break;
1074 padding[section_last] = pad_bytes;
1075 run_size += image->sections[++section_last].size;
1076 run_size += pad_bytes;
1077 padding[section_last] = 0;
1078
1079 LOG_INFO("Padding image section %d with %d bytes", section_last-1, pad_bytes);
1080 }
1081
1082 /* fit the run into bank constraints */
1083 if (run_address + run_size - 1 > c->base + c->size - 1)
1084 {
1085 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1086 (int)(c->base + c->size - run_address), (int)(run_size), (int)(c->size));
1087 run_size = c->base + c->size - run_address;
1088 }
1089
1090 /* allocate buffer */
1091 buffer = malloc(run_size);
1092 buffer_size = 0;
1093
1094 /* read sections to the buffer */
1095 while (buffer_size < run_size)
1096 {
1097 uint32_t size_read;
1098
1099 size_read = run_size - buffer_size;
1100 if (size_read > image->sections[section].size - section_offset)
1101 size_read = image->sections[section].size - section_offset;
1102
1103 if ((retval = image_read_section(image, section, section_offset,
1104 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
1105 {
1106 free(buffer);
1107 free(padding);
1108 return retval;
1109 }
1110
1111 /* see if we need to pad the section */
1112 while (padding[section]--)
1113 (buffer + buffer_size)[size_read++] = 0xff;
1114
1115 buffer_size += size_read;
1116 section_offset += size_read;
1117
1118 if (section_offset >= image->sections[section].size)
1119 {
1120 section++;
1121 section_offset = 0;
1122 }
1123 }
1124
1125 retval = ERROR_OK;
1126
1127 if (erase)
1128 {
1129 /* calculate and erase sectors */
1130 retval = flash_erase_address_range(target, run_address, run_size);
1131 }
1132
1133 if (retval == ERROR_OK)
1134 {
1135 /* write flash sectors */
1136 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
1137 }
1138
1139 free(buffer);
1140
1141 if (retval != ERROR_OK)
1142 {
1143 free(padding);
1144 return retval; /* abort operation */
1145 }
1146
1147 if (written != NULL)
1148 *written += run_size; /* add run size to total written counter */
1149 }
1150
1151 free(padding);
1152
1153 return retval;
1154 }
1155
1156 int default_flash_mem_blank_check(struct flash_bank_s *bank)
1157 {
1158 target_t *target = bank->target;
1159 uint8_t buffer[1024];
1160 int buffer_size = sizeof(buffer);
1161 int i;
1162 uint32_t nBytes;
1163
1164 if (bank->target->state != TARGET_HALTED)
1165 {
1166 LOG_ERROR("Target not halted");
1167 return ERROR_TARGET_NOT_HALTED;
1168 }
1169
1170 for (i = 0; i < bank->num_sectors; i++)
1171 {
1172 uint32_t j;
1173 bank->sectors[i].is_erased = 1;
1174
1175 for (j = 0; j < bank->sectors[i].size; j += buffer_size)
1176 {
1177 uint32_t chunk;
1178 int retval;
1179 chunk = buffer_size;
1180 if (chunk > (j - bank->sectors[i].size))
1181 {
1182 chunk = (j - bank->sectors[i].size);
1183 }
1184
1185 retval = target_read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
1186 if (retval != ERROR_OK)
1187 return retval;
1188
1189 for (nBytes = 0; nBytes < chunk; nBytes++)
1190 {
1191 if (buffer[nBytes] != 0xFF)
1192 {
1193 bank->sectors[i].is_erased = 0;
1194 break;
1195 }
1196 }
1197 }
1198 }
1199
1200 return ERROR_OK;
1201 }
1202
1203 int default_flash_blank_check(struct flash_bank_s *bank)
1204 {
1205 target_t *target = bank->target;
1206 int i;
1207 int retval;
1208 int fast_check = 0;
1209 uint32_t blank;
1210
1211 if (bank->target->state != TARGET_HALTED)
1212 {
1213 LOG_ERROR("Target not halted");
1214 return ERROR_TARGET_NOT_HALTED;
1215 }
1216
1217 for (i = 0; i < bank->num_sectors; i++)
1218 {
1219 uint32_t address = bank->base + bank->sectors[i].offset;
1220 uint32_t size = bank->sectors[i].size;
1221
1222 if ((retval = target_blank_check_memory(target, address, size, &blank)) != ERROR_OK)
1223 {
1224 fast_check = 0;
1225 break;
1226 }
1227 if (blank == 0xFF)
1228 bank->sectors[i].is_erased = 1;
1229 else
1230 bank->sectors[i].is_erased = 0;
1231 fast_check = 1;
1232 }
1233
1234 if (!fast_check)
1235 {
1236 LOG_USER("Running slow fallback erase check - add working memory");
1237 return default_flash_mem_blank_check(bank);
1238 }
1239
1240 return ERROR_OK;
1241 }
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)