1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
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. *
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. *
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 ***************************************************************************/
27 #include "time_support.h"
35 #include <sys/types.h>
40 /* command handlers */
41 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
42 int handle_flash_banks_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
43 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
44 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
45 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
46 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
47 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
48 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
49 int handle_flash_write_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
50 int handle_flash_write_binary_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_flash_auto_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
);
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
;
68 flash_driver_t
*flash_drivers
[] =
82 flash_bank_t
*flash_banks
;
83 static command_t
*flash_cmd
;
84 static int auto_erase
= 0;
86 int flash_register_commands(struct command_context_s
*cmd_ctx
)
88 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
90 register_command(cmd_ctx
, flash_cmd
, "bank", handle_flash_bank_command
, COMMAND_CONFIG
, NULL
);
95 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
99 register_command(cmd_ctx
, flash_cmd
, "banks", handle_flash_banks_command
, COMMAND_EXEC
,
100 "list configured flash banks ");
101 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
102 "print info about flash bank <num>");
103 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
104 "identify flash bank <num>");
105 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
106 "check erase state of sectors in flash bank <num>");
107 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
108 "check protection state of sectors in flash bank <num>");
109 register_command(cmd_ctx
, flash_cmd
, "erase", handle_flash_erase_command
, COMMAND_EXEC
,
110 "DEPRECATED, use 'erase_sector' instead");
111 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
112 "erase sectors at <bank> <first> <last>");
113 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
114 "erase address range <address> <length>");
115 register_command(cmd_ctx
, flash_cmd
, "write", handle_flash_write_binary_command
, COMMAND_EXEC
,
116 "DEPRECATED, use 'write_binary' instead");
117 register_command(cmd_ctx
, flash_cmd
, "write_binary", handle_flash_write_binary_command
, COMMAND_EXEC
,
118 "write binary <bank> <file> <offset>");
119 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
120 "write_image <file> [offset] [type]");
121 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
122 "set protection of sectors at <bank> <first> <last> <on|off>");
123 register_command(cmd_ctx
, flash_cmd
, "auto_erase", handle_flash_auto_erase_command
, COMMAND_EXEC
,
124 "auto erase flash sectors <on|off>");
130 flash_bank_t
*get_flash_bank_by_num(int num
)
135 for (p
= flash_banks
; p
; p
= p
->next
)
146 /* flash_bank <driver> <base> <size> <chip_width> <bus_width> <target> [driver_options ...]
148 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
156 WARNING("incomplete flash_bank configuration");
157 WARNING("flash_bank <driver> <base> <size> <chip_width> <bus_width> <target> [driver_options ...]");
161 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
163 ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
167 for (i
= 0; flash_drivers
[i
]; i
++)
169 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
173 /* register flash specific commands */
174 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
176 ERROR("couldn't register '%s' commands", args
[0]);
180 c
= malloc(sizeof(flash_bank_t
));
182 c
->driver
= flash_drivers
[i
];
183 c
->driver_priv
= NULL
;
184 c
->base
= strtoul(args
[1], NULL
, 0);
185 c
->size
= strtoul(args
[2], NULL
, 0);
186 c
->chip_width
= strtoul(args
[3], NULL
, 0);
187 c
->bus_width
= strtoul(args
[4], NULL
, 0);
192 if (flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
) != ERROR_OK
)
194 ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
199 /* put flash bank in linked list */
202 /* find last flash bank */
203 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
216 /* no matching flash driver found */
219 ERROR("flash driver '%s' not found", args
[0]);
226 int handle_flash_banks_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
233 command_print(cmd_ctx
, "no flash banks configured");
237 for (p
= flash_banks
; p
; p
= p
->next
)
239 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
240 i
++, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
246 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
254 command_print(cmd_ctx
, "usage: flash info <num>");
258 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
260 if (i
== strtoul(args
[0], NULL
, 0))
264 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
265 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
266 for (j
= 0; j
< p
->num_sectors
; j
++)
268 char *erase_state
, *protect_state
;
270 if (p
->sectors
[j
].is_erased
== 0)
271 erase_state
= "not erased";
272 else if (p
->sectors
[j
].is_erased
== 1)
273 erase_state
= "erased";
275 erase_state
= "erase state unknown";
277 if (p
->sectors
[j
].is_protected
== 0)
278 protect_state
= "not protected";
279 else if (p
->sectors
[j
].is_protected
== 1)
280 protect_state
= "protected";
282 protect_state
= "protection state unknown";
284 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s, %s",
285 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
286 erase_state
, protect_state
);
289 p
->driver
->info(p
, buf
, 1024);
290 command_print(cmd_ctx
, "%s", buf
);
297 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
304 command_print(cmd_ctx
, "usage: flash probe <num>");
308 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
311 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
313 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
315 else if (retval
== ERROR_FLASH_BANK_INVALID
)
317 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
322 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
328 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
334 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
341 command_print(cmd_ctx
, "usage: flash erase_check <num>");
345 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
348 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
350 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
354 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
360 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
366 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
375 target_t
*target
= get_current_target(cmd_ctx
);
379 command_print(cmd_ctx
, "usage: flash erase_address <address> <length>");
383 address
= strtoul(args
[0], NULL
, 0);
384 length
= strtoul(args
[1], NULL
, 0);
387 command_print(cmd_ctx
, "Length must be >0");
388 return ERROR_INVALID_ARGUMENTS
;
391 p
= get_flash_bank_by_addr(target
, address
);
394 command_print(cmd_ctx
, "No flash at that address");
395 return ERROR_INVALID_ARGUMENTS
;
398 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
401 duration_start_measure(&duration
);
403 if ((retval
= flash_erase_address_range(target
, address
, length
)) != ERROR_OK
)
407 case ERROR_TARGET_NOT_HALTED
:
408 command_print(cmd_ctx
, "can't work with this flash while target is running");
410 case ERROR_INVALID_ARGUMENTS
:
411 command_print(cmd_ctx
, "usage: flash erase_address <address> <length>");
413 case ERROR_FLASH_BANK_INVALID
:
414 command_print(cmd_ctx
, "no '%s' flash found at 0x%8.8x", p
->driver
->name
, p
->base
);
416 case ERROR_FLASH_OPERATION_FAILED
:
417 command_print(cmd_ctx
, "flash erase error");
419 case ERROR_FLASH_SECTOR_INVALID
:
420 command_print(cmd_ctx
, "sector number(s) invalid");
423 command_print(cmd_ctx
, "unknown error");
428 duration_stop_measure(&duration
, &duration_text
);
429 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
436 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
443 command_print(cmd_ctx
, "usage: flash protect_check <num>");
447 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
450 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
452 command_print(cmd_ctx
, "successfully checked protect state");
454 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
456 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
460 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
465 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
471 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
475 int first
= strtoul(args
[1], NULL
, 0);
476 int last
= strtoul(args
[2], NULL
, 0);
478 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
482 duration_start_measure(&duration
);
486 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
490 if ((retval
= p
->driver
->erase(p
, first
, last
)) != ERROR_OK
)
494 case ERROR_TARGET_NOT_HALTED
:
495 command_print(cmd_ctx
, "can't work with this flash while target is running");
497 case ERROR_INVALID_ARGUMENTS
:
498 command_print(cmd_ctx
, "usage: flash_erase <bank> <first> <last>");
500 case ERROR_FLASH_BANK_INVALID
:
501 command_print(cmd_ctx
, "no '%s' flash found at 0x%8.8x", p
->driver
->name
, p
->base
);
503 case ERROR_FLASH_OPERATION_FAILED
:
504 command_print(cmd_ctx
, "flash erase error");
506 case ERROR_FLASH_SECTOR_INVALID
:
507 command_print(cmd_ctx
, "sector number(s) invalid");
510 command_print(cmd_ctx
, "erased flash sectors %i to %i", first
, last
);
513 command_print(cmd_ctx
, "unknown error");
518 duration_stop_measure(&duration
, &duration_text
);
520 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
526 command_print(cmd_ctx
, "usage: flash erase <bank> <first> <last>");
532 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
536 int first
= strtoul(args
[1], NULL
, 0);
537 int last
= strtoul(args
[2], NULL
, 0);
540 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
543 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
547 if (strcmp(args
[3], "on") == 0)
549 else if (strcmp(args
[3], "off") == 0)
553 command_print(cmd_ctx
, "usage: flash protect <bank> <first> <last> <on|off>");
557 if ((retval
= p
->driver
->protect(p
, set
, first
, last
)) != ERROR_OK
)
561 case ERROR_TARGET_NOT_HALTED
:
562 command_print(cmd_ctx
, "can't work with this flash while target is running");
564 case ERROR_INVALID_ARGUMENTS
:
565 command_print(cmd_ctx
, "usage: flash protect <bank> <first> <last> <on|off>");
567 case ERROR_FLASH_BANK_INVALID
:
568 command_print(cmd_ctx
, "no '%s' flash found at 0x%8.8x", p
->driver
->name
, p
->base
);
570 case ERROR_FLASH_OPERATION_FAILED
:
571 command_print(cmd_ctx
, "flash program error");
573 case ERROR_FLASH_SECTOR_INVALID
:
574 command_print(cmd_ctx
, "sector number(s) invalid");
577 command_print(cmd_ctx
, "protection of flash sectors %i to %i turned %s", first
, last
, args
[3]);
580 command_print(cmd_ctx
, "unknown error");
585 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));
590 command_print(cmd_ctx
, "usage: flash protect <bank> <first> <last> <on|off>");
596 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
598 target_t
*target
= get_current_target(cmd_ctx
);
614 command_print(cmd_ctx
, "usage: flash %s <file> [offset] [type]", cmd
);
615 return ERROR_INVALID_ARGUMENTS
;
620 ERROR("no target selected");
624 duration_start_measure(&duration
);
628 image
.base_address_set
= 1;
629 image
.base_address
= strtoul(args
[1], NULL
, 0);
633 image
.base_address_set
= 0;
634 image
.base_address
= 0x0;
637 image
.start_address_set
= 0;
639 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
640 if (retval
!= ERROR_OK
)
642 command_print(cmd_ctx
, "image_open error: %s", image
.error_str
);
646 failed
= malloc(sizeof(int) * image
.num_sections
);
650 retval
= flash_write(target
, &image
, &written
, &error_str
, failed
, auto_erase
);
652 if (retval
!= ERROR_OK
)
656 command_print(cmd_ctx
, "failed writing image %s: %s", args
[0], error_str
);
664 for (i
= 0; i
< image
.num_sections
; i
++)
668 command_print(cmd_ctx
, "didn't write section at 0x%8.8x, size 0x%8.8x",
669 image
.sections
[i
].base_address
, image
.sections
[i
].size
);
673 duration_stop_measure(&duration
, &duration_text
);
674 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
675 written
, args
[0], duration_text
,
676 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
685 int handle_flash_write_binary_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
701 command_print(cmd_ctx
, "usage: flash write_binary <bank> <file> <offset>");
705 duration_start_measure(&duration
);
707 offset
= strtoul(args
[2], NULL
, 0);
708 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
711 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
715 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
717 command_print(cmd_ctx
, "flash write_binary error: %s", fileio
.error_str
);
721 buffer
= malloc(fileio
.size
);
722 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
724 command_print(cmd_ctx
, "flash write_binary error: %s", fileio
.error_str
);
728 if ((retval
= p
->driver
->write(p
, buffer
, offset
, buf_cnt
)) != ERROR_OK
)
730 command_print(cmd_ctx
, "failed writing file %s to flash bank %i at offset 0x%8.8x",
731 args
[1], strtoul(args
[0], NULL
, 0), strtoul(args
[2], NULL
, 0));
735 case ERROR_TARGET_NOT_HALTED
:
736 command_print(cmd_ctx
, "can't work with this flash while target is running");
738 case ERROR_INVALID_ARGUMENTS
:
739 command_print(cmd_ctx
, "usage: flash write <bank> <file> <offset>");
741 case ERROR_FLASH_BANK_INVALID
:
742 command_print(cmd_ctx
, "no '%s' flash found at 0x%8.8x", p
->driver
->name
, p
->base
);
744 case ERROR_FLASH_OPERATION_FAILED
:
745 command_print(cmd_ctx
, "flash program error");
747 case ERROR_FLASH_DST_BREAKS_ALIGNMENT
:
748 command_print(cmd_ctx
, "offset breaks required alignment");
750 case ERROR_FLASH_DST_OUT_OF_BANK
:
751 command_print(cmd_ctx
, "destination is out of flash bank (offset and/or file too large)");
753 case ERROR_FLASH_SECTOR_NOT_ERASED
:
754 command_print(cmd_ctx
, "destination sector(s) not erased");
757 command_print(cmd_ctx
, "unknown error");
763 duration_stop_measure(&duration
, &duration_text
);
764 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
765 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
766 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
769 fileio_close(&fileio
);
774 void flash_set_dirty(void)
779 /* set all flash to require erasing */
780 for (c
= flash_banks
; c
; c
= c
->next
)
782 for (i
= 0; i
< c
->num_sectors
; i
++)
784 c
->sectors
[i
].is_erased
= 0;
789 /* lookup flash bank by address */
790 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
794 /* cycle through bank list */
795 for (c
= flash_banks
; c
; c
= c
->next
)
797 /* check whether address belongs to this flash bank */
798 if ((addr
>= c
->base
) && (addr
< c
->base
+ c
->size
) && target
== c
->target
)
805 /* erase given flash region, selects proper bank according to target and address */
806 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
813 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
814 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
816 if (c
->size
== 0 || c
->num_sectors
== 0)
817 return ERROR_FLASH_BANK_INVALID
;
821 /* special case, erase whole bank when length is zero */
823 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
825 return c
->driver
->erase(c
, 0, c
->num_sectors
- 1);
828 /* check whether it fits */
829 if (addr
+ length
> c
->base
+ c
->size
)
830 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
834 for (i
= 0; i
< c
->num_sectors
; i
++)
836 /* check whether sector overlaps with the given range and is not yet erased */
837 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
838 /* if first is not set yet then this is the first sector */
841 last
= i
; /* and it is the last one so far in any case */
845 if( first
== -1 || last
== -1 )
848 return c
->driver
->erase(c
, first
, last
);
851 /* write (optional verify) an image to flash memory of the given target */
852 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, char **error_str
, int *failed
, int erase
)
868 for (i
= 0; i
< image
->num_sections
; i
++)
873 /* assume all sectors need erasing - stops any problems
874 * when flash_write is called multiple times */
879 /* loop until we reach end of the image */
880 while (section
< image
->num_sections
)
886 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
887 u32 run_size
= image
->sections
[section
].size
- section_offset
;
889 if (image
->sections
[section
].size
== 0)
891 WARNING("empty section %d", section
);
897 /* find the corresponding flash bank */
898 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
902 if (error_str
== NULL
)
903 return ERROR_FLASH_DST_OUT_OF_BANK
; /* abort operation */
904 *error_str
= malloc(FLASH_MAX_ERROR_STR
);
905 snprintf(*error_str
, FLASH_MAX_ERROR_STR
, "no flash mapped at requested address");
906 return ERROR_FLASH_DST_OUT_OF_BANK
; /* abort operation */
908 failed
[section
] = ERROR_FLASH_DST_OUT_OF_BANK
; /* mark the section as failed */
909 section
++; /* and skip it */
914 /* collect consecutive sections which fall into the same bank */
915 section_first
= section
;
916 section_last
= section
;
917 while ((run_address
+ run_size
< c
->base
+ c
->size
)
918 && (section_last
+ 1 < image
->num_sections
))
920 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
922 DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
925 if (image
->sections
[section_last
+ 1].base_address
!= (run_address
+ run_size
))
927 run_size
+= image
->sections
[++section_last
].size
;
930 /* fit the run into bank constraints */
931 if (run_address
+ run_size
> c
->base
+ c
->size
)
932 run_size
= c
->base
+ c
->size
- run_address
;
934 /* allocate buffer */
935 buffer
= malloc(run_size
);
938 /* read sections to the buffer */
939 while (buffer_size
< run_size
)
943 if (buffer_size
- run_size
<= image
->sections
[section
].size
- section_offset
)
944 size_read
= buffer_size
- run_size
;
946 size_read
= image
->sections
[section
].size
- section_offset
;
948 if ((retval
= image_read_section(image
, section
, section_offset
,
949 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
953 if (error_str
== NULL
)
954 return ERROR_IMAGE_TEMPORARILY_UNAVAILABLE
;
956 *error_str
= malloc(FLASH_MAX_ERROR_STR
);
958 /* if image_read_section returned an error there's an error string we can pass on */
959 if (retval
!= ERROR_OK
)
960 snprintf(*error_str
, FLASH_MAX_ERROR_STR
, "error reading from image: %s", image
->error_str
);
962 snprintf(*error_str
, FLASH_MAX_ERROR_STR
, "error reading from image");
964 return ERROR_IMAGE_TEMPORARILY_UNAVAILABLE
;
967 buffer_size
+= size_read
;
968 section_offset
+= size_read
;
970 if (section_offset
>= image
->sections
[section
].size
)
981 /* calculate and erase sectors */
982 retval
= flash_erase_address_range( target
, run_address
, run_size
);
985 if (retval
== ERROR_OK
)
987 /* write flash sectors */
988 retval
= c
->driver
->write(c
, buffer
, run_address
- c
->base
, run_size
);
993 if (retval
!= ERROR_OK
)
995 if (error_str
== NULL
)
996 return retval
; /* abort operation */
998 *error_str
= malloc(FLASH_MAX_ERROR_STR
);
1001 case ERROR_TARGET_NOT_HALTED
:
1002 snprintf(*error_str
, FLASH_MAX_ERROR_STR
, "can't flash image while target is running");
1004 case ERROR_INVALID_ARGUMENTS
:
1005 snprintf(*error_str
, FLASH_MAX_ERROR_STR
, "flash driver can't fulfill request");
1007 case ERROR_FLASH_OPERATION_FAILED
:
1008 snprintf(*error_str
, FLASH_MAX_ERROR_STR
, "flash program error");
1010 case ERROR_FLASH_DST_BREAKS_ALIGNMENT
:
1011 snprintf(*error_str
, FLASH_MAX_ERROR_STR
, "offset breaks required alignment");
1013 case ERROR_FLASH_DST_OUT_OF_BANK
:
1014 snprintf(*error_str
, FLASH_MAX_ERROR_STR
, "no flash mapped at requested address");
1016 case ERROR_FLASH_SECTOR_NOT_ERASED
:
1017 snprintf(*error_str
, FLASH_MAX_ERROR_STR
, "destination sector(s) not erased");
1020 snprintf(*error_str
, FLASH_MAX_ERROR_STR
, "unknown error: %i", retval
);
1023 return retval
; /* abort operation */
1026 if (written
!= NULL
)
1027 *written
+= run_size
; /* add run size to total written counter */
1033 int handle_flash_auto_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1037 command_print(cmd_ctx
, "usage: flash auto_erase <on|off>");
1041 if (strcmp(args
[0], "on") == 0)
1043 else if (strcmp(args
[0], "off") == 0)
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)