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");
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 %li in %s",
571 first
, last
, strtoul(args
[0], 0, 0), duration_text
);
577 return ERROR_COMMAND_SYNTAX_ERROR
;
583 static int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
587 int first
= strtoul(args
[1], NULL
, 0);
588 int last
= strtoul(args
[2], NULL
, 0);
591 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
594 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
598 if (strcmp(args
[3], "on") == 0)
600 else if (strcmp(args
[3], "off") == 0)
604 return ERROR_COMMAND_SYNTAX_ERROR
;
607 retval
= flash_driver_protect(p
, set
, first
, last
);
608 if (retval
== ERROR_OK
)
610 command_print(cmd_ctx
, "%s protection for sectors %i through %i on flash bank %li",
611 (set
) ? "set" : "cleared", first
,
612 last
, strtoul(args
[0], 0, 0));
617 return ERROR_COMMAND_SYNTAX_ERROR
;
624 static int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
626 target_t
*target
= get_current_target(cmd_ctx
);
634 int retval
, retvaltemp
;
638 return ERROR_COMMAND_SYNTAX_ERROR
;
641 /* flash auto-erase is disabled by default*/
644 if (strcmp(args
[0], "erase")==0)
649 command_print(cmd_ctx
, "auto erase enabled");
654 return ERROR_COMMAND_SYNTAX_ERROR
;
659 LOG_ERROR("no target selected");
663 duration_start_measure(&duration
);
667 image
.base_address_set
= 1;
668 image
.base_address
= strtoul(args
[1], NULL
, 0);
672 image
.base_address_set
= 0;
673 image
.base_address
= 0x0;
676 image
.start_address_set
= 0;
678 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
679 if (retval
!= ERROR_OK
)
684 retval
= flash_write(target
, &image
, &written
, auto_erase
);
685 if (retval
!= ERROR_OK
)
691 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
696 if (retval
== ERROR_OK
)
698 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
699 written
, args
[0], duration_text
,
700 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
709 static int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
711 int err
= ERROR_OK
, retval
;
722 target_t
*target
= get_current_target(cmd_ctx
);
728 return ERROR_COMMAND_SYNTAX_ERROR
;
731 address
= strtoul(args
[0], NULL
, 0);
732 pattern
= strtoul(args
[1], NULL
, 0);
733 count
= strtoul(args
[2], NULL
, 0);
750 return ERROR_COMMAND_SYNTAX_ERROR
;
753 chunk_count
= MIN(count
, (1024 / wordsize
));
757 for(i
= 0; i
< chunk_count
; i
++)
759 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
763 for(i
= 0; i
< chunk_count
; i
++)
765 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
769 memset(chunk
, pattern
, chunk_count
);
772 LOG_ERROR("BUG: can't happen");
776 duration_start_measure(&duration
);
778 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+= cur_size
)
780 cur_size
= MIN( (count
*wordsize
- wrote
), sizeof(chunk
) );
782 bank
= get_flash_bank_by_addr(target
, address
);
787 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
791 err
= target_read_buffer(target
, address
+ wrote
, cur_size
, readback
);
796 for (i
=0; i
<cur_size
; i
++)
798 if (readback
[i
]!=chunk
[i
])
800 LOG_ERROR("Verfication error address 0x%08x, read back 0x%02x, expected 0x%02x", address
+ wrote
+ i
, readback
[i
], chunk
[i
]);
807 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
815 speed
=wrote
/ 1024.0;
816 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
817 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
818 count
*wordsize
, address
, duration_text
,
825 static int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
836 int retval
, retvaltemp
;
841 return ERROR_COMMAND_SYNTAX_ERROR
;
844 duration_start_measure(&duration
);
846 offset
= strtoul(args
[2], NULL
, 0);
847 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
850 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
854 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
859 buffer
= malloc(fileio
.size
);
860 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
863 fileio_close(&fileio
);
867 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
872 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
874 fileio_close(&fileio
);
877 if (retval
==ERROR_OK
)
879 command_print(cmd_ctx
, "wrote %lld byte from file %s to flash bank %li at offset 0x%8.8x in %s (%f kb/s)",
880 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
881 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
885 fileio_close(&fileio
);
890 void flash_set_dirty(void)
895 /* set all flash to require erasing */
896 for (c
= flash_banks
; c
; c
= c
->next
)
898 for (i
= 0; i
< c
->num_sectors
; i
++)
900 c
->sectors
[i
].is_erased
= 0;
905 /* lookup flash bank by address */
906 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
910 /* cycle through bank list */
911 for (c
= flash_banks
; c
; c
= c
->next
)
914 retval
= c
->driver
->auto_probe(c
);
916 if (retval
!= ERROR_OK
)
918 LOG_ERROR("auto_probe failed %d\n", retval
);
921 /* check whether address belongs to this flash bank */
922 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
925 LOG_ERROR("No flash at address 0x%08x\n", addr
);
929 /* erase given flash region, selects proper bank according to target and address */
930 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
937 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
938 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
940 if (c
->size
== 0 || c
->num_sectors
== 0)
942 LOG_ERROR("Bank is invalid");
943 return ERROR_FLASH_BANK_INVALID
;
948 /* special case, erase whole bank when length is zero */
950 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
952 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
955 /* check whether it fits */
956 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
957 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
961 for (i
= 0; i
< c
->num_sectors
; i
++)
963 /* check whether sector overlaps with the given range and is not yet erased */
964 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
965 /* if first is not set yet then this is the first sector */
968 last
= i
; /* and it is the last one so far in any case */
972 if( first
== -1 || last
== -1 )
975 return flash_driver_erase(c
, first
, last
);
978 /* write (optional verify) an image to flash memory of the given target */
979 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
996 /* assume all sectors need erasing - stops any problems
997 * when flash_write is called multiple times */
1002 /* allocate padding array */
1003 padding
= malloc(image
->num_sections
* sizeof(padding
));
1005 /* loop until we reach end of the image */
1006 while (section
< image
->num_sections
)
1012 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
1013 u32 run_size
= image
->sections
[section
].size
- section_offset
;
1016 if (image
->sections
[section
].size
== 0)
1018 LOG_WARNING("empty section %d", section
);
1024 /* find the corresponding flash bank */
1025 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1027 section
++; /* and skip it */
1032 /* collect consecutive sections which fall into the same bank */
1033 section_first
= section
;
1034 section_last
= section
;
1035 padding
[section
] = 0;
1036 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
1037 && (section_last
+ 1 < image
->num_sections
))
1039 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1041 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1044 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1045 * attempt to rebuild a consecutive buffer for the flash loader */
1046 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1047 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1049 padding
[section_last
] = pad_bytes
;
1050 run_size
+= image
->sections
[++section_last
].size
;
1051 run_size
+= pad_bytes
;
1052 padding
[section_last
] = 0;
1054 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1057 /* fit the run into bank constraints */
1058 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
1060 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1061 c
->base
+ c
->size
- run_address
, run_size
, c
->size
);
1062 run_size
= c
->base
+ c
->size
- run_address
;
1065 /* allocate buffer */
1066 buffer
= malloc(run_size
);
1069 /* read sections to the buffer */
1070 while (buffer_size
< run_size
)
1074 size_read
= run_size
- buffer_size
;
1075 if (size_read
> image
->sections
[section
].size
- section_offset
)
1076 size_read
= image
->sections
[section
].size
- section_offset
;
1078 if ((retval
= image_read_section(image
, section
, section_offset
,
1079 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1086 /* see if we need to pad the section */
1087 while (padding
[section
]--)
1088 (buffer
+buffer_size
)[size_read
++] = 0xff;
1090 buffer_size
+= size_read
;
1091 section_offset
+= size_read
;
1093 if (section_offset
>= image
->sections
[section
].size
)
1104 /* calculate and erase sectors */
1105 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1108 if (retval
== ERROR_OK
)
1110 /* write flash sectors */
1111 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1116 if (retval
!= ERROR_OK
)
1119 return retval
; /* abort operation */
1122 if (written
!= NULL
)
1123 *written
+= run_size
; /* add run size to total written counter */
1131 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1133 target_t
*target
= bank
->target
;
1135 int buffer_size
= sizeof(buffer
);
1139 if (bank
->target
->state
!= TARGET_HALTED
)
1141 LOG_ERROR("Target not halted");
1142 return ERROR_TARGET_NOT_HALTED
;
1145 for (i
= 0; i
< bank
->num_sectors
; i
++)
1148 bank
->sectors
[i
].is_erased
= 1;
1150 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1154 chunk
= buffer_size
;
1155 if (chunk
> (j
- bank
->sectors
[i
].size
))
1157 chunk
= (j
- bank
->sectors
[i
].size
);
1160 retval
= target_read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1161 if (retval
!= ERROR_OK
)
1164 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1166 if (buffer
[nBytes
] != 0xFF)
1168 bank
->sectors
[i
].is_erased
= 0;
1178 int default_flash_blank_check(struct flash_bank_s
*bank
)
1180 target_t
*target
= bank
->target
;
1186 if (bank
->target
->state
!= TARGET_HALTED
)
1188 LOG_ERROR("Target not halted");
1189 return ERROR_TARGET_NOT_HALTED
;
1192 for (i
= 0; i
< bank
->num_sectors
; i
++)
1194 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1195 u32 size
= bank
->sectors
[i
].size
;
1197 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1203 bank
->sectors
[i
].is_erased
= 1;
1205 bank
->sectors
[i
].is_erased
= 0;
1211 LOG_USER("Running slow fallback erase check - add working memory");
1212 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)