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 stellaris_flash
;
73 extern flash_driver_t str9xpec_flash
;
74 extern flash_driver_t stm32x_flash
;
75 extern flash_driver_t tms470_flash
;
76 extern flash_driver_t ecosflash_flash
;
77 extern flash_driver_t lpc288x_flash
;
78 extern flash_driver_t ocl_flash
;
80 flash_driver_t
*flash_drivers
[] =
97 flash_bank_t
*flash_banks
;
98 static command_t
*flash_cmd
;
100 /* wafer thin wrapper for invoking the flash driver */
101 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
105 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
106 if (retval
!=ERROR_OK
)
108 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
114 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
118 retval
=bank
->driver
->erase(bank
, first
, last
);
119 if (retval
!=ERROR_OK
)
121 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
127 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
131 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
132 if (retval
!=ERROR_OK
)
134 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
140 int flash_register_commands(struct command_context_s
*cmd_ctx
)
142 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
144 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 ...]");
148 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
153 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
162 Jim_Obj
*list
=Jim_NewListObj(interp
, NULL
, 0);
163 for (p
= flash_banks
; p
; p
= p
->next
)
165 Jim_Obj
*elem
=Jim_NewListObj(interp
, NULL
, 0);
167 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
168 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
169 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
170 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
171 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
172 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
173 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
174 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
175 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
176 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
178 Jim_ListAppendElement(interp
, list
, elem
);
181 Jim_SetResult(interp
, list
);
186 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
190 register_jim(cmd_ctx
, "ocd_flash_banks", jim_flash_banks
, "return information about the flash banks");
192 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
193 "print info about flash bank <num>");
194 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
195 "identify flash bank <num>");
196 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
197 "check erase state of sectors in flash bank <num>");
198 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
199 "check protection state of sectors in flash bank <num>");
200 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
201 "erase sectors at <bank> <first> <last>");
202 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
203 "erase address range <address> <length>");
205 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
206 "fill with pattern <address> <word_pattern> <count>");
207 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
208 "fill with pattern <address> <halfword_pattern> <count>");
209 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
210 "fill with pattern <address> <byte_pattern> <count>");
212 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
213 "write binary data to <bank> <file> <offset>");
214 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
215 "write_image [erase] <file> [offset] [type]");
216 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
217 "set protection of sectors at <bank> <first> <last> <on|off>");
223 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
228 for (p
= flash_banks
; p
; p
= p
->next
)
235 LOG_ERROR("flash bank %d does not exist", num
);
239 int flash_get_bank_count(void)
243 for (p
= flash_banks
; p
; p
= p
->next
)
250 flash_bank_t
*get_flash_bank_by_num(int num
)
252 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
258 retval
= p
->driver
->auto_probe(p
);
260 if (retval
!= ERROR_OK
)
262 LOG_ERROR("auto_probe failed %d\n", retval
);
268 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
277 return ERROR_COMMAND_SYNTAX_ERROR
;
280 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
282 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
286 for (i
= 0; flash_drivers
[i
]; i
++)
288 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
292 /* register flash specific commands */
293 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
295 LOG_ERROR("couldn't register '%s' commands", args
[0]);
299 c
= malloc(sizeof(flash_bank_t
));
301 c
->driver
= flash_drivers
[i
];
302 c
->driver_priv
= NULL
;
303 c
->base
= strtoul(args
[1], NULL
, 0);
304 c
->size
= strtoul(args
[2], NULL
, 0);
305 c
->chip_width
= strtoul(args
[3], NULL
, 0);
306 c
->bus_width
= strtoul(args
[4], NULL
, 0);
311 if ((retval
=flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
)) != ERROR_OK
)
313 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
318 /* put flash bank in linked list */
321 /* find last flash bank */
322 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
335 /* no matching flash driver found */
338 LOG_ERROR("flash driver '%s' not found", args
[0]);
345 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
354 return ERROR_COMMAND_SYNTAX_ERROR
;
357 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
359 if (i
== strtoul(args
[0], NULL
, 0))
363 /* attempt auto probe */
364 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
367 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
368 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
369 for (j
= 0; j
< p
->num_sectors
; j
++)
373 if (p
->sectors
[j
].is_protected
== 0)
374 protect_state
= "not protected";
375 else if (p
->sectors
[j
].is_protected
== 1)
376 protect_state
= "protected";
378 protect_state
= "protection state unknown";
380 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
381 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
385 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
386 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
387 command_print(cmd_ctx
, "%s", buf
);
388 if (retval
!= ERROR_OK
)
389 LOG_ERROR("error retrieving flash info (%d)", retval
);
396 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
403 return ERROR_COMMAND_SYNTAX_ERROR
;
406 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
409 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
411 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
413 else if (retval
== ERROR_FLASH_BANK_INVALID
)
415 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
420 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
426 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
432 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
439 return ERROR_COMMAND_SYNTAX_ERROR
;
442 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
446 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
448 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
452 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
456 for (j
= 0; j
< p
->num_sectors
; j
++)
460 if (p
->sectors
[j
].is_erased
== 0)
461 erase_state
= "not erased";
462 else if (p
->sectors
[j
].is_erased
== 1)
463 erase_state
= "erased";
465 erase_state
= "erase state unknown";
467 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
468 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
477 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
486 target_t
*target
= get_current_target(cmd_ctx
);
490 return ERROR_COMMAND_SYNTAX_ERROR
;
493 address
= strtoul(args
[0], NULL
, 0);
494 length
= strtoul(args
[1], NULL
, 0);
497 command_print(cmd_ctx
, "Length must be >0");
498 return ERROR_COMMAND_SYNTAX_ERROR
;
501 p
= get_flash_bank_by_addr(target
, address
);
507 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
510 duration_start_measure(&duration
);
512 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
514 duration_stop_measure(&duration
, &duration_text
);
515 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
522 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
529 return ERROR_COMMAND_SYNTAX_ERROR
;
532 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
535 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
537 command_print(cmd_ctx
, "successfully checked protect state");
539 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
541 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
545 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
550 return ERROR_COMMAND_SYNTAX_ERROR
;
556 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
560 int first
= strtoul(args
[1], NULL
, 0);
561 int last
= strtoul(args
[2], NULL
, 0);
563 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
567 duration_start_measure(&duration
);
571 return ERROR_COMMAND_SYNTAX_ERROR
;
574 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
576 duration_stop_measure(&duration
, &duration_text
);
578 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
584 return ERROR_COMMAND_SYNTAX_ERROR
;
590 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
594 int first
= strtoul(args
[1], NULL
, 0);
595 int last
= strtoul(args
[2], NULL
, 0);
598 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
601 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
605 if (strcmp(args
[3], "on") == 0)
607 else if (strcmp(args
[3], "off") == 0)
611 return ERROR_COMMAND_SYNTAX_ERROR
;
614 retval
= flash_driver_protect(p
, set
, first
, last
);
615 if (retval
== ERROR_OK
)
617 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));
622 return ERROR_COMMAND_SYNTAX_ERROR
;
629 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
631 target_t
*target
= get_current_target(cmd_ctx
);
643 return ERROR_COMMAND_SYNTAX_ERROR
;
646 /* flash auto-erase is disabled by default*/
649 if (strcmp(args
[0], "erase")==0)
654 command_print(cmd_ctx
, "auto erase enabled");
660 return ERROR_COMMAND_SYNTAX_ERROR
;
665 LOG_ERROR("no target selected");
669 duration_start_measure(&duration
);
673 image
.base_address_set
= 1;
674 image
.base_address
= strtoul(args
[1], NULL
, 0);
678 image
.base_address_set
= 0;
679 image
.base_address
= 0x0;
682 image
.start_address_set
= 0;
684 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
685 if (retval
!= ERROR_OK
)
690 retval
= flash_write(target
, &image
, &written
, auto_erase
);
691 if (retval
!= ERROR_OK
)
697 duration_stop_measure(&duration
, &duration_text
);
698 if (retval
== ERROR_OK
)
700 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
701 written
, args
[0], duration_text
,
702 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
711 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
722 target_t
*target
= get_current_target(cmd_ctx
);
728 return ERROR_COMMAND_SYNTAX_ERROR
;
731 address
= strtoul(args
[0], NULL
, 0);
732 pattern
= strtoul(args
[1], NULL
, 0);
733 count
= strtoul(args
[2], NULL
, 0);
751 return ERROR_COMMAND_SYNTAX_ERROR
;
754 chunk_count
= MIN(count
, (1024 / wordsize
));
758 for(i
= 0; i
< chunk_count
; i
++)
760 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
764 for(i
= 0; i
< chunk_count
; i
++)
766 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
770 memset(chunk
, pattern
, chunk_count
);
773 LOG_ERROR("BUG: can't happen");
777 duration_start_measure(&duration
);
780 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
783 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
785 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
789 bank
= get_flash_bank_by_addr(target
, address
);
795 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
803 duration_stop_measure(&duration
, &duration_text
);
808 speed
=wrote
/ 1024.0;
809 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
810 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
811 count
*wordsize
, address
, duration_text
,
818 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
834 return ERROR_COMMAND_SYNTAX_ERROR
;
837 duration_start_measure(&duration
);
839 offset
= strtoul(args
[2], NULL
, 0);
840 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
843 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
847 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
852 buffer
= malloc(fileio
.size
);
853 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
856 fileio_close(&fileio
);
860 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
865 duration_stop_measure(&duration
, &duration_text
);
866 if (retval
!=ERROR_OK
)
868 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
869 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
870 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
874 fileio_close(&fileio
);
879 void flash_set_dirty(void)
884 /* set all flash to require erasing */
885 for (c
= flash_banks
; c
; c
= c
->next
)
887 for (i
= 0; i
< c
->num_sectors
; i
++)
889 c
->sectors
[i
].is_erased
= 0;
894 /* lookup flash bank by address */
895 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
899 /* cycle through bank list */
900 for (c
= flash_banks
; c
; c
= c
->next
)
903 retval
= c
->driver
->auto_probe(c
);
905 if (retval
!= ERROR_OK
)
907 LOG_ERROR("auto_probe failed %d\n", retval
);
910 /* check whether address belongs to this flash bank */
911 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
914 LOG_ERROR("No flash at address 0x%08x\n", addr
);
918 /* erase given flash region, selects proper bank according to target and address */
919 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
926 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
927 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
929 if (c
->size
== 0 || c
->num_sectors
== 0)
931 LOG_ERROR("Bank is invalid");
932 return ERROR_FLASH_BANK_INVALID
;
937 /* special case, erase whole bank when length is zero */
939 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
941 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
944 /* check whether it fits */
945 if (addr
+ length
> c
->base
+ c
->size
)
946 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
950 for (i
= 0; i
< c
->num_sectors
; i
++)
952 /* check whether sector overlaps with the given range and is not yet erased */
953 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
954 /* if first is not set yet then this is the first sector */
957 last
= i
; /* and it is the last one so far in any case */
961 if( first
== -1 || last
== -1 )
964 return flash_driver_erase(c
, first
, last
);
967 /* write (optional verify) an image to flash memory of the given target */
968 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
985 /* assume all sectors need erasing - stops any problems
986 * when flash_write is called multiple times */
991 /* allocate padding array */
992 padding
= malloc(image
->num_sections
* sizeof(padding
));
994 /* loop until we reach end of the image */
995 while (section
< image
->num_sections
)
1001 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
1002 u32 run_size
= image
->sections
[section
].size
- section_offset
;
1005 if (image
->sections
[section
].size
== 0)
1007 LOG_WARNING("empty section %d", section
);
1013 /* find the corresponding flash bank */
1014 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1016 section
++; /* and skip it */
1021 /* collect consecutive sections which fall into the same bank */
1022 section_first
= section
;
1023 section_last
= section
;
1024 padding
[section
] = 0;
1025 while ((run_address
+ run_size
< c
->base
+ c
->size
)
1026 && (section_last
+ 1 < image
->num_sections
))
1028 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1030 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1033 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1034 * attempt to rebuild a consecutive buffer for the flash loader */
1035 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1036 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1038 padding
[section_last
] = pad_bytes
;
1039 run_size
+= image
->sections
[++section_last
].size
;
1040 run_size
+= pad_bytes
;
1041 padding
[section_last
] = 0;
1043 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1046 /* fit the run into bank constraints */
1047 if (run_address
+ run_size
> c
->base
+ c
->size
)
1048 run_size
= c
->base
+ c
->size
- run_address
;
1050 /* allocate buffer */
1051 buffer
= malloc(run_size
);
1054 /* read sections to the buffer */
1055 while (buffer_size
< run_size
)
1059 size_read
= run_size
- buffer_size
;
1060 if (size_read
> image
->sections
[section
].size
- section_offset
)
1061 size_read
= image
->sections
[section
].size
- section_offset
;
1063 if ((retval
= image_read_section(image
, section
, section_offset
,
1064 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1071 /* see if we need to pad the section */
1072 while (padding
[section
]--)
1073 (buffer
+buffer_size
)[size_read
++] = 0xff;
1075 buffer_size
+= size_read
;
1076 section_offset
+= size_read
;
1078 if (section_offset
>= image
->sections
[section
].size
)
1089 /* calculate and erase sectors */
1090 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1093 if (retval
== ERROR_OK
)
1095 /* write flash sectors */
1096 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1101 if (retval
!= ERROR_OK
)
1104 return retval
; /* abort operation */
1107 if (written
!= NULL
)
1108 *written
+= run_size
; /* add run size to total written counter */
1116 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1118 target_t
*target
= bank
->target
;
1120 int buffer_size
= sizeof(buffer
);
1124 if (bank
->target
->state
!= TARGET_HALTED
)
1126 LOG_ERROR("Target not halted");
1127 return ERROR_TARGET_NOT_HALTED
;
1130 for (i
= 0; i
< bank
->num_sectors
; i
++)
1133 bank
->sectors
[i
].is_erased
= 1;
1135 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1139 chunk
= buffer_size
;
1140 if (chunk
> (j
- bank
->sectors
[i
].size
))
1142 chunk
= (j
- bank
->sectors
[i
].size
);
1145 retval
= target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1146 if (retval
!= ERROR_OK
)
1149 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1151 if (buffer
[nBytes
] != 0xFF)
1153 bank
->sectors
[i
].is_erased
= 0;
1163 int default_flash_blank_check(struct flash_bank_s
*bank
)
1165 target_t
*target
= bank
->target
;
1171 if (bank
->target
->state
!= TARGET_HALTED
)
1173 LOG_ERROR("Target not halted");
1174 return ERROR_TARGET_NOT_HALTED
;
1177 for (i
= 0; i
< bank
->num_sectors
; i
++)
1179 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1180 u32 size
= bank
->sectors
[i
].size
;
1182 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1188 bank
->sectors
[i
].is_erased
= 1;
1190 bank
->sectors
[i
].is_erased
= 0;
1196 LOG_USER("Running slow fallback erase check - add working memory");
1197 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)