Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
added an #error in case anybody tries to compile that broken code.
[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 return retval;
609 }
610
611 retval = flash_write(target, &image, &written, auto_erase);
612
613 if (retval != ERROR_OK)
614 {
615 image_close(&image);
616 return retval;
617 }
618
619 duration_stop_measure(&duration, &duration_text);
620 if (retval == ERROR_OK)
621 {
622 command_print(cmd_ctx, "wrote %u byte from file %s in %s (%f kb/s)",
623 written, args[0], duration_text,
624 (float)written / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
625 }
626 free(duration_text);
627
628 image_close(&image);
629
630 return retval;
631 }
632
633 int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
634 {
635 u32 offset;
636 u8 *buffer;
637 u32 buf_cnt;
638
639 fileio_t fileio;
640
641 duration_t duration;
642 char *duration_text;
643
644 int retval;
645 flash_bank_t *p;
646
647 if (argc != 3)
648 {
649 return ERROR_COMMAND_SYNTAX_ERROR;
650 }
651
652 duration_start_measure(&duration);
653
654 offset = strtoul(args[2], NULL, 0);
655 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
656 if (!p)
657 {
658 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
659 return ERROR_OK;
660 }
661
662 if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
663 {
664 return ERROR_OK;
665 }
666
667 buffer = malloc(fileio.size);
668 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
669 {
670 return ERROR_OK;
671 }
672
673 retval = flash_driver_write(p, buffer, offset, buf_cnt);
674
675 free(buffer);
676
677 duration_stop_measure(&duration, &duration_text);
678 if (retval!=ERROR_OK)
679 {
680 command_print(cmd_ctx, "wrote %"PRIi64" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
681 fileio.size, args[1], strtoul(args[0], NULL, 0), offset, duration_text,
682 (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
683 }
684 free(duration_text);
685
686 fileio_close(&fileio);
687
688 return retval;
689 }
690
691 void flash_set_dirty(void)
692 {
693 flash_bank_t *c;
694 int i;
695
696 /* set all flash to require erasing */
697 for (c = flash_banks; c; c = c->next)
698 {
699 for (i = 0; i < c->num_sectors; i++)
700 {
701 c->sectors[i].is_erased = 0;
702 }
703 }
704 }
705
706 /* lookup flash bank by address */
707 flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
708 {
709 flash_bank_t *c;
710
711 /* cycle through bank list */
712 for (c = flash_banks; c; c = c->next)
713 {
714 int retval;
715 retval = c->driver->auto_probe(c);
716
717 if (retval != ERROR_OK)
718 {
719 ERROR("auto_probe failed %d\n", retval);
720 return NULL;
721 }
722 /* check whether address belongs to this flash bank */
723 if ((addr >= c->base) && (addr < c->base + c->size) && target == c->target)
724 return c;
725 }
726 ERROR("No flash at address 0x%08x\n", addr);
727 return NULL;
728 }
729
730 /* erase given flash region, selects proper bank according to target and address */
731 int flash_erase_address_range(target_t *target, u32 addr, u32 length)
732 {
733 flash_bank_t *c;
734 int first = -1;
735 int last = -1;
736 int i;
737
738 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
739 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
740
741 if (c->size == 0 || c->num_sectors == 0)
742 return ERROR_FLASH_BANK_INVALID;
743
744 if (length == 0)
745 {
746 /* special case, erase whole bank when length is zero */
747 if (addr != c->base)
748 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
749
750 return flash_driver_erase(c, 0, c->num_sectors - 1);
751 }
752
753 /* check whether it fits */
754 if (addr + length > c->base + c->size)
755 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
756
757 addr -= c->base;
758
759 for (i = 0; i < c->num_sectors; i++)
760 {
761 /* check whether sector overlaps with the given range and is not yet erased */
762 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
763 /* if first is not set yet then this is the first sector */
764 if (first == -1)
765 first = i;
766 last = i; /* and it is the last one so far in any case */
767 }
768 }
769
770 if( first == -1 || last == -1 )
771 return ERROR_OK;
772
773 return flash_driver_erase(c, first, last);
774 }
775
776 /* write (optional verify) an image to flash memory of the given target */
777 int flash_write(target_t *target, image_t *image, u32 *written, int erase)
778 {
779 int retval;
780
781 int section;
782 u32 section_offset;
783 flash_bank_t *c;
784
785 section = 0;
786 section_offset = 0;
787
788 if (written)
789 *written = 0;
790
791 if (erase)
792 {
793 /* assume all sectors need erasing - stops any problems
794 * when flash_write is called multiple times */
795
796 flash_set_dirty();
797 }
798
799 /* loop until we reach end of the image */
800 while (section < image->num_sections)
801 {
802 u32 buffer_size;
803 u8 *buffer;
804 int section_first;
805 int section_last;
806 u32 run_address = image->sections[section].base_address + section_offset;
807 u32 run_size = image->sections[section].size - section_offset;
808
809 if (image->sections[section].size == 0)
810 {
811 WARNING("empty section %d", section);
812 section++;
813 section_offset = 0;
814 continue;
815 }
816
817 /* find the corresponding flash bank */
818 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
819 {
820 section++; /* and skip it */
821 section_offset = 0;
822 continue;
823 }
824
825 /* collect consecutive sections which fall into the same bank */
826 section_first = section;
827 section_last = section;
828 while ((run_address + run_size < c->base + c->size)
829 && (section_last + 1 < image->num_sections))
830 {
831 if (image->sections[section_last + 1].base_address < (run_address + run_size))
832 {
833 DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
834 break;
835 }
836 if (image->sections[section_last + 1].base_address != (run_address + run_size))
837 break;
838 run_size += image->sections[++section_last].size;
839 }
840
841 /* fit the run into bank constraints */
842 if (run_address + run_size > c->base + c->size)
843 run_size = c->base + c->size - run_address;
844
845 /* allocate buffer */
846 buffer = malloc(run_size);
847 buffer_size = 0;
848
849 /* read sections to the buffer */
850 while (buffer_size < run_size)
851 {
852 u32 size_read;
853
854 if (buffer_size - run_size <= image->sections[section].size - section_offset)
855 size_read = buffer_size - run_size;
856 else
857 size_read = image->sections[section].size - section_offset;
858
859 if ((retval = image_read_section(image, section, section_offset,
860 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
861 {
862 free(buffer);
863
864 return retval;
865 }
866
867 buffer_size += size_read;
868 section_offset += size_read;
869
870 if (section_offset >= image->sections[section].size)
871 {
872 section++;
873 section_offset = 0;
874 }
875 }
876
877 retval = ERROR_OK;
878
879 if (erase)
880 {
881 /* calculate and erase sectors */
882 retval = flash_erase_address_range( target, run_address, run_size );
883 }
884
885 if (retval == ERROR_OK)
886 {
887 /* write flash sectors */
888 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
889 }
890
891 free(buffer);
892
893 if (retval != ERROR_OK)
894 {
895 return retval; /* abort operation */
896 }
897
898 if (written != NULL)
899 *written += run_size; /* add run size to total written counter */
900 }
901
902 return ERROR_OK;
903 }
904
905 int handle_flash_auto_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
906 {
907 if (argc != 1)
908 {
909 return ERROR_COMMAND_SYNTAX_ERROR;
910
911 }
912
913 if (strcmp(args[0], "on") == 0)
914 auto_erase = 1;
915 else if (strcmp(args[0], "off") == 0)
916 auto_erase = 0;
917 else
918 return ERROR_COMMAND_SYNTAX_ERROR;
919
920 return ERROR_OK;
921 }
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)