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 lpc288x_flash
;
51 extern flash_driver_t lpc2900_flash
;
52 extern flash_driver_t cfi_flash
;
53 extern flash_driver_t at91sam3_flash
;
54 extern flash_driver_t at91sam7_flash
;
55 extern flash_driver_t str7x_flash
;
56 extern flash_driver_t str9x_flash
;
57 extern flash_driver_t aduc702x_flash
;
58 extern flash_driver_t stellaris_flash
;
59 extern flash_driver_t str9xpec_flash
;
60 extern flash_driver_t stm32x_flash
;
61 extern flash_driver_t tms470_flash
;
62 extern flash_driver_t ecosflash_flash
;
63 extern flash_driver_t ocl_flash
;
64 extern flash_driver_t pic32mx_flash
;
65 extern flash_driver_t avr_flash
;
67 flash_driver_t
*flash_drivers
[] = {
88 flash_bank_t
*flash_banks
;
89 static command_t
*flash_cmd
;
91 /* wafer thin wrapper for invoking the flash driver */
92 static int flash_driver_write(struct flash_bank_s
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
96 retval
= bank
->driver
->write(bank
, buffer
, offset
, count
);
97 if (retval
!= ERROR_OK
)
99 LOG_ERROR("error writing to flash at address 0x%08" PRIx32
" at offset 0x%8.8" PRIx32
" (%d)",
100 bank
->base
, offset
, retval
);
106 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
110 retval
= bank
->driver
->erase(bank
, first
, last
);
111 if (retval
!= ERROR_OK
)
113 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
119 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
123 retval
= bank
->driver
->protect(bank
, set
, first
, last
);
124 if (retval
!= ERROR_OK
)
126 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
132 int flash_register_commands(struct command_context_s
*cmd_ctx
)
134 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
136 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 ...]");
140 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
145 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
149 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
150 for (p
= flash_banks
; p
; p
= p
->next
)
152 Jim_Obj
*elem
= Jim_NewListObj(interp
, NULL
, 0);
154 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
155 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
156 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
157 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
158 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
159 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
160 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
161 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
162 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
163 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
165 Jim_ListAppendElement(interp
, list
, elem
);
168 Jim_SetResult(interp
, list
);
173 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
175 register_jim(cmd_ctx
, "ocd_flash_banks", jim_flash_banks
, "return information about the flash banks");
179 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
180 "print info about flash bank <num>");
181 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
182 "identify flash bank <num>");
183 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
184 "check erase state of sectors in flash bank <num>");
185 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
186 "check protection state of sectors in flash bank <num>");
187 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
188 "erase sectors at <bank> <first> <last>");
189 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
190 "erase address range <address> <length>");
192 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
193 "fill with pattern (no autoerase) <address> <word_pattern> <count>");
194 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
195 "fill with pattern <address> <halfword_pattern> <count>");
196 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
197 "fill with pattern <address> <byte_pattern> <count>");
199 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
200 "write binary data to <bank> <file> <offset>");
201 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
202 "write_image [erase] <file> [offset] [type]");
203 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
204 "set protection of sectors at <bank> <first> <last> <on | off>");
210 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
215 for (p
= flash_banks
; p
; p
= p
->next
)
222 LOG_ERROR("flash bank %d does not exist", num
);
226 int flash_get_bank_count(void)
230 for (p
= flash_banks
; p
; p
= p
->next
)
237 flash_bank_t
*get_flash_bank_by_num(int num
)
239 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
245 retval
= p
->driver
->auto_probe(p
);
247 if (retval
!= ERROR_OK
)
249 LOG_ERROR("auto_probe failed %d\n", retval
);
255 static int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
264 return ERROR_COMMAND_SYNTAX_ERROR
;
267 if ((target
= get_target(args
[5])) == NULL
)
269 LOG_ERROR("target '%s' not defined", args
[5]);
273 for (i
= 0; flash_drivers
[i
]; i
++)
275 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
279 /* register flash specific commands */
280 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
282 LOG_ERROR("couldn't register '%s' commands", args
[0]);
286 c
= malloc(sizeof(flash_bank_t
));
288 c
->driver
= flash_drivers
[i
];
289 c
->driver_priv
= NULL
;
290 c
->base
= strtoul(args
[1], NULL
, 0);
291 c
->size
= strtoul(args
[2], NULL
, 0);
292 c
->chip_width
= strtoul(args
[3], NULL
, 0);
293 c
->bus_width
= strtoul(args
[4], NULL
, 0);
298 if ((retval
= flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
)) != ERROR_OK
)
300 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32
, args
[0], c
->base
);
305 /* put flash bank in linked list */
309 /* find last flash bank */
310 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
) bank_num
++;
313 c
->bank_number
= bank_num
+ 1;
325 /* no matching flash driver found */
328 LOG_ERROR("flash driver '%s' not found", args
[0]);
335 static int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
344 return ERROR_COMMAND_SYNTAX_ERROR
;
347 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
349 if (i
== strtoul(args
[0], NULL
, 0))
353 /* attempt auto probe */
354 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
357 command_print(cmd_ctx
,
358 "#%" PRIi32
" : %s at 0x%8.8" PRIx32
", size 0x%8.8" PRIx32
", buswidth %i, chipwidth %i",
365 for (j
= 0; j
< p
->num_sectors
; j
++)
369 if (p
->sectors
[j
].is_protected
== 0)
370 protect_state
= "not protected";
371 else if (p
->sectors
[j
].is_protected
== 1)
372 protect_state
= "protected";
374 protect_state
= "protection state unknown";
376 command_print(cmd_ctx
,
377 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
379 p
->sectors
[j
].offset
,
381 p
->sectors
[j
].size
>> 10,
385 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
386 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
387 command_print(cmd_ctx
, "%s", buf
);
388 if (retval
!= ERROR_OK
)
389 LOG_ERROR("error retrieving flash info (%d)", retval
);
396 static int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
403 return ERROR_COMMAND_SYNTAX_ERROR
;
406 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
409 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
411 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8" PRIx32
, p
->driver
->name
, p
->base
);
413 else if (retval
== ERROR_FLASH_BANK_INVALID
)
415 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32
,
420 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32
,
426 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
432 static int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
439 return ERROR_COMMAND_SYNTAX_ERROR
;
442 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
446 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
448 command_print(cmd_ctx
, "successfully checked erase state");
452 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32
,
456 for (j
= 0; j
< p
->num_sectors
; j
++)
460 if (p
->sectors
[j
].is_erased
== 0)
461 erase_state
= "not erased";
462 else if (p
->sectors
[j
].is_erased
== 1)
463 erase_state
= "erased";
465 erase_state
= "erase state unknown";
467 command_print(cmd_ctx
,
468 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
470 p
->sectors
[j
].offset
,
472 p
->sectors
[j
].size
>> 10,
480 static int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
489 target_t
*target
= get_current_target(cmd_ctx
);
493 return ERROR_COMMAND_SYNTAX_ERROR
;
496 address
= strtoul(args
[0], NULL
, 0);
497 length
= strtoul(args
[1], NULL
, 0);
500 command_print(cmd_ctx
, "Length must be >0");
501 return ERROR_COMMAND_SYNTAX_ERROR
;
504 p
= get_flash_bank_by_addr(target
, address
);
510 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
513 duration_start_measure(&duration
);
515 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
517 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
521 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
528 static int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
535 return ERROR_COMMAND_SYNTAX_ERROR
;
538 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
541 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
543 command_print(cmd_ctx
, "successfully checked protect state");
545 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
547 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32
, args
[0], p
->base
);
551 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32
, args
[0], p
->base
);
556 return ERROR_COMMAND_SYNTAX_ERROR
;
562 static int flash_check_sector_parameters(struct command_context_s
*cmd_ctx
,
563 uint32_t first
, uint32_t last
, uint32_t num_sectors
)
565 if (!(first
<= last
)) {
566 command_print(cmd_ctx
, "ERROR: "
567 "first sector must be <= last sector");
571 if (!(last
<= (num_sectors
- 1))) {
572 command_print(cmd_ctx
, "ERROR: last sector must be <= %d",
573 (int) num_sectors
- 1);
580 static int handle_flash_erase_command(struct command_context_s
*cmd_ctx
,
581 char *cmd
, char **args
, int argc
)
590 if ((retval
= parse_u32(args
[0], &bank_nr
)) != ERROR_OK
)
593 flash_bank_t
*p
= get_flash_bank_by_num(bank_nr
);
597 if ((retval
= parse_u32(args
[1], &first
)) != ERROR_OK
)
599 if (strcmp(args
[2], "last") == 0)
600 last
= p
->num_sectors
- 1;
602 if ((retval
= parse_u32(args
[2], &last
)) != ERROR_OK
)
605 if ((retval
= flash_check_sector_parameters(cmd_ctx
,
606 first
, last
, p
->num_sectors
)) != ERROR_OK
)
611 duration_start_measure(&duration
);
613 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
) {
614 if ((retval
= duration_stop_measure(&duration
,
615 &duration_text
)) != ERROR_OK
)
617 command_print(cmd_ctx
, "erased sectors %i through %i "
618 "on flash bank %i in %s",
619 (int) first
, (int) last
, (int) bank_nr
,
625 return ERROR_COMMAND_SYNTAX_ERROR
;
630 static int handle_flash_protect_command(struct command_context_s
*cmd_ctx
,
631 char *cmd
, char **args
, int argc
)
641 if ((retval
= parse_u32(args
[0], &bank_nr
)) != ERROR_OK
)
644 flash_bank_t
*p
= get_flash_bank_by_num(bank_nr
);
648 if ((retval
= parse_u32(args
[1], &first
)) != ERROR_OK
)
650 if (strcmp(args
[2], "last") == 0)
651 last
= p
->num_sectors
- 1;
653 if ((retval
= parse_u32(args
[2], &last
)) != ERROR_OK
)
656 if (strcmp(args
[3], "on") == 0)
658 else if (strcmp(args
[3], "off") == 0)
661 return ERROR_COMMAND_SYNTAX_ERROR
;
663 if ((retval
= flash_check_sector_parameters(cmd_ctx
,
664 first
, last
, p
->num_sectors
)) != ERROR_OK
)
667 retval
= flash_driver_protect(p
, set
, first
, last
);
668 if (retval
== ERROR_OK
) {
669 command_print(cmd_ctx
, "%s protection for sectors %i "
670 "through %i on flash bank %i",
671 (set
) ? "set" : "cleared", (int) first
,
672 (int) last
, (int) bank_nr
);
676 return ERROR_COMMAND_SYNTAX_ERROR
;
681 static int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
683 target_t
*target
= get_current_target(cmd_ctx
);
691 int retval
, retvaltemp
;
695 return ERROR_COMMAND_SYNTAX_ERROR
;
698 /* flash auto-erase is disabled by default*/
701 if (strcmp(args
[0], "erase") == 0)
706 command_print(cmd_ctx
, "auto erase enabled");
711 return ERROR_COMMAND_SYNTAX_ERROR
;
716 LOG_ERROR("no target selected");
720 duration_start_measure(&duration
);
724 image
.base_address_set
= 1;
725 image
.base_address
= strtoul(args
[1], NULL
, 0);
729 image
.base_address_set
= 0;
730 image
.base_address
= 0x0;
733 image
.start_address_set
= 0;
735 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
736 if (retval
!= ERROR_OK
)
741 retval
= flash_write(target
, &image
, &written
, auto_erase
);
742 if (retval
!= ERROR_OK
)
748 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
756 speed
= written
/ 1024.0;
757 speed
/= ((float)duration
.duration
.tv_sec
758 + ((float)duration
.duration
.tv_usec
/ 1000000.0));
759 command_print(cmd_ctx
,
760 "wrote %" PRIu32
" byte from file %s in %s (%f kb/s)",
761 written
, args
[0], duration_text
, speed
);
770 static int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
772 int err
= ERROR_OK
, retval
;
777 uint8_t readback
[1024];
779 uint32_t cur_size
= 0;
780 uint32_t chunk_count
;
783 target_t
*target
= get_current_target(cmd_ctx
);
789 return ERROR_COMMAND_SYNTAX_ERROR
;
792 address
= strtoul(args
[0], NULL
, 0);
793 pattern
= strtoul(args
[1], NULL
, 0);
794 count
= strtoul(args
[2], NULL
, 0);
811 return ERROR_COMMAND_SYNTAX_ERROR
;
814 chunk_count
= MIN(count
, (1024 / wordsize
));
818 for (i
= 0; i
< chunk_count
; i
++)
820 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
824 for (i
= 0; i
< chunk_count
; i
++)
826 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
830 memset(chunk
, pattern
, chunk_count
);
833 LOG_ERROR("BUG: can't happen");
837 duration_start_measure(&duration
);
839 for (wrote
= 0; wrote
< (count
*wordsize
); wrote
+= cur_size
)
841 cur_size
= MIN((count
*wordsize
- wrote
), sizeof(chunk
));
843 bank
= get_flash_bank_by_addr(target
, address
);
848 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
852 err
= target_read_buffer(target
, address
+ wrote
, cur_size
, readback
);
857 for (i
= 0; i
< cur_size
; i
++)
859 if (readback
[i
]!=chunk
[i
])
861 LOG_ERROR("Verfication error address 0x%08" PRIx32
", read back 0x%02x, expected 0x%02x",
862 address
+ wrote
+ i
, readback
[i
], chunk
[i
]);
869 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
876 speed
= wrote
/ 1024.0;
877 speed
/= ((float)duration
.duration
.tv_sec
878 + ((float)duration
.duration
.tv_usec
/ 1000000.0));
879 command_print(cmd_ctx
,
880 "wrote %" PRIu32
" bytes to 0x%8.8" PRIx32
" in %s (%f kb/s)",
881 wrote
, address
, duration_text
, speed
);
887 static int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
898 int retval
, retvaltemp
;
903 return ERROR_COMMAND_SYNTAX_ERROR
;
906 duration_start_measure(&duration
);
908 offset
= strtoul(args
[2], NULL
, 0);
909 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
912 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
916 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
921 buffer
= malloc(fileio
.size
);
922 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
925 fileio_close(&fileio
);
929 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
934 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
936 fileio_close(&fileio
);
939 if (retval
== ERROR_OK
)
941 command_print(cmd_ctx
,
942 "wrote %lld byte from file %s to flash bank %li at offset 0x%8.8" PRIx32
" in %s (%f kb/s)",
945 strtoul(args
[0], NULL
, 0),
948 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
952 fileio_close(&fileio
);
957 void flash_set_dirty(void)
962 /* set all flash to require erasing */
963 for (c
= flash_banks
; c
; c
= c
->next
)
965 for (i
= 0; i
< c
->num_sectors
; i
++)
967 c
->sectors
[i
].is_erased
= 0;
972 /* lookup flash bank by address */
973 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, uint32_t addr
)
977 /* cycle through bank list */
978 for (c
= flash_banks
; c
; c
= c
->next
)
981 retval
= c
->driver
->auto_probe(c
);
983 if (retval
!= ERROR_OK
)
985 LOG_ERROR("auto_probe failed %d\n", retval
);
988 /* check whether address belongs to this flash bank */
989 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
992 LOG_ERROR("No flash at address 0x%08" PRIx32
"\n", addr
);
996 /* erase given flash region, selects proper bank according to target and address */
997 int flash_erase_address_range(target_t
*target
, uint32_t addr
, uint32_t length
)
1004 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
1005 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
1007 if (c
->size
== 0 || c
->num_sectors
== 0)
1009 LOG_ERROR("Bank is invalid");
1010 return ERROR_FLASH_BANK_INVALID
;
1015 /* special case, erase whole bank when length is zero */
1016 if (addr
!= c
->base
)
1017 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
1019 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
1022 /* check whether it fits */
1023 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
1024 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
1028 for (i
= 0; i
< c
->num_sectors
; i
++)
1030 /* check whether sector overlaps with the given range and is not yet erased */
1031 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
1032 /* if first is not set yet then this is the first sector */
1035 last
= i
; /* and it is the last one so far in any case */
1039 if (first
== -1 || last
== -1)
1042 return flash_driver_erase(c
, first
, last
);
1045 /* write (optional verify) an image to flash memory of the given target */
1046 int flash_write(target_t
*target
, image_t
*image
, uint32_t *written
, int erase
)
1048 int retval
= ERROR_OK
;
1051 uint32_t section_offset
;
1063 /* assume all sectors need erasing - stops any problems
1064 * when flash_write is called multiple times */
1069 /* allocate padding array */
1070 padding
= malloc(image
->num_sections
* sizeof(padding
));
1072 /* loop until we reach end of the image */
1073 while (section
< image
->num_sections
)
1075 uint32_t buffer_size
;
1079 uint32_t run_address
= image
->sections
[section
].base_address
+ section_offset
;
1080 uint32_t run_size
= image
->sections
[section
].size
- section_offset
;
1083 if (image
->sections
[section
].size
== 0)
1085 LOG_WARNING("empty section %d", section
);
1091 /* find the corresponding flash bank */
1092 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1094 section
++; /* and skip it */
1099 /* collect consecutive sections which fall into the same bank */
1100 section_first
= section
;
1101 section_last
= section
;
1102 padding
[section
] = 0;
1103 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
1104 && (section_last
+ 1 < image
->num_sections
))
1106 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1108 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1111 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1112 * attempt to rebuild a consecutive buffer for the flash loader */
1113 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1114 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1116 padding
[section_last
] = pad_bytes
;
1117 run_size
+= image
->sections
[++section_last
].size
;
1118 run_size
+= pad_bytes
;
1119 padding
[section_last
] = 0;
1121 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1124 /* fit the run into bank constraints */
1125 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
1127 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1128 (int)(c
->base
+ c
->size
- run_address
), (int)(run_size
), (int)(c
->size
));
1129 run_size
= c
->base
+ c
->size
- run_address
;
1132 /* allocate buffer */
1133 buffer
= malloc(run_size
);
1136 /* read sections to the buffer */
1137 while (buffer_size
< run_size
)
1141 size_read
= run_size
- buffer_size
;
1142 if (size_read
> image
->sections
[section
].size
- section_offset
)
1143 size_read
= image
->sections
[section
].size
- section_offset
;
1145 if ((retval
= image_read_section(image
, section
, section_offset
,
1146 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1153 /* see if we need to pad the section */
1154 while (padding
[section
]--)
1155 (buffer
+ buffer_size
)[size_read
++] = 0xff;
1157 buffer_size
+= size_read
;
1158 section_offset
+= size_read
;
1160 if (section_offset
>= image
->sections
[section
].size
)
1171 /* calculate and erase sectors */
1172 retval
= flash_erase_address_range(target
, run_address
, run_size
);
1175 if (retval
== ERROR_OK
)
1177 /* write flash sectors */
1178 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1183 if (retval
!= ERROR_OK
)
1186 return retval
; /* abort operation */
1189 if (written
!= NULL
)
1190 *written
+= run_size
; /* add run size to total written counter */
1198 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1200 target_t
*target
= bank
->target
;
1201 uint8_t buffer
[1024];
1202 int buffer_size
= sizeof(buffer
);
1206 if (bank
->target
->state
!= TARGET_HALTED
)
1208 LOG_ERROR("Target not halted");
1209 return ERROR_TARGET_NOT_HALTED
;
1212 for (i
= 0; i
< bank
->num_sectors
; i
++)
1215 bank
->sectors
[i
].is_erased
= 1;
1217 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1221 chunk
= buffer_size
;
1222 if (chunk
> (j
- bank
->sectors
[i
].size
))
1224 chunk
= (j
- bank
->sectors
[i
].size
);
1227 retval
= target_read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1228 if (retval
!= ERROR_OK
)
1231 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1233 if (buffer
[nBytes
] != 0xFF)
1235 bank
->sectors
[i
].is_erased
= 0;
1245 int default_flash_blank_check(struct flash_bank_s
*bank
)
1247 target_t
*target
= bank
->target
;
1253 if (bank
->target
->state
!= TARGET_HALTED
)
1255 LOG_ERROR("Target not halted");
1256 return ERROR_TARGET_NOT_HALTED
;
1259 for (i
= 0; i
< bank
->num_sectors
; i
++)
1261 uint32_t address
= bank
->base
+ bank
->sectors
[i
].offset
;
1262 uint32_t size
= bank
->sectors
[i
].size
;
1264 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1270 bank
->sectors
[i
].is_erased
= 1;
1272 bank
->sectors
[i
].is_erased
= 0;
1278 LOG_USER("Running slow fallback erase check - add working memory");
1279 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)