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 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
30 #include "time_support.h"
35 #include "algorithm.h"
36 #include "binarybuffer.h"
42 #include <sys/types.h>
47 /* command handlers */
48 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
49 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
50 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_flash_write_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
);
64 extern flash_driver_t lpc2000_flash
;
65 extern flash_driver_t cfi_flash
;
66 extern flash_driver_t at91sam7_flash
;
67 extern flash_driver_t str7x_flash
;
68 extern flash_driver_t str9x_flash
;
69 extern flash_driver_t stellaris_flash
;
70 extern flash_driver_t str9xpec_flash
;
71 extern flash_driver_t stm32x_flash
;
72 extern flash_driver_t tms470_flash
;
73 extern flash_driver_t ecosflash_flash
;
74 extern flash_driver_t lpc288x_flash
;
75 extern flash_driver_t ocl_flash
;
77 flash_driver_t
*flash_drivers
[] =
94 flash_bank_t
*flash_banks
;
95 static command_t
*flash_cmd
;
97 /* wafer thin wrapper for invoking the flash driver */
98 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
102 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
103 if (retval
!=ERROR_OK
)
105 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
111 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
115 retval
=bank
->driver
->erase(bank
, first
, last
);
116 if (retval
!=ERROR_OK
)
118 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
124 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
128 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
129 if (retval
!=ERROR_OK
)
131 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
137 int flash_register_commands(struct command_context_s
*cmd_ctx
)
139 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
141 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 ...]");
145 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
150 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
159 Jim_Obj
*list
=Jim_NewListObj(interp
, NULL
, 0);
160 for (p
= flash_banks
; p
; p
= p
->next
)
162 Jim_Obj
*elem
=Jim_NewListObj(interp
, NULL
, 0);
164 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
165 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
166 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
167 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
168 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
169 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
170 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
171 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
172 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
173 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
175 Jim_ListAppendElement(interp
, list
, elem
);
178 Jim_SetResult(interp
, list
);
183 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
187 register_jim(cmd_ctx
, "ocd_flash_banks", jim_flash_banks
, "return information about the flash banks");
189 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
190 "print info about flash bank <num>");
191 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
192 "identify flash bank <num>");
193 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
194 "check erase state of sectors in flash bank <num>");
195 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
196 "check protection state of sectors in flash bank <num>");
197 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
198 "erase sectors at <bank> <first> <last>");
199 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
200 "erase address range <address> <length>");
202 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
203 "fill with pattern <address> <word_pattern> <count>");
204 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
205 "fill with pattern <address> <halfword_pattern> <count>");
206 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
207 "fill with pattern <address> <byte_pattern> <count>");
209 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
210 "write binary data to <bank> <file> <offset>");
211 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
212 "write_image [erase] <file> [offset] [type]");
213 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
214 "set protection of sectors at <bank> <first> <last> <on|off>");
220 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
225 for (p
= flash_banks
; p
; p
= p
->next
)
232 LOG_ERROR("flash bank %d does not exist", num
);
236 int flash_get_bank_count(void)
240 for (p
= flash_banks
; p
; p
= p
->next
)
247 flash_bank_t
*get_flash_bank_by_num(int num
)
249 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
255 retval
= p
->driver
->auto_probe(p
);
257 if (retval
!= ERROR_OK
)
259 LOG_ERROR("auto_probe failed %d\n", retval
);
265 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
274 return ERROR_COMMAND_SYNTAX_ERROR
;
277 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
279 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
283 for (i
= 0; flash_drivers
[i
]; i
++)
285 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
289 /* register flash specific commands */
290 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
292 LOG_ERROR("couldn't register '%s' commands", args
[0]);
296 c
= malloc(sizeof(flash_bank_t
));
298 c
->driver
= flash_drivers
[i
];
299 c
->driver_priv
= NULL
;
300 c
->base
= strtoul(args
[1], NULL
, 0);
301 c
->size
= strtoul(args
[2], NULL
, 0);
302 c
->chip_width
= strtoul(args
[3], NULL
, 0);
303 c
->bus_width
= strtoul(args
[4], NULL
, 0);
308 if ((retval
=flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
)) != ERROR_OK
)
310 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
315 /* put flash bank in linked list */
318 /* find last flash bank */
319 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
332 /* no matching flash driver found */
335 LOG_ERROR("flash driver '%s' not found", args
[0]);
342 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
351 return ERROR_COMMAND_SYNTAX_ERROR
;
354 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
356 if (i
== strtoul(args
[0], NULL
, 0))
360 /* attempt auto probe */
361 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
364 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
365 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
366 for (j
= 0; j
< p
->num_sectors
; j
++)
370 if (p
->sectors
[j
].is_protected
== 0)
371 protect_state
= "not protected";
372 else if (p
->sectors
[j
].is_protected
== 1)
373 protect_state
= "protected";
375 protect_state
= "protection state unknown";
377 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
378 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
382 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
383 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
384 command_print(cmd_ctx
, "%s", buf
);
385 if (retval
!= ERROR_OK
)
386 LOG_ERROR("error retrieving flash info (%d)", retval
);
393 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
400 return ERROR_COMMAND_SYNTAX_ERROR
;
403 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
406 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
408 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
410 else if (retval
== ERROR_FLASH_BANK_INVALID
)
412 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
417 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
423 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
429 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
436 return ERROR_COMMAND_SYNTAX_ERROR
;
439 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
443 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
445 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
449 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
453 for (j
= 0; j
< p
->num_sectors
; j
++)
457 if (p
->sectors
[j
].is_erased
== 0)
458 erase_state
= "not erased";
459 else if (p
->sectors
[j
].is_erased
== 1)
460 erase_state
= "erased";
462 erase_state
= "erase state unknown";
464 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
465 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
474 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
483 target_t
*target
= get_current_target(cmd_ctx
);
487 return ERROR_COMMAND_SYNTAX_ERROR
;
490 address
= strtoul(args
[0], NULL
, 0);
491 length
= strtoul(args
[1], NULL
, 0);
494 command_print(cmd_ctx
, "Length must be >0");
495 return ERROR_COMMAND_SYNTAX_ERROR
;
498 p
= get_flash_bank_by_addr(target
, address
);
504 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
507 duration_start_measure(&duration
);
509 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
511 duration_stop_measure(&duration
, &duration_text
);
512 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
519 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
526 return ERROR_COMMAND_SYNTAX_ERROR
;
529 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
532 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
534 command_print(cmd_ctx
, "successfully checked protect state");
536 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
538 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
542 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
547 return ERROR_COMMAND_SYNTAX_ERROR
;
553 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
557 int first
= strtoul(args
[1], NULL
, 0);
558 int last
= strtoul(args
[2], NULL
, 0);
560 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
564 duration_start_measure(&duration
);
568 return ERROR_COMMAND_SYNTAX_ERROR
;
571 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
573 duration_stop_measure(&duration
, &duration_text
);
575 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
581 return ERROR_COMMAND_SYNTAX_ERROR
;
587 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
591 int first
= strtoul(args
[1], NULL
, 0);
592 int last
= strtoul(args
[2], NULL
, 0);
595 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
598 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
602 if (strcmp(args
[3], "on") == 0)
604 else if (strcmp(args
[3], "off") == 0)
608 return ERROR_COMMAND_SYNTAX_ERROR
;
611 retval
= flash_driver_protect(p
, set
, first
, last
);
612 if (retval
== ERROR_OK
)
614 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));
619 return ERROR_COMMAND_SYNTAX_ERROR
;
626 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
628 target_t
*target
= get_current_target(cmd_ctx
);
640 return ERROR_COMMAND_SYNTAX_ERROR
;
643 /* flash auto-erase is disabled by default*/
646 if (strcmp(args
[0], "erase")==0)
651 command_print(cmd_ctx
, "auto erase enabled");
657 return ERROR_COMMAND_SYNTAX_ERROR
;
662 LOG_ERROR("no target selected");
666 duration_start_measure(&duration
);
670 image
.base_address_set
= 1;
671 image
.base_address
= strtoul(args
[1], NULL
, 0);
675 image
.base_address_set
= 0;
676 image
.base_address
= 0x0;
679 image
.start_address_set
= 0;
681 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
682 if (retval
!= ERROR_OK
)
687 retval
= flash_write(target
, &image
, &written
, auto_erase
);
688 if (retval
!= ERROR_OK
)
694 duration_stop_measure(&duration
, &duration_text
);
695 if (retval
== ERROR_OK
)
697 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
698 written
, args
[0], duration_text
,
699 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
708 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
719 target_t
*target
= get_current_target(cmd_ctx
);
725 return ERROR_COMMAND_SYNTAX_ERROR
;
728 address
= strtoul(args
[0], NULL
, 0);
729 pattern
= strtoul(args
[1], NULL
, 0);
730 count
= strtoul(args
[2], NULL
, 0);
748 return ERROR_COMMAND_SYNTAX_ERROR
;
751 chunk_count
= MIN(count
, (1024 / wordsize
));
755 for(i
= 0; i
< chunk_count
; i
++)
757 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
761 for(i
= 0; i
< chunk_count
; i
++)
763 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
767 memset(chunk
, pattern
, chunk_count
);
770 LOG_ERROR("BUG: can't happen");
774 duration_start_measure(&duration
);
777 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
780 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
782 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
786 bank
= get_flash_bank_by_addr(target
, address
);
792 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
800 duration_stop_measure(&duration
, &duration_text
);
805 speed
=wrote
/ 1024.0;
806 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
807 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
808 count
*wordsize
, address
, duration_text
,
815 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
831 return ERROR_COMMAND_SYNTAX_ERROR
;
834 duration_start_measure(&duration
);
836 offset
= strtoul(args
[2], NULL
, 0);
837 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
840 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
844 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
849 buffer
= malloc(fileio
.size
);
850 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
853 fileio_close(&fileio
);
857 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
862 duration_stop_measure(&duration
, &duration_text
);
863 if (retval
!=ERROR_OK
)
865 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
866 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
867 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
871 fileio_close(&fileio
);
876 void flash_set_dirty(void)
881 /* set all flash to require erasing */
882 for (c
= flash_banks
; c
; c
= c
->next
)
884 for (i
= 0; i
< c
->num_sectors
; i
++)
886 c
->sectors
[i
].is_erased
= 0;
891 /* lookup flash bank by address */
892 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
896 /* cycle through bank list */
897 for (c
= flash_banks
; c
; c
= c
->next
)
900 retval
= c
->driver
->auto_probe(c
);
902 if (retval
!= ERROR_OK
)
904 LOG_ERROR("auto_probe failed %d\n", retval
);
907 /* check whether address belongs to this flash bank */
908 if ((addr
>= c
->base
) && (addr
< c
->base
+ c
->size
) && target
== c
->target
)
911 LOG_ERROR("No flash at address 0x%08x\n", addr
);
915 /* erase given flash region, selects proper bank according to target and address */
916 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
923 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
924 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
926 if (c
->size
== 0 || c
->num_sectors
== 0)
928 LOG_ERROR("Bank is invalid");
929 return ERROR_FLASH_BANK_INVALID
;
934 /* special case, erase whole bank when length is zero */
936 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
938 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
941 /* check whether it fits */
942 if (addr
+ length
> c
->base
+ c
->size
)
943 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
947 for (i
= 0; i
< c
->num_sectors
; i
++)
949 /* check whether sector overlaps with the given range and is not yet erased */
950 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
951 /* if first is not set yet then this is the first sector */
954 last
= i
; /* and it is the last one so far in any case */
958 if( first
== -1 || last
== -1 )
961 return flash_driver_erase(c
, first
, last
);
964 /* write (optional verify) an image to flash memory of the given target */
965 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
982 /* assume all sectors need erasing - stops any problems
983 * when flash_write is called multiple times */
988 /* allocate padding array */
989 padding
= malloc(image
->num_sections
* sizeof(padding
));
991 /* loop until we reach end of the image */
992 while (section
< image
->num_sections
)
998 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
999 u32 run_size
= image
->sections
[section
].size
- section_offset
;
1002 if (image
->sections
[section
].size
== 0)
1004 LOG_WARNING("empty section %d", section
);
1010 /* find the corresponding flash bank */
1011 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1013 section
++; /* and skip it */
1018 /* collect consecutive sections which fall into the same bank */
1019 section_first
= section
;
1020 section_last
= section
;
1021 padding
[section
] = 0;
1022 while ((run_address
+ run_size
< c
->base
+ c
->size
)
1023 && (section_last
+ 1 < image
->num_sections
))
1025 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1027 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1030 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1031 * attempt to rebuild a consecutive buffer for the flash loader */
1032 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1033 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1035 padding
[section_last
] = pad_bytes
;
1036 run_size
+= image
->sections
[++section_last
].size
;
1037 run_size
+= pad_bytes
;
1038 padding
[section_last
] = 0;
1040 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1043 /* fit the run into bank constraints */
1044 if (run_address
+ run_size
> c
->base
+ c
->size
)
1045 run_size
= c
->base
+ c
->size
- run_address
;
1047 /* allocate buffer */
1048 buffer
= malloc(run_size
);
1051 /* read sections to the buffer */
1052 while (buffer_size
< run_size
)
1056 size_read
= run_size
- buffer_size
;
1057 if (size_read
> image
->sections
[section
].size
- section_offset
)
1058 size_read
= image
->sections
[section
].size
- section_offset
;
1060 if ((retval
= image_read_section(image
, section
, section_offset
,
1061 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1068 /* see if we need to pad the section */
1069 while (padding
[section
]--)
1070 (buffer
+buffer_size
)[size_read
++] = 0xff;
1072 buffer_size
+= size_read
;
1073 section_offset
+= size_read
;
1075 if (section_offset
>= image
->sections
[section
].size
)
1086 /* calculate and erase sectors */
1087 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1090 if (retval
== ERROR_OK
)
1092 /* write flash sectors */
1093 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1098 if (retval
!= ERROR_OK
)
1101 return retval
; /* abort operation */
1104 if (written
!= NULL
)
1105 *written
+= run_size
; /* add run size to total written counter */
1113 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1115 target_t
*target
= bank
->target
;
1117 int buffer_size
= sizeof(buffer
);
1121 if (bank
->target
->state
!= TARGET_HALTED
)
1123 LOG_ERROR("Target not halted");
1124 return ERROR_TARGET_NOT_HALTED
;
1127 for (i
= 0; i
< bank
->num_sectors
; i
++)
1130 bank
->sectors
[i
].is_erased
= 1;
1132 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1136 chunk
= buffer_size
;
1137 if (chunk
> (j
- bank
->sectors
[i
].size
))
1139 chunk
= (j
- bank
->sectors
[i
].size
);
1142 retval
= target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1143 if (retval
!= ERROR_OK
)
1146 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1148 if (buffer
[nBytes
] != 0xFF)
1150 bank
->sectors
[i
].is_erased
= 0;
1160 int default_flash_blank_check(struct flash_bank_s
*bank
)
1162 target_t
*target
= bank
->target
;
1168 if (bank
->target
->state
!= TARGET_HALTED
)
1170 LOG_ERROR("Target not halted");
1171 return ERROR_TARGET_NOT_HALTED
;
1174 for (i
= 0; i
< bank
->num_sectors
; i
++)
1176 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1177 u32 size
= bank
->sectors
[i
].size
;
1179 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1185 bank
->sectors
[i
].is_erased
= 1;
1187 bank
->sectors
[i
].is_erased
= 0;
1193 LOG_USER("Running slow fallback erase check - add working memory");
1194 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)