1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
33 #include "time_support.h"
38 #include "algorithm.h"
39 #include "binarybuffer.h"
45 #include <sys/types.h>
50 /* command handlers */
51 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_flash_write_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
63 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
);
67 extern flash_driver_t lpc2000_flash
;
68 extern flash_driver_t cfi_flash
;
69 extern flash_driver_t at91sam7_flash
;
70 extern flash_driver_t str7x_flash
;
71 extern flash_driver_t str9x_flash
;
72 extern flash_driver_t x7026_flash
;
73 extern flash_driver_t stellaris_flash
;
74 extern flash_driver_t str9xpec_flash
;
75 extern flash_driver_t stm32x_flash
;
76 extern flash_driver_t tms470_flash
;
77 extern flash_driver_t ecosflash_flash
;
78 extern flash_driver_t lpc288x_flash
;
79 extern flash_driver_t ocl_flash
;
81 flash_driver_t
*flash_drivers
[] =
99 flash_bank_t
*flash_banks
;
100 static command_t
*flash_cmd
;
102 /* wafer thin wrapper for invoking the flash driver */
103 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
107 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
108 if (retval
!=ERROR_OK
)
110 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
116 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
120 retval
=bank
->driver
->erase(bank
, first
, last
);
121 if (retval
!=ERROR_OK
)
123 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
129 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
133 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
134 if (retval
!=ERROR_OK
)
136 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
142 int flash_register_commands(struct command_context_s
*cmd_ctx
)
144 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
146 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 ...]");
150 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
155 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
164 Jim_Obj
*list
=Jim_NewListObj(interp
, NULL
, 0);
165 for (p
= flash_banks
; p
; p
= p
->next
)
167 Jim_Obj
*elem
=Jim_NewListObj(interp
, NULL
, 0);
169 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
170 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
171 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
172 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
173 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
174 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
175 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
176 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
177 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
178 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
180 Jim_ListAppendElement(interp
, list
, elem
);
183 Jim_SetResult(interp
, list
);
188 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
192 register_jim(cmd_ctx
, "ocd_flash_banks", jim_flash_banks
, "return information about the flash banks");
194 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
195 "print info about flash bank <num>");
196 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
197 "identify flash bank <num>");
198 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
199 "check erase state of sectors in flash bank <num>");
200 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
201 "check protection state of sectors in flash bank <num>");
202 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
203 "erase sectors at <bank> <first> <last>");
204 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
205 "erase address range <address> <length>");
207 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
208 "fill with pattern <address> <word_pattern> <count>");
209 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
210 "fill with pattern <address> <halfword_pattern> <count>");
211 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
212 "fill with pattern <address> <byte_pattern> <count>");
214 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
215 "write binary data to <bank> <file> <offset>");
216 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
217 "write_image [erase] <file> [offset] [type]");
218 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
219 "set protection of sectors at <bank> <first> <last> <on|off>");
225 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
230 for (p
= flash_banks
; p
; p
= p
->next
)
237 LOG_ERROR("flash bank %d does not exist", num
);
241 int flash_get_bank_count(void)
245 for (p
= flash_banks
; p
; p
= p
->next
)
252 flash_bank_t
*get_flash_bank_by_num(int num
)
254 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
260 retval
= p
->driver
->auto_probe(p
);
262 if (retval
!= ERROR_OK
)
264 LOG_ERROR("auto_probe failed %d\n", retval
);
270 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
279 return ERROR_COMMAND_SYNTAX_ERROR
;
282 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
284 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
288 for (i
= 0; flash_drivers
[i
]; i
++)
290 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
294 /* register flash specific commands */
295 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
297 LOG_ERROR("couldn't register '%s' commands", args
[0]);
301 c
= malloc(sizeof(flash_bank_t
));
303 c
->driver
= flash_drivers
[i
];
304 c
->driver_priv
= NULL
;
305 c
->base
= strtoul(args
[1], NULL
, 0);
306 c
->size
= strtoul(args
[2], NULL
, 0);
307 c
->chip_width
= strtoul(args
[3], NULL
, 0);
308 c
->bus_width
= strtoul(args
[4], NULL
, 0);
313 if ((retval
=flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
)) != ERROR_OK
)
315 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
320 /* put flash bank in linked list */
323 /* find last flash bank */
324 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
337 /* no matching flash driver found */
340 LOG_ERROR("flash driver '%s' not found", args
[0]);
347 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
356 return ERROR_COMMAND_SYNTAX_ERROR
;
359 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
361 if (i
== strtoul(args
[0], NULL
, 0))
365 /* attempt auto probe */
366 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
369 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
370 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
371 for (j
= 0; j
< p
->num_sectors
; j
++)
375 if (p
->sectors
[j
].is_protected
== 0)
376 protect_state
= "not protected";
377 else if (p
->sectors
[j
].is_protected
== 1)
378 protect_state
= "protected";
380 protect_state
= "protection state unknown";
382 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
383 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
387 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
388 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
389 command_print(cmd_ctx
, "%s", buf
);
390 if (retval
!= ERROR_OK
)
391 LOG_ERROR("error retrieving flash info (%d)", retval
);
398 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
405 return ERROR_COMMAND_SYNTAX_ERROR
;
408 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
411 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
413 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
415 else if (retval
== ERROR_FLASH_BANK_INVALID
)
417 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
422 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
428 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
434 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
441 return ERROR_COMMAND_SYNTAX_ERROR
;
444 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
448 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
450 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
454 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
458 for (j
= 0; j
< p
->num_sectors
; j
++)
462 if (p
->sectors
[j
].is_erased
== 0)
463 erase_state
= "not erased";
464 else if (p
->sectors
[j
].is_erased
== 1)
465 erase_state
= "erased";
467 erase_state
= "erase state unknown";
469 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
470 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
479 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
488 target_t
*target
= get_current_target(cmd_ctx
);
492 return ERROR_COMMAND_SYNTAX_ERROR
;
495 address
= strtoul(args
[0], NULL
, 0);
496 length
= strtoul(args
[1], NULL
, 0);
499 command_print(cmd_ctx
, "Length must be >0");
500 return ERROR_COMMAND_SYNTAX_ERROR
;
503 p
= get_flash_bank_by_addr(target
, address
);
509 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
512 duration_start_measure(&duration
);
514 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
516 duration_stop_measure(&duration
, &duration_text
);
517 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
524 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
531 return ERROR_COMMAND_SYNTAX_ERROR
;
534 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
537 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
539 command_print(cmd_ctx
, "successfully checked protect state");
541 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
543 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
547 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
552 return ERROR_COMMAND_SYNTAX_ERROR
;
558 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
562 int first
= strtoul(args
[1], NULL
, 0);
563 int last
= strtoul(args
[2], NULL
, 0);
565 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
569 duration_start_measure(&duration
);
573 return ERROR_COMMAND_SYNTAX_ERROR
;
576 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
578 duration_stop_measure(&duration
, &duration_text
);
580 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
586 return ERROR_COMMAND_SYNTAX_ERROR
;
592 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
596 int first
= strtoul(args
[1], NULL
, 0);
597 int last
= strtoul(args
[2], NULL
, 0);
600 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
603 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
607 if (strcmp(args
[3], "on") == 0)
609 else if (strcmp(args
[3], "off") == 0)
613 return ERROR_COMMAND_SYNTAX_ERROR
;
616 retval
= flash_driver_protect(p
, set
, first
, last
);
617 if (retval
== ERROR_OK
)
619 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));
624 return ERROR_COMMAND_SYNTAX_ERROR
;
631 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
633 target_t
*target
= get_current_target(cmd_ctx
);
645 return ERROR_COMMAND_SYNTAX_ERROR
;
648 /* flash auto-erase is disabled by default*/
651 if (strcmp(args
[0], "erase")==0)
656 command_print(cmd_ctx
, "auto erase enabled");
662 return ERROR_COMMAND_SYNTAX_ERROR
;
667 LOG_ERROR("no target selected");
671 duration_start_measure(&duration
);
675 image
.base_address_set
= 1;
676 image
.base_address
= strtoul(args
[1], NULL
, 0);
680 image
.base_address_set
= 0;
681 image
.base_address
= 0x0;
684 image
.start_address_set
= 0;
686 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
687 if (retval
!= ERROR_OK
)
692 retval
= flash_write(target
, &image
, &written
, auto_erase
);
693 if (retval
!= ERROR_OK
)
699 duration_stop_measure(&duration
, &duration_text
);
700 if (retval
== ERROR_OK
)
702 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
703 written
, args
[0], duration_text
,
704 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
713 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
724 target_t
*target
= get_current_target(cmd_ctx
);
730 return ERROR_COMMAND_SYNTAX_ERROR
;
733 address
= strtoul(args
[0], NULL
, 0);
734 pattern
= strtoul(args
[1], NULL
, 0);
735 count
= strtoul(args
[2], NULL
, 0);
753 return ERROR_COMMAND_SYNTAX_ERROR
;
756 chunk_count
= MIN(count
, (1024 / wordsize
));
760 for(i
= 0; i
< chunk_count
; i
++)
762 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
766 for(i
= 0; i
< chunk_count
; i
++)
768 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
772 memset(chunk
, pattern
, chunk_count
);
775 LOG_ERROR("BUG: can't happen");
779 duration_start_measure(&duration
);
782 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
785 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
787 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
791 bank
= get_flash_bank_by_addr(target
, address
);
797 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
805 duration_stop_measure(&duration
, &duration_text
);
810 speed
=wrote
/ 1024.0;
811 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
812 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
813 count
*wordsize
, address
, duration_text
,
820 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
836 return ERROR_COMMAND_SYNTAX_ERROR
;
839 duration_start_measure(&duration
);
841 offset
= strtoul(args
[2], NULL
, 0);
842 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
845 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
849 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
854 buffer
= malloc(fileio
.size
);
855 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
858 fileio_close(&fileio
);
862 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
867 duration_stop_measure(&duration
, &duration_text
);
868 if (retval
!=ERROR_OK
)
870 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
871 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
872 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
876 fileio_close(&fileio
);
881 void flash_set_dirty(void)
886 /* set all flash to require erasing */
887 for (c
= flash_banks
; c
; c
= c
->next
)
889 for (i
= 0; i
< c
->num_sectors
; i
++)
891 c
->sectors
[i
].is_erased
= 0;
896 /* lookup flash bank by address */
897 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
901 /* cycle through bank list */
902 for (c
= flash_banks
; c
; c
= c
->next
)
905 retval
= c
->driver
->auto_probe(c
);
907 if (retval
!= ERROR_OK
)
909 LOG_ERROR("auto_probe failed %d\n", retval
);
912 /* check whether address belongs to this flash bank */
913 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
916 LOG_ERROR("No flash at address 0x%08x\n", addr
);
920 /* erase given flash region, selects proper bank according to target and address */
921 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
928 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
929 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
931 if (c
->size
== 0 || c
->num_sectors
== 0)
933 LOG_ERROR("Bank is invalid");
934 return ERROR_FLASH_BANK_INVALID
;
939 /* special case, erase whole bank when length is zero */
941 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
943 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
946 /* check whether it fits */
947 if (addr
+ length
> c
->base
+ c
->size
)
948 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
952 for (i
= 0; i
< c
->num_sectors
; i
++)
954 /* check whether sector overlaps with the given range and is not yet erased */
955 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
956 /* if first is not set yet then this is the first sector */
959 last
= i
; /* and it is the last one so far in any case */
963 if( first
== -1 || last
== -1 )
966 return flash_driver_erase(c
, first
, last
);
969 /* write (optional verify) an image to flash memory of the given target */
970 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
987 /* assume all sectors need erasing - stops any problems
988 * when flash_write is called multiple times */
993 /* allocate padding array */
994 padding
= malloc(image
->num_sections
* sizeof(padding
));
996 /* loop until we reach end of the image */
997 while (section
< image
->num_sections
)
1003 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
1004 u32 run_size
= image
->sections
[section
].size
- section_offset
;
1007 if (image
->sections
[section
].size
== 0)
1009 LOG_WARNING("empty section %d", section
);
1015 /* find the corresponding flash bank */
1016 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1018 section
++; /* and skip it */
1023 /* collect consecutive sections which fall into the same bank */
1024 section_first
= section
;
1025 section_last
= section
;
1026 padding
[section
] = 0;
1027 while ((run_address
+ run_size
< c
->base
+ c
->size
)
1028 && (section_last
+ 1 < image
->num_sections
))
1030 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1032 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1035 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1036 * attempt to rebuild a consecutive buffer for the flash loader */
1037 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1038 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1040 padding
[section_last
] = pad_bytes
;
1041 run_size
+= image
->sections
[++section_last
].size
;
1042 run_size
+= pad_bytes
;
1043 padding
[section_last
] = 0;
1045 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1048 /* fit the run into bank constraints */
1049 if (run_address
+ run_size
> c
->base
+ c
->size
)
1050 run_size
= c
->base
+ c
->size
- run_address
;
1052 /* allocate buffer */
1053 buffer
= malloc(run_size
);
1056 /* read sections to the buffer */
1057 while (buffer_size
< run_size
)
1061 size_read
= run_size
- buffer_size
;
1062 if (size_read
> image
->sections
[section
].size
- section_offset
)
1063 size_read
= image
->sections
[section
].size
- section_offset
;
1065 if ((retval
= image_read_section(image
, section
, section_offset
,
1066 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1073 /* see if we need to pad the section */
1074 while (padding
[section
]--)
1075 (buffer
+buffer_size
)[size_read
++] = 0xff;
1077 buffer_size
+= size_read
;
1078 section_offset
+= size_read
;
1080 if (section_offset
>= image
->sections
[section
].size
)
1091 /* calculate and erase sectors */
1092 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1095 if (retval
== ERROR_OK
)
1097 /* write flash sectors */
1098 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1103 if (retval
!= ERROR_OK
)
1106 return retval
; /* abort operation */
1109 if (written
!= NULL
)
1110 *written
+= run_size
; /* add run size to total written counter */
1118 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1120 target_t
*target
= bank
->target
;
1122 int buffer_size
= sizeof(buffer
);
1126 if (bank
->target
->state
!= TARGET_HALTED
)
1128 LOG_ERROR("Target not halted");
1129 return ERROR_TARGET_NOT_HALTED
;
1132 for (i
= 0; i
< bank
->num_sectors
; i
++)
1135 bank
->sectors
[i
].is_erased
= 1;
1137 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1141 chunk
= buffer_size
;
1142 if (chunk
> (j
- bank
->sectors
[i
].size
))
1144 chunk
= (j
- bank
->sectors
[i
].size
);
1147 retval
= target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1148 if (retval
!= ERROR_OK
)
1151 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1153 if (buffer
[nBytes
] != 0xFF)
1155 bank
->sectors
[i
].is_erased
= 0;
1165 int default_flash_blank_check(struct flash_bank_s
*bank
)
1167 target_t
*target
= bank
->target
;
1173 if (bank
->target
->state
!= TARGET_HALTED
)
1175 LOG_ERROR("Target not halted");
1176 return ERROR_TARGET_NOT_HALTED
;
1179 for (i
= 0; i
< bank
->num_sectors
; i
++)
1181 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1182 u32 size
= bank
->sectors
[i
].size
;
1184 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1190 bank
->sectors
[i
].is_erased
= 1;
1192 bank
->sectors
[i
].is_erased
= 0;
1198 LOG_USER("Running slow fallback erase check - add working memory");
1199 return default_flash_mem_blank_check(bank
);
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)