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 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
32 #include "time_support.h"
34 /* command handlers */
35 static int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
36 static int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
37 static int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
38 static int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
39 static int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
40 static int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
41 static int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
42 static int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
43 static int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
44 static int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
45 static int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
49 extern flash_driver_t lpc2000_flash
;
50 extern flash_driver_t cfi_flash
;
51 extern flash_driver_t at91sam7_flash
;
52 extern flash_driver_t str7x_flash
;
53 extern flash_driver_t str9x_flash
;
54 extern flash_driver_t aduc702x_flash
;
55 extern flash_driver_t stellaris_flash
;
56 extern flash_driver_t str9xpec_flash
;
57 extern flash_driver_t stm32x_flash
;
58 extern flash_driver_t tms470_flash
;
59 extern flash_driver_t ecosflash_flash
;
60 extern flash_driver_t lpc288x_flash
;
61 extern flash_driver_t ocl_flash
;
62 extern flash_driver_t pic32mx_flash
;
63 extern flash_driver_t avr_flash
;
65 flash_driver_t
*flash_drivers
[] = {
84 flash_bank_t
*flash_banks
;
85 static command_t
*flash_cmd
;
87 /* wafer thin wrapper for invoking the flash driver */
88 static int flash_driver_write(struct flash_bank_s
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
92 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
95 LOG_ERROR("error writing to flash at address 0x%08" PRIx32
" at offset 0x%8.8" PRIx32
" (%d)",
96 bank
->base
, offset
, retval
);
102 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
106 retval
=bank
->driver
->erase(bank
, first
, last
);
107 if (retval
!=ERROR_OK
)
109 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
115 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
119 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
120 if (retval
!=ERROR_OK
)
122 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
128 int flash_register_commands(struct command_context_s
*cmd_ctx
)
130 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
132 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 ...]");
136 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
141 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
145 Jim_Obj
*list
=Jim_NewListObj(interp
, NULL
, 0);
146 for (p
= flash_banks
; p
; p
= p
->next
)
148 Jim_Obj
*elem
=Jim_NewListObj(interp
, NULL
, 0);
150 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
151 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
152 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
153 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
154 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
155 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
156 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
157 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
158 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
159 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
161 Jim_ListAppendElement(interp
, list
, elem
);
164 Jim_SetResult(interp
, list
);
169 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
171 register_jim(cmd_ctx
, "ocd_flash_banks", jim_flash_banks
, "return information about the flash banks");
175 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
176 "print info about flash bank <num>");
177 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
178 "identify flash bank <num>");
179 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
180 "check erase state of sectors in flash bank <num>");
181 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
182 "check protection state of sectors in flash bank <num>");
183 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
184 "erase sectors at <bank> <first> <last>");
185 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
186 "erase address range <address> <length>");
188 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
189 "fill with pattern (no autoerase) <address> <word_pattern> <count>");
190 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
191 "fill with pattern <address> <halfword_pattern> <count>");
192 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
193 "fill with pattern <address> <byte_pattern> <count>");
195 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
196 "write binary data to <bank> <file> <offset>");
197 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
198 "write_image [erase] <file> [offset] [type]");
199 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
200 "set protection of sectors at <bank> <first> <last> <on|off>");
206 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
211 for (p
= flash_banks
; p
; p
= p
->next
)
218 LOG_ERROR("flash bank %d does not exist", num
);
222 int flash_get_bank_count(void)
226 for (p
= flash_banks
; p
; p
= p
->next
)
233 flash_bank_t
*get_flash_bank_by_num(int num
)
235 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
241 retval
= p
->driver
->auto_probe(p
);
243 if (retval
!= ERROR_OK
)
245 LOG_ERROR("auto_probe failed %d\n", retval
);
251 static int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
260 return ERROR_COMMAND_SYNTAX_ERROR
;
263 if ((target
= get_target(args
[5])) == NULL
)
265 LOG_ERROR("target '%s' not defined", args
[5]);
269 for (i
= 0; flash_drivers
[i
]; i
++)
271 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
275 /* register flash specific commands */
276 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
278 LOG_ERROR("couldn't register '%s' commands", args
[0]);
282 c
= malloc(sizeof(flash_bank_t
));
284 c
->driver
= flash_drivers
[i
];
285 c
->driver_priv
= NULL
;
286 c
->base
= strtoul(args
[1], NULL
, 0);
287 c
->size
= strtoul(args
[2], NULL
, 0);
288 c
->chip_width
= strtoul(args
[3], NULL
, 0);
289 c
->bus_width
= strtoul(args
[4], NULL
, 0);
294 if ((retval
=flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
)) != ERROR_OK
)
296 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32
, args
[0], c
->base
);
301 /* put flash bank in linked list */
305 /* find last flash bank */
306 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
) bank_num
++;
309 c
->bank_number
= bank_num
+ 1;
321 /* no matching flash driver found */
324 LOG_ERROR("flash driver '%s' not found", args
[0]);
331 static int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
340 return ERROR_COMMAND_SYNTAX_ERROR
;
343 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
345 if (i
== strtoul(args
[0], NULL
, 0))
349 /* attempt auto probe */
350 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
353 command_print(cmd_ctx
,
354 "#%" PRIi32
" : %s at 0x%8.8" PRIx32
", size 0x%8.8" PRIx32
", buswidth %i, chipwidth %i",
361 for (j
= 0; j
< p
->num_sectors
; j
++)
365 if (p
->sectors
[j
].is_protected
== 0)
366 protect_state
= "not protected";
367 else if (p
->sectors
[j
].is_protected
== 1)
368 protect_state
= "protected";
370 protect_state
= "protection state unknown";
372 command_print(cmd_ctx
,
373 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
375 p
->sectors
[j
].offset
,
377 p
->sectors
[j
].size
>>10,
381 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
382 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
383 command_print(cmd_ctx
, "%s", buf
);
384 if (retval
!= ERROR_OK
)
385 LOG_ERROR("error retrieving flash info (%d)", retval
);
392 static int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
399 return ERROR_COMMAND_SYNTAX_ERROR
;
402 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
405 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
407 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8" PRIx32
, p
->driver
->name
, p
->base
);
409 else if (retval
== ERROR_FLASH_BANK_INVALID
)
411 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32
,
416 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32
,
422 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
428 static int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
435 return ERROR_COMMAND_SYNTAX_ERROR
;
438 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
442 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
444 command_print(cmd_ctx
, "successfully checked erase state");
448 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32
,
452 for (j
= 0; j
< p
->num_sectors
; j
++)
456 if (p
->sectors
[j
].is_erased
== 0)
457 erase_state
= "not erased";
458 else if (p
->sectors
[j
].is_erased
== 1)
459 erase_state
= "erased";
461 erase_state
= "erase state unknown";
463 command_print(cmd_ctx
,
464 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
466 p
->sectors
[j
].offset
,
468 p
->sectors
[j
].size
>>10,
476 static 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 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
517 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
524 static int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
531 return ERROR_COMMAND_SYNTAX_ERROR
;
534 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
537 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
539 command_print(cmd_ctx
, "successfully checked protect state");
541 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
543 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32
, args
[0], p
->base
);
547 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32
, args
[0], p
->base
);
552 return ERROR_COMMAND_SYNTAX_ERROR
;
558 static int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
562 int first
= strtoul(args
[1], NULL
, 0);
563 int last
= strtoul(args
[2], NULL
, 0);
565 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
569 duration_start_measure(&duration
);
573 return ERROR_COMMAND_SYNTAX_ERROR
;
576 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
578 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
583 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %li in %s",
584 first
, last
, strtoul(args
[0], 0, 0), duration_text
);
590 return ERROR_COMMAND_SYNTAX_ERROR
;
596 static int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
600 int first
= strtoul(args
[1], NULL
, 0);
601 int last
= strtoul(args
[2], NULL
, 0);
604 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
607 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
611 if (strcmp(args
[3], "on") == 0)
613 else if (strcmp(args
[3], "off") == 0)
617 return ERROR_COMMAND_SYNTAX_ERROR
;
620 retval
= flash_driver_protect(p
, set
, first
, last
);
621 if (retval
== ERROR_OK
)
623 command_print(cmd_ctx
, "%s protection for sectors %i through %i on flash bank %li",
624 (set
) ? "set" : "cleared", first
,
625 last
, strtoul(args
[0], 0, 0));
630 return ERROR_COMMAND_SYNTAX_ERROR
;
637 static int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
639 target_t
*target
= get_current_target(cmd_ctx
);
647 int retval
, retvaltemp
;
651 return ERROR_COMMAND_SYNTAX_ERROR
;
654 /* flash auto-erase is disabled by default*/
657 if (strcmp(args
[0], "erase")==0)
662 command_print(cmd_ctx
, "auto erase enabled");
667 return ERROR_COMMAND_SYNTAX_ERROR
;
672 LOG_ERROR("no target selected");
676 duration_start_measure(&duration
);
680 image
.base_address_set
= 1;
681 image
.base_address
= strtoul(args
[1], NULL
, 0);
685 image
.base_address_set
= 0;
686 image
.base_address
= 0x0;
689 image
.start_address_set
= 0;
691 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
692 if (retval
!= ERROR_OK
)
697 retval
= flash_write(target
, &image
, &written
, auto_erase
);
698 if (retval
!= ERROR_OK
)
704 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
709 if (retval
== ERROR_OK
)
711 command_print(cmd_ctx
,
712 "wrote %" PRIu32
" byte from file %s in %s (%f kb/s)",
716 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
725 static int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
727 int err
= ERROR_OK
, retval
;
732 uint8_t readback
[1024];
734 uint32_t cur_size
= 0;
735 uint32_t chunk_count
;
738 target_t
*target
= get_current_target(cmd_ctx
);
744 return ERROR_COMMAND_SYNTAX_ERROR
;
747 address
= strtoul(args
[0], NULL
, 0);
748 pattern
= strtoul(args
[1], NULL
, 0);
749 count
= strtoul(args
[2], NULL
, 0);
766 return ERROR_COMMAND_SYNTAX_ERROR
;
769 chunk_count
= MIN(count
, (1024 / wordsize
));
773 for(i
= 0; i
< chunk_count
; i
++)
775 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
779 for(i
= 0; i
< chunk_count
; i
++)
781 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
785 memset(chunk
, pattern
, chunk_count
);
788 LOG_ERROR("BUG: can't happen");
792 duration_start_measure(&duration
);
794 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+= cur_size
)
796 cur_size
= MIN( (count
*wordsize
- wrote
), sizeof(chunk
) );
798 bank
= get_flash_bank_by_addr(target
, address
);
803 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
807 err
= target_read_buffer(target
, address
+ wrote
, cur_size
, readback
);
812 for (i
=0; i
<cur_size
; i
++)
814 if (readback
[i
]!=chunk
[i
])
816 LOG_ERROR("Verfication error address 0x%08" PRIx32
", read back 0x%02x, expected 0x%02x",
817 address
+ wrote
+ i
, readback
[i
], chunk
[i
]);
824 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
832 speed
=wrote
/ 1024.0;
833 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
834 command_print(cmd_ctx
,
835 "wrote %" PRId32
" bytes to 0x%8.8" PRIx32
" in %s (%f kb/s)",
845 static int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
856 int retval
, retvaltemp
;
861 return ERROR_COMMAND_SYNTAX_ERROR
;
864 duration_start_measure(&duration
);
866 offset
= strtoul(args
[2], NULL
, 0);
867 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
870 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
874 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
879 buffer
= malloc(fileio
.size
);
880 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
883 fileio_close(&fileio
);
887 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
892 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
894 fileio_close(&fileio
);
897 if (retval
==ERROR_OK
)
899 command_print(cmd_ctx
,
900 "wrote %lld byte from file %s to flash bank %li at offset 0x%8.8" PRIx32
" in %s (%f kb/s)",
903 strtoul(args
[0], NULL
, 0),
906 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
910 fileio_close(&fileio
);
915 void flash_set_dirty(void)
920 /* set all flash to require erasing */
921 for (c
= flash_banks
; c
; c
= c
->next
)
923 for (i
= 0; i
< c
->num_sectors
; i
++)
925 c
->sectors
[i
].is_erased
= 0;
930 /* lookup flash bank by address */
931 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, uint32_t addr
)
935 /* cycle through bank list */
936 for (c
= flash_banks
; c
; c
= c
->next
)
939 retval
= c
->driver
->auto_probe(c
);
941 if (retval
!= ERROR_OK
)
943 LOG_ERROR("auto_probe failed %d\n", retval
);
946 /* check whether address belongs to this flash bank */
947 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
950 LOG_ERROR("No flash at address 0x%08" PRIx32
"\n", addr
);
954 /* erase given flash region, selects proper bank according to target and address */
955 int flash_erase_address_range(target_t
*target
, uint32_t addr
, uint32_t length
)
962 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
963 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
965 if (c
->size
== 0 || c
->num_sectors
== 0)
967 LOG_ERROR("Bank is invalid");
968 return ERROR_FLASH_BANK_INVALID
;
973 /* special case, erase whole bank when length is zero */
975 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
977 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
980 /* check whether it fits */
981 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
982 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
986 for (i
= 0; i
< c
->num_sectors
; i
++)
988 /* check whether sector overlaps with the given range and is not yet erased */
989 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
990 /* if first is not set yet then this is the first sector */
993 last
= i
; /* and it is the last one so far in any case */
997 if( first
== -1 || last
== -1 )
1000 return flash_driver_erase(c
, first
, last
);
1003 /* write (optional verify) an image to flash memory of the given target */
1004 int flash_write(target_t
*target
, image_t
*image
, uint32_t *written
, int erase
)
1006 int retval
=ERROR_OK
;
1009 uint32_t section_offset
;
1021 /* assume all sectors need erasing - stops any problems
1022 * when flash_write is called multiple times */
1027 /* allocate padding array */
1028 padding
= malloc(image
->num_sections
* sizeof(padding
));
1030 /* loop until we reach end of the image */
1031 while (section
< image
->num_sections
)
1033 uint32_t buffer_size
;
1037 uint32_t run_address
= image
->sections
[section
].base_address
+ section_offset
;
1038 uint32_t run_size
= image
->sections
[section
].size
- section_offset
;
1041 if (image
->sections
[section
].size
== 0)
1043 LOG_WARNING("empty section %d", section
);
1049 /* find the corresponding flash bank */
1050 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1052 section
++; /* and skip it */
1057 /* collect consecutive sections which fall into the same bank */
1058 section_first
= section
;
1059 section_last
= section
;
1060 padding
[section
] = 0;
1061 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
1062 && (section_last
+ 1 < image
->num_sections
))
1064 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1066 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1069 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1070 * attempt to rebuild a consecutive buffer for the flash loader */
1071 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1072 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1074 padding
[section_last
] = pad_bytes
;
1075 run_size
+= image
->sections
[++section_last
].size
;
1076 run_size
+= pad_bytes
;
1077 padding
[section_last
] = 0;
1079 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1082 /* fit the run into bank constraints */
1083 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
1085 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1086 (int)(c
->base
+ c
->size
- run_address
), (int)(run_size
), (int)(c
->size
));
1087 run_size
= c
->base
+ c
->size
- run_address
;
1090 /* allocate buffer */
1091 buffer
= malloc(run_size
);
1094 /* read sections to the buffer */
1095 while (buffer_size
< run_size
)
1099 size_read
= run_size
- buffer_size
;
1100 if (size_read
> image
->sections
[section
].size
- section_offset
)
1101 size_read
= image
->sections
[section
].size
- section_offset
;
1103 if ((retval
= image_read_section(image
, section
, section_offset
,
1104 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1111 /* see if we need to pad the section */
1112 while (padding
[section
]--)
1113 (buffer
+buffer_size
)[size_read
++] = 0xff;
1115 buffer_size
+= size_read
;
1116 section_offset
+= size_read
;
1118 if (section_offset
>= image
->sections
[section
].size
)
1129 /* calculate and erase sectors */
1130 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1133 if (retval
== ERROR_OK
)
1135 /* write flash sectors */
1136 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1141 if (retval
!= ERROR_OK
)
1144 return retval
; /* abort operation */
1147 if (written
!= NULL
)
1148 *written
+= run_size
; /* add run size to total written counter */
1156 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1158 target_t
*target
= bank
->target
;
1159 uint8_t buffer
[1024];
1160 int buffer_size
= sizeof(buffer
);
1164 if (bank
->target
->state
!= TARGET_HALTED
)
1166 LOG_ERROR("Target not halted");
1167 return ERROR_TARGET_NOT_HALTED
;
1170 for (i
= 0; i
< bank
->num_sectors
; i
++)
1173 bank
->sectors
[i
].is_erased
= 1;
1175 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1179 chunk
= buffer_size
;
1180 if (chunk
> (j
- bank
->sectors
[i
].size
))
1182 chunk
= (j
- bank
->sectors
[i
].size
);
1185 retval
= target_read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1186 if (retval
!= ERROR_OK
)
1189 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1191 if (buffer
[nBytes
] != 0xFF)
1193 bank
->sectors
[i
].is_erased
= 0;
1203 int default_flash_blank_check(struct flash_bank_s
*bank
)
1205 target_t
*target
= bank
->target
;
1211 if (bank
->target
->state
!= TARGET_HALTED
)
1213 LOG_ERROR("Target not halted");
1214 return ERROR_TARGET_NOT_HALTED
;
1217 for (i
= 0; i
< bank
->num_sectors
; i
++)
1219 uint32_t address
= bank
->base
+ bank
->sectors
[i
].offset
;
1220 uint32_t size
= bank
->sectors
[i
].size
;
1222 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1228 bank
->sectors
[i
].is_erased
= 1;
1230 bank
->sectors
[i
].is_erased
= 0;
1236 LOG_USER("Running slow fallback erase check - add working memory");
1237 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)