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