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 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
30 #include "time_support.h"
35 #include "algorithm.h"
36 #include "binarybuffer.h"
42 #include <sys/types.h>
47 /* command handlers */
48 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
49 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
50 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_flash_write_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
60 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
);
64 extern flash_driver_t lpc2000_flash
;
65 extern flash_driver_t cfi_flash
;
66 extern flash_driver_t at91sam7_flash
;
67 extern flash_driver_t str7x_flash
;
68 extern flash_driver_t str9x_flash
;
69 extern flash_driver_t stellaris_flash
;
70 extern flash_driver_t str9xpec_flash
;
71 extern flash_driver_t stm32x_flash
;
72 extern flash_driver_t tms470_flash
;
73 extern flash_driver_t ecosflash_flash
;
74 extern flash_driver_t lpc288x_flash
;
75 extern flash_driver_t ocl_flash
;
77 flash_driver_t
*flash_drivers
[] =
94 flash_bank_t
*flash_banks
;
95 static command_t
*flash_cmd
;
97 /* wafer thin wrapper for invoking the flash driver */
98 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
102 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
103 if (retval
!=ERROR_OK
)
105 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
111 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
115 retval
=bank
->driver
->erase(bank
, first
, last
);
116 if (retval
!=ERROR_OK
)
118 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
124 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
128 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
129 if (retval
!=ERROR_OK
)
131 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
137 int flash_register_commands(struct command_context_s
*cmd_ctx
)
139 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
141 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 ...]");
145 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
150 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
159 Jim_Obj
*list
=Jim_NewListObj(interp
, NULL
, 0);
160 for (p
= flash_banks
; p
; p
= p
->next
)
162 Jim_Obj
*elem
=Jim_NewListObj(interp
, NULL
, 0);
164 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
165 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
166 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
167 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
168 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
169 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
170 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
171 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
172 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
173 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
175 Jim_ListAppendElement(interp
, list
, elem
);
178 Jim_SetResult(interp
, list
);
183 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
187 register_jim(cmd_ctx
, "ocd_flash_banks", jim_flash_banks
, "return information about the flash banks");
189 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
190 "print info about flash bank <num>");
191 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
192 "identify flash bank <num>");
193 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
194 "check erase state of sectors in flash bank <num>");
195 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
196 "check protection state of sectors in flash bank <num>");
197 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
198 "erase sectors at <bank> <first> <last>");
199 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
200 "erase address range <address> <length>");
202 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
203 "fill with pattern <address> <word_pattern> <count>");
204 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
205 "fill with pattern <address> <halfword_pattern> <count>");
206 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
207 "fill with pattern <address> <byte_pattern> <count>");
209 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
210 "write binary data to <bank> <file> <offset>");
211 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
212 "write_image [erase] <file> [offset] [type]");
213 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
214 "set protection of sectors at <bank> <first> <last> <on|off>");
220 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
225 for (p
= flash_banks
; p
; p
= p
->next
)
232 LOG_ERROR("flash bank %d does not exist", num
);
236 int flash_get_bank_count(void)
240 for (p
= flash_banks
; p
; p
= p
->next
)
247 flash_bank_t
*get_flash_bank_by_num(int num
)
249 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
255 retval
= p
->driver
->auto_probe(p
);
257 if (retval
!= ERROR_OK
)
259 LOG_ERROR("auto_probe failed %d\n", retval
);
265 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
273 return ERROR_COMMAND_SYNTAX_ERROR
;
276 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
278 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
282 for (i
= 0; flash_drivers
[i
]; i
++)
284 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
288 /* register flash specific commands */
289 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
291 LOG_ERROR("couldn't register '%s' commands", args
[0]);
295 c
= malloc(sizeof(flash_bank_t
));
297 c
->driver
= flash_drivers
[i
];
298 c
->driver_priv
= NULL
;
299 c
->base
= strtoul(args
[1], NULL
, 0);
300 c
->size
= strtoul(args
[2], NULL
, 0);
301 c
->chip_width
= strtoul(args
[3], NULL
, 0);
302 c
->bus_width
= strtoul(args
[4], NULL
, 0);
307 if (flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
) != ERROR_OK
)
309 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
314 /* put flash bank in linked list */
317 /* find last flash bank */
318 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
331 /* no matching flash driver found */
334 LOG_ERROR("flash driver '%s' not found", args
[0]);
341 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
350 return ERROR_COMMAND_SYNTAX_ERROR
;
353 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
355 if (i
== strtoul(args
[0], NULL
, 0))
359 /* attempt auto probe */
360 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
363 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
364 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
365 for (j
= 0; j
< p
->num_sectors
; j
++)
369 if (p
->sectors
[j
].is_protected
== 0)
370 protect_state
= "not protected";
371 else if (p
->sectors
[j
].is_protected
== 1)
372 protect_state
= "protected";
374 protect_state
= "protection state unknown";
376 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
377 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
381 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
382 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
383 command_print(cmd_ctx
, "%s", buf
);
384 if (retval
!= ERROR_OK
)
385 LOG_ERROR("error retrieving flash info (%d)", retval
);
392 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
399 return ERROR_COMMAND_SYNTAX_ERROR
;
402 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
405 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
407 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
409 else if (retval
== ERROR_FLASH_BANK_INVALID
)
411 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
416 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
422 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
428 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
435 return ERROR_COMMAND_SYNTAX_ERROR
;
438 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
442 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
444 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
448 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
452 for (j
= 0; j
< p
->num_sectors
; j
++)
456 if (p
->sectors
[j
].is_erased
== 0)
457 erase_state
= "not erased";
458 else if (p
->sectors
[j
].is_erased
== 1)
459 erase_state
= "erased";
461 erase_state
= "erase state unknown";
463 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
464 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
473 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
482 target_t
*target
= get_current_target(cmd_ctx
);
486 return ERROR_COMMAND_SYNTAX_ERROR
;
489 address
= strtoul(args
[0], NULL
, 0);
490 length
= strtoul(args
[1], NULL
, 0);
493 command_print(cmd_ctx
, "Length must be >0");
494 return ERROR_COMMAND_SYNTAX_ERROR
;
497 p
= get_flash_bank_by_addr(target
, address
);
503 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
506 duration_start_measure(&duration
);
508 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
510 duration_stop_measure(&duration
, &duration_text
);
511 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
518 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
525 return ERROR_COMMAND_SYNTAX_ERROR
;
528 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
531 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
533 command_print(cmd_ctx
, "successfully checked protect state");
535 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
537 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
541 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
546 return ERROR_COMMAND_SYNTAX_ERROR
;
552 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
556 int first
= strtoul(args
[1], NULL
, 0);
557 int last
= strtoul(args
[2], NULL
, 0);
559 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
563 duration_start_measure(&duration
);
567 return ERROR_COMMAND_SYNTAX_ERROR
;
570 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
572 duration_stop_measure(&duration
, &duration_text
);
574 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
580 return ERROR_COMMAND_SYNTAX_ERROR
;
586 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
590 int first
= strtoul(args
[1], NULL
, 0);
591 int last
= strtoul(args
[2], NULL
, 0);
594 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
597 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
601 if (strcmp(args
[3], "on") == 0)
603 else if (strcmp(args
[3], "off") == 0)
607 return ERROR_COMMAND_SYNTAX_ERROR
;
610 retval
= flash_driver_protect(p
, set
, first
, last
);
611 if (retval
== ERROR_OK
)
613 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));
618 return ERROR_COMMAND_SYNTAX_ERROR
;
625 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
627 target_t
*target
= get_current_target(cmd_ctx
);
639 return ERROR_COMMAND_SYNTAX_ERROR
;
642 /* flash auto-erase is disabled by default*/
645 if (strcmp(args
[0], "erase")==0)
650 command_print(cmd_ctx
, "auto erase enabled");
656 return ERROR_COMMAND_SYNTAX_ERROR
;
661 LOG_ERROR("no target selected");
665 duration_start_measure(&duration
);
669 image
.base_address_set
= 1;
670 image
.base_address
= strtoul(args
[1], NULL
, 0);
674 image
.base_address_set
= 0;
675 image
.base_address
= 0x0;
678 image
.start_address_set
= 0;
680 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
681 if (retval
!= ERROR_OK
)
686 retval
= flash_write(target
, &image
, &written
, auto_erase
);
687 if (retval
!= ERROR_OK
)
693 duration_stop_measure(&duration
, &duration_text
);
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 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
718 target_t
*target
= get_current_target(cmd_ctx
);
724 return ERROR_COMMAND_SYNTAX_ERROR
;
727 address
= strtoul(args
[0], NULL
, 0);
728 pattern
= strtoul(args
[1], NULL
, 0);
729 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
);
776 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
779 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
781 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
785 bank
= get_flash_bank_by_addr(target
, address
);
791 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
799 duration_stop_measure(&duration
, &duration_text
);
804 speed
=wrote
/ 1024.0;
805 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
806 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
807 count
*wordsize
, address
, duration_text
,
814 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
830 return ERROR_COMMAND_SYNTAX_ERROR
;
833 duration_start_measure(&duration
);
835 offset
= strtoul(args
[2], NULL
, 0);
836 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
839 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
843 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
848 buffer
= malloc(fileio
.size
);
849 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
852 fileio_close(&fileio
);
856 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
861 duration_stop_measure(&duration
, &duration_text
);
862 if (retval
!=ERROR_OK
)
864 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
865 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
866 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
870 fileio_close(&fileio
);
875 void flash_set_dirty(void)
880 /* set all flash to require erasing */
881 for (c
= flash_banks
; c
; c
= c
->next
)
883 for (i
= 0; i
< c
->num_sectors
; i
++)
885 c
->sectors
[i
].is_erased
= 0;
890 /* lookup flash bank by address */
891 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
895 /* cycle through bank list */
896 for (c
= flash_banks
; c
; c
= c
->next
)
899 retval
= c
->driver
->auto_probe(c
);
901 if (retval
!= ERROR_OK
)
903 LOG_ERROR("auto_probe failed %d\n", retval
);
906 /* check whether address belongs to this flash bank */
907 if ((addr
>= c
->base
) && (addr
< c
->base
+ c
->size
) && target
== c
->target
)
910 LOG_ERROR("No flash at address 0x%08x\n", addr
);
914 /* erase given flash region, selects proper bank according to target and address */
915 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
922 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
923 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
925 if (c
->size
== 0 || c
->num_sectors
== 0)
927 LOG_ERROR("Bank is invalid");
928 return ERROR_FLASH_BANK_INVALID
;
933 /* special case, erase whole bank when length is zero */
935 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
937 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
940 /* check whether it fits */
941 if (addr
+ length
> c
->base
+ c
->size
)
942 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
946 for (i
= 0; i
< c
->num_sectors
; i
++)
948 /* check whether sector overlaps with the given range and is not yet erased */
949 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
950 /* if first is not set yet then this is the first sector */
953 last
= i
; /* and it is the last one so far in any case */
957 if( first
== -1 || last
== -1 )
960 return flash_driver_erase(c
, first
, last
);
963 /* write (optional verify) an image to flash memory of the given target */
964 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
981 /* assume all sectors need erasing - stops any problems
982 * when flash_write is called multiple times */
987 /* allocate padding array */
988 padding
= malloc(image
->num_sections
* sizeof(padding
));
990 /* loop until we reach end of the image */
991 while (section
< image
->num_sections
)
997 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
998 u32 run_size
= image
->sections
[section
].size
- section_offset
;
1001 if (image
->sections
[section
].size
== 0)
1003 LOG_WARNING("empty section %d", section
);
1009 /* find the corresponding flash bank */
1010 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1012 section
++; /* and skip it */
1017 /* collect consecutive sections which fall into the same bank */
1018 section_first
= section
;
1019 section_last
= section
;
1020 padding
[section
] = 0;
1021 while ((run_address
+ run_size
< c
->base
+ c
->size
)
1022 && (section_last
+ 1 < image
->num_sections
))
1024 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1026 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1029 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1030 * attempt to rebuild a consecutive buffer for the flash loader */
1031 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1032 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1034 padding
[section_last
] = pad_bytes
;
1035 run_size
+= image
->sections
[++section_last
].size
;
1036 run_size
+= pad_bytes
;
1037 padding
[section_last
] = 0;
1039 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1042 /* fit the run into bank constraints */
1043 if (run_address
+ run_size
> c
->base
+ c
->size
)
1044 run_size
= c
->base
+ c
->size
- run_address
;
1046 /* allocate buffer */
1047 buffer
= malloc(run_size
);
1050 /* read sections to the buffer */
1051 while (buffer_size
< run_size
)
1055 size_read
= run_size
- buffer_size
;
1056 if (size_read
> image
->sections
[section
].size
- section_offset
)
1057 size_read
= image
->sections
[section
].size
- section_offset
;
1059 if ((retval
= image_read_section(image
, section
, section_offset
,
1060 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1067 /* see if we need to pad the section */
1068 while (padding
[section
]--)
1069 (buffer
+buffer_size
)[size_read
++] = 0xff;
1071 buffer_size
+= size_read
;
1072 section_offset
+= size_read
;
1074 if (section_offset
>= image
->sections
[section
].size
)
1085 /* calculate and erase sectors */
1086 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1089 if (retval
== ERROR_OK
)
1091 /* write flash sectors */
1092 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1097 if (retval
!= ERROR_OK
)
1100 return retval
; /* abort operation */
1103 if (written
!= NULL
)
1104 *written
+= run_size
; /* add run size to total written counter */
1112 int default_flash_mem_blank_check(struct flash_bank_s
*bank
)
1114 target_t
*target
= bank
->target
;
1116 int buffer_size
= sizeof(buffer
);
1120 if (bank
->target
->state
!= TARGET_HALTED
)
1122 return ERROR_TARGET_NOT_HALTED
;
1125 for (i
= 0; i
< bank
->num_sectors
; i
++)
1128 bank
->sectors
[i
].is_erased
= 1;
1130 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1134 chunk
= buffer_size
;
1135 if (chunk
> (j
- bank
->sectors
[i
].size
))
1137 chunk
= (j
- bank
->sectors
[i
].size
);
1140 retval
= target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1141 if (retval
!= ERROR_OK
)
1144 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1146 if (buffer
[nBytes
] != 0xFF)
1148 bank
->sectors
[i
].is_erased
= 0;
1158 int default_flash_blank_check(struct flash_bank_s
*bank
)
1160 target_t
*target
= bank
->target
;
1166 if (bank
->target
->state
!= TARGET_HALTED
)
1168 return ERROR_TARGET_NOT_HALTED
;
1171 for (i
= 0; i
< bank
->num_sectors
; i
++)
1173 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1174 u32 size
= bank
->sectors
[i
].size
;
1176 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1182 bank
->sectors
[i
].is_erased
= 1;
1184 bank
->sectors
[i
].is_erased
= 0;
1190 LOG_USER("Running slow fallback erase check - add working memory");
1191 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)