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