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