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 COMMAND_PARSE_NUMBER(u32
, args
[1], c
->base
);
311 COMMAND_PARSE_NUMBER(u32
, args
[2], c
->size
);
312 COMMAND_PARSE_NUMBER(int, args
[3], c
->chip_width
);
313 COMMAND_PARSE_NUMBER(int, args
[4], c
->bus_width
);
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
)
363 return ERROR_COMMAND_SYNTAX_ERROR
;
366 COMMAND_PARSE_NUMBER(uint
, args
[0], bank_nr
);
368 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
374 /* attempt auto probe */
375 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
378 command_print(cmd_ctx
,
379 "#%" PRIi32
" : %s at 0x%8.8" PRIx32
", size 0x%8.8" PRIx32
", buswidth %i, chipwidth %i",
386 for (j
= 0; j
< p
->num_sectors
; j
++)
390 if (p
->sectors
[j
].is_protected
== 0)
391 protect_state
= "not protected";
392 else if (p
->sectors
[j
].is_protected
== 1)
393 protect_state
= "protected";
395 protect_state
= "protection state unknown";
397 command_print(cmd_ctx
,
398 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
400 p
->sectors
[j
].offset
,
402 p
->sectors
[j
].size
>> 10,
406 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
407 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
408 command_print(cmd_ctx
, "%s", buf
);
409 if (retval
!= ERROR_OK
)
410 LOG_ERROR("error retrieving flash info (%d)", retval
);
417 static int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
423 return ERROR_COMMAND_SYNTAX_ERROR
;
427 COMMAND_PARSE_NUMBER(uint
, args
[0], bank_nr
);
428 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(bank_nr
);
431 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
433 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8" PRIx32
, p
->driver
->name
, p
->base
);
435 else if (retval
== ERROR_FLASH_BANK_INVALID
)
437 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32
,
442 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32
,
448 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
454 static int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
458 return ERROR_COMMAND_SYNTAX_ERROR
;
462 int retval
= flash_command_get_bank_by_num(cmd_ctx
, args
[0], &p
);
463 if (ERROR_OK
!= retval
)
469 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
471 command_print(cmd_ctx
, "successfully checked erase state");
475 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32
,
479 for (j
= 0; j
< p
->num_sectors
; j
++)
483 if (p
->sectors
[j
].is_erased
== 0)
484 erase_state
= "not erased";
485 else if (p
->sectors
[j
].is_erased
== 1)
486 erase_state
= "erased";
488 erase_state
= "erase state unknown";
490 command_print(cmd_ctx
,
491 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
493 p
->sectors
[j
].offset
,
495 p
->sectors
[j
].size
>> 10,
503 static int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
512 target_t
*target
= get_current_target(cmd_ctx
);
515 return ERROR_COMMAND_SYNTAX_ERROR
;
517 COMMAND_PARSE_NUMBER(int, args
[0], address
);
518 COMMAND_PARSE_NUMBER(int, args
[1], length
);
521 command_print(cmd_ctx
, "Length must be >0");
522 return ERROR_COMMAND_SYNTAX_ERROR
;
525 p
= get_flash_bank_by_addr(target
, address
);
531 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
534 duration_start_measure(&duration
);
536 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
538 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
542 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
549 static int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
552 return ERROR_COMMAND_SYNTAX_ERROR
;
555 int retval
= flash_command_get_bank_by_num(cmd_ctx
, args
[0], &p
);
556 if (ERROR_OK
!= retval
)
562 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
564 command_print(cmd_ctx
, "successfully checked protect state");
566 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
568 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32
, args
[0], p
->base
);
572 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32
, args
[0], p
->base
);
579 static int flash_check_sector_parameters(struct command_context_s
*cmd_ctx
,
580 uint32_t first
, uint32_t last
, uint32_t num_sectors
)
582 if (!(first
<= last
)) {
583 command_print(cmd_ctx
, "ERROR: "
584 "first sector must be <= last sector");
588 if (!(last
<= (num_sectors
- 1))) {
589 command_print(cmd_ctx
, "ERROR: last sector must be <= %d",
590 (int) num_sectors
- 1);
597 static int handle_flash_erase_command(struct command_context_s
*cmd_ctx
,
598 char *cmd
, char **args
, int argc
)
606 COMMAND_PARSE_NUMBER(u32
, args
[0], bank_nr
);
607 flash_bank_t
*p
= get_flash_bank_by_num(bank_nr
);
611 COMMAND_PARSE_NUMBER(u32
, args
[1], first
);
612 if (strcmp(args
[2], "last") == 0)
613 last
= p
->num_sectors
- 1;
615 COMMAND_PARSE_NUMBER(u32
, args
[2], last
);
618 if ((retval
= flash_check_sector_parameters(cmd_ctx
,
619 first
, last
, p
->num_sectors
)) != ERROR_OK
)
624 duration_start_measure(&duration
);
626 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
) {
627 if ((retval
= duration_stop_measure(&duration
,
628 &duration_text
)) != ERROR_OK
)
630 command_print(cmd_ctx
, "erased sectors %i through %i "
631 "on flash bank %i in %s",
632 (int) first
, (int) last
, (int) bank_nr
,
638 return ERROR_COMMAND_SYNTAX_ERROR
;
643 static int handle_flash_protect_command(struct command_context_s
*cmd_ctx
,
644 char *cmd
, char **args
, int argc
)
653 COMMAND_PARSE_NUMBER(u32
, args
[0], bank_nr
);
654 flash_bank_t
*p
= get_flash_bank_by_num(bank_nr
);
658 COMMAND_PARSE_NUMBER(u32
, args
[1], first
);
659 if (strcmp(args
[2], "last") == 0)
660 last
= p
->num_sectors
- 1;
662 COMMAND_PARSE_NUMBER(u32
, args
[2], last
);
664 if (strcmp(args
[3], "on") == 0)
666 else if (strcmp(args
[3], "off") == 0)
669 return ERROR_COMMAND_SYNTAX_ERROR
;
672 if ((retval
= flash_check_sector_parameters(cmd_ctx
,
673 first
, last
, p
->num_sectors
)) != ERROR_OK
)
676 retval
= flash_driver_protect(p
, set
, first
, last
);
677 if (retval
== ERROR_OK
) {
678 command_print(cmd_ctx
, "%s protection for sectors %i "
679 "through %i on flash bank %i",
680 (set
) ? "set" : "cleared", (int) first
,
681 (int) last
, (int) bank_nr
);
685 return ERROR_COMMAND_SYNTAX_ERROR
;
690 static int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
692 target_t
*target
= get_current_target(cmd_ctx
);
700 int retval
, retvaltemp
;
704 return ERROR_COMMAND_SYNTAX_ERROR
;
707 /* flash auto-erase is disabled by default*/
709 bool auto_unlock
= false;
713 if (strcmp(args
[0], "erase") == 0)
718 command_print(cmd_ctx
, "auto erase enabled");
719 } else if (strcmp(args
[0], "unlock") == 0)
724 command_print(cmd_ctx
, "auto unlock enabled");
733 return ERROR_COMMAND_SYNTAX_ERROR
;
738 LOG_ERROR("no target selected");
742 duration_start_measure(&duration
);
746 image
.base_address_set
= 1;
747 COMMAND_PARSE_NUMBER(int, args
[1], image
.base_address
);
751 image
.base_address_set
= 0;
752 image
.base_address
= 0x0;
755 image
.start_address_set
= 0;
757 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
758 if (retval
!= ERROR_OK
)
763 retval
= flash_write_unlock(target
, &image
, &written
, auto_erase
, auto_unlock
);
764 if (retval
!= ERROR_OK
)
770 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
778 speed
= written
/ 1024.0;
779 speed
/= ((float)duration
.duration
.tv_sec
780 + ((float)duration
.duration
.tv_usec
/ 1000000.0));
781 command_print(cmd_ctx
,
782 "wrote %" PRIu32
" byte from file %s in %s (%f kb/s)",
783 written
, args
[0], duration_text
, speed
);
792 static int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
794 int err
= ERROR_OK
, retval
;
799 uint8_t readback
[1024];
801 uint32_t cur_size
= 0;
802 uint32_t chunk_count
;
805 target_t
*target
= get_current_target(cmd_ctx
);
810 return ERROR_COMMAND_SYNTAX_ERROR
;
812 COMMAND_PARSE_NUMBER(u32
, args
[0], address
);
813 COMMAND_PARSE_NUMBER(u32
, args
[1], pattern
);
814 COMMAND_PARSE_NUMBER(u32
, args
[2], count
);
831 return ERROR_COMMAND_SYNTAX_ERROR
;
834 chunk_count
= MIN(count
, (1024 / wordsize
));
838 for (i
= 0; i
< chunk_count
; i
++)
840 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
844 for (i
= 0; i
< chunk_count
; i
++)
846 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
850 memset(chunk
, pattern
, chunk_count
);
853 LOG_ERROR("BUG: can't happen");
857 duration_start_measure(&duration
);
859 for (wrote
= 0; wrote
< (count
*wordsize
); wrote
+= cur_size
)
861 cur_size
= MIN((count
*wordsize
- wrote
), sizeof(chunk
));
863 bank
= get_flash_bank_by_addr(target
, address
);
868 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
872 err
= target_read_buffer(target
, address
+ wrote
, cur_size
, readback
);
877 for (i
= 0; i
< cur_size
; i
++)
879 if (readback
[i
]!=chunk
[i
])
881 LOG_ERROR("Verfication error address 0x%08" PRIx32
", read back 0x%02x, expected 0x%02x",
882 address
+ wrote
+ i
, readback
[i
], chunk
[i
]);
889 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
896 speed
= wrote
/ 1024.0;
897 speed
/= ((float)duration
.duration
.tv_sec
898 + ((float)duration
.duration
.tv_usec
/ 1000000.0));
899 command_print(cmd_ctx
,
900 "wrote %" PRIu32
" bytes to 0x%8.8" PRIx32
" in %s (%f kb/s)",
901 wrote
, address
, duration_text
, speed
);
907 static int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
920 return ERROR_COMMAND_SYNTAX_ERROR
;
922 duration_start_measure(&duration
);
925 int retval
= flash_command_get_bank_by_num(cmd_ctx
, args
[0], &p
);
926 if (ERROR_OK
!= retval
)
929 COMMAND_PARSE_NUMBER(u32
, args
[2], offset
);
931 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
936 buffer
= malloc(fileio
.size
);
937 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
940 fileio_close(&fileio
);
944 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
950 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
952 fileio_close(&fileio
);
955 if (retval
== ERROR_OK
)
957 float elapsed
= (float)duration
.duration
.tv_sec
;
958 elapsed
+= (float)duration
.duration
.tv_usec
/ 1000000.0;
959 float speed
= (float)fileio
.size
/ elapsed
;
960 command_print(cmd_ctx
,
961 "wrote %lld byte from file %s to flash bank %u "
962 "at offset 0x%8.8" PRIx32
" in %s (%f kb/s)",
963 fileio
.size
, args
[1], p
->bank_number
, offset
,
964 duration_text
, speed
/ 1024);
968 fileio_close(&fileio
);
973 void flash_set_dirty(void)
978 /* set all flash to require erasing */
979 for (c
= flash_banks
; c
; c
= c
->next
)
981 for (i
= 0; i
< c
->num_sectors
; i
++)
983 c
->sectors
[i
].is_erased
= 0;
988 /* lookup flash bank by address */
989 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, uint32_t addr
)
993 /* cycle through bank list */
994 for (c
= flash_banks
; c
; c
= c
->next
)
997 retval
= c
->driver
->auto_probe(c
);
999 if (retval
!= ERROR_OK
)
1001 LOG_ERROR("auto_probe failed %d\n", retval
);
1004 /* check whether address belongs to this flash bank */
1005 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
1008 LOG_ERROR("No flash at address 0x%08" PRIx32
"\n", addr
);
1012 /* erase given flash region, selects proper bank according to target and address */
1013 static int flash_iterate_address_range(target_t
*target
, uint32_t addr
, uint32_t length
,
1014 int (*callback
)(struct flash_bank_s
*bank
, int first
, int last
))
1021 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
1022 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
1024 if (c
->size
== 0 || c
->num_sectors
== 0)
1026 LOG_ERROR("Bank is invalid");
1027 return ERROR_FLASH_BANK_INVALID
;
1032 /* special case, erase whole bank when length is zero */
1033 if (addr
!= c
->base
)
1034 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
1036 return callback(c
, 0, c
->num_sectors
- 1);
1039 /* check whether it fits */
1040 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
1041 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
1045 for (i
= 0; i
< c
->num_sectors
; i
++)
1047 /* check whether sector overlaps with the given range and is not yet erased */
1048 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
1049 /* if first is not set yet then this is the first sector */
1052 last
= i
; /* and it is the last one so far in any case */
1056 if (first
== -1 || last
== -1)
1059 return callback(c
, first
, last
);
1064 int flash_erase_address_range(target_t
*target
, uint32_t addr
, uint32_t length
)
1066 return flash_iterate_address_range(target
, addr
, length
, &flash_driver_erase
);
1069 static int flash_driver_unprotect(struct flash_bank_s
*bank
, int first
, int last
)
1071 return flash_driver_protect(bank
, 0, first
, last
);
1074 static int flash_unlock_address_range(target_t
*target
, uint32_t addr
, uint32_t length
)
1076 return flash_iterate_address_range(target
, addr
, length
, &flash_driver_unprotect
);
1080 /* write (optional verify) an image to flash memory of the given target */
1081 static int flash_write_unlock(target_t
*target
, image_t
*image
, uint32_t *written
, int erase
, bool unlock
)
1083 int retval
= ERROR_OK
;
1086 uint32_t section_offset
;
1098 /* assume all sectors need erasing - stops any problems
1099 * when flash_write is called multiple times */
1104 /* allocate padding array */
1105 padding
= malloc(image
->num_sections
* sizeof(padding
));
1107 /* loop until we reach end of the image */
1108 while (section
< image
->num_sections
)
1110 uint32_t buffer_size
;
1114 uint32_t run_address
= image
->sections
[section
].base_address
+ section_offset
;
1115 uint32_t run_size
= image
->sections
[section
].size
- section_offset
;
1118 if (image
->sections
[section
].size
== 0)
1120 LOG_WARNING("empty section %d", section
);
1126 /* find the corresponding flash bank */
1127 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1129 section
++; /* and skip it */
1134 /* collect consecutive sections which fall into the same bank */
1135 section_first
= section
;
1136 section_last
= section
;
1137 padding
[section
] = 0;
1138 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
1139 && (section_last
+ 1 < image
->num_sections
))
1141 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1143 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1146 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1147 * attempt to rebuild a consecutive buffer for the flash loader */
1148 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1149 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1151 padding
[section_last
] = pad_bytes
;
1152 run_size
+= image
->sections
[++section_last
].size
;
1153 run_size
+= pad_bytes
;
1154 padding
[section_last
] = 0;
1156 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1159 /* fit the run into bank constraints */
1160 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
1162 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1163 (int)(c
->base
+ c
->size
- run_address
), (int)(run_size
), (int)(c
->size
));
1164 run_size
= c
->base
+ c
->size
- run_address
;
1167 /* allocate buffer */
1168 buffer
= malloc(run_size
);
1171 /* read sections to the buffer */
1172 while (buffer_size
< run_size
)
1176 size_read
= run_size
- buffer_size
;
1177 if (size_read
> image
->sections
[section
].size
- section_offset
)
1178 size_read
= image
->sections
[section
].size
- section_offset
;
1180 if ((retval
= image_read_section(image
, section
, section_offset
,
1181 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1188 /* see if we need to pad the section */
1189 while (padding
[section
]--)
1190 (buffer
+ buffer_size
)[size_read
++] = 0xff;
1192 buffer_size
+= size_read
;
1193 section_offset
+= size_read
;
1195 if (section_offset
>= image
->sections
[section
].size
)
1206 retval
= flash_unlock_address_range(target
, run_address
, run_size
);
1208 if (retval
== ERROR_OK
)
1212 /* calculate and erase sectors */
1213 retval
= flash_erase_address_range(target
, run_address
, run_size
);
1217 if (retval
== ERROR_OK
)
1219 /* write flash sectors */
1220 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1225 if (retval
!= ERROR_OK
)
1228 return retval
; /* abort operation */
1231 if (written
!= NULL
)
1232 *written
+= run_size
; /* add run size to total written counter */
1240 int flash_write(target_t
*target
, image_t
*image
, uint32_t *written
, int erase
)
1242 return flash_write_unlock(target
, image
, written
, erase
, false);
1245 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1247 target_t
*target
= bank
->target
;
1248 uint8_t buffer
[1024];
1249 int buffer_size
= sizeof(buffer
);
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
++)
1262 bank
->sectors
[i
].is_erased
= 1;
1264 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1268 chunk
= buffer_size
;
1269 if (chunk
> (j
- bank
->sectors
[i
].size
))
1271 chunk
= (j
- bank
->sectors
[i
].size
);
1274 retval
= target_read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1275 if (retval
!= ERROR_OK
)
1278 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1280 if (buffer
[nBytes
] != 0xFF)
1282 bank
->sectors
[i
].is_erased
= 0;
1292 int default_flash_blank_check(struct flash_bank_s
*bank
)
1294 target_t
*target
= bank
->target
;
1300 if (bank
->target
->state
!= TARGET_HALTED
)
1302 LOG_ERROR("Target not halted");
1303 return ERROR_TARGET_NOT_HALTED
;
1306 for (i
= 0; i
< bank
->num_sectors
; i
++)
1308 uint32_t address
= bank
->base
+ bank
->sectors
[i
].offset
;
1309 uint32_t size
= bank
->sectors
[i
].size
;
1311 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1317 bank
->sectors
[i
].is_erased
= 1;
1319 bank
->sectors
[i
].is_erased
= 0;
1325 LOG_USER("Running slow fallback erase check - add working memory");
1326 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)