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 at91sam7_old_flash
;
71 extern flash_driver_t str7x_flash
;
72 extern flash_driver_t str9x_flash
;
73 extern flash_driver_t aduc702x_flash
;
74 extern flash_driver_t stellaris_flash
;
75 extern flash_driver_t str9xpec_flash
;
76 extern flash_driver_t stm32x_flash
;
77 extern flash_driver_t tms470_flash
;
78 extern flash_driver_t ecosflash_flash
;
79 extern flash_driver_t lpc288x_flash
;
80 extern flash_driver_t ocl_flash
;
82 flash_driver_t
*flash_drivers
[] = {
102 flash_bank_t
*flash_banks
;
103 static command_t
*flash_cmd
;
105 /* wafer thin wrapper for invoking the flash driver */
106 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
110 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
111 if (retval
!=ERROR_OK
)
113 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
119 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
123 retval
=bank
->driver
->erase(bank
, first
, last
);
124 if (retval
!=ERROR_OK
)
126 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
132 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
136 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
137 if (retval
!=ERROR_OK
)
139 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
145 int flash_register_commands(struct command_context_s
*cmd_ctx
)
147 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
149 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 ...]");
153 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
158 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
167 Jim_Obj
*list
=Jim_NewListObj(interp
, NULL
, 0);
168 for (p
= flash_banks
; p
; p
= p
->next
)
170 Jim_Obj
*elem
=Jim_NewListObj(interp
, NULL
, 0);
172 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
173 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
174 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
175 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
176 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
177 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
178 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
179 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
180 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
181 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
183 Jim_ListAppendElement(interp
, list
, elem
);
186 Jim_SetResult(interp
, list
);
191 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
195 register_jim(cmd_ctx
, "ocd_flash_banks", jim_flash_banks
, "return information about the flash banks");
197 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
198 "print info about flash bank <num>");
199 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
200 "identify flash bank <num>");
201 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
202 "check erase state of sectors in flash bank <num>");
203 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
204 "check protection state of sectors in flash bank <num>");
205 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
206 "erase sectors at <bank> <first> <last>");
207 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
208 "erase address range <address> <length>");
210 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
211 "fill with pattern <address> <word_pattern> <count>");
212 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
213 "fill with pattern <address> <halfword_pattern> <count>");
214 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
215 "fill with pattern <address> <byte_pattern> <count>");
217 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
218 "write binary data to <bank> <file> <offset>");
219 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
220 "write_image [erase] <file> [offset] [type]");
221 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
222 "set protection of sectors at <bank> <first> <last> <on|off>");
228 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
233 for (p
= flash_banks
; p
; p
= p
->next
)
240 LOG_ERROR("flash bank %d does not exist", num
);
244 int flash_get_bank_count(void)
248 for (p
= flash_banks
; p
; p
= p
->next
)
255 flash_bank_t
*get_flash_bank_by_num(int num
)
257 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
263 retval
= p
->driver
->auto_probe(p
);
265 if (retval
!= ERROR_OK
)
267 LOG_ERROR("auto_probe failed %d\n", retval
);
273 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
282 return ERROR_COMMAND_SYNTAX_ERROR
;
285 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
287 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
291 for (i
= 0; flash_drivers
[i
]; i
++)
293 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
297 /* register flash specific commands */
298 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
300 LOG_ERROR("couldn't register '%s' commands", args
[0]);
304 c
= malloc(sizeof(flash_bank_t
));
306 c
->driver
= flash_drivers
[i
];
307 c
->driver_priv
= NULL
;
308 c
->base
= strtoul(args
[1], NULL
, 0);
309 c
->size
= strtoul(args
[2], NULL
, 0);
310 c
->chip_width
= strtoul(args
[3], NULL
, 0);
311 c
->bus_width
= strtoul(args
[4], NULL
, 0);
316 if ((retval
=flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
)) != ERROR_OK
)
318 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
323 /* put flash bank in linked list */
326 /* find last flash bank */
327 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
340 /* no matching flash driver found */
343 LOG_ERROR("flash driver '%s' not found", args
[0]);
350 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
359 return ERROR_COMMAND_SYNTAX_ERROR
;
362 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
364 if (i
== strtoul(args
[0], NULL
, 0))
368 /* attempt auto probe */
369 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
372 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
373 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
374 for (j
= 0; j
< p
->num_sectors
; j
++)
378 if (p
->sectors
[j
].is_protected
== 0)
379 protect_state
= "not protected";
380 else if (p
->sectors
[j
].is_protected
== 1)
381 protect_state
= "protected";
383 protect_state
= "protection state unknown";
385 command_print(cmd_ctx
, "\t#%3i: 0x%8.8x (0x%x %ikB) %s",
386 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
390 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
391 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
392 command_print(cmd_ctx
, "%s", buf
);
393 if (retval
!= ERROR_OK
)
394 LOG_ERROR("error retrieving flash info (%d)", retval
);
401 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
408 return ERROR_COMMAND_SYNTAX_ERROR
;
411 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
414 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
416 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
418 else if (retval
== ERROR_FLASH_BANK_INVALID
)
420 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
425 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
431 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
437 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
444 return ERROR_COMMAND_SYNTAX_ERROR
;
447 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
451 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
453 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
457 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
461 for (j
= 0; j
< p
->num_sectors
; j
++)
465 if (p
->sectors
[j
].is_erased
== 0)
466 erase_state
= "not erased";
467 else if (p
->sectors
[j
].is_erased
== 1)
468 erase_state
= "erased";
470 erase_state
= "erase state unknown";
472 command_print(cmd_ctx
, "\t#%3i: 0x%8.8x (0x%x %ikB) %s",
473 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
482 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
491 target_t
*target
= get_current_target(cmd_ctx
);
495 return ERROR_COMMAND_SYNTAX_ERROR
;
498 address
= strtoul(args
[0], NULL
, 0);
499 length
= strtoul(args
[1], NULL
, 0);
502 command_print(cmd_ctx
, "Length must be >0");
503 return ERROR_COMMAND_SYNTAX_ERROR
;
506 p
= get_flash_bank_by_addr(target
, address
);
512 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
515 duration_start_measure(&duration
);
517 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
519 duration_stop_measure(&duration
, &duration_text
);
520 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
527 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
534 return ERROR_COMMAND_SYNTAX_ERROR
;
537 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
540 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
542 command_print(cmd_ctx
, "successfully checked protect state");
544 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
546 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
550 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
555 return ERROR_COMMAND_SYNTAX_ERROR
;
561 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
565 int first
= strtoul(args
[1], NULL
, 0);
566 int last
= strtoul(args
[2], NULL
, 0);
568 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
572 duration_start_measure(&duration
);
576 return ERROR_COMMAND_SYNTAX_ERROR
;
579 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
581 duration_stop_measure(&duration
, &duration_text
);
583 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
589 return ERROR_COMMAND_SYNTAX_ERROR
;
595 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
599 int first
= strtoul(args
[1], NULL
, 0);
600 int last
= strtoul(args
[2], NULL
, 0);
603 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
606 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
610 if (strcmp(args
[3], "on") == 0)
612 else if (strcmp(args
[3], "off") == 0)
616 return ERROR_COMMAND_SYNTAX_ERROR
;
619 retval
= flash_driver_protect(p
, set
, first
, last
);
620 if (retval
== ERROR_OK
)
622 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));
627 return ERROR_COMMAND_SYNTAX_ERROR
;
634 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
636 target_t
*target
= get_current_target(cmd_ctx
);
648 return ERROR_COMMAND_SYNTAX_ERROR
;
651 /* flash auto-erase is disabled by default*/
654 if (strcmp(args
[0], "erase")==0)
659 command_print(cmd_ctx
, "auto erase enabled");
665 return ERROR_COMMAND_SYNTAX_ERROR
;
670 LOG_ERROR("no target selected");
674 duration_start_measure(&duration
);
678 image
.base_address_set
= 1;
679 image
.base_address
= strtoul(args
[1], NULL
, 0);
683 image
.base_address_set
= 0;
684 image
.base_address
= 0x0;
687 image
.start_address_set
= 0;
689 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
690 if (retval
!= ERROR_OK
)
695 retval
= flash_write(target
, &image
, &written
, auto_erase
);
696 if (retval
!= ERROR_OK
)
702 duration_stop_measure(&duration
, &duration_text
);
703 if (retval
== ERROR_OK
)
705 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
706 written
, args
[0], duration_text
,
707 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
716 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
727 target_t
*target
= get_current_target(cmd_ctx
);
733 return ERROR_COMMAND_SYNTAX_ERROR
;
736 address
= strtoul(args
[0], NULL
, 0);
737 pattern
= strtoul(args
[1], NULL
, 0);
738 count
= strtoul(args
[2], NULL
, 0);
756 return ERROR_COMMAND_SYNTAX_ERROR
;
759 chunk_count
= MIN(count
, (1024 / wordsize
));
763 for(i
= 0; i
< chunk_count
; i
++)
765 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
769 for(i
= 0; i
< chunk_count
; i
++)
771 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
775 memset(chunk
, pattern
, chunk_count
);
778 LOG_ERROR("BUG: can't happen");
782 duration_start_measure(&duration
);
785 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
788 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
790 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
794 bank
= get_flash_bank_by_addr(target
, address
);
800 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
808 duration_stop_measure(&duration
, &duration_text
);
813 speed
=wrote
/ 1024.0;
814 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
815 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
816 count
*wordsize
, address
, duration_text
,
823 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
839 return ERROR_COMMAND_SYNTAX_ERROR
;
842 duration_start_measure(&duration
);
844 offset
= strtoul(args
[2], NULL
, 0);
845 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
848 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
852 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
857 buffer
= malloc(fileio
.size
);
858 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
861 fileio_close(&fileio
);
865 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
870 duration_stop_measure(&duration
, &duration_text
);
871 if (retval
!=ERROR_OK
)
873 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
874 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
875 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
879 fileio_close(&fileio
);
884 void flash_set_dirty(void)
889 /* set all flash to require erasing */
890 for (c
= flash_banks
; c
; c
= c
->next
)
892 for (i
= 0; i
< c
->num_sectors
; i
++)
894 c
->sectors
[i
].is_erased
= 0;
899 /* lookup flash bank by address */
900 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
904 /* cycle through bank list */
905 for (c
= flash_banks
; c
; c
= c
->next
)
908 retval
= c
->driver
->auto_probe(c
);
910 if (retval
!= ERROR_OK
)
912 LOG_ERROR("auto_probe failed %d\n", retval
);
915 /* check whether address belongs to this flash bank */
916 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
919 LOG_ERROR("No flash at address 0x%08x\n", addr
);
923 /* erase given flash region, selects proper bank according to target and address */
924 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
931 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
932 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
934 if (c
->size
== 0 || c
->num_sectors
== 0)
936 LOG_ERROR("Bank is invalid");
937 return ERROR_FLASH_BANK_INVALID
;
942 /* special case, erase whole bank when length is zero */
944 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
946 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
949 /* check whether it fits */
950 if (addr
+ length
> c
->base
+ c
->size
)
951 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
955 for (i
= 0; i
< c
->num_sectors
; i
++)
957 /* check whether sector overlaps with the given range and is not yet erased */
958 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
959 /* if first is not set yet then this is the first sector */
962 last
= i
; /* and it is the last one so far in any case */
966 if( first
== -1 || last
== -1 )
969 return flash_driver_erase(c
, first
, last
);
972 /* write (optional verify) an image to flash memory of the given target */
973 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
990 /* assume all sectors need erasing - stops any problems
991 * when flash_write is called multiple times */
996 /* allocate padding array */
997 padding
= malloc(image
->num_sections
* sizeof(padding
));
999 /* loop until we reach end of the image */
1000 while (section
< image
->num_sections
)
1006 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
1007 u32 run_size
= image
->sections
[section
].size
- section_offset
;
1010 if (image
->sections
[section
].size
== 0)
1012 LOG_WARNING("empty section %d", section
);
1018 /* find the corresponding flash bank */
1019 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1021 section
++; /* and skip it */
1026 /* collect consecutive sections which fall into the same bank */
1027 section_first
= section
;
1028 section_last
= section
;
1029 padding
[section
] = 0;
1030 while ((run_address
+ run_size
< c
->base
+ c
->size
)
1031 && (section_last
+ 1 < image
->num_sections
))
1033 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1035 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1038 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1039 * attempt to rebuild a consecutive buffer for the flash loader */
1040 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1041 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1043 padding
[section_last
] = pad_bytes
;
1044 run_size
+= image
->sections
[++section_last
].size
;
1045 run_size
+= pad_bytes
;
1046 padding
[section_last
] = 0;
1048 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1051 /* fit the run into bank constraints */
1052 if (run_address
+ run_size
> c
->base
+ c
->size
)
1053 run_size
= c
->base
+ c
->size
- run_address
;
1055 /* allocate buffer */
1056 buffer
= malloc(run_size
);
1059 /* read sections to the buffer */
1060 while (buffer_size
< run_size
)
1064 size_read
= run_size
- buffer_size
;
1065 if (size_read
> image
->sections
[section
].size
- section_offset
)
1066 size_read
= image
->sections
[section
].size
- section_offset
;
1068 if ((retval
= image_read_section(image
, section
, section_offset
,
1069 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1076 /* see if we need to pad the section */
1077 while (padding
[section
]--)
1078 (buffer
+buffer_size
)[size_read
++] = 0xff;
1080 buffer_size
+= size_read
;
1081 section_offset
+= size_read
;
1083 if (section_offset
>= image
->sections
[section
].size
)
1094 /* calculate and erase sectors */
1095 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1098 if (retval
== ERROR_OK
)
1100 /* write flash sectors */
1101 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1106 if (retval
!= ERROR_OK
)
1109 return retval
; /* abort operation */
1112 if (written
!= NULL
)
1113 *written
+= run_size
; /* add run size to total written counter */
1121 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1123 target_t
*target
= bank
->target
;
1125 int buffer_size
= sizeof(buffer
);
1129 if (bank
->target
->state
!= TARGET_HALTED
)
1131 LOG_ERROR("Target not halted");
1132 return ERROR_TARGET_NOT_HALTED
;
1135 for (i
= 0; i
< bank
->num_sectors
; i
++)
1138 bank
->sectors
[i
].is_erased
= 1;
1140 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1144 chunk
= buffer_size
;
1145 if (chunk
> (j
- bank
->sectors
[i
].size
))
1147 chunk
= (j
- bank
->sectors
[i
].size
);
1150 retval
= target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1151 if (retval
!= ERROR_OK
)
1154 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1156 if (buffer
[nBytes
] != 0xFF)
1158 bank
->sectors
[i
].is_erased
= 0;
1168 int default_flash_blank_check(struct flash_bank_s
*bank
)
1170 target_t
*target
= bank
->target
;
1176 if (bank
->target
->state
!= TARGET_HALTED
)
1178 LOG_ERROR("Target not halted");
1179 return ERROR_TARGET_NOT_HALTED
;
1182 for (i
= 0; i
< bank
->num_sectors
; i
++)
1184 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1185 u32 size
= bank
->sectors
[i
].size
;
1187 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1193 bank
->sectors
[i
].is_erased
= 1;
1195 bank
->sectors
[i
].is_erased
= 0;
1201 LOG_USER("Running slow fallback erase check - add working memory");
1202 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)