Code Review / openocd.git / blob
? search:


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