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 ***************************************************************************/
33 #include "time_support.h"
38 #include "algorithm.h"
39 #include "binarybuffer.h"
45 #include <sys/types.h>
50 /* command handlers */
51 static int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 static int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 static int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 static int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 static int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 static int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 static int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 static int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 static int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 static int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
61 static int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
65 extern flash_driver_t lpc2000_flash
;
66 extern flash_driver_t cfi_flash
;
67 extern flash_driver_t at91sam7_flash
;
68 extern flash_driver_t str7x_flash
;
69 extern flash_driver_t str9x_flash
;
70 extern flash_driver_t aduc702x_flash
;
71 extern flash_driver_t stellaris_flash
;
72 extern flash_driver_t str9xpec_flash
;
73 extern flash_driver_t stm32x_flash
;
74 extern flash_driver_t tms470_flash
;
75 extern flash_driver_t ecosflash_flash
;
76 extern flash_driver_t lpc288x_flash
;
77 extern flash_driver_t ocl_flash
;
78 extern flash_driver_t pic32mx_flash
;
79 extern flash_driver_t avr_flash
;
81 flash_driver_t
*flash_drivers
[] = {
100 flash_bank_t
*flash_banks
;
101 static command_t
*flash_cmd
;
103 /* wafer thin wrapper for invoking the flash driver */
104 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
108 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
109 if (retval
!=ERROR_OK
)
111 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
117 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
121 retval
=bank
->driver
->erase(bank
, first
, last
);
122 if (retval
!=ERROR_OK
)
124 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
130 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
134 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
135 if (retval
!=ERROR_OK
)
137 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
143 int flash_register_commands(struct command_context_s
*cmd_ctx
)
145 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
147 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 ...]");
151 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
156 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
160 Jim_Obj
*list
=Jim_NewListObj(interp
, NULL
, 0);
161 for (p
= flash_banks
; p
; p
= p
->next
)
163 Jim_Obj
*elem
=Jim_NewListObj(interp
, NULL
, 0);
165 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
166 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
167 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
168 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
169 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
170 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
171 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
172 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
173 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
174 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
176 Jim_ListAppendElement(interp
, list
, elem
);
179 Jim_SetResult(interp
, list
);
184 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
186 register_jim(cmd_ctx
, "ocd_flash_banks", jim_flash_banks
, "return information about the flash banks");
190 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
191 "print info about flash bank <num>");
192 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
193 "identify flash bank <num>");
194 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
195 "check erase state of sectors in flash bank <num>");
196 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
197 "check protection state of sectors in flash bank <num>");
198 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
199 "erase sectors at <bank> <first> <last>");
200 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
201 "erase address range <address> <length>");
203 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
204 "fill with pattern (no autoerase) <address> <word_pattern> <count>");
205 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
206 "fill with pattern <address> <halfword_pattern> <count>");
207 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
208 "fill with pattern <address> <byte_pattern> <count>");
210 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
211 "write binary data to <bank> <file> <offset>");
212 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
213 "write_image [erase] <file> [offset] [type]");
214 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
215 "set protection of sectors at <bank> <first> <last> <on|off>");
221 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
226 for (p
= flash_banks
; p
; p
= p
->next
)
233 LOG_ERROR("flash bank %d does not exist", num
);
237 int flash_get_bank_count(void)
241 for (p
= flash_banks
; p
; p
= p
->next
)
248 flash_bank_t
*get_flash_bank_by_num(int num
)
250 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
256 retval
= p
->driver
->auto_probe(p
);
258 if (retval
!= ERROR_OK
)
260 LOG_ERROR("auto_probe failed %d\n", retval
);
266 static int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
275 return ERROR_COMMAND_SYNTAX_ERROR
;
278 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
280 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
284 for (i
= 0; flash_drivers
[i
]; i
++)
286 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
290 /* register flash specific commands */
291 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
293 LOG_ERROR("couldn't register '%s' commands", args
[0]);
297 c
= malloc(sizeof(flash_bank_t
));
299 c
->driver
= flash_drivers
[i
];
300 c
->driver_priv
= NULL
;
301 c
->base
= strtoul(args
[1], NULL
, 0);
302 c
->size
= strtoul(args
[2], NULL
, 0);
303 c
->chip_width
= strtoul(args
[3], NULL
, 0);
304 c
->bus_width
= strtoul(args
[4], NULL
, 0);
309 if ((retval
=flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
)) != ERROR_OK
)
311 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
316 /* put flash bank in linked list */
320 /* find last flash bank */
321 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
) bank_num
++;
324 c
->bank_number
= bank_num
+ 1;
336 /* no matching flash driver found */
339 LOG_ERROR("flash driver '%s' not found", args
[0]);
346 static int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
355 return ERROR_COMMAND_SYNTAX_ERROR
;
358 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
360 if (i
== strtoul(args
[0], NULL
, 0))
364 /* attempt auto probe */
365 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
368 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
369 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
370 for (j
= 0; j
< p
->num_sectors
; j
++)
374 if (p
->sectors
[j
].is_protected
== 0)
375 protect_state
= "not protected";
376 else if (p
->sectors
[j
].is_protected
== 1)
377 protect_state
= "protected";
379 protect_state
= "protection state unknown";
381 command_print(cmd_ctx
, "\t#%3i: 0x%8.8x (0x%x %ikB) %s",
382 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
386 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
387 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
388 command_print(cmd_ctx
, "%s", buf
);
389 if (retval
!= ERROR_OK
)
390 LOG_ERROR("error retrieving flash info (%d)", retval
);
397 static int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
404 return ERROR_COMMAND_SYNTAX_ERROR
;
407 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
410 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
412 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
414 else if (retval
== ERROR_FLASH_BANK_INVALID
)
416 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
421 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
427 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
433 static int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
440 return ERROR_COMMAND_SYNTAX_ERROR
;
443 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
447 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
449 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
453 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
457 for (j
= 0; j
< p
->num_sectors
; j
++)
461 if (p
->sectors
[j
].is_erased
== 0)
462 erase_state
= "not erased";
463 else if (p
->sectors
[j
].is_erased
== 1)
464 erase_state
= "erased";
466 erase_state
= "erase state unknown";
468 command_print(cmd_ctx
, "\t#%3i: 0x%8.8x (0x%x %ikB) %s",
469 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
477 static int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
486 target_t
*target
= get_current_target(cmd_ctx
);
490 return ERROR_COMMAND_SYNTAX_ERROR
;
493 address
= strtoul(args
[0], NULL
, 0);
494 length
= strtoul(args
[1], NULL
, 0);
497 command_print(cmd_ctx
, "Length must be >0");
498 return ERROR_COMMAND_SYNTAX_ERROR
;
501 p
= get_flash_bank_by_addr(target
, address
);
507 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
510 duration_start_measure(&duration
);
512 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
514 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
518 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
525 static int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
532 return ERROR_COMMAND_SYNTAX_ERROR
;
535 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
538 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
540 command_print(cmd_ctx
, "successfully checked protect state");
542 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
544 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
548 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
553 return ERROR_COMMAND_SYNTAX_ERROR
;
559 static int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
563 int first
= strtoul(args
[1], NULL
, 0);
564 int last
= strtoul(args
[2], NULL
, 0);
566 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
570 duration_start_measure(&duration
);
574 return ERROR_COMMAND_SYNTAX_ERROR
;
577 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
579 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
584 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
590 return ERROR_COMMAND_SYNTAX_ERROR
;
596 static int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
600 int first
= strtoul(args
[1], NULL
, 0);
601 int last
= strtoul(args
[2], NULL
, 0);
604 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
607 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
611 if (strcmp(args
[3], "on") == 0)
613 else if (strcmp(args
[3], "off") == 0)
617 return ERROR_COMMAND_SYNTAX_ERROR
;
620 retval
= flash_driver_protect(p
, set
, first
, last
);
621 if (retval
== ERROR_OK
)
623 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));
628 return ERROR_COMMAND_SYNTAX_ERROR
;
635 static int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
637 target_t
*target
= get_current_target(cmd_ctx
);
645 int retval
, retvaltemp
;
649 return ERROR_COMMAND_SYNTAX_ERROR
;
652 /* flash auto-erase is disabled by default*/
655 if (strcmp(args
[0], "erase")==0)
660 command_print(cmd_ctx
, "auto erase enabled");
665 return ERROR_COMMAND_SYNTAX_ERROR
;
670 LOG_ERROR("no target selected");
674 duration_start_measure(&duration
);
678 image
.base_address_set
= 1;
679 image
.base_address
= strtoul(args
[1], NULL
, 0);
683 image
.base_address_set
= 0;
684 image
.base_address
= 0x0;
687 image
.start_address_set
= 0;
689 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
690 if (retval
!= ERROR_OK
)
695 retval
= flash_write(target
, &image
, &written
, auto_erase
);
696 if (retval
!= ERROR_OK
)
702 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
707 if (retval
== ERROR_OK
)
709 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
710 written
, args
[0], duration_text
,
711 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
720 static int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
722 int err
= ERROR_OK
, retval
;
733 target_t
*target
= get_current_target(cmd_ctx
);
739 return ERROR_COMMAND_SYNTAX_ERROR
;
742 address
= strtoul(args
[0], NULL
, 0);
743 pattern
= strtoul(args
[1], NULL
, 0);
744 count
= strtoul(args
[2], NULL
, 0);
761 return ERROR_COMMAND_SYNTAX_ERROR
;
764 chunk_count
= MIN(count
, (1024 / wordsize
));
768 for(i
= 0; i
< chunk_count
; i
++)
770 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
774 for(i
= 0; i
< chunk_count
; i
++)
776 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
780 memset(chunk
, pattern
, chunk_count
);
783 LOG_ERROR("BUG: can't happen");
787 duration_start_measure(&duration
);
789 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+= cur_size
)
791 cur_size
= MIN( (count
*wordsize
- wrote
), sizeof(chunk
) );
793 bank
= get_flash_bank_by_addr(target
, address
);
798 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
802 err
= target_read_buffer(target
, address
+ wrote
, cur_size
, readback
);
807 for (i
=0; i
<cur_size
; i
++)
809 if (readback
[i
]!=chunk
[i
])
811 LOG_ERROR("Verfication error address 0x%08x, read back 0x%02x, expected 0x%02x", address
+ wrote
+ i
, readback
[i
], chunk
[i
]);
818 if ((retval
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
826 speed
=wrote
/ 1024.0;
827 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
828 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
829 count
*wordsize
, address
, duration_text
,
836 static int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
847 int retval
, retvaltemp
;
852 return ERROR_COMMAND_SYNTAX_ERROR
;
855 duration_start_measure(&duration
);
857 offset
= strtoul(args
[2], NULL
, 0);
858 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
861 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
865 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
870 buffer
= malloc(fileio
.size
);
871 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
874 fileio_close(&fileio
);
878 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
883 if ((retvaltemp
= duration_stop_measure(&duration
, &duration_text
)) != ERROR_OK
)
885 fileio_close(&fileio
);
888 if (retval
==ERROR_OK
)
890 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
891 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
892 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
896 fileio_close(&fileio
);
901 void flash_set_dirty(void)
906 /* set all flash to require erasing */
907 for (c
= flash_banks
; c
; c
= c
->next
)
909 for (i
= 0; i
< c
->num_sectors
; i
++)
911 c
->sectors
[i
].is_erased
= 0;
916 /* lookup flash bank by address */
917 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
921 /* cycle through bank list */
922 for (c
= flash_banks
; c
; c
= c
->next
)
925 retval
= c
->driver
->auto_probe(c
);
927 if (retval
!= ERROR_OK
)
929 LOG_ERROR("auto_probe failed %d\n", retval
);
932 /* check whether address belongs to this flash bank */
933 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
936 LOG_ERROR("No flash at address 0x%08x\n", addr
);
940 /* erase given flash region, selects proper bank according to target and address */
941 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
948 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
949 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
951 if (c
->size
== 0 || c
->num_sectors
== 0)
953 LOG_ERROR("Bank is invalid");
954 return ERROR_FLASH_BANK_INVALID
;
959 /* special case, erase whole bank when length is zero */
961 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
963 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
966 /* check whether it fits */
967 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
968 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
972 for (i
= 0; i
< c
->num_sectors
; i
++)
974 /* check whether sector overlaps with the given range and is not yet erased */
975 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
976 /* if first is not set yet then this is the first sector */
979 last
= i
; /* and it is the last one so far in any case */
983 if( first
== -1 || last
== -1 )
986 return flash_driver_erase(c
, first
, last
);
989 /* write (optional verify) an image to flash memory of the given target */
990 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
1007 /* assume all sectors need erasing - stops any problems
1008 * when flash_write is called multiple times */
1013 /* allocate padding array */
1014 padding
= malloc(image
->num_sections
* sizeof(padding
));
1016 /* loop until we reach end of the image */
1017 while (section
< image
->num_sections
)
1023 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
1024 u32 run_size
= image
->sections
[section
].size
- section_offset
;
1027 if (image
->sections
[section
].size
== 0)
1029 LOG_WARNING("empty section %d", section
);
1035 /* find the corresponding flash bank */
1036 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1038 section
++; /* and skip it */
1043 /* collect consecutive sections which fall into the same bank */
1044 section_first
= section
;
1045 section_last
= section
;
1046 padding
[section
] = 0;
1047 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
1048 && (section_last
+ 1 < image
->num_sections
))
1050 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1052 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1055 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1056 * attempt to rebuild a consecutive buffer for the flash loader */
1057 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1058 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1060 padding
[section_last
] = pad_bytes
;
1061 run_size
+= image
->sections
[++section_last
].size
;
1062 run_size
+= pad_bytes
;
1063 padding
[section_last
] = 0;
1065 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1068 /* fit the run into bank constraints */
1069 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
1071 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1072 c
->base
+ c
->size
- run_address
, run_size
, c
->size
);
1073 run_size
= c
->base
+ c
->size
- run_address
;
1076 /* allocate buffer */
1077 buffer
= malloc(run_size
);
1080 /* read sections to the buffer */
1081 while (buffer_size
< run_size
)
1085 size_read
= run_size
- buffer_size
;
1086 if (size_read
> image
->sections
[section
].size
- section_offset
)
1087 size_read
= image
->sections
[section
].size
- section_offset
;
1089 if ((retval
= image_read_section(image
, section
, section_offset
,
1090 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1097 /* see if we need to pad the section */
1098 while (padding
[section
]--)
1099 (buffer
+buffer_size
)[size_read
++] = 0xff;
1101 buffer_size
+= size_read
;
1102 section_offset
+= size_read
;
1104 if (section_offset
>= image
->sections
[section
].size
)
1115 /* calculate and erase sectors */
1116 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1119 if (retval
== ERROR_OK
)
1121 /* write flash sectors */
1122 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1127 if (retval
!= ERROR_OK
)
1130 return retval
; /* abort operation */
1133 if (written
!= NULL
)
1134 *written
+= run_size
; /* add run size to total written counter */
1142 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1144 target_t
*target
= bank
->target
;
1146 int buffer_size
= sizeof(buffer
);
1150 if (bank
->target
->state
!= TARGET_HALTED
)
1152 LOG_ERROR("Target not halted");
1153 return ERROR_TARGET_NOT_HALTED
;
1156 for (i
= 0; i
< bank
->num_sectors
; i
++)
1159 bank
->sectors
[i
].is_erased
= 1;
1161 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1165 chunk
= buffer_size
;
1166 if (chunk
> (j
- bank
->sectors
[i
].size
))
1168 chunk
= (j
- bank
->sectors
[i
].size
);
1171 retval
= target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1172 if (retval
!= ERROR_OK
)
1175 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1177 if (buffer
[nBytes
] != 0xFF)
1179 bank
->sectors
[i
].is_erased
= 0;
1189 int default_flash_blank_check(struct flash_bank_s
*bank
)
1191 target_t
*target
= bank
->target
;
1197 if (bank
->target
->state
!= TARGET_HALTED
)
1199 LOG_ERROR("Target not halted");
1200 return ERROR_TARGET_NOT_HALTED
;
1203 for (i
= 0; i
< bank
->num_sectors
; i
++)
1205 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1206 u32 size
= bank
->sectors
[i
].size
;
1208 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1214 bank
->sectors
[i
].is_erased
= 1;
1216 bank
->sectors
[i
].is_erased
= 0;
1222 LOG_USER("Running slow fallback erase check - add working memory");
1223 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)