Code Review / openocd.git / blob
? search:


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