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