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>
44 /* command handlers */
45 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
46 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
47 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
48 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
49 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
50 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_flash_write_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
);
61 extern flash_driver_t lpc2000_flash
;
62 extern flash_driver_t cfi_flash
;
63 extern flash_driver_t at91sam7_flash
;
64 extern flash_driver_t str7x_flash
;
65 extern flash_driver_t str9x_flash
;
66 extern flash_driver_t stellaris_flash
;
67 extern flash_driver_t str9xpec_flash
;
68 extern flash_driver_t stm32x_flash
;
69 extern flash_driver_t tms470_flash
;
70 extern flash_driver_t ecosflash_flash
;
71 extern flash_driver_t lpc288x_flash
;
72 extern flash_driver_t ocl_flash
;
74 flash_driver_t
*flash_drivers
[] =
91 flash_bank_t
*flash_banks
;
92 static command_t
*flash_cmd
;
94 /* wafer thin wrapper for invoking the flash driver */
95 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
99 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
100 if (retval
!=ERROR_OK
)
102 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
108 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
112 retval
=bank
->driver
->erase(bank
, first
, last
);
113 if (retval
!=ERROR_OK
)
115 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
121 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
125 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
126 if (retval
!=ERROR_OK
)
128 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
134 int flash_register_commands(struct command_context_s
*cmd_ctx
)
136 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
138 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 ...]");
142 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
147 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
156 Jim_Obj
*list
=Jim_NewListObj(interp
, NULL
, 0);
157 for (p
= flash_banks
; p
; p
= p
->next
)
159 Jim_Obj
*elem
=Jim_NewListObj(interp
, NULL
, 0);
161 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
162 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
163 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
164 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
165 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
166 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
167 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
168 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
169 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
170 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
172 Jim_ListAppendElement(interp
, list
, elem
);
175 Jim_SetResult(interp
, list
);
180 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
184 register_jim(cmd_ctx
, "ocd_flash_banks", jim_flash_banks
, "return information about the flash banks");
186 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
187 "print info about flash bank <num>");
188 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
189 "identify flash bank <num>");
190 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
191 "check erase state of sectors in flash bank <num>");
192 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
193 "check protection state of sectors in flash bank <num>");
194 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
195 "erase sectors at <bank> <first> <last>");
196 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
197 "erase address range <address> <length>");
199 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
200 "fill with pattern <address> <word_pattern> <count>");
201 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
202 "fill with pattern <address> <halfword_pattern> <count>");
203 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
204 "fill with pattern <address> <byte_pattern> <count>");
206 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
207 "write binary data to <bank> <file> <offset>");
208 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
209 "write_image [erase] <file> [offset] [type]");
210 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
211 "set protection of sectors at <bank> <first> <last> <on|off>");
217 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
222 for (p
= flash_banks
; p
; p
= p
->next
)
229 LOG_ERROR("flash bank %d does not exist", num
);
233 int flash_get_bank_count()
237 for (p
= flash_banks
; p
; p
= p
->next
)
244 flash_bank_t
*get_flash_bank_by_num(int num
)
246 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
252 retval
= p
->driver
->auto_probe(p
);
254 if (retval
!= ERROR_OK
)
256 LOG_ERROR("auto_probe failed %d\n", retval
);
262 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
270 return ERROR_COMMAND_SYNTAX_ERROR
;
273 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
275 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
279 for (i
= 0; flash_drivers
[i
]; i
++)
281 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
285 /* register flash specific commands */
286 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
288 LOG_ERROR("couldn't register '%s' commands", args
[0]);
292 c
= malloc(sizeof(flash_bank_t
));
294 c
->driver
= flash_drivers
[i
];
295 c
->driver_priv
= NULL
;
296 c
->base
= strtoul(args
[1], NULL
, 0);
297 c
->size
= strtoul(args
[2], NULL
, 0);
298 c
->chip_width
= strtoul(args
[3], NULL
, 0);
299 c
->bus_width
= strtoul(args
[4], NULL
, 0);
304 if (flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
) != ERROR_OK
)
306 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
311 /* put flash bank in linked list */
314 /* find last flash bank */
315 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
328 /* no matching flash driver found */
331 LOG_ERROR("flash driver '%s' not found", args
[0]);
338 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
347 return ERROR_COMMAND_SYNTAX_ERROR
;
350 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
352 if (i
== strtoul(args
[0], NULL
, 0))
356 /* attempt auto probe */
357 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
360 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
361 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
362 for (j
= 0; j
< p
->num_sectors
; j
++)
366 if (p
->sectors
[j
].is_protected
== 0)
367 protect_state
= "not protected";
368 else if (p
->sectors
[j
].is_protected
== 1)
369 protect_state
= "protected";
371 protect_state
= "protection state unknown";
373 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
374 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
378 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
379 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
380 command_print(cmd_ctx
, "%s", buf
);
381 if (retval
!= ERROR_OK
)
382 LOG_ERROR("error retrieving flash info (%d)", retval
);
389 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
396 return ERROR_COMMAND_SYNTAX_ERROR
;
399 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
402 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
404 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
406 else if (retval
== ERROR_FLASH_BANK_INVALID
)
408 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
413 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
419 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
425 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
432 return ERROR_COMMAND_SYNTAX_ERROR
;
435 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
439 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
441 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
445 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
449 for (j
= 0; j
< p
->num_sectors
; j
++)
453 if (p
->sectors
[j
].is_erased
== 0)
454 erase_state
= "not erased";
455 else if (p
->sectors
[j
].is_erased
== 1)
456 erase_state
= "erased";
458 erase_state
= "erase state unknown";
460 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
461 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
470 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
479 target_t
*target
= get_current_target(cmd_ctx
);
483 return ERROR_COMMAND_SYNTAX_ERROR
;
486 address
= strtoul(args
[0], NULL
, 0);
487 length
= strtoul(args
[1], NULL
, 0);
490 command_print(cmd_ctx
, "Length must be >0");
491 return ERROR_COMMAND_SYNTAX_ERROR
;
494 p
= get_flash_bank_by_addr(target
, address
);
500 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
503 duration_start_measure(&duration
);
505 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
507 duration_stop_measure(&duration
, &duration_text
);
508 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
515 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
522 return ERROR_COMMAND_SYNTAX_ERROR
;
525 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
528 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
530 command_print(cmd_ctx
, "successfully checked protect state");
532 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
534 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
538 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
543 return ERROR_COMMAND_SYNTAX_ERROR
;
549 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
553 int first
= strtoul(args
[1], NULL
, 0);
554 int last
= strtoul(args
[2], NULL
, 0);
556 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
560 duration_start_measure(&duration
);
564 return ERROR_COMMAND_SYNTAX_ERROR
;
567 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
569 duration_stop_measure(&duration
, &duration_text
);
571 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
577 return ERROR_COMMAND_SYNTAX_ERROR
;
583 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
587 int first
= strtoul(args
[1], NULL
, 0);
588 int last
= strtoul(args
[2], NULL
, 0);
591 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
594 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
598 if (strcmp(args
[3], "on") == 0)
600 else if (strcmp(args
[3], "off") == 0)
604 return ERROR_COMMAND_SYNTAX_ERROR
;
607 retval
= flash_driver_protect(p
, set
, first
, last
);
608 if (retval
== ERROR_OK
)
610 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));
615 return ERROR_COMMAND_SYNTAX_ERROR
;
622 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
624 target_t
*target
= get_current_target(cmd_ctx
);
636 return ERROR_COMMAND_SYNTAX_ERROR
;
639 /* flash auto-erase is disabled by default*/
642 if (strcmp(args
[0], "erase")==0)
647 command_print(cmd_ctx
, "auto erase enabled");
653 return ERROR_COMMAND_SYNTAX_ERROR
;
658 LOG_ERROR("no target selected");
662 duration_start_measure(&duration
);
666 image
.base_address_set
= 1;
667 image
.base_address
= strtoul(args
[1], NULL
, 0);
671 image
.base_address_set
= 0;
672 image
.base_address
= 0x0;
675 image
.start_address_set
= 0;
677 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
678 if (retval
!= ERROR_OK
)
683 retval
= flash_write(target
, &image
, &written
, auto_erase
);
684 if (retval
!= ERROR_OK
)
690 duration_stop_measure(&duration
, &duration_text
);
691 if (retval
== ERROR_OK
)
693 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
694 written
, args
[0], duration_text
,
695 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
704 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
715 target_t
*target
= get_current_target(cmd_ctx
);
721 return ERROR_COMMAND_SYNTAX_ERROR
;
724 address
= strtoul(args
[0], NULL
, 0);
725 pattern
= strtoul(args
[1], NULL
, 0);
726 count
= strtoul(args
[2], NULL
, 0);
744 return ERROR_COMMAND_SYNTAX_ERROR
;
747 chunk_count
= MIN(count
, (1024 / wordsize
));
751 for(i
= 0; i
< chunk_count
; i
++)
753 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
757 for(i
= 0; i
< chunk_count
; i
++)
759 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
763 memset(chunk
, pattern
, chunk_count
);
766 LOG_ERROR("BUG: can't happen");
770 duration_start_measure(&duration
);
773 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
776 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
778 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
782 bank
= get_flash_bank_by_addr(target
, address
);
788 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
796 duration_stop_measure(&duration
, &duration_text
);
801 speed
=wrote
/ 1024.0;
802 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
803 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
804 count
*wordsize
, address
, duration_text
,
811 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
827 return ERROR_COMMAND_SYNTAX_ERROR
;
830 duration_start_measure(&duration
);
832 offset
= strtoul(args
[2], NULL
, 0);
833 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
836 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
840 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
845 buffer
= malloc(fileio
.size
);
846 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
849 fileio_close(&fileio
);
853 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
858 duration_stop_measure(&duration
, &duration_text
);
859 if (retval
!=ERROR_OK
)
861 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
862 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
863 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
867 fileio_close(&fileio
);
872 void flash_set_dirty(void)
877 /* set all flash to require erasing */
878 for (c
= flash_banks
; c
; c
= c
->next
)
880 for (i
= 0; i
< c
->num_sectors
; i
++)
882 c
->sectors
[i
].is_erased
= 0;
887 /* lookup flash bank by address */
888 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
892 /* cycle through bank list */
893 for (c
= flash_banks
; c
; c
= c
->next
)
896 retval
= c
->driver
->auto_probe(c
);
898 if (retval
!= ERROR_OK
)
900 LOG_ERROR("auto_probe failed %d\n", retval
);
903 /* check whether address belongs to this flash bank */
904 if ((addr
>= c
->base
) && (addr
< c
->base
+ c
->size
) && target
== c
->target
)
907 LOG_ERROR("No flash at address 0x%08x\n", addr
);
911 /* erase given flash region, selects proper bank according to target and address */
912 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
919 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
920 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
922 if (c
->size
== 0 || c
->num_sectors
== 0)
924 LOG_ERROR("Bank is invalid");
925 return ERROR_FLASH_BANK_INVALID
;
930 /* special case, erase whole bank when length is zero */
932 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
934 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
937 /* check whether it fits */
938 if (addr
+ length
> c
->base
+ c
->size
)
939 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
943 for (i
= 0; i
< c
->num_sectors
; i
++)
945 /* check whether sector overlaps with the given range and is not yet erased */
946 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
947 /* if first is not set yet then this is the first sector */
950 last
= i
; /* and it is the last one so far in any case */
954 if( first
== -1 || last
== -1 )
957 return flash_driver_erase(c
, first
, last
);
960 /* write (optional verify) an image to flash memory of the given target */
961 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
978 /* assume all sectors need erasing - stops any problems
979 * when flash_write is called multiple times */
984 /* allocate padding array */
985 padding
= malloc(image
->num_sections
* sizeof(padding
));
987 /* loop until we reach end of the image */
988 while (section
< image
->num_sections
)
994 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
995 u32 run_size
= image
->sections
[section
].size
- section_offset
;
998 if (image
->sections
[section
].size
== 0)
1000 LOG_WARNING("empty section %d", section
);
1006 /* find the corresponding flash bank */
1007 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1009 section
++; /* and skip it */
1014 /* collect consecutive sections which fall into the same bank */
1015 section_first
= section
;
1016 section_last
= section
;
1017 padding
[section
] = 0;
1018 while ((run_address
+ run_size
< c
->base
+ c
->size
)
1019 && (section_last
+ 1 < image
->num_sections
))
1021 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1023 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1026 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1027 * attempt to rebuild a consecutive buffer for the flash loader */
1028 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1029 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1031 padding
[section_last
] = pad_bytes
;
1032 run_size
+= image
->sections
[++section_last
].size
;
1033 run_size
+= pad_bytes
;
1034 padding
[section_last
] = 0;
1036 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1039 /* fit the run into bank constraints */
1040 if (run_address
+ run_size
> c
->base
+ c
->size
)
1041 run_size
= c
->base
+ c
->size
- run_address
;
1043 /* allocate buffer */
1044 buffer
= malloc(run_size
);
1047 /* read sections to the buffer */
1048 while (buffer_size
< run_size
)
1052 if (buffer_size
- run_size
<= image
->sections
[section
].size
- section_offset
)
1053 size_read
= buffer_size
- run_size
;
1055 size_read
= image
->sections
[section
].size
- section_offset
;
1057 if ((retval
= image_read_section(image
, section
, section_offset
,
1058 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1065 /* see if we need to pad the section */
1066 while (padding
[section
]--)
1067 buffer
[size_read
++] = 0xff;
1069 buffer_size
+= size_read
;
1070 section_offset
+= size_read
;
1072 if (section_offset
>= image
->sections
[section
].size
)
1083 /* calculate and erase sectors */
1084 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1087 if (retval
== ERROR_OK
)
1089 /* write flash sectors */
1090 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1095 if (retval
!= ERROR_OK
)
1098 return retval
; /* abort operation */
1101 if (written
!= NULL
)
1102 *written
+= run_size
; /* add run size to total written counter */
1110 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1112 target_t
*target
= bank
->target
;
1114 int buffer_size
= sizeof(buffer
);
1118 if (bank
->target
->state
!= TARGET_HALTED
)
1120 return ERROR_TARGET_NOT_HALTED
;
1123 for (i
= 0; i
< bank
->num_sectors
; i
++)
1126 bank
->sectors
[i
].is_erased
= 1;
1128 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1132 chunk
= buffer_size
;
1133 if (chunk
> (j
- bank
->sectors
[i
].size
))
1135 chunk
= (j
- bank
->sectors
[i
].size
);
1138 retval
= target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1139 if (retval
!= ERROR_OK
)
1142 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1144 if (buffer
[nBytes
] != 0xFF)
1146 bank
->sectors
[i
].is_erased
= 0;
1156 int default_flash_blank_check(struct flash_bank_s
*bank
)
1158 target_t
*target
= bank
->target
;
1164 if (bank
->target
->state
!= TARGET_HALTED
)
1166 return ERROR_TARGET_NOT_HALTED
;
1169 for (i
= 0; i
< bank
->num_sectors
; i
++)
1171 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1172 u32 size
= bank
->sectors
[i
].size
;
1174 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1180 bank
->sectors
[i
].is_erased
= 1;
1182 bank
->sectors
[i
].is_erased
= 0;
1188 LOG_USER("Running slow fallback erase check - add working memory");
1189 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)