Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- removed flash write_image - binary compare function has been moved to verify_image...
[openocd.git] / src / flash / flash.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include "flash.h"
25 #include "command.h"
26 #include "target.h"
27 #include "time_support.h"
28 #include "fileio.h"
29 #include "image.h"
30 #include "log.h"
31
32 #include <string.h>
33 #include <unistd.h>
34 #include <stdlib.h>
35 #include <sys/types.h>
36 #include <sys/stat.h>
37 #include <errno.h>
38 #include <inttypes.h>
39
40 /* command handlers */
41 int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
42 int handle_flash_banks_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
43 int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
44 int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
45 int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
46 int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
47 int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
48 int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
49 int handle_flash_write_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
50 int handle_flash_write_binary_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
51 int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
52 int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
53 int handle_flash_auto_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
54 flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr);
55
56 /* flash drivers
57 */
58 extern flash_driver_t lpc2000_flash;
59 extern flash_driver_t cfi_flash;
60 extern flash_driver_t at91sam7_flash;
61 extern flash_driver_t str7x_flash;
62 extern flash_driver_t str9x_flash;
63 extern flash_driver_t stellaris_flash;
64 extern flash_driver_t str9xpec_flash;
65 extern flash_driver_t stm32x_flash;
66
67 flash_driver_t *flash_drivers[] =
68 {
69 &lpc2000_flash,
70 &cfi_flash,
71 &at91sam7_flash,
72 &str7x_flash,
73 &str9x_flash,
74 &stellaris_flash,
75 &str9xpec_flash,
76 &stm32x_flash,
77 NULL,
78 };
79
80 flash_bank_t *flash_banks;
81 static command_t *flash_cmd;
82 static int auto_erase = 0;
83
84 int flash_register_commands(struct command_context_s *cmd_ctx)
85 {
86 flash_cmd = register_command(cmd_ctx, NULL, "flash", NULL, COMMAND_ANY, NULL);
87
88 register_command(cmd_ctx, flash_cmd, "bank", handle_flash_bank_command, COMMAND_CONFIG, NULL);
89
90 return ERROR_OK;
91 }
92
93 int flash_init(struct command_context_s *cmd_ctx)
94 {
95 if (flash_banks)
96 {
97 register_command(cmd_ctx, flash_cmd, "banks", handle_flash_banks_command, COMMAND_EXEC,
98 "list configured flash banks ");
99 register_command(cmd_ctx, flash_cmd, "info", handle_flash_info_command, COMMAND_EXEC,
100 "print info about flash bank <num>");
101 register_command(cmd_ctx, flash_cmd, "probe", handle_flash_probe_command, COMMAND_EXEC,
102 "identify flash bank <num>");
103 register_command(cmd_ctx, flash_cmd, "erase_check", handle_flash_erase_check_command, COMMAND_EXEC,
104 "check erase state of sectors in flash bank <num>");
105 register_command(cmd_ctx, flash_cmd, "protect_check", handle_flash_protect_check_command, COMMAND_EXEC,
106 "check protection state of sectors in flash bank <num>");
107 register_command(cmd_ctx, flash_cmd, "erase", handle_flash_erase_command, COMMAND_EXEC,
108 "DEPRECATED, use 'erase_sector' instead");
109 register_command(cmd_ctx, flash_cmd, "erase_sector", handle_flash_erase_command, COMMAND_EXEC,
110 "erase sectors at <bank> <first> <last>");
111 register_command(cmd_ctx, flash_cmd, "erase_address", handle_flash_erase_address_command, COMMAND_EXEC,
112 "erase address range <address> <length>");
113 register_command(cmd_ctx, flash_cmd, "write", handle_flash_write_binary_command, COMMAND_EXEC,
114 "DEPRECATED, use 'write_binary' instead");
115 register_command(cmd_ctx, flash_cmd, "write_binary", handle_flash_write_binary_command, COMMAND_EXEC,
116 "write binary <bank> <file> <offset>");
117 register_command(cmd_ctx, flash_cmd, "write_image", handle_flash_write_image_command, COMMAND_EXEC,
118 "write_image <file> [offset] [type]");
119 register_command(cmd_ctx, flash_cmd, "protect", handle_flash_protect_command, COMMAND_EXEC,
120 "set protection of sectors at <bank> <first> <last> <on|off>");
121 register_command(cmd_ctx, flash_cmd, "auto_erase", handle_flash_auto_erase_command, COMMAND_EXEC,
122 "auto erase flash sectors <on|off>");
123 }
124
125 return ERROR_OK;
126 }
127
128 flash_bank_t *get_flash_bank_by_num(int num)
129 {
130 flash_bank_t *p;
131 int i = 0;
132
133 for (p = flash_banks; p; p = p->next)
134 {
135 if (i++ == num)
136 {
137 return p;
138 }
139 }
140
141 return NULL;
142 }
143
144 /* flash_bank <driver> <base> <size> <chip_width> <bus_width> <target> [driver_options ...]
145 */
146 int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
147 {
148 int i;
149 int found = 0;
150 target_t *target;
151
152 if (argc < 6)
153 {
154 WARNING("incomplete flash_bank configuration");
155 WARNING("flash_bank <driver> <base> <size> <chip_width> <bus_width> <target> [driver_options ...]");
156 return ERROR_OK;
157 }
158
159 if ((target = get_target_by_num(strtoul(args[5], NULL, 0))) == NULL)
160 {
161 ERROR("target %lu not defined", strtoul(args[5], NULL, 0));
162 return ERROR_OK;
163 }
164
165 for (i = 0; flash_drivers[i]; i++)
166 {
167 if (strcmp(args[0], flash_drivers[i]->name) == 0)
168 {
169 flash_bank_t *p, *c;
170
171 /* register flash specific commands */
172 if (flash_drivers[i]->register_commands(cmd_ctx) != ERROR_OK)
173 {
174 ERROR("couldn't register '%s' commands", args[0]);
175 exit(-1);
176 }
177
178 c = malloc(sizeof(flash_bank_t));
179 c->target = target;
180 c->driver = flash_drivers[i];
181 c->driver_priv = NULL;
182 c->base = strtoul(args[1], NULL, 0);
183 c->size = strtoul(args[2], NULL, 0);
184 c->chip_width = strtoul(args[3], NULL, 0);
185 c->bus_width = strtoul(args[4], NULL, 0);
186 c->num_sectors = 0;
187 c->sectors = NULL;
188 c->next = NULL;
189
190 if (flash_drivers[i]->flash_bank_command(cmd_ctx, cmd, args, argc, c) != ERROR_OK)
191 {
192 ERROR("'%s' driver rejected flash bank at 0x%8.8x", args[0], c->base);
193 free(c);
194 return ERROR_OK;
195 }
196
197 /* put flash bank in linked list */
198 if (flash_banks)
199 {
200 /* find last flash bank */
201 for (p = flash_banks; p && p->next; p = p->next);
202 if (p)
203 p->next = c;
204 }
205 else
206 {
207 flash_banks = c;
208 }
209
210 found = 1;
211 }
212 }
213
214 /* no matching flash driver found */
215 if (!found)
216 {
217 ERROR("flash driver '%s' not found", args[0]);
218 exit(-1);
219 }
220
221 return ERROR_OK;
222 }
223
224 int handle_flash_banks_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
225 {
226 flash_bank_t *p;
227 int i = 0;
228
229 if (!flash_banks)
230 {
231 command_print(cmd_ctx, "no flash banks configured");
232 return ERROR_OK;
233 }
234
235 for (p = flash_banks; p; p = p->next)
236 {
237 command_print(cmd_ctx, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
238 i++, p->driver->name, p->base, p->size, p->bus_width, p->chip_width);
239 }
240
241 return ERROR_OK;
242 }
243
244 int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
245 {
246 flash_bank_t *p;
247 int i = 0;
248 int j = 0;
249
250 if (argc != 1)
251 {
252 command_print(cmd_ctx, "usage: flash info <num>");
253 return ERROR_OK;
254 }
255
256 for (p = flash_banks; p; p = p->next, i++)
257 {
258 if (i == strtoul(args[0], NULL, 0))
259 {
260 char buf[1024];
261
262 command_print(cmd_ctx, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
263 i, p->driver->name, p->base, p->size, p->bus_width, p->chip_width);
264 for (j = 0; j < p->num_sectors; j++)
265 {
266 char *erase_state, *protect_state;
267
268 if (p->sectors[j].is_erased == 0)
269 erase_state = "not erased";
270 else if (p->sectors[j].is_erased == 1)
271 erase_state = "erased";
272 else
273 erase_state = "erase state unknown";
274
275 if (p->sectors[j].is_protected == 0)
276 protect_state = "not protected";
277 else if (p->sectors[j].is_protected == 1)
278 protect_state = "protected";
279 else
280 protect_state = "protection state unknown";
281
282 command_print(cmd_ctx, "\t#%i: 0x%8.8x (0x%x %ikB) %s, %s",
283 j, p->sectors[j].offset, p->sectors[j].size, p->sectors[j].size>>10,
284 erase_state, protect_state);
285 }
286
287 p->driver->info(p, buf, 1024);
288 command_print(cmd_ctx, "%s", buf);
289 }
290 }
291
292 return ERROR_OK;
293 }
294
295 int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
296 {
297 flash_bank_t *p;
298 int retval;
299
300 if (argc != 1)
301 {
302 command_print(cmd_ctx, "usage: flash probe <num>");
303 return ERROR_OK;
304 }
305
306 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
307 if (p)
308 {
309 if ((retval = p->driver->probe(p)) == ERROR_OK)
310 {
311 command_print(cmd_ctx, "flash '%s' found at 0x%8.8x", p->driver->name, p->base);
312 }
313 else if (retval == ERROR_FLASH_BANK_INVALID)
314 {
315 command_print(cmd_ctx, "probing failed for flash bank '#%s' at 0x%8.8x",
316 args[0], p->base);
317 }
318 else
319 {
320 command_print(cmd_ctx, "unknown error when probing flash bank '#%s' at 0x%8.8x",
321 args[0], p->base);
322 }
323 }
324 else
325 {
326 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
327 }
328
329 return ERROR_OK;
330 }
331
332 int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
333 {
334 flash_bank_t *p;
335 int retval;
336
337 if (argc != 1)
338 {
339 command_print(cmd_ctx, "usage: flash erase_check <num>");
340 return ERROR_OK;
341 }
342
343 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
344 if (p)
345 {
346 if ((retval = p->driver->erase_check(p)) == ERROR_OK)
347 {
348 command_print(cmd_ctx, "successfully checked erase state", p->driver->name, p->base);
349 }
350 else
351 {
352 command_print(cmd_ctx, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
353 args[0], p->base);
354 }
355 }
356 else
357 {
358 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
359 }
360
361 return ERROR_OK;
362 }
363
364 int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
365 {
366 flash_bank_t *p;
367 int retval;
368 int address;
369 int length;
370 duration_t duration;
371 char *duration_text;
372
373 target_t *target = get_current_target(cmd_ctx);
374
375 if (argc != 2)
376 {
377 command_print(cmd_ctx, "usage: flash erase_address <address> <length>");
378 return ERROR_OK;
379 }
380
381 address = strtoul(args[0], NULL, 0);
382 length = strtoul(args[1], NULL, 0);
383 if (length <= 0)
384 {
385 command_print(cmd_ctx, "Length must be >0");
386 return ERROR_INVALID_ARGUMENTS;
387 }
388
389 p = get_flash_bank_by_addr(target, address);
390 if (p == NULL)
391 {
392 command_print(cmd_ctx, "No flash at that address");
393 return ERROR_INVALID_ARGUMENTS;
394 }
395
396 duration_start_measure(&duration);
397
398 if ((retval = flash_erase(target, address, length)) != ERROR_OK)
399 {
400 switch (retval)
401 {
402 case ERROR_TARGET_NOT_HALTED:
403 command_print(cmd_ctx, "can't work with this flash while target is running");
404 break;
405 case ERROR_INVALID_ARGUMENTS:
406 command_print(cmd_ctx, "usage: flash erase_address <address> <length>");
407 break;
408 case ERROR_FLASH_BANK_INVALID:
409 command_print(cmd_ctx, "no '%s' flash found at 0x%8.8x", p->driver->name, p->base);
410 break;
411 case ERROR_FLASH_OPERATION_FAILED:
412 command_print(cmd_ctx, "flash erase error");
413 break;
414 case ERROR_FLASH_SECTOR_INVALID:
415 command_print(cmd_ctx, "sector number(s) invalid");
416 break;
417 default:
418 command_print(cmd_ctx, "unknown error");
419 }
420 }
421 else
422 {
423 duration_stop_measure(&duration, &duration_text);
424 command_print(cmd_ctx, "erased address 0x%8.8x length %i in %s", address, length, duration_text);
425 free(duration_text);
426 }
427
428 return retval;
429 }
430
431 int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
432 {
433 flash_bank_t *p;
434 int retval;
435
436 if (argc != 1)
437 {
438 command_print(cmd_ctx, "usage: flash protect_check <num>");
439 return ERROR_OK;
440 }
441
442 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
443 if (p)
444 {
445 if ((retval = p->driver->protect_check(p)) == ERROR_OK)
446 {
447 command_print(cmd_ctx, "successfully checked protect state");
448 }
449 else if (retval == ERROR_FLASH_OPERATION_FAILED)
450 {
451 command_print(cmd_ctx, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args[0], p->base);
452 }
453 else
454 {
455 command_print(cmd_ctx, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args[0], p->base);
456 }
457 }
458 else
459 {
460 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
461 }
462
463 return ERROR_OK;
464 }
465
466 int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
467 {
468 if (argc > 2)
469 {
470 int first = strtoul(args[1], NULL, 0);
471 int last = strtoul(args[2], NULL, 0);
472 int retval;
473 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
474 duration_t duration;
475 char *duration_text;
476
477 duration_start_measure(&duration);
478
479 if (!p)
480 {
481 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
482 return ERROR_OK;
483 }
484
485 if ((retval = p->driver->erase(p, first, last)) != ERROR_OK)
486 {
487 switch (retval)
488 {
489 case ERROR_TARGET_NOT_HALTED:
490 command_print(cmd_ctx, "can't work with this flash while target is running");
491 break;
492 case ERROR_INVALID_ARGUMENTS:
493 command_print(cmd_ctx, "usage: flash_erase <bank> <first> <last>");
494 break;
495 case ERROR_FLASH_BANK_INVALID:
496 command_print(cmd_ctx, "no '%s' flash found at 0x%8.8x", p->driver->name, p->base);
497 break;
498 case ERROR_FLASH_OPERATION_FAILED:
499 command_print(cmd_ctx, "flash erase error");
500 break;
501 case ERROR_FLASH_SECTOR_INVALID:
502 command_print(cmd_ctx, "sector number(s) invalid");
503 break;
504 case ERROR_OK:
505 command_print(cmd_ctx, "erased flash sectors %i to %i", first, last);
506 break;
507 default:
508 command_print(cmd_ctx, "unknown error");
509 }
510 }
511 else
512 {
513 duration_stop_measure(&duration, &duration_text);
514
515 command_print(cmd_ctx, "erased sectors %i through %i on flash bank %i in %s", first, last, strtoul(args[0], 0, 0), duration_text);
516 free(duration_text);
517 }
518 }
519 else
520 {
521 command_print(cmd_ctx, "usage: flash erase <bank> <first> <last>");
522 }
523
524 return ERROR_OK;
525 }
526
527 int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
528 {
529 if (argc > 3)
530 {
531 int first = strtoul(args[1], NULL, 0);
532 int last = strtoul(args[2], NULL, 0);
533 int set;
534 int retval;
535 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
536 if (!p)
537 {
538 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
539 return ERROR_OK;
540 }
541
542 if (strcmp(args[3], "on") == 0)
543 set = 1;
544 else if (strcmp(args[3], "off") == 0)
545 set = 0;
546 else
547 {
548 command_print(cmd_ctx, "usage: flash protect <bank> <first> <last> <on|off>");
549 return ERROR_OK;
550 }
551
552 if ((retval = p->driver->protect(p, set, first, last)) != ERROR_OK)
553 {
554 switch (retval)
555 {
556 case ERROR_TARGET_NOT_HALTED:
557 command_print(cmd_ctx, "can't work with this flash while target is running");
558 break;
559 case ERROR_INVALID_ARGUMENTS:
560 command_print(cmd_ctx, "usage: flash protect <bank> <first> <last> <on|off>");
561 break;
562 case ERROR_FLASH_BANK_INVALID:
563 command_print(cmd_ctx, "no '%s' flash found at 0x%8.8x", p->driver->name, p->base);
564 break;
565 case ERROR_FLASH_OPERATION_FAILED:
566 command_print(cmd_ctx, "flash program error");
567 break;
568 case ERROR_FLASH_SECTOR_INVALID:
569 command_print(cmd_ctx, "sector number(s) invalid");
570 break;
571 case ERROR_OK:
572 command_print(cmd_ctx, "protection of flash sectors %i to %i turned %s", first, last, args[3]);
573 break;
574 default:
575 command_print(cmd_ctx, "unknown error");
576 }
577 }
578 else
579 {
580 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));
581 }
582 }
583 else
584 {
585 command_print(cmd_ctx, "usage: flash protect <bank> <first> <last> <on|off>");
586 }
587
588 return ERROR_OK;
589 }
590
591 int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
592 {
593 target_t *target = get_current_target(cmd_ctx);
594
595 image_t image;
596 u32 written;
597 char *error_str;
598 int *failed;
599
600 int i;
601
602 duration_t duration;
603 char *duration_text;
604
605 int retval;
606
607 if (argc < 1)
608 {
609 command_print(cmd_ctx, "usage: flash %s <file> [offset] [type]", cmd);
610 return ERROR_INVALID_ARGUMENTS;
611 }
612
613 if (!target)
614 {
615 ERROR("no target selected");
616 return ERROR_OK;
617 }
618
619 duration_start_measure(&duration);
620
621 if (argc >= 2)
622 {
623 image.base_address_set = 1;
624 image.base_address = strtoul(args[1], NULL, 0);
625 }
626 else
627 {
628 image.base_address_set = 0;
629 image.base_address = 0x0;
630 }
631
632 image.start_address_set = 0;
633
634 retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL);
635 if (retval != ERROR_OK)
636 {
637 command_print(cmd_ctx, "image_open error: %s", image.error_str);
638 return retval;
639 }
640
641 failed = malloc(sizeof(int) * image.num_sections);
642
643 error_str = NULL;
644
645 retval = flash_write(target, &image, &written, &error_str, failed, auto_erase);
646
647 if (retval != ERROR_OK)
648 {
649 if (error_str)
650 {
651 command_print(cmd_ctx, "failed writing image %s: %s", args[0], error_str);
652 free(error_str);
653 }
654 image_close(&image);
655 free(failed);
656 return retval;
657 }
658
659 for (i = 0; i < image.num_sections; i++)
660 {
661 if (failed[i])
662 {
663 command_print(cmd_ctx, "didn't write section at 0x%8.8x, size 0x%8.8x",
664 image.sections[i].base_address, image.sections[i].size);
665 }
666 }
667
668 duration_stop_measure(&duration, &duration_text);
669 command_print(cmd_ctx, "wrote %u byte from file %s in %s (%f kb/s)",
670 written, args[0], duration_text,
671 (float)written / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
672 free(duration_text);
673 free(failed);
674
675 image_close(&image);
676
677 return ERROR_OK;
678 }
679
680 int handle_flash_write_binary_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
681 {
682 u32 offset;
683 u8 *buffer;
684 u32 buf_cnt;
685
686 fileio_t fileio;
687
688 duration_t duration;
689 char *duration_text;
690
691 int retval;
692 flash_bank_t *p;
693
694 if (argc < 3)
695 {
696 command_print(cmd_ctx, "usage: flash write_binary <bank> <file> <offset>");
697 return ERROR_OK;
698 }
699
700 duration_start_measure(&duration);
701
702 offset = strtoul(args[2], NULL, 0);
703 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
704 if (!p)
705 {
706 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
707 return ERROR_OK;
708 }
709
710 if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
711 {
712 command_print(cmd_ctx, "flash write_binary error: %s", fileio.error_str);
713 return ERROR_OK;
714 }
715
716 buffer = malloc(fileio.size);
717 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
718 {
719 command_print(cmd_ctx, "flash write_binary error: %s", fileio.error_str);
720 return ERROR_OK;
721 }
722
723 if ((retval = p->driver->write(p, buffer, offset, buf_cnt)) != ERROR_OK)
724 {
725 command_print(cmd_ctx, "failed writing file %s to flash bank %i at offset 0x%8.8x",
726 args[1], strtoul(args[0], NULL, 0), strtoul(args[2], NULL, 0));
727
728 switch (retval)
729 {
730 case ERROR_TARGET_NOT_HALTED:
731 command_print(cmd_ctx, "can't work with this flash while target is running");
732 break;
733 case ERROR_INVALID_ARGUMENTS:
734 command_print(cmd_ctx, "usage: flash write <bank> <file> <offset>");
735 break;
736 case ERROR_FLASH_BANK_INVALID:
737 command_print(cmd_ctx, "no '%s' flash found at 0x%8.8x", p->driver->name, p->base);
738 break;
739 case ERROR_FLASH_OPERATION_FAILED:
740 command_print(cmd_ctx, "flash program error");
741 break;
742 case ERROR_FLASH_DST_BREAKS_ALIGNMENT:
743 command_print(cmd_ctx, "offset breaks required alignment");
744 break;
745 case ERROR_FLASH_DST_OUT_OF_BANK:
746 command_print(cmd_ctx, "destination is out of flash bank (offset and/or file too large)");
747 break;
748 case ERROR_FLASH_SECTOR_NOT_ERASED:
749 command_print(cmd_ctx, "destination sector(s) not erased");
750 break;
751 default:
752 command_print(cmd_ctx, "unknown error");
753 }
754 }
755
756 free(buffer);
757
758 duration_stop_measure(&duration, &duration_text);
759 command_print(cmd_ctx, "wrote %"PRIi64" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
760 fileio.size, args[1], strtoul(args[0], NULL, 0), offset, duration_text,
761 (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
762 free(duration_text);
763
764 fileio_close(&fileio);
765
766 return ERROR_OK;
767 }
768
769 /* lookup flash bank by address */
770 flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
771 {
772 flash_bank_t *c;
773
774 /* cycle through bank list */
775 for (c = flash_banks; c; c = c->next)
776 {
777 /* check whether address belongs to this flash bank */
778 if ((addr >= c->base) && (addr < c->base + c->size) && target == c->target)
779 return c;
780 }
781
782 return NULL;
783 }
784
785 /* erase given flash region, selects proper bank according to target and address */
786 int flash_erase(target_t *target, u32 addr, u32 length)
787 {
788 flash_bank_t *c;
789 int first = -1;
790 int last = -1;
791 int i;
792
793 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
794 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
795
796 if (c->size == 0 || c->num_sectors == 0)
797 return ERROR_FLASH_BANK_INVALID;
798
799 if (length == 0)
800 {
801 /* special case, erase whole bank when length is zero */
802 if (addr != c->base)
803 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
804
805 return c->driver->erase(c, 0, c->num_sectors - 1);
806 }
807
808 /* check whether it fits */
809 if (addr + length > c->base + c->size)
810 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
811
812 addr -= c->base;
813
814 for (i = 0; i < c->num_sectors; i++)
815 {
816 /* check whether sector overlaps with the given range and is not yet erased */
817 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
818 /* if first is not set yet then this is the first sector */
819 if (first == -1)
820 first = i;
821 last = i; /* and it is the last one so far in any case */
822 }
823 }
824
825 if( first == -1 || last == -1 )
826 return ERROR_OK;
827
828 return c->driver->erase(c, first, last);
829 }
830
831 /* write (optional verify) an image to flash memory of the given target */
832 int flash_write(target_t *target, image_t *image, u32 *written, char **error_str, int *failed, int erase)
833 {
834 int retval;
835 int i;
836
837 int section;
838 u32 section_offset;
839
840 section = 0;
841 section_offset = 0;
842
843 if (written)
844 *written = 0;
845
846 if (failed != NULL)
847 for (i = 0; i < image->num_sections; i++)
848 failed[i] = 0;
849
850 /* loop until we reach end of the image */
851 while (section < image->num_sections)
852 {
853 flash_bank_t *c;
854 u32 buffer_size;
855 u8 *buffer;
856 int section_first;
857 int section_last;
858 u32 run_address = image->sections[section].base_address + section_offset;
859 u32 run_size = image->sections[section].size - section_offset;
860
861 if (image->sections[section].size == 0)
862 {
863 WARNING("empty section %d", section);
864 section++;
865 section_offset = 0;
866 continue;
867 }
868
869 /* find the corresponding flash bank */
870 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
871 {
872 if (failed == NULL)
873 {
874 if (error_str == NULL)
875 return ERROR_FLASH_DST_OUT_OF_BANK; /* abort operation */
876 *error_str = malloc(FLASH_MAX_ERROR_STR);
877 snprintf(*error_str, FLASH_MAX_ERROR_STR, "no flash mapped at requested address");
878 return ERROR_FLASH_DST_OUT_OF_BANK; /* abort operation */
879 }
880 failed[section] = ERROR_FLASH_DST_OUT_OF_BANK; /* mark the section as failed */
881 section++; /* and skip it */
882 section_offset = 0;
883 continue;
884 }
885
886 /* collect consecutive sections which fall into the same bank */
887 section_first = section;
888 section_last = section;
889 while ((run_address + run_size < c->base + c->size)
890 && (section_last + 1 < image->num_sections))
891 {
892 if (image->sections[section_last + 1].base_address < (run_address + run_size))
893 {
894 DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
895 break;
896 }
897 if (image->sections[section_last + 1].base_address != (run_address + run_size))
898 break;
899 run_size += image->sections[++section_last].size;
900 }
901
902 /* fit the run into bank constraints */
903 if (run_address + run_size > c->base + c->size)
904 run_size = c->base + c->size - run_address;
905
906 /* allocate buffer */
907 buffer = malloc(run_size);
908 buffer_size = 0;
909
910 /* read sections to the buffer */
911 while (buffer_size < run_size)
912 {
913 u32 size_read;
914
915 if (buffer_size - run_size <= image->sections[section].size - section_offset)
916 size_read = buffer_size - run_size;
917 else
918 size_read = image->sections[section].size - section_offset;
919
920 if ((retval = image_read_section(image, section, section_offset,
921 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
922 {
923 free(buffer);
924
925 if (error_str == NULL)
926 return ERROR_IMAGE_TEMPORARILY_UNAVAILABLE;
927
928 *error_str = malloc(FLASH_MAX_ERROR_STR);
929
930 /* if image_read_section returned an error there's an error string we can pass on */
931 if (retval != ERROR_OK)
932 snprintf(*error_str, FLASH_MAX_ERROR_STR, "error reading from image: %s", image->error_str);
933 else
934 snprintf(*error_str, FLASH_MAX_ERROR_STR, "error reading from image");
935
936 return ERROR_IMAGE_TEMPORARILY_UNAVAILABLE;
937 }
938
939 buffer_size += size_read;
940 section_offset += size_read;
941
942 if (section_offset >= image->sections[section].size)
943 {
944 section++;
945 section_offset = 0;
946 }
947 }
948
949 retval = ERROR_OK;
950
951 if (erase)
952 {
953 /* calculate and erase sectors */
954 retval = flash_erase( target, run_address, run_size );
955 }
956
957 if (retval == ERROR_OK)
958 {
959 /* write flash sectors */
960 retval = c->driver->write(c, buffer, run_address - c->base, run_size);
961 }
962
963 free(buffer);
964
965 if (retval != ERROR_OK)
966 {
967 if (error_str == NULL)
968 return retval; /* abort operation */
969
970 *error_str = malloc(FLASH_MAX_ERROR_STR);
971 switch (retval)
972 {
973 case ERROR_TARGET_NOT_HALTED:
974 snprintf(*error_str, FLASH_MAX_ERROR_STR, "can't flash image while target is running");
975 break;
976 case ERROR_INVALID_ARGUMENTS:
977 snprintf(*error_str, FLASH_MAX_ERROR_STR, "flash driver can't fulfill request");
978 break;
979 case ERROR_FLASH_OPERATION_FAILED:
980 snprintf(*error_str, FLASH_MAX_ERROR_STR, "flash program error");
981 break;
982 case ERROR_FLASH_DST_BREAKS_ALIGNMENT:
983 snprintf(*error_str, FLASH_MAX_ERROR_STR, "offset breaks required alignment");
984 break;
985 case ERROR_FLASH_DST_OUT_OF_BANK:
986 snprintf(*error_str, FLASH_MAX_ERROR_STR, "no flash mapped at requested address");
987 break;
988 case ERROR_FLASH_SECTOR_NOT_ERASED:
989 snprintf(*error_str, FLASH_MAX_ERROR_STR, "destination sector(s) not erased");
990 break;
991 default:
992 snprintf(*error_str, FLASH_MAX_ERROR_STR, "unknown error: %i", retval);
993 }
994
995 return retval; /* abort operation */
996 }
997
998 if (written != NULL)
999 *written += run_size; /* add run size to total written counter */
1000 }
1001
1002 return ERROR_OK;
1003 }
1004
1005 int handle_flash_auto_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1006 {
1007 if (argc != 1)
1008 {
1009 command_print(cmd_ctx, "usage: flash auto_erase <on|off>");
1010 return ERROR_OK;
1011 }
1012
1013 if (strcmp(args[0], "on") == 0)
1014 auto_erase = 1;
1015 else if (strcmp(args[0], "off") == 0)
1016 auto_erase = 0;
1017
1018 return ERROR_OK;
1019 }
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)