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
, p
->driver
->name
, -1));
168 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
169 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
170 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
171 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
173 Jim_ListAppendElement(interp
, list
, elem
);
176 Jim_SetResult(interp
, list
);
182 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
186 Jim_CreateCommand(interp
, "flash_banks", Jim_Command_flash_banks
, NULL
, NULL
);
188 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
189 "print info about flash bank <num>");
190 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
191 "identify flash bank <num>");
192 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
193 "check erase state of sectors in flash bank <num>");
194 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
195 "check protection state of sectors in flash bank <num>");
196 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
197 "erase sectors at <bank> <first> <last>");
198 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
199 "erase address range <address> <length>");
201 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
202 "fill with pattern <address> <word_pattern> <count>");
203 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
204 "fill with pattern <address> <halfword_pattern> <count>");
205 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
206 "fill with pattern <address> <byte_pattern> <count>");
208 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
209 "write binary data to <bank> <file> <offset>");
210 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
211 "write_image [erase] <file> [offset] [type]");
212 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
213 "set protection of sectors at <bank> <first> <last> <on|off>");
219 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
224 for (p
= flash_banks
; p
; p
= p
->next
)
231 LOG_ERROR("flash bank %d does not exist", num
);
235 int flash_get_bank_count()
239 for (p
= flash_banks
; p
; p
= p
->next
)
246 flash_bank_t
*get_flash_bank_by_num(int num
)
248 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
254 retval
= p
->driver
->auto_probe(p
);
256 if (retval
!= ERROR_OK
)
258 LOG_ERROR("auto_probe failed %d\n", retval
);
264 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
272 return ERROR_COMMAND_SYNTAX_ERROR
;
275 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
277 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
281 for (i
= 0; flash_drivers
[i
]; i
++)
283 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
287 /* register flash specific commands */
288 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
290 LOG_ERROR("couldn't register '%s' commands", args
[0]);
294 c
= malloc(sizeof(flash_bank_t
));
296 c
->driver
= flash_drivers
[i
];
297 c
->driver_priv
= NULL
;
298 c
->base
= strtoul(args
[1], NULL
, 0);
299 c
->size
= strtoul(args
[2], NULL
, 0);
300 c
->chip_width
= strtoul(args
[3], NULL
, 0);
301 c
->bus_width
= strtoul(args
[4], NULL
, 0);
306 if (flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
) != ERROR_OK
)
308 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
313 /* put flash bank in linked list */
316 /* find last flash bank */
317 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
330 /* no matching flash driver found */
333 LOG_ERROR("flash driver '%s' not found", args
[0]);
340 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
349 return ERROR_COMMAND_SYNTAX_ERROR
;
352 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
354 if (i
== strtoul(args
[0], NULL
, 0))
358 /* attempt auto probe */
359 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
362 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
363 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
364 for (j
= 0; j
< p
->num_sectors
; j
++)
368 if (p
->sectors
[j
].is_protected
== 0)
369 protect_state
= "not protected";
370 else if (p
->sectors
[j
].is_protected
== 1)
371 protect_state
= "protected";
373 protect_state
= "protection state unknown";
375 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
376 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
380 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
381 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
382 command_print(cmd_ctx
, "%s", buf
);
383 if (retval
!= ERROR_OK
)
384 LOG_ERROR("error retrieving flash info (%d)", retval
);
391 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
398 return ERROR_COMMAND_SYNTAX_ERROR
;
401 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
404 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
406 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
408 else if (retval
== ERROR_FLASH_BANK_INVALID
)
410 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
415 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
421 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
427 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
434 return ERROR_COMMAND_SYNTAX_ERROR
;
437 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
441 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
443 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
447 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
451 for (j
= 0; j
< p
->num_sectors
; j
++)
455 if (p
->sectors
[j
].is_erased
== 0)
456 erase_state
= "not erased";
457 else if (p
->sectors
[j
].is_erased
== 1)
458 erase_state
= "erased";
460 erase_state
= "erase state unknown";
462 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
463 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
472 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
481 target_t
*target
= get_current_target(cmd_ctx
);
485 return ERROR_COMMAND_SYNTAX_ERROR
;
488 address
= strtoul(args
[0], NULL
, 0);
489 length
= strtoul(args
[1], NULL
, 0);
492 command_print(cmd_ctx
, "Length must be >0");
493 return ERROR_COMMAND_SYNTAX_ERROR
;
496 p
= get_flash_bank_by_addr(target
, address
);
502 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
505 duration_start_measure(&duration
);
507 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
509 duration_stop_measure(&duration
, &duration_text
);
510 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
517 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
524 return ERROR_COMMAND_SYNTAX_ERROR
;
527 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
530 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
532 command_print(cmd_ctx
, "successfully checked protect state");
534 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
536 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
540 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
545 return ERROR_COMMAND_SYNTAX_ERROR
;
551 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
555 int first
= strtoul(args
[1], NULL
, 0);
556 int last
= strtoul(args
[2], NULL
, 0);
558 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
562 duration_start_measure(&duration
);
566 return ERROR_COMMAND_SYNTAX_ERROR
;
569 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
571 duration_stop_measure(&duration
, &duration_text
);
573 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
579 return ERROR_COMMAND_SYNTAX_ERROR
;
585 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
589 int first
= strtoul(args
[1], NULL
, 0);
590 int last
= strtoul(args
[2], NULL
, 0);
593 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
596 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
600 if (strcmp(args
[3], "on") == 0)
602 else if (strcmp(args
[3], "off") == 0)
606 return ERROR_COMMAND_SYNTAX_ERROR
;
609 retval
= flash_driver_protect(p
, set
, first
, last
);
610 if (retval
== ERROR_OK
)
612 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));
617 return ERROR_COMMAND_SYNTAX_ERROR
;
624 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
626 target_t
*target
= get_current_target(cmd_ctx
);
638 return ERROR_COMMAND_SYNTAX_ERROR
;
641 /* flash auto-erase is disabled by default*/
644 if (strcmp(args
[0], "erase")==0)
649 command_print(cmd_ctx
, "auto erase enabled");
655 return ERROR_COMMAND_SYNTAX_ERROR
;
660 LOG_ERROR("no target selected");
664 duration_start_measure(&duration
);
668 image
.base_address_set
= 1;
669 image
.base_address
= strtoul(args
[1], NULL
, 0);
673 image
.base_address_set
= 0;
674 image
.base_address
= 0x0;
677 image
.start_address_set
= 0;
679 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
680 if (retval
!= ERROR_OK
)
685 retval
= flash_write(target
, &image
, &written
, auto_erase
);
686 if (retval
!= ERROR_OK
)
692 duration_stop_measure(&duration
, &duration_text
);
693 if (retval
== ERROR_OK
)
695 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
696 written
, args
[0], duration_text
,
697 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
706 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
717 target_t
*target
= get_current_target(cmd_ctx
);
723 return ERROR_COMMAND_SYNTAX_ERROR
;
726 address
= strtoul(args
[0], NULL
, 0);
727 pattern
= strtoul(args
[1], NULL
, 0);
728 count
= strtoul(args
[2], NULL
, 0);
746 return ERROR_COMMAND_SYNTAX_ERROR
;
749 chunk_count
= MIN(count
, (1024 / wordsize
));
753 for(i
= 0; i
< chunk_count
; i
++)
755 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
759 for(i
= 0; i
< chunk_count
; i
++)
761 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
765 memset(chunk
, pattern
, chunk_count
);
768 LOG_ERROR("BUG: can't happen");
772 duration_start_measure(&duration
);
775 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
778 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
780 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
784 bank
= get_flash_bank_by_addr(target
, address
);
790 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
798 duration_stop_measure(&duration
, &duration_text
);
803 speed
=wrote
/ 1024.0;
804 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
805 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
806 count
*wordsize
, address
, duration_text
,
813 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
829 return ERROR_COMMAND_SYNTAX_ERROR
;
832 duration_start_measure(&duration
);
834 offset
= strtoul(args
[2], NULL
, 0);
835 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
838 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
842 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
847 buffer
= malloc(fileio
.size
);
848 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
851 fileio_close(&fileio
);
855 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
860 duration_stop_measure(&duration
, &duration_text
);
861 if (retval
!=ERROR_OK
)
863 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
864 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
865 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
869 fileio_close(&fileio
);
874 void flash_set_dirty(void)
879 /* set all flash to require erasing */
880 for (c
= flash_banks
; c
; c
= c
->next
)
882 for (i
= 0; i
< c
->num_sectors
; i
++)
884 c
->sectors
[i
].is_erased
= 0;
889 /* lookup flash bank by address */
890 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
894 /* cycle through bank list */
895 for (c
= flash_banks
; c
; c
= c
->next
)
898 retval
= c
->driver
->auto_probe(c
);
900 if (retval
!= ERROR_OK
)
902 LOG_ERROR("auto_probe failed %d\n", retval
);
905 /* check whether address belongs to this flash bank */
906 if ((addr
>= c
->base
) && (addr
< c
->base
+ c
->size
) && target
== c
->target
)
909 LOG_ERROR("No flash at address 0x%08x\n", addr
);
913 /* erase given flash region, selects proper bank according to target and address */
914 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
921 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
922 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
924 if (c
->size
== 0 || c
->num_sectors
== 0)
926 LOG_ERROR("Bank is invalid");
927 return ERROR_FLASH_BANK_INVALID
;
932 /* special case, erase whole bank when length is zero */
934 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
936 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
939 /* check whether it fits */
940 if (addr
+ length
> c
->base
+ c
->size
)
941 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
945 for (i
= 0; i
< c
->num_sectors
; i
++)
947 /* check whether sector overlaps with the given range and is not yet erased */
948 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
949 /* if first is not set yet then this is the first sector */
952 last
= i
; /* and it is the last one so far in any case */
956 if( first
== -1 || last
== -1 )
959 return flash_driver_erase(c
, first
, last
);
962 /* write (optional verify) an image to flash memory of the given target */
963 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
980 /* assume all sectors need erasing - stops any problems
981 * when flash_write is called multiple times */
986 /* allocate padding array */
987 padding
= malloc(image
->num_sections
* sizeof(padding
));
989 /* loop until we reach end of the image */
990 while (section
< image
->num_sections
)
996 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
997 u32 run_size
= image
->sections
[section
].size
- section_offset
;
1000 if (image
->sections
[section
].size
== 0)
1002 LOG_WARNING("empty section %d", section
);
1008 /* find the corresponding flash bank */
1009 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1011 section
++; /* and skip it */
1016 /* collect consecutive sections which fall into the same bank */
1017 section_first
= section
;
1018 section_last
= section
;
1019 padding
[section
] = 0;
1020 while ((run_address
+ run_size
< c
->base
+ c
->size
)
1021 && (section_last
+ 1 < image
->num_sections
))
1023 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1025 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1028 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1029 * attempt to rebuild a consecutive buffer for the flash loader */
1030 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1031 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1033 padding
[section_last
] = pad_bytes
;
1034 run_size
+= image
->sections
[++section_last
].size
;
1035 run_size
+= pad_bytes
;
1036 padding
[section_last
] = 0;
1038 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1041 /* fit the run into bank constraints */
1042 if (run_address
+ run_size
> c
->base
+ c
->size
)
1043 run_size
= c
->base
+ c
->size
- run_address
;
1045 /* allocate buffer */
1046 buffer
= malloc(run_size
);
1049 /* read sections to the buffer */
1050 while (buffer_size
< run_size
)
1054 if (buffer_size
- run_size
<= image
->sections
[section
].size
- section_offset
)
1055 size_read
= buffer_size
- run_size
;
1057 size_read
= image
->sections
[section
].size
- section_offset
;
1059 if ((retval
= image_read_section(image
, section
, section_offset
,
1060 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1067 /* see if we need to pad the section */
1068 while (padding
[section
]--)
1069 buffer
[size_read
++] = 0xff;
1071 buffer_size
+= size_read
;
1072 section_offset
+= size_read
;
1074 if (section_offset
>= image
->sections
[section
].size
)
1085 /* calculate and erase sectors */
1086 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1089 if (retval
== ERROR_OK
)
1091 /* write flash sectors */
1092 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1097 if (retval
!= ERROR_OK
)
1100 return retval
; /* abort operation */
1103 if (written
!= NULL
)
1104 *written
+= run_size
; /* add run size to total written counter */
1112 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1114 target_t
*target
= bank
->target
;
1116 int buffer_size
= sizeof(buffer
);
1120 if (bank
->target
->state
!= TARGET_HALTED
)
1122 return ERROR_TARGET_NOT_HALTED
;
1125 for (i
= 0; i
< bank
->num_sectors
; i
++)
1128 bank
->sectors
[i
].is_erased
= 1;
1130 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1134 chunk
= buffer_size
;
1135 if (chunk
> (j
- bank
->sectors
[i
].size
))
1137 chunk
= (j
- bank
->sectors
[i
].size
);
1140 retval
= target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1141 if (retval
!= ERROR_OK
)
1144 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1146 if (buffer
[nBytes
] != 0xFF)
1148 bank
->sectors
[i
].is_erased
= 0;
1158 int default_flash_blank_check(struct flash_bank_s
*bank
)
1160 target_t
*target
= bank
->target
;
1166 if (bank
->target
->state
!= TARGET_HALTED
)
1168 return ERROR_TARGET_NOT_HALTED
;
1171 for (i
= 0; i
< bank
->num_sectors
; i
++)
1173 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1174 u32 size
= bank
->sectors
[i
].size
;
1176 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1182 bank
->sectors
[i
].is_erased
= 1;
1184 bank
->sectors
[i
].is_erased
= 0;
1190 LOG_USER("Running slow fallback erase check - add working memory");
1191 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)