Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- typo with flash bank help command
[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
472 return ERROR_OK;
473 }
474
475 int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
476 {
477 flash_bank_t *p;
478 int retval;
479 int address;
480 int length;
481 duration_t duration;
482 char *duration_text;
483
484 target_t *target = get_current_target(cmd_ctx);
485
486 if (argc != 2)
487 {
488 return ERROR_COMMAND_SYNTAX_ERROR;
489 }
490
491 address = strtoul(args[0], NULL, 0);
492 length = strtoul(args[1], NULL, 0);
493 if (length <= 0)
494 {
495 command_print(cmd_ctx, "Length must be >0");
496 return ERROR_COMMAND_SYNTAX_ERROR;
497 }
498
499 p = get_flash_bank_by_addr(target, address);
500 if (p == NULL)
501 {
502 return ERROR_FAIL;
503 }
504
505 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
506 flash_set_dirty();
507
508 duration_start_measure(&duration);
509
510 if ((retval = flash_erase_address_range(target, address, length)) == ERROR_OK)
511 {
512 if ((retval = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
513 {
514 return retval;
515 }
516 command_print(cmd_ctx, "erased address 0x%8.8x length %i in %s", address, length, duration_text);
517 free(duration_text);
518 }
519
520 return retval;
521 }
522
523 int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
524 {
525 flash_bank_t *p;
526 int retval;
527
528 if (argc != 1)
529 {
530 return ERROR_COMMAND_SYNTAX_ERROR;
531 }
532
533 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
534 if (p)
535 {
536 if ((retval = p->driver->protect_check(p)) == ERROR_OK)
537 {
538 command_print(cmd_ctx, "successfully checked protect state");
539 }
540 else if (retval == ERROR_FLASH_OPERATION_FAILED)
541 {
542 command_print(cmd_ctx, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args[0], p->base);
543 }
544 else
545 {
546 command_print(cmd_ctx, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args[0], p->base);
547 }
548 }
549 else
550 {
551 return ERROR_COMMAND_SYNTAX_ERROR;
552 }
553
554 return ERROR_OK;
555 }
556
557 int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
558 {
559 if (argc > 2)
560 {
561 int first = strtoul(args[1], NULL, 0);
562 int last = strtoul(args[2], NULL, 0);
563 int retval;
564 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
565 duration_t duration;
566 char *duration_text;
567
568 duration_start_measure(&duration);
569
570 if (!p)
571 {
572 return ERROR_COMMAND_SYNTAX_ERROR;
573 }
574
575 if ((retval = flash_driver_erase(p, first, last)) == ERROR_OK)
576 {
577 if ((retval = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
578 {
579 return retval;
580 }
581
582 command_print(cmd_ctx, "erased sectors %i through %i on flash bank %i in %s", first, last, strtoul(args[0], 0, 0), duration_text);
583 free(duration_text);
584 }
585 }
586 else
587 {
588 return ERROR_COMMAND_SYNTAX_ERROR;
589 }
590
591 return ERROR_OK;
592 }
593
594 int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
595 {
596 if (argc > 3)
597 {
598 int first = strtoul(args[1], NULL, 0);
599 int last = strtoul(args[2], NULL, 0);
600 int set;
601 int retval;
602 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
603 if (!p)
604 {
605 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
606 return ERROR_OK;
607 }
608
609 if (strcmp(args[3], "on") == 0)
610 set = 1;
611 else if (strcmp(args[3], "off") == 0)
612 set = 0;
613 else
614 {
615 return ERROR_COMMAND_SYNTAX_ERROR;
616 }
617
618 retval = flash_driver_protect(p, set, first, last);
619 if (retval == ERROR_OK)
620 {
621 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));
622 }
623 }
624 else
625 {
626 return ERROR_COMMAND_SYNTAX_ERROR;
627
628 }
629
630 return ERROR_OK;
631 }
632
633 int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
634 {
635 target_t *target = get_current_target(cmd_ctx);
636
637 image_t image;
638 u32 written;
639
640 duration_t duration;
641 char *duration_text;
642
643 int retval, retvaltemp;
644
645 if (argc < 1)
646 {
647 return ERROR_COMMAND_SYNTAX_ERROR;
648 }
649
650 /* flash auto-erase is disabled by default*/
651 int auto_erase = 0;
652
653 if (strcmp(args[0], "erase")==0)
654 {
655 auto_erase = 1;
656 args++;
657 argc--;
658 command_print(cmd_ctx, "auto erase enabled");
659 }
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 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 u32 wrote = 0;
727 int chunk_count;
728 char *duration_text;
729 duration_t duration;
730 target_t *target = get_current_target(cmd_ctx);
731 u32 i;
732 int wordsize;
733
734 if (argc != 3)
735 {
736 return ERROR_COMMAND_SYNTAX_ERROR;
737 }
738
739 address = strtoul(args[0], NULL, 0);
740 pattern = strtoul(args[1], NULL, 0);
741 count = strtoul(args[2], NULL, 0);
742
743 if(count == 0)
744 return ERROR_OK;
745
746
747 switch(cmd[4])
748 {
749 case 'w':
750 wordsize=4;
751 break;
752 case 'h':
753 wordsize=2;
754 break;
755 case 'b':
756 wordsize=1;
757 break;
758 default:
759 return ERROR_COMMAND_SYNTAX_ERROR;
760 }
761
762 chunk_count = MIN(count, (1024 / wordsize));
763 switch(wordsize)
764 {
765 case 4:
766 for(i = 0; i < chunk_count; i++)
767 {
768 target_buffer_set_u32(target, chunk + i * wordsize, pattern);
769 }
770 break;
771 case 2:
772 for(i = 0; i < chunk_count; i++)
773 {
774 target_buffer_set_u16(target, chunk + i * wordsize, pattern);
775 }
776 break;
777 case 1:
778 memset(chunk, pattern, chunk_count);
779 break;
780 default:
781 LOG_ERROR("BUG: can't happen");
782 exit(-1);
783 }
784
785 duration_start_measure(&duration);
786
787 for (wrote=0; wrote<(count*wordsize); wrote+=sizeof(chunk))
788 {
789 int cur_size = MIN( (count*wordsize - wrote) , 1024 );
790 flash_bank_t *bank;
791 bank = get_flash_bank_by_addr(target, address);
792 if(bank == NULL)
793 {
794 return ERROR_FAIL;
795 }
796 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
797 if (err!=ERROR_OK)
798 return err;
799 wrote += cur_size;
800 }
801
802 if ((retval = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
803 {
804 return retval;
805 }
806
807
808 if(err == ERROR_OK)
809 {
810 float speed;
811 speed=wrote / 1024.0;
812 speed/=((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0));
813 command_print(cmd_ctx, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
814 count*wordsize, address, duration_text,
815 speed);
816 }
817 free(duration_text);
818 return ERROR_OK;
819 }
820
821 int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
822 {
823 u32 offset;
824 u8 *buffer;
825 u32 buf_cnt;
826
827 fileio_t fileio;
828
829 duration_t duration;
830 char *duration_text;
831
832 int retval, retvaltemp;
833 flash_bank_t *p;
834
835 if (argc != 3)
836 {
837 return ERROR_COMMAND_SYNTAX_ERROR;
838 }
839
840 duration_start_measure(&duration);
841
842 offset = strtoul(args[2], NULL, 0);
843 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
844 if (!p)
845 {
846 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
847 return ERROR_OK;
848 }
849
850 if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
851 {
852 return ERROR_OK;
853 }
854
855 buffer = malloc(fileio.size);
856 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
857 {
858 free(buffer);
859 fileio_close(&fileio);
860 return ERROR_OK;
861 }
862
863 retval = flash_driver_write(p, buffer, offset, buf_cnt);
864
865 free(buffer);
866 buffer = NULL;
867
868 if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
869 {
870 fileio_close(&fileio);
871 return retvaltemp;
872 }
873 if (retval==ERROR_OK)
874 {
875 command_print(cmd_ctx, "wrote %"PRIi64" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
876 fileio.size, args[1], strtoul(args[0], NULL, 0), offset, duration_text,
877 (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
878 }
879 free(duration_text);
880
881 fileio_close(&fileio);
882
883 return retval;
884 }
885
886 void flash_set_dirty(void)
887 {
888 flash_bank_t *c;
889 int i;
890
891 /* set all flash to require erasing */
892 for (c = flash_banks; c; c = c->next)
893 {
894 for (i = 0; i < c->num_sectors; i++)
895 {
896 c->sectors[i].is_erased = 0;
897 }
898 }
899 }
900
901 /* lookup flash bank by address */
902 flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
903 {
904 flash_bank_t *c;
905
906 /* cycle through bank list */
907 for (c = flash_banks; c; c = c->next)
908 {
909 int retval;
910 retval = c->driver->auto_probe(c);
911
912 if (retval != ERROR_OK)
913 {
914 LOG_ERROR("auto_probe failed %d\n", retval);
915 return NULL;
916 }
917 /* check whether address belongs to this flash bank */
918 if ((addr >= c->base) && (addr <= c->base + (c->size - 1)) && target == c->target)
919 return c;
920 }
921 LOG_ERROR("No flash at address 0x%08x\n", addr);
922 return NULL;
923 }
924
925 /* erase given flash region, selects proper bank according to target and address */
926 int flash_erase_address_range(target_t *target, u32 addr, u32 length)
927 {
928 flash_bank_t *c;
929 int first = -1;
930 int last = -1;
931 int i;
932
933 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
934 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
935
936 if (c->size == 0 || c->num_sectors == 0)
937 {
938 LOG_ERROR("Bank is invalid");
939 return ERROR_FLASH_BANK_INVALID;
940 }
941
942 if (length == 0)
943 {
944 /* special case, erase whole bank when length is zero */
945 if (addr != c->base)
946 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
947
948 return flash_driver_erase(c, 0, c->num_sectors - 1);
949 }
950
951 /* check whether it fits */
952 if (addr + length > c->base + c->size)
953 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
954
955 addr -= c->base;
956
957 for (i = 0; i < c->num_sectors; i++)
958 {
959 /* check whether sector overlaps with the given range and is not yet erased */
960 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
961 /* if first is not set yet then this is the first sector */
962 if (first == -1)
963 first = i;
964 last = i; /* and it is the last one so far in any case */
965 }
966 }
967
968 if( first == -1 || last == -1 )
969 return ERROR_OK;
970
971 return flash_driver_erase(c, first, last);
972 }
973
974 /* write (optional verify) an image to flash memory of the given target */
975 int flash_write(target_t *target, image_t *image, u32 *written, int erase)
976 {
977 int retval=ERROR_OK;
978
979 int section;
980 u32 section_offset;
981 flash_bank_t *c;
982 int *padding;
983
984 section = 0;
985 section_offset = 0;
986
987 if (written)
988 *written = 0;
989
990 if (erase)
991 {
992 /* assume all sectors need erasing - stops any problems
993 * when flash_write is called multiple times */
994
995 flash_set_dirty();
996 }
997
998 /* allocate padding array */
999 padding = malloc(image->num_sections * sizeof(padding));
1000
1001 /* loop until we reach end of the image */
1002 while (section < image->num_sections)
1003 {
1004 u32 buffer_size;
1005 u8 *buffer;
1006 int section_first;
1007 int section_last;
1008 u32 run_address = image->sections[section].base_address + section_offset;
1009 u32 run_size = image->sections[section].size - section_offset;
1010 int pad_bytes = 0;
1011
1012 if (image->sections[section].size == 0)
1013 {
1014 LOG_WARNING("empty section %d", section);
1015 section++;
1016 section_offset = 0;
1017 continue;
1018 }
1019
1020 /* find the corresponding flash bank */
1021 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
1022 {
1023 section++; /* and skip it */
1024 section_offset = 0;
1025 continue;
1026 }
1027
1028 /* collect consecutive sections which fall into the same bank */
1029 section_first = section;
1030 section_last = section;
1031 padding[section] = 0;
1032 while ((run_address + run_size < c->base + c->size)
1033 && (section_last + 1 < image->num_sections))
1034 {
1035 if (image->sections[section_last + 1].base_address < (run_address + run_size))
1036 {
1037 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
1038 break;
1039 }
1040 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1041 * attempt to rebuild a consecutive buffer for the flash loader */
1042 pad_bytes = (image->sections[section_last + 1].base_address) - (run_address + run_size);
1043 if ((run_address + run_size + pad_bytes) > (c->base + c->size))
1044 break;
1045 padding[section_last] = pad_bytes;
1046 run_size += image->sections[++section_last].size;
1047 run_size += pad_bytes;
1048 padding[section_last] = 0;
1049
1050 LOG_INFO("Padding image section %d with %d bytes", section_last-1, pad_bytes );
1051 }
1052
1053 /* fit the run into bank constraints */
1054 if (run_address + run_size > c->base + c->size)
1055 run_size = c->base + c->size - run_address;
1056
1057 /* allocate buffer */
1058 buffer = malloc(run_size);
1059 buffer_size = 0;
1060
1061 /* read sections to the buffer */
1062 while (buffer_size < run_size)
1063 {
1064 u32 size_read;
1065
1066 size_read = run_size - buffer_size;
1067 if (size_read > image->sections[section].size - section_offset)
1068 size_read = image->sections[section].size - section_offset;
1069
1070 if ((retval = image_read_section(image, section, section_offset,
1071 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
1072 {
1073 free(buffer);
1074 free(padding);
1075 return retval;
1076 }
1077
1078 /* see if we need to pad the section */
1079 while (padding[section]--)
1080 (buffer+buffer_size)[size_read++] = 0xff;
1081
1082 buffer_size += size_read;
1083 section_offset += size_read;
1084
1085 if (section_offset >= image->sections[section].size)
1086 {
1087 section++;
1088 section_offset = 0;
1089 }
1090 }
1091
1092 retval = ERROR_OK;
1093
1094 if (erase)
1095 {
1096 /* calculate and erase sectors */
1097 retval = flash_erase_address_range( target, run_address, run_size );
1098 }
1099
1100 if (retval == ERROR_OK)
1101 {
1102 /* write flash sectors */
1103 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
1104 }
1105
1106 free(buffer);
1107
1108 if (retval != ERROR_OK)
1109 {
1110 free(padding);
1111 return retval; /* abort operation */
1112 }
1113
1114 if (written != NULL)
1115 *written += run_size; /* add run size to total written counter */
1116 }
1117
1118 free(padding);
1119
1120 return retval;
1121 }
1122
1123 int default_flash_mem_blank_check(struct flash_bank_s *bank)
1124 {
1125 target_t *target = bank->target;
1126 u8 buffer[1024];
1127 int buffer_size = sizeof(buffer);
1128 int i;
1129 int nBytes;
1130
1131 if (bank->target->state != TARGET_HALTED)
1132 {
1133 LOG_ERROR("Target not halted");
1134 return ERROR_TARGET_NOT_HALTED;
1135 }
1136
1137 for (i = 0; i < bank->num_sectors; i++)
1138 {
1139 int j;
1140 bank->sectors[i].is_erased = 1;
1141
1142 for (j = 0; j < bank->sectors[i].size; j += buffer_size)
1143 {
1144 int chunk;
1145 int retval;
1146 chunk = buffer_size;
1147 if (chunk > (j - bank->sectors[i].size))
1148 {
1149 chunk = (j - bank->sectors[i].size);
1150 }
1151
1152 retval = target->type->read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
1153 if (retval != ERROR_OK)
1154 return retval;
1155
1156 for (nBytes = 0; nBytes < chunk; nBytes++)
1157 {
1158 if (buffer[nBytes] != 0xFF)
1159 {
1160 bank->sectors[i].is_erased = 0;
1161 break;
1162 }
1163 }
1164 }
1165 }
1166
1167 return ERROR_OK;
1168 }
1169
1170 int default_flash_blank_check(struct flash_bank_s *bank)
1171 {
1172 target_t *target = bank->target;
1173 int i;
1174 int retval;
1175 int fast_check = 0;
1176 u32 blank;
1177
1178 if (bank->target->state != TARGET_HALTED)
1179 {
1180 LOG_ERROR("Target not halted");
1181 return ERROR_TARGET_NOT_HALTED;
1182 }
1183
1184 for (i = 0; i < bank->num_sectors; i++)
1185 {
1186 u32 address = bank->base + bank->sectors[i].offset;
1187 u32 size = bank->sectors[i].size;
1188
1189 if ((retval = target_blank_check_memory(target, address, size, &blank)) != ERROR_OK)
1190 {
1191 fast_check = 0;
1192 break;
1193 }
1194 if (blank == 0xFF)
1195 bank->sectors[i].is_erased = 1;
1196 else
1197 bank->sectors[i].is_erased = 0;
1198 fast_check = 1;
1199 }
1200
1201 if (!fast_check)
1202 {
1203 LOG_USER("Running slow fallback erase check - add working memory");
1204 return default_flash_mem_blank_check(bank);
1205 }
1206
1207 return ERROR_OK;
1208 }
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)