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
);
46 static int flash_write_unlock(target_t
*target
, image_t
*image
, uint32_t *written
, int erase
, bool unlock
);
50 extern flash_driver_t lpc2000_flash
;
51 extern flash_driver_t lpc288x_flash
;
52 extern flash_driver_t lpc2900_flash
;
53 extern flash_driver_t cfi_flash
;
54 extern flash_driver_t at91sam3_flash
;
55 extern flash_driver_t at91sam7_flash
;
56 extern flash_driver_t str7x_flash
;
57 extern flash_driver_t str9x_flash
;
58 extern flash_driver_t aduc702x_flash
;
59 extern flash_driver_t stellaris_flash
;
60 extern flash_driver_t str9xpec_flash
;
61 extern flash_driver_t stm32x_flash
;
62 extern flash_driver_t tms470_flash
;
63 extern flash_driver_t ecosflash_flash
;
64 extern flash_driver_t ocl_flash
;
65 extern flash_driver_t pic32mx_flash
;
66 extern flash_driver_t avr_flash
;
67 extern flash_driver_t faux_flash
;
69 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
, uint8_t *buffer
, uint32_t offset
, uint32_t 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%08" PRIx32
" at offset 0x%8.8" PRIx32
" (%d)",
103 bank
->base
, offset
, retval
);
109 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
113 retval
= bank
->driver
->erase(bank
, first
, last
);
114 if (retval
!= ERROR_OK
)
116 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
122 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
126 retval
= bank
->driver
->protect(bank
, set
, first
, last
);
127 if (retval
!= ERROR_OK
)
129 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
135 int flash_register_commands(struct command_context_s
*cmd_ctx
)
137 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
139 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 ...]");
143 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
148 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
152 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
153 for (p
= flash_banks
; p
; p
= p
->next
)
155 Jim_Obj
*elem
= Jim_NewListObj(interp
, NULL
, 0);
157 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
158 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
159 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
160 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
161 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
162 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
163 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
164 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
165 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
166 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
168 Jim_ListAppendElement(interp
, list
, elem
);
171 Jim_SetResult(interp
, list
);
176 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
178 register_jim(cmd_ctx
, "ocd_flash_banks", jim_flash_banks
, "return information about the flash banks");
182 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
183 "print info about flash bank <num>");
184 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
185 "identify flash bank <num>");
186 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
187 "check erase state of sectors in flash bank <num>");
188 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
189 "check protection state of sectors in flash bank <num>");
190 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
191 "erase sectors at <bank> <first> <last>");
192 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
193 "erase address range <address> <length>");
195 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
196 "fill with pattern (no autoerase) <address> <word_pattern> <count>");
197 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
198 "fill with pattern <address> <halfword_pattern> <count>");
199 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
200 "fill with pattern <address> <byte_pattern> <count>");
202 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
203 "write binary data to <bank> <file> <offset>");
204 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
205 "write_image [erase] [unlock] <file> [offset] [type]");
206 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
207 "set protection of sectors at <bank> <first> <last> <on | off>");
213 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
218 for (p
= flash_banks
; p
; p
= p
->next
)
225 LOG_ERROR("flash bank %d does not exist", num
);
229 int flash_get_bank_count(void)
233 for (p
= flash_banks
; p
; p
= p
->next
)
240 flash_bank_t
*get_flash_bank_by_num(int num
)
242 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
248 retval
= p
->driver
->auto_probe(p
);
250 if (retval
!= ERROR_OK
)
252 LOG_ERROR("auto_probe failed %d\n", retval
);
258 int flash_command_get_bank_by_num(
259 struct command_context_s
*cmd_ctx
, char *str
, flash_bank_t
**bank
)
262 COMMAND_PARSE_NUMBER(uint
, str
, bank_num
);
264 *bank
= get_flash_bank_by_num(bank_num
);
267 command_print(cmd_ctx
,
268 "flash bank '#%u' not found", bank_num
);
269 return ERROR_INVALID_ARGUMENTS
;
275 static int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
284 return ERROR_COMMAND_SYNTAX_ERROR
;
287 if ((target
= get_target(args
[5])) == NULL
)
289 LOG_ERROR("target '%s' not defined", args
[5]);
293 for (i
= 0; flash_drivers
[i
]; i
++)
295 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
299 /* register flash specific commands */
300 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
302 LOG_ERROR("couldn't register '%s' commands", args
[0]);
306 c
= malloc(sizeof(flash_bank_t
));
308 c
->driver
= flash_drivers
[i
];
309 c
->driver_priv
= NULL
;
310 c
->base
= strtoul(args
[1], NULL
, 0);
311 c
->size
= strtoul(args
[2], NULL
, 0);
312 c
->chip_width
= strtoul(args
[3], NULL
, 0);
313 c
->bus_width
= strtoul(args
[4], NULL
, 0);
318 if ((retval
= flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
)) != ERROR_OK
)
320 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32
, args
[0], c
->base
);
325 /* put flash bank in linked list */
329 /* find last flash bank */
330 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
) bank_num
++;
333 c
->bank_number
= bank_num
+ 1;
345 /* no matching flash driver found */
348 LOG_ERROR("flash driver '%s' not found", args
[0]);
355 static int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
364 return ERROR_COMMAND_SYNTAX_ERROR
;
367 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
369 if (i
== strtoul(args
[0], NULL
, 0))
373 /* attempt auto probe */
374 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
377 command_print(cmd_ctx
,
378 "#%" PRIi32
" : %s at 0x%8.8" PRIx32
", size 0x%8.8" PRIx32
", buswidth %i, chipwidth %i",
385 for (j
= 0; j
< p
->num_sectors
; j
++)
389 if (p
->sectors
[j
].is_protected
== 0)
390 protect_state
= "not protected";
391 else if (p
->sectors
[j
].is_protected
== 1)
392 protect_state
= "protected";
394 protect_state
= "protection state unknown";
396 command_print(cmd_ctx
,
397 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
399 p
->sectors
[j
].offset
,
401 p
->sectors
[j
].size
>> 10,
405 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
406 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
407 command_print(cmd_ctx
, "%s", buf
);
408 if (retval
!= ERROR_OK
)
409 LOG_ERROR("error retrieving flash info (%d)", retval
);
416 static int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
423 return ERROR_COMMAND_SYNTAX_ERROR
;
426 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
429 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
431 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8" PRIx32
, p
->driver
->name
, p
->base
);
433 else if (retval
== ERROR_FLASH_BANK_INVALID
)
435 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32
,
440 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32
,
446 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
452 static int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
459 return ERROR_COMMAND_SYNTAX_ERROR
;
462 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
466 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
468 command_print(cmd_ctx
, "successfully checked erase state");
472 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32
,
476 for (j
= 0; j
< p
->num_sectors
; j
++)
480 if (p
->sectors
[j
].is_erased
== 0)
481 erase_state
= "not erased";
482 else if (p
->sectors
[j
].is_erased
== 1)
483 erase_state
= "erased";
485 erase_state
= "erase state unknown";
487 command_print(cmd_ctx
,
488 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
490 p
->sectors
[j
].offset
,
492 p
->sectors
[j
].size
>> 10,
500 static int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
509 target_t
*target
= get_current_target(cmd_ctx
);
513 return ERROR_COMMAND_SYNTAX_ERROR
;
516 address
= strtoul(args
[0], NULL
, 0);
517 length
= strtoul(args
[1], NULL
, 0);
520 command_print(cmd_ctx
, "Length must be >0");
521 return ERROR_COMMAND_SYNTAX_ERROR
;
524 p
= get_flash_bank_by_addr(target
, address
);
530 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
533 duration_start_measure(&duration
);
535 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
537 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
541 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
548 static int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
555 return ERROR_COMMAND_SYNTAX_ERROR
;
558 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
561 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
563 command_print(cmd_ctx
, "successfully checked protect state");
565 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
567 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32
, args
[0], p
->base
);
571 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32
, args
[0], p
->base
);
576 return ERROR_COMMAND_SYNTAX_ERROR
;
582 static int flash_check_sector_parameters(struct command_context_s
*cmd_ctx
,
583 uint32_t first
, uint32_t last
, uint32_t num_sectors
)
585 if (!(first
<= last
)) {
586 command_print(cmd_ctx
, "ERROR: "
587 "first sector must be <= last sector");
591 if (!(last
<= (num_sectors
- 1))) {
592 command_print(cmd_ctx
, "ERROR: last sector must be <= %d",
593 (int) num_sectors
- 1);
600 static int handle_flash_erase_command(struct command_context_s
*cmd_ctx
,
601 char *cmd
, char **args
, int argc
)
610 if ((retval
= parse_u32(args
[0], &bank_nr
)) != ERROR_OK
)
613 flash_bank_t
*p
= get_flash_bank_by_num(bank_nr
);
617 if ((retval
= parse_u32(args
[1], &first
)) != ERROR_OK
)
619 if (strcmp(args
[2], "last") == 0)
620 last
= p
->num_sectors
- 1;
622 if ((retval
= parse_u32(args
[2], &last
)) != ERROR_OK
)
625 if ((retval
= flash_check_sector_parameters(cmd_ctx
,
626 first
, last
, p
->num_sectors
)) != ERROR_OK
)
631 duration_start_measure(&duration
);
633 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
) {
634 if ((retval
= duration_stop_measure(&duration
,
635 &duration_text
)) != ERROR_OK
)
637 command_print(cmd_ctx
, "erased sectors %i through %i "
638 "on flash bank %i in %s",
639 (int) first
, (int) last
, (int) bank_nr
,
645 return ERROR_COMMAND_SYNTAX_ERROR
;
650 static int handle_flash_protect_command(struct command_context_s
*cmd_ctx
,
651 char *cmd
, char **args
, int argc
)
661 if ((retval
= parse_u32(args
[0], &bank_nr
)) != ERROR_OK
)
664 flash_bank_t
*p
= get_flash_bank_by_num(bank_nr
);
668 if ((retval
= parse_u32(args
[1], &first
)) != ERROR_OK
)
670 if (strcmp(args
[2], "last") == 0)
671 last
= p
->num_sectors
- 1;
673 if ((retval
= parse_u32(args
[2], &last
)) != ERROR_OK
)
676 if (strcmp(args
[3], "on") == 0)
678 else if (strcmp(args
[3], "off") == 0)
681 return ERROR_COMMAND_SYNTAX_ERROR
;
683 if ((retval
= flash_check_sector_parameters(cmd_ctx
,
684 first
, last
, p
->num_sectors
)) != ERROR_OK
)
687 retval
= flash_driver_protect(p
, set
, first
, last
);
688 if (retval
== ERROR_OK
) {
689 command_print(cmd_ctx
, "%s protection for sectors %i "
690 "through %i on flash bank %i",
691 (set
) ? "set" : "cleared", (int) first
,
692 (int) last
, (int) bank_nr
);
696 return ERROR_COMMAND_SYNTAX_ERROR
;
701 static int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
703 target_t
*target
= get_current_target(cmd_ctx
);
711 int retval
, retvaltemp
;
715 return ERROR_COMMAND_SYNTAX_ERROR
;
718 /* flash auto-erase is disabled by default*/
720 bool auto_unlock
= false;
724 if (strcmp(args
[0], "erase") == 0)
729 command_print(cmd_ctx
, "auto erase enabled");
730 } else if (strcmp(args
[0], "unlock") == 0)
735 command_print(cmd_ctx
, "auto unlock enabled");
744 return ERROR_COMMAND_SYNTAX_ERROR
;
749 LOG_ERROR("no target selected");
753 duration_start_measure(&duration
);
757 image
.base_address_set
= 1;
758 image
.base_address
= strtoul(args
[1], NULL
, 0);
762 image
.base_address_set
= 0;
763 image
.base_address
= 0x0;
766 image
.start_address_set
= 0;
768 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
769 if (retval
!= ERROR_OK
)
774 retval
= flash_write_unlock(target
, &image
, &written
, auto_erase
, auto_unlock
);
775 if (retval
!= ERROR_OK
)
781 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
789 speed
= written
/ 1024.0;
790 speed
/= ((float)duration
.duration
.tv_sec
791 + ((float)duration
.duration
.tv_usec
/ 1000000.0));
792 command_print(cmd_ctx
,
793 "wrote %" PRIu32
" byte from file %s in %s (%f kb/s)",
794 written
, args
[0], duration_text
, speed
);
803 static int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
805 int err
= ERROR_OK
, retval
;
810 uint8_t readback
[1024];
812 uint32_t cur_size
= 0;
813 uint32_t chunk_count
;
816 target_t
*target
= get_current_target(cmd_ctx
);
822 return ERROR_COMMAND_SYNTAX_ERROR
;
825 address
= strtoul(args
[0], NULL
, 0);
826 pattern
= strtoul(args
[1], NULL
, 0);
827 count
= strtoul(args
[2], NULL
, 0);
844 return ERROR_COMMAND_SYNTAX_ERROR
;
847 chunk_count
= MIN(count
, (1024 / wordsize
));
851 for (i
= 0; i
< chunk_count
; i
++)
853 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
857 for (i
= 0; i
< chunk_count
; i
++)
859 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
863 memset(chunk
, pattern
, chunk_count
);
866 LOG_ERROR("BUG: can't happen");
870 duration_start_measure(&duration
);
872 for (wrote
= 0; wrote
< (count
*wordsize
); wrote
+= cur_size
)
874 cur_size
= MIN((count
*wordsize
- wrote
), sizeof(chunk
));
876 bank
= get_flash_bank_by_addr(target
, address
);
881 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
885 err
= target_read_buffer(target
, address
+ wrote
, cur_size
, readback
);
890 for (i
= 0; i
< cur_size
; i
++)
892 if (readback
[i
]!=chunk
[i
])
894 LOG_ERROR("Verfication error address 0x%08" PRIx32
", read back 0x%02x, expected 0x%02x",
895 address
+ wrote
+ i
, readback
[i
], chunk
[i
]);
902 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
909 speed
= wrote
/ 1024.0;
910 speed
/= ((float)duration
.duration
.tv_sec
911 + ((float)duration
.duration
.tv_usec
/ 1000000.0));
912 command_print(cmd_ctx
,
913 "wrote %" PRIu32
" bytes to 0x%8.8" PRIx32
" in %s (%f kb/s)",
914 wrote
, address
, duration_text
, speed
);
920 static int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
931 int retval
, retvaltemp
;
936 return ERROR_COMMAND_SYNTAX_ERROR
;
939 duration_start_measure(&duration
);
941 offset
= strtoul(args
[2], NULL
, 0);
942 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
945 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
949 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
954 buffer
= malloc(fileio
.size
);
955 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
958 fileio_close(&fileio
);
962 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
967 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
969 fileio_close(&fileio
);
972 if (retval
== ERROR_OK
)
974 command_print(cmd_ctx
,
975 "wrote %lld byte from file %s to flash bank %li at offset 0x%8.8" PRIx32
" in %s (%f kb/s)",
978 strtoul(args
[0], NULL
, 0),
981 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
985 fileio_close(&fileio
);
990 void flash_set_dirty(void)
995 /* set all flash to require erasing */
996 for (c
= flash_banks
; c
; c
= c
->next
)
998 for (i
= 0; i
< c
->num_sectors
; i
++)
1000 c
->sectors
[i
].is_erased
= 0;
1005 /* lookup flash bank by address */
1006 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, uint32_t addr
)
1010 /* cycle through bank list */
1011 for (c
= flash_banks
; c
; c
= c
->next
)
1014 retval
= c
->driver
->auto_probe(c
);
1016 if (retval
!= ERROR_OK
)
1018 LOG_ERROR("auto_probe failed %d\n", retval
);
1021 /* check whether address belongs to this flash bank */
1022 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
1025 LOG_ERROR("No flash at address 0x%08" PRIx32
"\n", addr
);
1029 /* erase given flash region, selects proper bank according to target and address */
1030 static int flash_iterate_address_range(target_t
*target
, uint32_t addr
, uint32_t length
,
1031 int (*callback
)(struct flash_bank_s
*bank
, int first
, int last
))
1038 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
1039 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
1041 if (c
->size
== 0 || c
->num_sectors
== 0)
1043 LOG_ERROR("Bank is invalid");
1044 return ERROR_FLASH_BANK_INVALID
;
1049 /* special case, erase whole bank when length is zero */
1050 if (addr
!= c
->base
)
1051 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
1053 return callback(c
, 0, c
->num_sectors
- 1);
1056 /* check whether it fits */
1057 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
1058 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
1062 for (i
= 0; i
< c
->num_sectors
; i
++)
1064 /* check whether sector overlaps with the given range and is not yet erased */
1065 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
1066 /* if first is not set yet then this is the first sector */
1069 last
= i
; /* and it is the last one so far in any case */
1073 if (first
== -1 || last
== -1)
1076 return callback(c
, first
, last
);
1081 int flash_erase_address_range(target_t
*target
, uint32_t addr
, uint32_t length
)
1083 return flash_iterate_address_range(target
, addr
, length
, &flash_driver_erase
);
1086 static int flash_driver_unprotect(struct flash_bank_s
*bank
, int first
, int last
)
1088 return flash_driver_protect(bank
, 0, first
, last
);
1091 static int flash_unlock_address_range(target_t
*target
, uint32_t addr
, uint32_t length
)
1093 return flash_iterate_address_range(target
, addr
, length
, &flash_driver_unprotect
);
1097 /* write (optional verify) an image to flash memory of the given target */
1098 static int flash_write_unlock(target_t
*target
, image_t
*image
, uint32_t *written
, int erase
, bool unlock
)
1100 int retval
= ERROR_OK
;
1103 uint32_t section_offset
;
1115 /* assume all sectors need erasing - stops any problems
1116 * when flash_write is called multiple times */
1121 /* allocate padding array */
1122 padding
= malloc(image
->num_sections
* sizeof(padding
));
1124 /* loop until we reach end of the image */
1125 while (section
< image
->num_sections
)
1127 uint32_t buffer_size
;
1131 uint32_t run_address
= image
->sections
[section
].base_address
+ section_offset
;
1132 uint32_t run_size
= image
->sections
[section
].size
- section_offset
;
1135 if (image
->sections
[section
].size
== 0)
1137 LOG_WARNING("empty section %d", section
);
1143 /* find the corresponding flash bank */
1144 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1146 section
++; /* and skip it */
1151 /* collect consecutive sections which fall into the same bank */
1152 section_first
= section
;
1153 section_last
= section
;
1154 padding
[section
] = 0;
1155 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
1156 && (section_last
+ 1 < image
->num_sections
))
1158 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1160 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1163 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1164 * attempt to rebuild a consecutive buffer for the flash loader */
1165 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1166 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1168 padding
[section_last
] = pad_bytes
;
1169 run_size
+= image
->sections
[++section_last
].size
;
1170 run_size
+= pad_bytes
;
1171 padding
[section_last
] = 0;
1173 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1176 /* fit the run into bank constraints */
1177 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
1179 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1180 (int)(c
->base
+ c
->size
- run_address
), (int)(run_size
), (int)(c
->size
));
1181 run_size
= c
->base
+ c
->size
- run_address
;
1184 /* allocate buffer */
1185 buffer
= malloc(run_size
);
1188 /* read sections to the buffer */
1189 while (buffer_size
< run_size
)
1193 size_read
= run_size
- buffer_size
;
1194 if (size_read
> image
->sections
[section
].size
- section_offset
)
1195 size_read
= image
->sections
[section
].size
- section_offset
;
1197 if ((retval
= image_read_section(image
, section
, section_offset
,
1198 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1205 /* see if we need to pad the section */
1206 while (padding
[section
]--)
1207 (buffer
+ buffer_size
)[size_read
++] = 0xff;
1209 buffer_size
+= size_read
;
1210 section_offset
+= size_read
;
1212 if (section_offset
>= image
->sections
[section
].size
)
1223 retval
= flash_unlock_address_range(target
, run_address
, run_size
);
1225 if (retval
== ERROR_OK
)
1229 /* calculate and erase sectors */
1230 retval
= flash_erase_address_range(target
, run_address
, run_size
);
1234 if (retval
== ERROR_OK
)
1236 /* write flash sectors */
1237 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1242 if (retval
!= ERROR_OK
)
1245 return retval
; /* abort operation */
1248 if (written
!= NULL
)
1249 *written
+= run_size
; /* add run size to total written counter */
1257 int flash_write(target_t
*target
, image_t
*image
, uint32_t *written
, int erase
)
1259 return flash_write_unlock(target
, image
, written
, erase
, false);
1262 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1264 target_t
*target
= bank
->target
;
1265 uint8_t buffer
[1024];
1266 int buffer_size
= sizeof(buffer
);
1270 if (bank
->target
->state
!= TARGET_HALTED
)
1272 LOG_ERROR("Target not halted");
1273 return ERROR_TARGET_NOT_HALTED
;
1276 for (i
= 0; i
< bank
->num_sectors
; i
++)
1279 bank
->sectors
[i
].is_erased
= 1;
1281 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1285 chunk
= buffer_size
;
1286 if (chunk
> (j
- bank
->sectors
[i
].size
))
1288 chunk
= (j
- bank
->sectors
[i
].size
);
1291 retval
= target_read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1292 if (retval
!= ERROR_OK
)
1295 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1297 if (buffer
[nBytes
] != 0xFF)
1299 bank
->sectors
[i
].is_erased
= 0;
1309 int default_flash_blank_check(struct flash_bank_s
*bank
)
1311 target_t
*target
= bank
->target
;
1317 if (bank
->target
->state
!= TARGET_HALTED
)
1319 LOG_ERROR("Target not halted");
1320 return ERROR_TARGET_NOT_HALTED
;
1323 for (i
= 0; i
< bank
->num_sectors
; i
++)
1325 uint32_t address
= bank
->base
+ bank
->sectors
[i
].offset
;
1326 uint32_t size
= bank
->sectors
[i
].size
;
1328 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1334 bank
->sectors
[i
].is_erased
= 1;
1336 bank
->sectors
[i
].is_erased
= 0;
1342 LOG_USER("Running slow fallback erase check - add working memory");
1343 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)