1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
27 #include "time_support.h"
32 #include "algorithm.h"
33 #include "binarybuffer.h"
39 #include <sys/types.h>
46 extern Jim_Interp
*interp
;
49 /* command handlers */
50 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_flash_write_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
62 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
);
66 extern flash_driver_t lpc2000_flash
;
67 extern flash_driver_t cfi_flash
;
68 extern flash_driver_t at91sam7_flash
;
69 extern flash_driver_t str7x_flash
;
70 extern flash_driver_t str9x_flash
;
71 extern flash_driver_t stellaris_flash
;
72 extern flash_driver_t str9xpec_flash
;
73 extern flash_driver_t stm32x_flash
;
74 extern flash_driver_t tms470_flash
;
75 extern flash_driver_t ecosflash_flash
;
76 extern flash_driver_t lpc288x_flash
;
77 extern flash_driver_t ocl_flash
;
79 flash_driver_t
*flash_drivers
[] =
96 flash_bank_t
*flash_banks
;
97 static command_t
*flash_cmd
;
99 /* wafer thin wrapper for invoking the flash driver */
100 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
104 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
105 if (retval
!=ERROR_OK
)
107 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
113 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
117 retval
=bank
->driver
->erase(bank
, first
, last
);
118 if (retval
!=ERROR_OK
)
120 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
126 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
130 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
131 if (retval
!=ERROR_OK
)
133 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
139 int flash_register_commands(struct command_context_s
*cmd_ctx
)
141 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
143 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 ...]");
147 static int Jim_Command_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
150 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
161 Jim_Obj
*list
=Jim_NewListObj(interp
, NULL
, 0);
162 for (p
= flash_banks
; p
; p
= p
->next
)
164 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
);
187 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
191 Jim_CreateCommand(interp
, "openocd_flash_banks", Jim_Command_flash_banks
, NULL
, NULL
);
193 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
194 "print info about flash bank <num>");
195 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
196 "identify flash bank <num>");
197 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
198 "check erase state of sectors in flash bank <num>");
199 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
200 "check protection state of sectors in flash bank <num>");
201 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
202 "erase sectors at <bank> <first> <last>");
203 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
204 "erase address range <address> <length>");
206 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
207 "fill with pattern <address> <word_pattern> <count>");
208 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
209 "fill with pattern <address> <halfword_pattern> <count>");
210 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
211 "fill with pattern <address> <byte_pattern> <count>");
213 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
214 "write binary data to <bank> <file> <offset>");
215 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
216 "write_image [erase] <file> [offset] [type]");
217 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
218 "set protection of sectors at <bank> <first> <last> <on|off>");
224 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
229 for (p
= flash_banks
; p
; p
= p
->next
)
236 LOG_ERROR("flash bank %d does not exist", num
);
240 int flash_get_bank_count()
244 for (p
= flash_banks
; p
; p
= p
->next
)
251 flash_bank_t
*get_flash_bank_by_num(int num
)
253 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
259 retval
= p
->driver
->auto_probe(p
);
261 if (retval
!= ERROR_OK
)
263 LOG_ERROR("auto_probe failed %d\n", retval
);
269 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 (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
) && 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 if (buffer_size
- run_size
<= image
->sections
[section
].size
- section_offset
)
1060 size_read
= buffer_size
- run_size
;
1062 size_read
= image
->sections
[section
].size
- section_offset
;
1064 if ((retval
= image_read_section(image
, section
, section_offset
,
1065 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1072 /* see if we need to pad the section */
1073 while (padding
[section
]--)
1074 buffer
[size_read
++] = 0xff;
1076 buffer_size
+= size_read
;
1077 section_offset
+= size_read
;
1079 if (section_offset
>= image
->sections
[section
].size
)
1090 /* calculate and erase sectors */
1091 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1094 if (retval
== ERROR_OK
)
1096 /* write flash sectors */
1097 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1102 if (retval
!= ERROR_OK
)
1105 return retval
; /* abort operation */
1108 if (written
!= NULL
)
1109 *written
+= run_size
; /* add run size to total written counter */
1117 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1119 target_t
*target
= bank
->target
;
1121 int buffer_size
= sizeof(buffer
);
1125 if (bank
->target
->state
!= TARGET_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 return ERROR_TARGET_NOT_HALTED
;
1176 for (i
= 0; i
< bank
->num_sectors
; i
++)
1178 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1179 u32 size
= bank
->sectors
[i
].size
;
1181 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1187 bank
->sectors
[i
].is_erased
= 1;
1189 bank
->sectors
[i
].is_erased
= 0;
1195 LOG_USER("Running slow fallback erase check - add working memory");
1196 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)