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
[] = {
100 flash_bank_t
*flash_banks
;
101 static command_t
*flash_cmd
;
103 /* wafer thin wrapper for invoking the flash driver */
104 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
108 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
109 if (retval
!=ERROR_OK
)
111 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
117 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
121 retval
=bank
->driver
->erase(bank
, first
, last
);
122 if (retval
!=ERROR_OK
)
124 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
130 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
134 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
135 if (retval
!=ERROR_OK
)
137 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
143 int flash_register_commands(struct command_context_s
*cmd_ctx
)
145 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
147 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 ...]");
151 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
156 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
160 Jim_Obj
*list
=Jim_NewListObj(interp
, NULL
, 0);
161 for (p
= flash_banks
; p
; p
= p
->next
)
163 Jim_Obj
*elem
=Jim_NewListObj(interp
, NULL
, 0);
165 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
166 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
167 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
168 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
169 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
170 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
171 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
172 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
173 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
174 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
176 Jim_ListAppendElement(interp
, list
, elem
);
179 Jim_SetResult(interp
, list
);
184 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
186 register_jim(cmd_ctx
, "ocd_flash_banks", jim_flash_banks
, "return information about the flash banks");
190 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
191 "print info about flash bank <num>");
192 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
193 "identify flash bank <num>");
194 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
195 "check erase state of sectors in flash bank <num>");
196 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
197 "check protection state of sectors in flash bank <num>");
198 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
199 "erase sectors at <bank> <first> <last>");
200 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
201 "erase address range <address> <length>");
203 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
204 "fill with pattern (no autoerase) <address> <word_pattern> <count>");
205 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
206 "fill with pattern <address> <halfword_pattern> <count>");
207 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
208 "fill with pattern <address> <byte_pattern> <count>");
210 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
211 "write binary data to <bank> <file> <offset>");
212 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
213 "write_image [erase] <file> [offset] [type]");
214 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
215 "set protection of sectors at <bank> <first> <last> <on|off>");
221 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
226 for (p
= flash_banks
; p
; p
= p
->next
)
233 LOG_ERROR("flash bank %d does not exist", num
);
237 int flash_get_bank_count(void)
241 for (p
= flash_banks
; p
; p
= p
->next
)
248 flash_bank_t
*get_flash_bank_by_num(int num
)
250 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
256 retval
= p
->driver
->auto_probe(p
);
258 if (retval
!= ERROR_OK
)
260 LOG_ERROR("auto_probe failed %d\n", retval
);
266 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
275 return ERROR_COMMAND_SYNTAX_ERROR
;
278 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
280 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
284 for (i
= 0; flash_drivers
[i
]; i
++)
286 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
290 /* register flash specific commands */
291 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
293 LOG_ERROR("couldn't register '%s' commands", args
[0]);
297 c
= malloc(sizeof(flash_bank_t
));
299 c
->driver
= flash_drivers
[i
];
300 c
->driver_priv
= NULL
;
301 c
->base
= strtoul(args
[1], NULL
, 0);
302 c
->size
= strtoul(args
[2], NULL
, 0);
303 c
->chip_width
= strtoul(args
[3], NULL
, 0);
304 c
->bus_width
= strtoul(args
[4], NULL
, 0);
309 if ((retval
=flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
)) != ERROR_OK
)
311 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
316 /* put flash bank in linked list */
319 /* find last flash bank */
320 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
333 /* no matching flash driver found */
336 LOG_ERROR("flash driver '%s' not found", args
[0]);
343 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
352 return ERROR_COMMAND_SYNTAX_ERROR
;
355 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
357 if (i
== strtoul(args
[0], NULL
, 0))
361 /* attempt auto probe */
362 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
365 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
366 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
367 for (j
= 0; j
< p
->num_sectors
; j
++)
371 if (p
->sectors
[j
].is_protected
== 0)
372 protect_state
= "not protected";
373 else if (p
->sectors
[j
].is_protected
== 1)
374 protect_state
= "protected";
376 protect_state
= "protection state unknown";
378 command_print(cmd_ctx
, "\t#%3i: 0x%8.8x (0x%x %ikB) %s",
379 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
383 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
384 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
385 command_print(cmd_ctx
, "%s", buf
);
386 if (retval
!= ERROR_OK
)
387 LOG_ERROR("error retrieving flash info (%d)", retval
);
394 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
401 return ERROR_COMMAND_SYNTAX_ERROR
;
404 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
407 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
409 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
411 else if (retval
== ERROR_FLASH_BANK_INVALID
)
413 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
418 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
424 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
430 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
437 return ERROR_COMMAND_SYNTAX_ERROR
;
440 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
444 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
446 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
450 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
454 for (j
= 0; j
< p
->num_sectors
; j
++)
458 if (p
->sectors
[j
].is_erased
== 0)
459 erase_state
= "not erased";
460 else if (p
->sectors
[j
].is_erased
== 1)
461 erase_state
= "erased";
463 erase_state
= "erase state unknown";
465 command_print(cmd_ctx
, "\t#%3i: 0x%8.8x (0x%x %ikB) %s",
466 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
475 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
484 target_t
*target
= get_current_target(cmd_ctx
);
488 return ERROR_COMMAND_SYNTAX_ERROR
;
491 address
= strtoul(args
[0], NULL
, 0);
492 length
= strtoul(args
[1], NULL
, 0);
495 command_print(cmd_ctx
, "Length must be >0");
496 return ERROR_COMMAND_SYNTAX_ERROR
;
499 p
= get_flash_bank_by_addr(target
, address
);
505 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
508 duration_start_measure(&duration
);
510 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
512 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
516 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
523 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
530 return ERROR_COMMAND_SYNTAX_ERROR
;
533 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
536 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
538 command_print(cmd_ctx
, "successfully checked protect state");
540 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
542 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
546 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
551 return ERROR_COMMAND_SYNTAX_ERROR
;
557 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
561 int first
= strtoul(args
[1], NULL
, 0);
562 int last
= strtoul(args
[2], NULL
, 0);
564 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
568 duration_start_measure(&duration
);
572 return ERROR_COMMAND_SYNTAX_ERROR
;
575 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
577 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
582 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
588 return ERROR_COMMAND_SYNTAX_ERROR
;
594 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
598 int first
= strtoul(args
[1], NULL
, 0);
599 int last
= strtoul(args
[2], NULL
, 0);
602 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
605 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
609 if (strcmp(args
[3], "on") == 0)
611 else if (strcmp(args
[3], "off") == 0)
615 return ERROR_COMMAND_SYNTAX_ERROR
;
618 retval
= flash_driver_protect(p
, set
, first
, last
);
619 if (retval
== ERROR_OK
)
621 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));
626 return ERROR_COMMAND_SYNTAX_ERROR
;
633 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
635 target_t
*target
= get_current_target(cmd_ctx
);
643 int retval
, retvaltemp
;
647 return ERROR_COMMAND_SYNTAX_ERROR
;
650 /* flash auto-erase is disabled by default*/
653 if (strcmp(args
[0], "erase")==0)
658 command_print(cmd_ctx
, "auto erase enabled");
664 return ERROR_COMMAND_SYNTAX_ERROR
;
669 LOG_ERROR("no target selected");
673 duration_start_measure(&duration
);
677 image
.base_address_set
= 1;
678 image
.base_address
= strtoul(args
[1], NULL
, 0);
682 image
.base_address_set
= 0;
683 image
.base_address
= 0x0;
686 image
.start_address_set
= 0;
688 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
689 if (retval
!= ERROR_OK
)
694 retval
= flash_write(target
, &image
, &written
, auto_erase
);
695 if (retval
!= ERROR_OK
)
701 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
706 if (retval
== ERROR_OK
)
708 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
709 written
, args
[0], duration_text
,
710 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
719 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
721 int err
= ERROR_OK
, retval
;
730 target_t
*target
= get_current_target(cmd_ctx
);
736 return ERROR_COMMAND_SYNTAX_ERROR
;
739 address
= strtoul(args
[0], NULL
, 0);
740 pattern
= strtoul(args
[1], NULL
, 0);
741 count
= strtoul(args
[2], NULL
, 0);
759 return ERROR_COMMAND_SYNTAX_ERROR
;
762 chunk_count
= MIN(count
, (1024 / wordsize
));
766 for(i
= 0; i
< chunk_count
; i
++)
768 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
772 for(i
= 0; i
< chunk_count
; i
++)
774 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
778 memset(chunk
, pattern
, chunk_count
);
781 LOG_ERROR("BUG: can't happen");
785 duration_start_measure(&duration
);
787 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
789 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
791 bank
= get_flash_bank_by_addr(target
, address
);
796 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
802 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
811 speed
=wrote
/ 1024.0;
812 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
813 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
814 count
*wordsize
, address
, duration_text
,
821 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
832 int retval
, retvaltemp
;
837 return ERROR_COMMAND_SYNTAX_ERROR
;
840 duration_start_measure(&duration
);
842 offset
= strtoul(args
[2], NULL
, 0);
843 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
846 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
850 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
855 buffer
= malloc(fileio
.size
);
856 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
859 fileio_close(&fileio
);
863 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
868 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
870 fileio_close(&fileio
);
873 if (retval
==ERROR_OK
)
875 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
876 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
877 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
881 fileio_close(&fileio
);
886 void flash_set_dirty(void)
891 /* set all flash to require erasing */
892 for (c
= flash_banks
; c
; c
= c
->next
)
894 for (i
= 0; i
< c
->num_sectors
; i
++)
896 c
->sectors
[i
].is_erased
= 0;
901 /* lookup flash bank by address */
902 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
906 /* cycle through bank list */
907 for (c
= flash_banks
; c
; c
= c
->next
)
910 retval
= c
->driver
->auto_probe(c
);
912 if (retval
!= ERROR_OK
)
914 LOG_ERROR("auto_probe failed %d\n", retval
);
917 /* check whether address belongs to this flash bank */
918 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
921 LOG_ERROR("No flash at address 0x%08x\n", addr
);
925 /* erase given flash region, selects proper bank according to target and address */
926 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
933 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
934 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
936 if (c
->size
== 0 || c
->num_sectors
== 0)
938 LOG_ERROR("Bank is invalid");
939 return ERROR_FLASH_BANK_INVALID
;
944 /* special case, erase whole bank when length is zero */
946 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
948 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
951 /* check whether it fits */
952 if (addr
+ length
> c
->base
+ c
->size
)
953 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
957 for (i
= 0; i
< c
->num_sectors
; i
++)
959 /* check whether sector overlaps with the given range and is not yet erased */
960 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
961 /* if first is not set yet then this is the first sector */
964 last
= i
; /* and it is the last one so far in any case */
968 if( first
== -1 || last
== -1 )
971 return flash_driver_erase(c
, first
, last
);
974 /* write (optional verify) an image to flash memory of the given target */
975 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
992 /* assume all sectors need erasing - stops any problems
993 * when flash_write is called multiple times */
998 /* allocate padding array */
999 padding
= malloc(image
->num_sections
* sizeof(padding
));
1001 /* loop until we reach end of the image */
1002 while (section
< image
->num_sections
)
1008 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
1009 u32 run_size
= image
->sections
[section
].size
- section_offset
;
1012 if (image
->sections
[section
].size
== 0)
1014 LOG_WARNING("empty section %d", section
);
1020 /* find the corresponding flash bank */
1021 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1023 section
++; /* and skip it */
1028 /* collect consecutive sections which fall into the same bank */
1029 section_first
= section
;
1030 section_last
= section
;
1031 padding
[section
] = 0;
1032 while ((run_address
+ run_size
< c
->base
+ c
->size
)
1033 && (section_last
+ 1 < image
->num_sections
))
1035 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1037 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1040 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1041 * attempt to rebuild a consecutive buffer for the flash loader */
1042 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1043 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1045 padding
[section_last
] = pad_bytes
;
1046 run_size
+= image
->sections
[++section_last
].size
;
1047 run_size
+= pad_bytes
;
1048 padding
[section_last
] = 0;
1050 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1053 /* fit the run into bank constraints */
1054 if (run_address
+ run_size
> c
->base
+ c
->size
)
1055 run_size
= c
->base
+ c
->size
- run_address
;
1057 /* allocate buffer */
1058 buffer
= malloc(run_size
);
1061 /* read sections to the buffer */
1062 while (buffer_size
< run_size
)
1066 size_read
= run_size
- buffer_size
;
1067 if (size_read
> image
->sections
[section
].size
- section_offset
)
1068 size_read
= image
->sections
[section
].size
- section_offset
;
1070 if ((retval
= image_read_section(image
, section
, section_offset
,
1071 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1078 /* see if we need to pad the section */
1079 while (padding
[section
]--)
1080 (buffer
+buffer_size
)[size_read
++] = 0xff;
1082 buffer_size
+= size_read
;
1083 section_offset
+= size_read
;
1085 if (section_offset
>= image
->sections
[section
].size
)
1096 /* calculate and erase sectors */
1097 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1100 if (retval
== ERROR_OK
)
1102 /* write flash sectors */
1103 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1108 if (retval
!= ERROR_OK
)
1111 return retval
; /* abort operation */
1114 if (written
!= NULL
)
1115 *written
+= run_size
; /* add run size to total written counter */
1123 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1125 target_t
*target
= bank
->target
;
1127 int buffer_size
= sizeof(buffer
);
1131 if (bank
->target
->state
!= TARGET_HALTED
)
1133 LOG_ERROR("Target not halted");
1134 return ERROR_TARGET_NOT_HALTED
;
1137 for (i
= 0; i
< bank
->num_sectors
; i
++)
1140 bank
->sectors
[i
].is_erased
= 1;
1142 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1146 chunk
= buffer_size
;
1147 if (chunk
> (j
- bank
->sectors
[i
].size
))
1149 chunk
= (j
- bank
->sectors
[i
].size
);
1152 retval
= target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1153 if (retval
!= ERROR_OK
)
1156 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1158 if (buffer
[nBytes
] != 0xFF)
1160 bank
->sectors
[i
].is_erased
= 0;
1170 int default_flash_blank_check(struct flash_bank_s
*bank
)
1172 target_t
*target
= bank
->target
;
1178 if (bank
->target
->state
!= TARGET_HALTED
)
1180 LOG_ERROR("Target not halted");
1181 return ERROR_TARGET_NOT_HALTED
;
1184 for (i
= 0; i
< bank
->num_sectors
; i
++)
1186 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1187 u32 size
= bank
->sectors
[i
].size
;
1189 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1195 bank
->sectors
[i
].is_erased
= 1;
1197 bank
->sectors
[i
].is_erased
= 0;
1203 LOG_USER("Running slow fallback erase check - add working memory");
1204 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)