Code Review / openocd.git / blob
? search:


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