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"
36 /* command handlers */
37 static int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
38 static int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
39 static int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
40 static int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
41 static int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
42 static int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
43 static int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
44 static int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
45 static int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
46 static int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
47 static int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 extern flash_driver_t lpc2000_flash
;
52 extern flash_driver_t cfi_flash
;
53 extern flash_driver_t at91sam7_flash
;
54 extern flash_driver_t str7x_flash
;
55 extern flash_driver_t str9x_flash
;
56 extern flash_driver_t aduc702x_flash
;
57 extern flash_driver_t stellaris_flash
;
58 extern flash_driver_t str9xpec_flash
;
59 extern flash_driver_t stm32x_flash
;
60 extern flash_driver_t tms470_flash
;
61 extern flash_driver_t ecosflash_flash
;
62 extern flash_driver_t lpc288x_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
[] = {
86 flash_bank_t
*flash_banks
;
87 static command_t
*flash_cmd
;
89 /* wafer thin wrapper for invoking the flash driver */
90 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
94 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
97 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
103 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
107 retval
=bank
->driver
->erase(bank
, first
, last
);
108 if (retval
!=ERROR_OK
)
110 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
116 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
120 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
121 if (retval
!=ERROR_OK
)
123 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
129 int flash_register_commands(struct command_context_s
*cmd_ctx
)
131 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
133 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 ...]");
137 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
142 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
146 Jim_Obj
*list
=Jim_NewListObj(interp
, NULL
, 0);
147 for (p
= flash_banks
; p
; p
= p
->next
)
149 Jim_Obj
*elem
=Jim_NewListObj(interp
, NULL
, 0);
151 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
152 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
153 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
154 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
155 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
156 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
157 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
158 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
159 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
160 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
162 Jim_ListAppendElement(interp
, list
, elem
);
165 Jim_SetResult(interp
, list
);
170 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
172 register_jim(cmd_ctx
, "ocd_flash_banks", jim_flash_banks
, "return information about the flash banks");
176 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
177 "print info about flash bank <num>");
178 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
179 "identify flash bank <num>");
180 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
181 "check erase state of sectors in flash bank <num>");
182 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
183 "check protection state of sectors in flash bank <num>");
184 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
185 "erase sectors at <bank> <first> <last>");
186 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
187 "erase address range <address> <length>");
189 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
190 "fill with pattern (no autoerase) <address> <word_pattern> <count>");
191 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
192 "fill with pattern <address> <halfword_pattern> <count>");
193 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
194 "fill with pattern <address> <byte_pattern> <count>");
196 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
197 "write binary data to <bank> <file> <offset>");
198 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
199 "write_image [erase] <file> [offset] [type]");
200 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
201 "set protection of sectors at <bank> <first> <last> <on|off>");
207 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
212 for (p
= flash_banks
; p
; p
= p
->next
)
219 LOG_ERROR("flash bank %d does not exist", num
);
223 int flash_get_bank_count(void)
227 for (p
= flash_banks
; p
; p
= p
->next
)
234 flash_bank_t
*get_flash_bank_by_num(int num
)
236 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
242 retval
= p
->driver
->auto_probe(p
);
244 if (retval
!= ERROR_OK
)
246 LOG_ERROR("auto_probe failed %d\n", retval
);
252 static int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
261 return ERROR_COMMAND_SYNTAX_ERROR
;
264 if ((target
= get_target(args
[5])) == NULL
)
266 LOG_ERROR("target '%s' not defined", args
[5]);
270 for (i
= 0; flash_drivers
[i
]; i
++)
272 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
276 /* register flash specific commands */
277 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
279 LOG_ERROR("couldn't register '%s' commands", args
[0]);
283 c
= malloc(sizeof(flash_bank_t
));
285 c
->driver
= flash_drivers
[i
];
286 c
->driver_priv
= NULL
;
287 c
->base
= strtoul(args
[1], NULL
, 0);
288 c
->size
= strtoul(args
[2], NULL
, 0);
289 c
->chip_width
= strtoul(args
[3], NULL
, 0);
290 c
->bus_width
= strtoul(args
[4], NULL
, 0);
295 if ((retval
=flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
)) != ERROR_OK
)
297 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
302 /* put flash bank in linked list */
306 /* find last flash bank */
307 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
) bank_num
++;
310 c
->bank_number
= bank_num
+ 1;
322 /* no matching flash driver found */
325 LOG_ERROR("flash driver '%s' not found", args
[0]);
332 static int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
341 return ERROR_COMMAND_SYNTAX_ERROR
;
344 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
346 if (i
== strtoul(args
[0], NULL
, 0))
350 /* attempt auto probe */
351 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
354 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
355 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
356 for (j
= 0; j
< p
->num_sectors
; j
++)
360 if (p
->sectors
[j
].is_protected
== 0)
361 protect_state
= "not protected";
362 else if (p
->sectors
[j
].is_protected
== 1)
363 protect_state
= "protected";
365 protect_state
= "protection state unknown";
367 command_print(cmd_ctx
, "\t#%3i: 0x%8.8x (0x%x %ikB) %s",
368 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
372 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
373 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
374 command_print(cmd_ctx
, "%s", buf
);
375 if (retval
!= ERROR_OK
)
376 LOG_ERROR("error retrieving flash info (%d)", retval
);
383 static int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
390 return ERROR_COMMAND_SYNTAX_ERROR
;
393 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
396 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
398 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
400 else if (retval
== ERROR_FLASH_BANK_INVALID
)
402 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
407 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
413 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
419 static int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
426 return ERROR_COMMAND_SYNTAX_ERROR
;
429 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
433 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
435 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
439 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
443 for (j
= 0; j
< p
->num_sectors
; j
++)
447 if (p
->sectors
[j
].is_erased
== 0)
448 erase_state
= "not erased";
449 else if (p
->sectors
[j
].is_erased
== 1)
450 erase_state
= "erased";
452 erase_state
= "erase state unknown";
454 command_print(cmd_ctx
, "\t#%3i: 0x%8.8x (0x%x %ikB) %s",
455 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
463 static int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
472 target_t
*target
= get_current_target(cmd_ctx
);
476 return ERROR_COMMAND_SYNTAX_ERROR
;
479 address
= strtoul(args
[0], NULL
, 0);
480 length
= strtoul(args
[1], NULL
, 0);
483 command_print(cmd_ctx
, "Length must be >0");
484 return ERROR_COMMAND_SYNTAX_ERROR
;
487 p
= get_flash_bank_by_addr(target
, address
);
493 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
496 duration_start_measure(&duration
);
498 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
500 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
504 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
511 static int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
518 return ERROR_COMMAND_SYNTAX_ERROR
;
521 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
524 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
526 command_print(cmd_ctx
, "successfully checked protect state");
528 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
530 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
534 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
539 return ERROR_COMMAND_SYNTAX_ERROR
;
545 static int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
549 int first
= strtoul(args
[1], NULL
, 0);
550 int last
= strtoul(args
[2], NULL
, 0);
552 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
556 duration_start_measure(&duration
);
560 return ERROR_COMMAND_SYNTAX_ERROR
;
563 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
565 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
570 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
576 return ERROR_COMMAND_SYNTAX_ERROR
;
582 static int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
586 int first
= strtoul(args
[1], NULL
, 0);
587 int last
= strtoul(args
[2], NULL
, 0);
590 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
593 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
597 if (strcmp(args
[3], "on") == 0)
599 else if (strcmp(args
[3], "off") == 0)
603 return ERROR_COMMAND_SYNTAX_ERROR
;
606 retval
= flash_driver_protect(p
, set
, first
, last
);
607 if (retval
== ERROR_OK
)
609 command_print(cmd_ctx
, "%s protection for sectors %i through %i on flash bank %i", (set
) ? "set" : "cleared", first
, last
, strtoul(args
[0], 0, 0));
614 return ERROR_COMMAND_SYNTAX_ERROR
;
621 static int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
623 target_t
*target
= get_current_target(cmd_ctx
);
631 int retval
, retvaltemp
;
635 return ERROR_COMMAND_SYNTAX_ERROR
;
638 /* flash auto-erase is disabled by default*/
641 if (strcmp(args
[0], "erase")==0)
646 command_print(cmd_ctx
, "auto erase enabled");
651 return ERROR_COMMAND_SYNTAX_ERROR
;
656 LOG_ERROR("no target selected");
660 duration_start_measure(&duration
);
664 image
.base_address_set
= 1;
665 image
.base_address
= strtoul(args
[1], NULL
, 0);
669 image
.base_address_set
= 0;
670 image
.base_address
= 0x0;
673 image
.start_address_set
= 0;
675 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
676 if (retval
!= ERROR_OK
)
681 retval
= flash_write(target
, &image
, &written
, auto_erase
);
682 if (retval
!= ERROR_OK
)
688 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
693 if (retval
== ERROR_OK
)
695 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
696 written
, args
[0], duration_text
,
697 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
706 static int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
708 int err
= ERROR_OK
, retval
;
719 target_t
*target
= get_current_target(cmd_ctx
);
725 return ERROR_COMMAND_SYNTAX_ERROR
;
728 address
= strtoul(args
[0], NULL
, 0);
729 pattern
= strtoul(args
[1], NULL
, 0);
730 count
= strtoul(args
[2], NULL
, 0);
747 return ERROR_COMMAND_SYNTAX_ERROR
;
750 chunk_count
= MIN(count
, (1024 / wordsize
));
754 for(i
= 0; i
< chunk_count
; i
++)
756 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
760 for(i
= 0; i
< chunk_count
; i
++)
762 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
766 memset(chunk
, pattern
, chunk_count
);
769 LOG_ERROR("BUG: can't happen");
773 duration_start_measure(&duration
);
775 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+= cur_size
)
777 cur_size
= MIN( (count
*wordsize
- wrote
), sizeof(chunk
) );
779 bank
= get_flash_bank_by_addr(target
, address
);
784 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
788 err
= target_read_buffer(target
, address
+ wrote
, cur_size
, readback
);
793 for (i
=0; i
<cur_size
; i
++)
795 if (readback
[i
]!=chunk
[i
])
797 LOG_ERROR("Verfication error address 0x%08x, read back 0x%02x, expected 0x%02x", address
+ wrote
+ i
, readback
[i
], chunk
[i
]);
804 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
812 speed
=wrote
/ 1024.0;
813 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
814 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
815 count
*wordsize
, address
, duration_text
,
822 static int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
833 int retval
, retvaltemp
;
838 return ERROR_COMMAND_SYNTAX_ERROR
;
841 duration_start_measure(&duration
);
843 offset
= strtoul(args
[2], NULL
, 0);
844 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
847 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
851 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
856 buffer
= malloc(fileio
.size
);
857 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
860 fileio_close(&fileio
);
864 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
869 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
871 fileio_close(&fileio
);
874 if (retval
==ERROR_OK
)
876 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
877 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
878 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
882 fileio_close(&fileio
);
887 void flash_set_dirty(void)
892 /* set all flash to require erasing */
893 for (c
= flash_banks
; c
; c
= c
->next
)
895 for (i
= 0; i
< c
->num_sectors
; i
++)
897 c
->sectors
[i
].is_erased
= 0;
902 /* lookup flash bank by address */
903 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
907 /* cycle through bank list */
908 for (c
= flash_banks
; c
; c
= c
->next
)
911 retval
= c
->driver
->auto_probe(c
);
913 if (retval
!= ERROR_OK
)
915 LOG_ERROR("auto_probe failed %d\n", retval
);
918 /* check whether address belongs to this flash bank */
919 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
922 LOG_ERROR("No flash at address 0x%08x\n", addr
);
926 /* erase given flash region, selects proper bank according to target and address */
927 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
934 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
935 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
937 if (c
->size
== 0 || c
->num_sectors
== 0)
939 LOG_ERROR("Bank is invalid");
940 return ERROR_FLASH_BANK_INVALID
;
945 /* special case, erase whole bank when length is zero */
947 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
949 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
952 /* check whether it fits */
953 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
954 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
958 for (i
= 0; i
< c
->num_sectors
; i
++)
960 /* check whether sector overlaps with the given range and is not yet erased */
961 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
962 /* if first is not set yet then this is the first sector */
965 last
= i
; /* and it is the last one so far in any case */
969 if( first
== -1 || last
== -1 )
972 return flash_driver_erase(c
, first
, last
);
975 /* write (optional verify) an image to flash memory of the given target */
976 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
993 /* assume all sectors need erasing - stops any problems
994 * when flash_write is called multiple times */
999 /* allocate padding array */
1000 padding
= malloc(image
->num_sections
* sizeof(padding
));
1002 /* loop until we reach end of the image */
1003 while (section
< image
->num_sections
)
1009 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
1010 u32 run_size
= image
->sections
[section
].size
- section_offset
;
1013 if (image
->sections
[section
].size
== 0)
1015 LOG_WARNING("empty section %d", section
);
1021 /* find the corresponding flash bank */
1022 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1024 section
++; /* and skip it */
1029 /* collect consecutive sections which fall into the same bank */
1030 section_first
= section
;
1031 section_last
= section
;
1032 padding
[section
] = 0;
1033 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
1034 && (section_last
+ 1 < image
->num_sections
))
1036 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1038 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1041 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1042 * attempt to rebuild a consecutive buffer for the flash loader */
1043 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1044 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1046 padding
[section_last
] = pad_bytes
;
1047 run_size
+= image
->sections
[++section_last
].size
;
1048 run_size
+= pad_bytes
;
1049 padding
[section_last
] = 0;
1051 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1054 /* fit the run into bank constraints */
1055 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
1057 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1058 c
->base
+ c
->size
- run_address
, run_size
, c
->size
);
1059 run_size
= c
->base
+ c
->size
- run_address
;
1062 /* allocate buffer */
1063 buffer
= malloc(run_size
);
1066 /* read sections to the buffer */
1067 while (buffer_size
< run_size
)
1071 size_read
= run_size
- buffer_size
;
1072 if (size_read
> image
->sections
[section
].size
- section_offset
)
1073 size_read
= image
->sections
[section
].size
- section_offset
;
1075 if ((retval
= image_read_section(image
, section
, section_offset
,
1076 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1083 /* see if we need to pad the section */
1084 while (padding
[section
]--)
1085 (buffer
+buffer_size
)[size_read
++] = 0xff;
1087 buffer_size
+= size_read
;
1088 section_offset
+= size_read
;
1090 if (section_offset
>= image
->sections
[section
].size
)
1101 /* calculate and erase sectors */
1102 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1105 if (retval
== ERROR_OK
)
1107 /* write flash sectors */
1108 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1113 if (retval
!= ERROR_OK
)
1116 return retval
; /* abort operation */
1119 if (written
!= NULL
)
1120 *written
+= run_size
; /* add run size to total written counter */
1128 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1130 target_t
*target
= bank
->target
;
1132 int buffer_size
= sizeof(buffer
);
1136 if (bank
->target
->state
!= TARGET_HALTED
)
1138 LOG_ERROR("Target not halted");
1139 return ERROR_TARGET_NOT_HALTED
;
1142 for (i
= 0; i
< bank
->num_sectors
; i
++)
1145 bank
->sectors
[i
].is_erased
= 1;
1147 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1151 chunk
= buffer_size
;
1152 if (chunk
> (j
- bank
->sectors
[i
].size
))
1154 chunk
= (j
- bank
->sectors
[i
].size
);
1157 retval
= target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1158 if (retval
!= ERROR_OK
)
1161 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1163 if (buffer
[nBytes
] != 0xFF)
1165 bank
->sectors
[i
].is_erased
= 0;
1175 int default_flash_blank_check(struct flash_bank_s
*bank
)
1177 target_t
*target
= bank
->target
;
1183 if (bank
->target
->state
!= TARGET_HALTED
)
1185 LOG_ERROR("Target not halted");
1186 return ERROR_TARGET_NOT_HALTED
;
1189 for (i
= 0; i
< bank
->num_sectors
; i
++)
1191 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1192 u32 size
= bank
->sectors
[i
].size
;
1194 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1200 bank
->sectors
[i
].is_erased
= 1;
1202 bank
->sectors
[i
].is_erased
= 0;
1208 LOG_USER("Running slow fallback erase check - add working memory");
1209 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)