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>
45 extern Jim_Interp
*interp
;
48 /* command handlers */
49 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
50 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_flash_write_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
);
65 extern flash_driver_t lpc2000_flash
;
66 extern flash_driver_t cfi_flash
;
67 extern flash_driver_t at91sam7_flash
;
68 extern flash_driver_t str7x_flash
;
69 extern flash_driver_t str9x_flash
;
70 extern flash_driver_t stellaris_flash
;
71 extern flash_driver_t str9xpec_flash
;
72 extern flash_driver_t stm32x_flash
;
73 extern flash_driver_t tms470_flash
;
74 extern flash_driver_t ecosflash_flash
;
75 extern flash_driver_t lpc288x_flash
;
76 extern flash_driver_t ocl_flash
;
78 flash_driver_t
*flash_drivers
[] =
95 flash_bank_t
*flash_banks
;
96 static command_t
*flash_cmd
;
98 /* wafer thin wrapper for invoking the flash driver */
99 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
103 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
104 if (retval
!=ERROR_OK
)
106 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
112 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
116 retval
=bank
->driver
->erase(bank
, first
, last
);
117 if (retval
!=ERROR_OK
)
119 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
125 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
129 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
130 if (retval
!=ERROR_OK
)
132 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
138 int flash_register_commands(struct command_context_s
*cmd_ctx
)
140 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
142 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 ...]");
146 static int Jim_Command_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
149 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);
166 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
167 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
168 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
169 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
170 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
171 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
172 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
173 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
174 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
175 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
177 Jim_ListAppendElement(interp
, list
, elem
);
180 Jim_SetResult(interp
, list
);
186 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
190 Jim_CreateCommand(interp
, "openocd_flash_banks", Jim_Command_flash_banks
, NULL
, NULL
);
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()
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
)
276 return ERROR_COMMAND_SYNTAX_ERROR
;
279 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
281 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
285 for (i
= 0; flash_drivers
[i
]; i
++)
287 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
291 /* register flash specific commands */
292 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
294 LOG_ERROR("couldn't register '%s' commands", args
[0]);
298 c
= malloc(sizeof(flash_bank_t
));
300 c
->driver
= flash_drivers
[i
];
301 c
->driver_priv
= NULL
;
302 c
->base
= strtoul(args
[1], NULL
, 0);
303 c
->size
= strtoul(args
[2], NULL
, 0);
304 c
->chip_width
= strtoul(args
[3], NULL
, 0);
305 c
->bus_width
= strtoul(args
[4], NULL
, 0);
310 if (flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
) != ERROR_OK
)
312 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
317 /* put flash bank in linked list */
320 /* find last flash bank */
321 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
334 /* no matching flash driver found */
337 LOG_ERROR("flash driver '%s' not found", args
[0]);
344 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
353 return ERROR_COMMAND_SYNTAX_ERROR
;
356 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
358 if (i
== strtoul(args
[0], NULL
, 0))
362 /* attempt auto probe */
363 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
366 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
367 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
368 for (j
= 0; j
< p
->num_sectors
; j
++)
372 if (p
->sectors
[j
].is_protected
== 0)
373 protect_state
= "not protected";
374 else if (p
->sectors
[j
].is_protected
== 1)
375 protect_state
= "protected";
377 protect_state
= "protection state unknown";
379 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
380 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
384 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
385 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
386 command_print(cmd_ctx
, "%s", buf
);
387 if (retval
!= ERROR_OK
)
388 LOG_ERROR("error retrieving flash info (%d)", retval
);
395 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
402 return ERROR_COMMAND_SYNTAX_ERROR
;
405 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
408 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
410 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
412 else if (retval
== ERROR_FLASH_BANK_INVALID
)
414 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
419 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
425 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
431 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
438 return ERROR_COMMAND_SYNTAX_ERROR
;
441 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
445 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
447 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
451 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
455 for (j
= 0; j
< p
->num_sectors
; j
++)
459 if (p
->sectors
[j
].is_erased
== 0)
460 erase_state
= "not erased";
461 else if (p
->sectors
[j
].is_erased
== 1)
462 erase_state
= "erased";
464 erase_state
= "erase state unknown";
466 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
467 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
476 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
485 target_t
*target
= get_current_target(cmd_ctx
);
489 return ERROR_COMMAND_SYNTAX_ERROR
;
492 address
= strtoul(args
[0], NULL
, 0);
493 length
= strtoul(args
[1], NULL
, 0);
496 command_print(cmd_ctx
, "Length must be >0");
497 return ERROR_COMMAND_SYNTAX_ERROR
;
500 p
= get_flash_bank_by_addr(target
, address
);
506 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
509 duration_start_measure(&duration
);
511 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
513 duration_stop_measure(&duration
, &duration_text
);
514 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
521 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
528 return ERROR_COMMAND_SYNTAX_ERROR
;
531 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
534 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
536 command_print(cmd_ctx
, "successfully checked protect state");
538 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
540 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
544 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
549 return ERROR_COMMAND_SYNTAX_ERROR
;
555 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
559 int first
= strtoul(args
[1], NULL
, 0);
560 int last
= strtoul(args
[2], NULL
, 0);
562 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
566 duration_start_measure(&duration
);
570 return ERROR_COMMAND_SYNTAX_ERROR
;
573 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
575 duration_stop_measure(&duration
, &duration_text
);
577 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
583 return ERROR_COMMAND_SYNTAX_ERROR
;
589 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
593 int first
= strtoul(args
[1], NULL
, 0);
594 int last
= strtoul(args
[2], NULL
, 0);
597 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
600 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
604 if (strcmp(args
[3], "on") == 0)
606 else if (strcmp(args
[3], "off") == 0)
610 return ERROR_COMMAND_SYNTAX_ERROR
;
613 retval
= flash_driver_protect(p
, set
, first
, last
);
614 if (retval
== ERROR_OK
)
616 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));
621 return ERROR_COMMAND_SYNTAX_ERROR
;
628 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
630 target_t
*target
= get_current_target(cmd_ctx
);
642 return ERROR_COMMAND_SYNTAX_ERROR
;
645 /* flash auto-erase is disabled by default*/
648 if (strcmp(args
[0], "erase")==0)
653 command_print(cmd_ctx
, "auto erase enabled");
659 return ERROR_COMMAND_SYNTAX_ERROR
;
664 LOG_ERROR("no target selected");
668 duration_start_measure(&duration
);
672 image
.base_address_set
= 1;
673 image
.base_address
= strtoul(args
[1], NULL
, 0);
677 image
.base_address_set
= 0;
678 image
.base_address
= 0x0;
681 image
.start_address_set
= 0;
683 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
684 if (retval
!= ERROR_OK
)
689 retval
= flash_write(target
, &image
, &written
, auto_erase
);
690 if (retval
!= ERROR_OK
)
696 duration_stop_measure(&duration
, &duration_text
);
697 if (retval
== ERROR_OK
)
699 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
700 written
, args
[0], duration_text
,
701 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
710 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
721 target_t
*target
= get_current_target(cmd_ctx
);
727 return ERROR_COMMAND_SYNTAX_ERROR
;
730 address
= strtoul(args
[0], NULL
, 0);
731 pattern
= strtoul(args
[1], NULL
, 0);
732 count
= strtoul(args
[2], NULL
, 0);
750 return ERROR_COMMAND_SYNTAX_ERROR
;
753 chunk_count
= MIN(count
, (1024 / wordsize
));
757 for(i
= 0; i
< chunk_count
; i
++)
759 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
763 for(i
= 0; i
< chunk_count
; i
++)
765 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
769 memset(chunk
, pattern
, chunk_count
);
772 LOG_ERROR("BUG: can't happen");
776 duration_start_measure(&duration
);
779 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
782 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
784 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
788 bank
= get_flash_bank_by_addr(target
, address
);
794 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
802 duration_stop_measure(&duration
, &duration_text
);
807 speed
=wrote
/ 1024.0;
808 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
809 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
810 count
*wordsize
, address
, duration_text
,
817 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
833 return ERROR_COMMAND_SYNTAX_ERROR
;
836 duration_start_measure(&duration
);
838 offset
= strtoul(args
[2], NULL
, 0);
839 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
842 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
846 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
851 buffer
= malloc(fileio
.size
);
852 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
855 fileio_close(&fileio
);
859 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
864 duration_stop_measure(&duration
, &duration_text
);
865 if (retval
!=ERROR_OK
)
867 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
868 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
869 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
873 fileio_close(&fileio
);
878 void flash_set_dirty(void)
883 /* set all flash to require erasing */
884 for (c
= flash_banks
; c
; c
= c
->next
)
886 for (i
= 0; i
< c
->num_sectors
; i
++)
888 c
->sectors
[i
].is_erased
= 0;
893 /* lookup flash bank by address */
894 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
898 /* cycle through bank list */
899 for (c
= flash_banks
; c
; c
= c
->next
)
902 retval
= c
->driver
->auto_probe(c
);
904 if (retval
!= ERROR_OK
)
906 LOG_ERROR("auto_probe failed %d\n", retval
);
909 /* check whether address belongs to this flash bank */
910 if ((addr
>= c
->base
) && (addr
< c
->base
+ c
->size
) && target
== c
->target
)
913 LOG_ERROR("No flash at address 0x%08x\n", addr
);
917 /* erase given flash region, selects proper bank according to target and address */
918 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
925 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
926 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
928 if (c
->size
== 0 || c
->num_sectors
== 0)
930 LOG_ERROR("Bank is invalid");
931 return ERROR_FLASH_BANK_INVALID
;
936 /* special case, erase whole bank when length is zero */
938 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
940 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
943 /* check whether it fits */
944 if (addr
+ length
> c
->base
+ c
->size
)
945 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
949 for (i
= 0; i
< c
->num_sectors
; i
++)
951 /* check whether sector overlaps with the given range and is not yet erased */
952 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
953 /* if first is not set yet then this is the first sector */
956 last
= i
; /* and it is the last one so far in any case */
960 if( first
== -1 || last
== -1 )
963 return flash_driver_erase(c
, first
, last
);
966 /* write (optional verify) an image to flash memory of the given target */
967 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
984 /* assume all sectors need erasing - stops any problems
985 * when flash_write is called multiple times */
990 /* allocate padding array */
991 padding
= malloc(image
->num_sections
* sizeof(padding
));
993 /* loop until we reach end of the image */
994 while (section
< image
->num_sections
)
1000 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
1001 u32 run_size
= image
->sections
[section
].size
- section_offset
;
1004 if (image
->sections
[section
].size
== 0)
1006 LOG_WARNING("empty section %d", section
);
1012 /* find the corresponding flash bank */
1013 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1015 section
++; /* and skip it */
1020 /* collect consecutive sections which fall into the same bank */
1021 section_first
= section
;
1022 section_last
= section
;
1023 padding
[section
] = 0;
1024 while ((run_address
+ run_size
< c
->base
+ c
->size
)
1025 && (section_last
+ 1 < image
->num_sections
))
1027 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1029 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1032 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1033 * attempt to rebuild a consecutive buffer for the flash loader */
1034 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1035 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1037 padding
[section_last
] = pad_bytes
;
1038 run_size
+= image
->sections
[++section_last
].size
;
1039 run_size
+= pad_bytes
;
1040 padding
[section_last
] = 0;
1042 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1045 /* fit the run into bank constraints */
1046 if (run_address
+ run_size
> c
->base
+ c
->size
)
1047 run_size
= c
->base
+ c
->size
- run_address
;
1049 /* allocate buffer */
1050 buffer
= malloc(run_size
);
1053 /* read sections to the buffer */
1054 while (buffer_size
< run_size
)
1058 if (buffer_size
- run_size
<= image
->sections
[section
].size
- section_offset
)
1059 size_read
= buffer_size
- run_size
;
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
[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 return ERROR_TARGET_NOT_HALTED
;
1129 for (i
= 0; i
< bank
->num_sectors
; i
++)
1132 bank
->sectors
[i
].is_erased
= 1;
1134 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1138 chunk
= buffer_size
;
1139 if (chunk
> (j
- bank
->sectors
[i
].size
))
1141 chunk
= (j
- bank
->sectors
[i
].size
);
1144 retval
= target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1145 if (retval
!= ERROR_OK
)
1148 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1150 if (buffer
[nBytes
] != 0xFF)
1152 bank
->sectors
[i
].is_erased
= 0;
1162 int default_flash_blank_check(struct flash_bank_s
*bank
)
1164 target_t
*target
= bank
->target
;
1170 if (bank
->target
->state
!= TARGET_HALTED
)
1172 return ERROR_TARGET_NOT_HALTED
;
1175 for (i
= 0; i
< bank
->num_sectors
; i
++)
1177 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1178 u32 size
= bank
->sectors
[i
].size
;
1180 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1186 bank
->sectors
[i
].is_erased
= 1;
1188 bank
->sectors
[i
].is_erased
= 0;
1194 LOG_USER("Running slow fallback erase check - add working memory");
1195 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)