1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
32 #include "time_support.h"
34 /* command handlers */
35 static int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
36 static int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
37 static int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
38 static int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
39 static int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
40 static int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
41 static int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
42 static int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
43 static int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
44 static int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
45 static int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
49 extern flash_driver_t lpc2000_flash
;
50 extern flash_driver_t cfi_flash
;
51 extern flash_driver_t at91sam7_flash
;
52 extern flash_driver_t str7x_flash
;
53 extern flash_driver_t str9x_flash
;
54 extern flash_driver_t aduc702x_flash
;
55 extern flash_driver_t stellaris_flash
;
56 extern flash_driver_t str9xpec_flash
;
57 extern flash_driver_t stm32x_flash
;
58 extern flash_driver_t tms470_flash
;
59 extern flash_driver_t ecosflash_flash
;
60 extern flash_driver_t lpc288x_flash
;
61 extern flash_driver_t ocl_flash
;
62 extern flash_driver_t pic32mx_flash
;
63 extern flash_driver_t avr_flash
;
65 flash_driver_t
*flash_drivers
[] = {
84 flash_bank_t
*flash_banks
;
85 static command_t
*flash_cmd
;
87 /* wafer thin wrapper for invoking the flash driver */
88 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
92 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
95 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
101 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
105 retval
=bank
->driver
->erase(bank
, first
, last
);
106 if (retval
!=ERROR_OK
)
108 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
114 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
118 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
119 if (retval
!=ERROR_OK
)
121 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
127 int flash_register_commands(struct command_context_s
*cmd_ctx
)
129 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
131 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 ...]");
135 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
140 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
144 Jim_Obj
*list
=Jim_NewListObj(interp
, NULL
, 0);
145 for (p
= flash_banks
; p
; p
= p
->next
)
147 Jim_Obj
*elem
=Jim_NewListObj(interp
, NULL
, 0);
149 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
150 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
151 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
152 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
153 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
154 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
155 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
156 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
157 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
158 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
160 Jim_ListAppendElement(interp
, list
, elem
);
163 Jim_SetResult(interp
, list
);
168 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
170 register_jim(cmd_ctx
, "ocd_flash_banks", jim_flash_banks
, "return information about the flash banks");
174 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
175 "print info about flash bank <num>");
176 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
177 "identify flash bank <num>");
178 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
179 "check erase state of sectors in flash bank <num>");
180 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
181 "check protection state of sectors in flash bank <num>");
182 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
183 "erase sectors at <bank> <first> <last>");
184 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
185 "erase address range <address> <length>");
187 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
188 "fill with pattern (no autoerase) <address> <word_pattern> <count>");
189 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
190 "fill with pattern <address> <halfword_pattern> <count>");
191 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
192 "fill with pattern <address> <byte_pattern> <count>");
194 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
195 "write binary data to <bank> <file> <offset>");
196 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
197 "write_image [erase] <file> [offset] [type]");
198 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
199 "set protection of sectors at <bank> <first> <last> <on|off>");
205 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
210 for (p
= flash_banks
; p
; p
= p
->next
)
217 LOG_ERROR("flash bank %d does not exist", num
);
221 int flash_get_bank_count(void)
225 for (p
= flash_banks
; p
; p
= p
->next
)
232 flash_bank_t
*get_flash_bank_by_num(int num
)
234 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
240 retval
= p
->driver
->auto_probe(p
);
242 if (retval
!= ERROR_OK
)
244 LOG_ERROR("auto_probe failed %d\n", retval
);
250 static int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
259 return ERROR_COMMAND_SYNTAX_ERROR
;
262 if ((target
= get_target(args
[5])) == NULL
)
264 LOG_ERROR("target '%s' not defined", args
[5]);
268 for (i
= 0; flash_drivers
[i
]; i
++)
270 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
274 /* register flash specific commands */
275 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
277 LOG_ERROR("couldn't register '%s' commands", args
[0]);
281 c
= malloc(sizeof(flash_bank_t
));
283 c
->driver
= flash_drivers
[i
];
284 c
->driver_priv
= NULL
;
285 c
->base
= strtoul(args
[1], NULL
, 0);
286 c
->size
= strtoul(args
[2], NULL
, 0);
287 c
->chip_width
= strtoul(args
[3], NULL
, 0);
288 c
->bus_width
= strtoul(args
[4], NULL
, 0);
293 if ((retval
=flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
)) != ERROR_OK
)
295 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
300 /* put flash bank in linked list */
304 /* find last flash bank */
305 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
) bank_num
++;
308 c
->bank_number
= bank_num
+ 1;
320 /* no matching flash driver found */
323 LOG_ERROR("flash driver '%s' not found", args
[0]);
330 static int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
339 return ERROR_COMMAND_SYNTAX_ERROR
;
342 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
344 if (i
== strtoul(args
[0], NULL
, 0))
348 /* attempt auto probe */
349 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
352 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
353 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
354 for (j
= 0; j
< p
->num_sectors
; j
++)
358 if (p
->sectors
[j
].is_protected
== 0)
359 protect_state
= "not protected";
360 else if (p
->sectors
[j
].is_protected
== 1)
361 protect_state
= "protected";
363 protect_state
= "protection state unknown";
365 command_print(cmd_ctx
, "\t#%3i: 0x%8.8x (0x%x %ikB) %s",
366 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
370 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
371 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
372 command_print(cmd_ctx
, "%s", buf
);
373 if (retval
!= ERROR_OK
)
374 LOG_ERROR("error retrieving flash info (%d)", retval
);
381 static int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
388 return ERROR_COMMAND_SYNTAX_ERROR
;
391 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
394 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
396 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
398 else if (retval
== ERROR_FLASH_BANK_INVALID
)
400 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
405 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
411 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
417 static int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
424 return ERROR_COMMAND_SYNTAX_ERROR
;
427 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
431 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
433 command_print(cmd_ctx
, "successfully checked erase state");
437 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
441 for (j
= 0; j
< p
->num_sectors
; j
++)
445 if (p
->sectors
[j
].is_erased
== 0)
446 erase_state
= "not erased";
447 else if (p
->sectors
[j
].is_erased
== 1)
448 erase_state
= "erased";
450 erase_state
= "erase state unknown";
452 command_print(cmd_ctx
, "\t#%3i: 0x%8.8x (0x%x %ikB) %s",
453 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
461 static int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
470 target_t
*target
= get_current_target(cmd_ctx
);
474 return ERROR_COMMAND_SYNTAX_ERROR
;
477 address
= strtoul(args
[0], NULL
, 0);
478 length
= strtoul(args
[1], NULL
, 0);
481 command_print(cmd_ctx
, "Length must be >0");
482 return ERROR_COMMAND_SYNTAX_ERROR
;
485 p
= get_flash_bank_by_addr(target
, address
);
491 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
494 duration_start_measure(&duration
);
496 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
498 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
502 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
509 static int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
516 return ERROR_COMMAND_SYNTAX_ERROR
;
519 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
522 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
524 command_print(cmd_ctx
, "successfully checked protect state");
526 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
528 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
532 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
537 return ERROR_COMMAND_SYNTAX_ERROR
;
543 static int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
547 int first
= strtoul(args
[1], NULL
, 0);
548 int last
= strtoul(args
[2], NULL
, 0);
550 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
554 duration_start_measure(&duration
);
558 return ERROR_COMMAND_SYNTAX_ERROR
;
561 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
563 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
568 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %li in %s",
569 first
, last
, strtoul(args
[0], 0, 0), duration_text
);
575 return ERROR_COMMAND_SYNTAX_ERROR
;
581 static int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
585 int first
= strtoul(args
[1], NULL
, 0);
586 int last
= strtoul(args
[2], NULL
, 0);
589 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
592 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
596 if (strcmp(args
[3], "on") == 0)
598 else if (strcmp(args
[3], "off") == 0)
602 return ERROR_COMMAND_SYNTAX_ERROR
;
605 retval
= flash_driver_protect(p
, set
, first
, last
);
606 if (retval
== ERROR_OK
)
608 command_print(cmd_ctx
, "%s protection for sectors %i through %i on flash bank %li",
609 (set
) ? "set" : "cleared", first
,
610 last
, strtoul(args
[0], 0, 0));
615 return ERROR_COMMAND_SYNTAX_ERROR
;
622 static int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
624 target_t
*target
= get_current_target(cmd_ctx
);
632 int retval
, retvaltemp
;
636 return ERROR_COMMAND_SYNTAX_ERROR
;
639 /* flash auto-erase is disabled by default*/
642 if (strcmp(args
[0], "erase")==0)
647 command_print(cmd_ctx
, "auto erase enabled");
652 return ERROR_COMMAND_SYNTAX_ERROR
;
657 LOG_ERROR("no target selected");
661 duration_start_measure(&duration
);
665 image
.base_address_set
= 1;
666 image
.base_address
= strtoul(args
[1], NULL
, 0);
670 image
.base_address_set
= 0;
671 image
.base_address
= 0x0;
674 image
.start_address_set
= 0;
676 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
677 if (retval
!= ERROR_OK
)
682 retval
= flash_write(target
, &image
, &written
, auto_erase
);
683 if (retval
!= ERROR_OK
)
689 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
694 if (retval
== ERROR_OK
)
696 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
697 written
, args
[0], duration_text
,
698 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
707 static int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
709 int err
= ERROR_OK
, retval
;
720 target_t
*target
= get_current_target(cmd_ctx
);
726 return ERROR_COMMAND_SYNTAX_ERROR
;
729 address
= strtoul(args
[0], NULL
, 0);
730 pattern
= strtoul(args
[1], NULL
, 0);
731 count
= strtoul(args
[2], NULL
, 0);
748 return ERROR_COMMAND_SYNTAX_ERROR
;
751 chunk_count
= MIN(count
, (1024 / wordsize
));
755 for(i
= 0; i
< chunk_count
; i
++)
757 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
761 for(i
= 0; i
< chunk_count
; i
++)
763 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
767 memset(chunk
, pattern
, chunk_count
);
770 LOG_ERROR("BUG: can't happen");
774 duration_start_measure(&duration
);
776 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+= cur_size
)
778 cur_size
= MIN( (count
*wordsize
- wrote
), sizeof(chunk
) );
780 bank
= get_flash_bank_by_addr(target
, address
);
785 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
789 err
= target_read_buffer(target
, address
+ wrote
, cur_size
, readback
);
794 for (i
=0; i
<cur_size
; i
++)
796 if (readback
[i
]!=chunk
[i
])
798 LOG_ERROR("Verfication error address 0x%08x, read back 0x%02x, expected 0x%02x", address
+ wrote
+ i
, readback
[i
], chunk
[i
]);
805 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
813 speed
=wrote
/ 1024.0;
814 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
815 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
816 count
*wordsize
, address
, duration_text
,
823 static int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
834 int retval
, retvaltemp
;
839 return ERROR_COMMAND_SYNTAX_ERROR
;
842 duration_start_measure(&duration
);
844 offset
= strtoul(args
[2], NULL
, 0);
845 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
848 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
852 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
857 buffer
= malloc(fileio
.size
);
858 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
861 fileio_close(&fileio
);
865 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
870 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
872 fileio_close(&fileio
);
875 if (retval
==ERROR_OK
)
877 command_print(cmd_ctx
, "wrote %lld byte from file %s to flash bank %li at offset 0x%8.8x in %s (%f kb/s)",
878 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
879 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
883 fileio_close(&fileio
);
888 void flash_set_dirty(void)
893 /* set all flash to require erasing */
894 for (c
= flash_banks
; c
; c
= c
->next
)
896 for (i
= 0; i
< c
->num_sectors
; i
++)
898 c
->sectors
[i
].is_erased
= 0;
903 /* lookup flash bank by address */
904 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
908 /* cycle through bank list */
909 for (c
= flash_banks
; c
; c
= c
->next
)
912 retval
= c
->driver
->auto_probe(c
);
914 if (retval
!= ERROR_OK
)
916 LOG_ERROR("auto_probe failed %d\n", retval
);
919 /* check whether address belongs to this flash bank */
920 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
923 LOG_ERROR("No flash at address 0x%08x\n", addr
);
927 /* erase given flash region, selects proper bank according to target and address */
928 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
935 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
936 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
938 if (c
->size
== 0 || c
->num_sectors
== 0)
940 LOG_ERROR("Bank is invalid");
941 return ERROR_FLASH_BANK_INVALID
;
946 /* special case, erase whole bank when length is zero */
948 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
950 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
953 /* check whether it fits */
954 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
955 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
959 for (i
= 0; i
< c
->num_sectors
; i
++)
961 /* check whether sector overlaps with the given range and is not yet erased */
962 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
963 /* if first is not set yet then this is the first sector */
966 last
= i
; /* and it is the last one so far in any case */
970 if( first
== -1 || last
== -1 )
973 return flash_driver_erase(c
, first
, last
);
976 /* write (optional verify) an image to flash memory of the given target */
977 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
994 /* assume all sectors need erasing - stops any problems
995 * when flash_write is called multiple times */
1000 /* allocate padding array */
1001 padding
= malloc(image
->num_sections
* sizeof(padding
));
1003 /* loop until we reach end of the image */
1004 while (section
< image
->num_sections
)
1010 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
1011 u32 run_size
= image
->sections
[section
].size
- section_offset
;
1014 if (image
->sections
[section
].size
== 0)
1016 LOG_WARNING("empty section %d", section
);
1022 /* find the corresponding flash bank */
1023 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1025 section
++; /* and skip it */
1030 /* collect consecutive sections which fall into the same bank */
1031 section_first
= section
;
1032 section_last
= section
;
1033 padding
[section
] = 0;
1034 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
1035 && (section_last
+ 1 < image
->num_sections
))
1037 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1039 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1042 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1043 * attempt to rebuild a consecutive buffer for the flash loader */
1044 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1045 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1047 padding
[section_last
] = pad_bytes
;
1048 run_size
+= image
->sections
[++section_last
].size
;
1049 run_size
+= pad_bytes
;
1050 padding
[section_last
] = 0;
1052 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1055 /* fit the run into bank constraints */
1056 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
1058 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1059 c
->base
+ c
->size
- run_address
, run_size
, c
->size
);
1060 run_size
= c
->base
+ c
->size
- run_address
;
1063 /* allocate buffer */
1064 buffer
= malloc(run_size
);
1067 /* read sections to the buffer */
1068 while (buffer_size
< run_size
)
1072 size_read
= run_size
- buffer_size
;
1073 if (size_read
> image
->sections
[section
].size
- section_offset
)
1074 size_read
= image
->sections
[section
].size
- section_offset
;
1076 if ((retval
= image_read_section(image
, section
, section_offset
,
1077 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1084 /* see if we need to pad the section */
1085 while (padding
[section
]--)
1086 (buffer
+buffer_size
)[size_read
++] = 0xff;
1088 buffer_size
+= size_read
;
1089 section_offset
+= size_read
;
1091 if (section_offset
>= image
->sections
[section
].size
)
1102 /* calculate and erase sectors */
1103 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1106 if (retval
== ERROR_OK
)
1108 /* write flash sectors */
1109 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1114 if (retval
!= ERROR_OK
)
1117 return retval
; /* abort operation */
1120 if (written
!= NULL
)
1121 *written
+= run_size
; /* add run size to total written counter */
1129 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1131 target_t
*target
= bank
->target
;
1133 int buffer_size
= sizeof(buffer
);
1137 if (bank
->target
->state
!= TARGET_HALTED
)
1139 LOG_ERROR("Target not halted");
1140 return ERROR_TARGET_NOT_HALTED
;
1143 for (i
= 0; i
< bank
->num_sectors
; i
++)
1146 bank
->sectors
[i
].is_erased
= 1;
1148 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1152 chunk
= buffer_size
;
1153 if (chunk
> (j
- bank
->sectors
[i
].size
))
1155 chunk
= (j
- bank
->sectors
[i
].size
);
1158 retval
= target_read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1159 if (retval
!= ERROR_OK
)
1162 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1164 if (buffer
[nBytes
] != 0xFF)
1166 bank
->sectors
[i
].is_erased
= 0;
1176 int default_flash_blank_check(struct flash_bank_s
*bank
)
1178 target_t
*target
= bank
->target
;
1184 if (bank
->target
->state
!= TARGET_HALTED
)
1186 LOG_ERROR("Target not halted");
1187 return ERROR_TARGET_NOT_HALTED
;
1190 for (i
= 0; i
< bank
->num_sectors
; i
++)
1192 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1193 u32 size
= bank
->sectors
[i
].size
;
1195 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1201 bank
->sectors
[i
].is_erased
= 1;
1203 bank
->sectors
[i
].is_erased
= 0;
1209 LOG_USER("Running slow fallback erase check - add working memory");
1210 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)