1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
27 #include "time_support.h"
32 #include "algorithm.h"
33 #include "binarybuffer.h"
39 #include <sys/types.h>
44 /* command handlers */
45 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
46 int handle_flash_banks_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
47 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
48 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
49 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
50 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
51 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
52 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
53 int handle_flash_write_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
54 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
55 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
56 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
57 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
58 int handle_flash_auto_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
59 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
);
63 extern flash_driver_t lpc2000_flash
;
64 extern flash_driver_t cfi_flash
;
65 extern flash_driver_t at91sam7_flash
;
66 extern flash_driver_t str7x_flash
;
67 extern flash_driver_t str9x_flash
;
68 extern flash_driver_t stellaris_flash
;
69 extern flash_driver_t str9xpec_flash
;
70 extern flash_driver_t stm32x_flash
;
71 extern flash_driver_t tms470_flash
;
72 extern flash_driver_t ecosflash_flash
;
74 flash_driver_t
*flash_drivers
[] =
89 flash_bank_t
*flash_banks
;
90 static command_t
*flash_cmd
;
92 /* flash auto-erase is disabled by default*/
93 static int auto_erase
= 0;
95 /* wafer thin wrapper for invoking the flash driver */
96 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
100 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
101 if (retval
!=ERROR_OK
)
103 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
109 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
113 retval
=bank
->driver
->erase(bank
, first
, last
);
114 if (retval
!=ERROR_OK
)
116 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
122 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
126 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
127 if (retval
!=ERROR_OK
)
129 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
136 int flash_register_commands(struct command_context_s
*cmd_ctx
)
138 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
140 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 ...]");
141 register_command(cmd_ctx
, flash_cmd
, "auto_erase", handle_flash_auto_erase_command
, COMMAND_ANY
,
142 "auto erase flash sectors <on|off>");
146 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
150 register_command(cmd_ctx
, flash_cmd
, "banks", handle_flash_banks_command
, COMMAND_EXEC
,
151 "list configured flash banks ");
152 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
153 "print info about flash bank <num>");
154 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
155 "identify flash bank <num>");
156 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
157 "check erase state of sectors in flash bank <num>");
158 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
159 "check protection state of sectors in flash bank <num>");
160 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
161 "erase sectors at <bank> <first> <last>");
162 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
163 "erase address range <address> <length>");
165 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
166 "fill with pattern <address> <word_pattern> <count>");
167 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
168 "fill with pattern <address> <halfword_pattern> <count>");
169 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
170 "fill with pattern <address> <byte_pattern> <count>");
172 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
173 "write binary data to <bank> <file> <offset>");
174 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
175 "write_image <file> [offset] [type]");
176 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
177 "set protection of sectors at <bank> <first> <last> <on|off>");
183 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
188 for (p
= flash_banks
; p
; p
= p
->next
)
195 LOG_ERROR("flash bank %d does not exist", num
);
199 int flash_get_bank_count()
203 for (p
= flash_banks
; p
; p
= p
->next
)
210 flash_bank_t
*get_flash_bank_by_num(int num
)
212 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
218 retval
= p
->driver
->auto_probe(p
);
220 if (retval
!= ERROR_OK
)
222 LOG_ERROR("auto_probe failed %d\n", retval
);
228 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
236 return ERROR_COMMAND_SYNTAX_ERROR
;
239 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
241 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
245 for (i
= 0; flash_drivers
[i
]; i
++)
247 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
251 /* register flash specific commands */
252 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
254 LOG_ERROR("couldn't register '%s' commands", args
[0]);
258 c
= malloc(sizeof(flash_bank_t
));
260 c
->driver
= flash_drivers
[i
];
261 c
->driver_priv
= NULL
;
262 c
->base
= strtoul(args
[1], NULL
, 0);
263 c
->size
= strtoul(args
[2], NULL
, 0);
264 c
->chip_width
= strtoul(args
[3], NULL
, 0);
265 c
->bus_width
= strtoul(args
[4], NULL
, 0);
270 if (flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
) != ERROR_OK
)
272 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
277 /* put flash bank in linked list */
280 /* find last flash bank */
281 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
294 /* no matching flash driver found */
297 LOG_ERROR("flash driver '%s' not found", args
[0]);
304 int handle_flash_banks_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
311 command_print(cmd_ctx
, "no flash banks configured");
315 for (p
= flash_banks
; p
; p
= p
->next
)
317 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
318 i
++, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
324 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
333 return ERROR_COMMAND_SYNTAX_ERROR
;
336 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
338 if (i
== strtoul(args
[0], NULL
, 0))
342 /* attempt auto probe */
343 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
346 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
347 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
348 for (j
= 0; j
< p
->num_sectors
; j
++)
352 if (p
->sectors
[j
].is_protected
== 0)
353 protect_state
= "not protected";
354 else if (p
->sectors
[j
].is_protected
== 1)
355 protect_state
= "protected";
357 protect_state
= "protection state unknown";
359 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
360 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
364 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
365 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
366 command_print(cmd_ctx
, "%s", buf
);
367 if (retval
!= ERROR_OK
)
368 LOG_ERROR("error retrieving flash info (%d)", retval
);
375 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
382 return ERROR_COMMAND_SYNTAX_ERROR
;
385 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
388 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
390 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
392 else if (retval
== ERROR_FLASH_BANK_INVALID
)
394 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
399 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
405 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
411 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
418 return ERROR_COMMAND_SYNTAX_ERROR
;
421 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
425 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
427 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
431 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
435 for (j
= 0; j
< p
->num_sectors
; j
++)
439 if (p
->sectors
[j
].is_erased
== 0)
440 erase_state
= "not erased";
441 else if (p
->sectors
[j
].is_erased
== 1)
442 erase_state
= "erased";
444 erase_state
= "erase state unknown";
446 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
447 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
456 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
465 target_t
*target
= get_current_target(cmd_ctx
);
469 return ERROR_COMMAND_SYNTAX_ERROR
;
472 address
= strtoul(args
[0], NULL
, 0);
473 length
= strtoul(args
[1], NULL
, 0);
476 command_print(cmd_ctx
, "Length must be >0");
477 return ERROR_COMMAND_SYNTAX_ERROR
;
480 p
= get_flash_bank_by_addr(target
, address
);
483 return ERROR_COMMAND_SYNTAX_ERROR
;
486 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
489 duration_start_measure(&duration
);
491 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
493 duration_stop_measure(&duration
, &duration_text
);
494 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
501 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
508 return ERROR_COMMAND_SYNTAX_ERROR
;
511 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
514 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
516 command_print(cmd_ctx
, "successfully checked protect state");
518 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
520 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
524 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
529 return ERROR_COMMAND_SYNTAX_ERROR
;
535 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
539 int first
= strtoul(args
[1], NULL
, 0);
540 int last
= strtoul(args
[2], NULL
, 0);
542 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
546 duration_start_measure(&duration
);
550 return ERROR_COMMAND_SYNTAX_ERROR
;
553 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
555 duration_stop_measure(&duration
, &duration_text
);
557 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
563 return ERROR_COMMAND_SYNTAX_ERROR
;
569 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
573 int first
= strtoul(args
[1], NULL
, 0);
574 int last
= strtoul(args
[2], NULL
, 0);
577 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
580 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
584 if (strcmp(args
[3], "on") == 0)
586 else if (strcmp(args
[3], "off") == 0)
590 return ERROR_COMMAND_SYNTAX_ERROR
;
593 retval
= flash_driver_protect(p
, set
, first
, last
);
594 if (retval
== ERROR_OK
)
596 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));
601 return ERROR_COMMAND_SYNTAX_ERROR
;
608 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
610 target_t
*target
= get_current_target(cmd_ctx
);
622 return ERROR_COMMAND_SYNTAX_ERROR
;
627 LOG_ERROR("no target selected");
631 duration_start_measure(&duration
);
635 image
.base_address_set
= 1;
636 image
.base_address
= strtoul(args
[1], NULL
, 0);
640 image
.base_address_set
= 0;
641 image
.base_address
= 0x0;
644 image
.start_address_set
= 0;
646 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
647 if (retval
!= ERROR_OK
)
652 retval
= flash_write(target
, &image
, &written
, auto_erase
);
653 if (retval
!= ERROR_OK
)
659 duration_stop_measure(&duration
, &duration_text
);
660 if (retval
== ERROR_OK
)
662 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
663 written
, args
[0], duration_text
,
664 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
673 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
684 target_t
*target
= get_current_target(cmd_ctx
);
690 return ERROR_COMMAND_SYNTAX_ERROR
;
693 address
= strtoul(args
[0], NULL
, 0);
694 pattern
= strtoul(args
[1], NULL
, 0);
695 count
= strtoul(args
[2], NULL
, 0);
713 return ERROR_COMMAND_SYNTAX_ERROR
;
716 chunk_count
= MIN(count
, (1024 / wordsize
));
720 for(i
= 0; i
< chunk_count
; i
++)
722 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
726 for(i
= 0; i
< chunk_count
; i
++)
728 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
732 memset(chunk
, pattern
, chunk_count
);
735 LOG_ERROR("BUG: can't happen");
739 duration_start_measure(&duration
);
742 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
745 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
747 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
751 bank
= get_flash_bank_by_addr(target
, address
);
757 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
765 duration_stop_measure(&duration
, &duration_text
);
770 speed
=wrote
/ 1024.0;
771 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
772 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
773 count
*wordsize
, address
, duration_text
,
780 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
796 return ERROR_COMMAND_SYNTAX_ERROR
;
799 duration_start_measure(&duration
);
801 offset
= strtoul(args
[2], NULL
, 0);
802 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
805 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
809 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
814 buffer
= malloc(fileio
.size
);
815 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
820 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
824 duration_stop_measure(&duration
, &duration_text
);
825 if (retval
!=ERROR_OK
)
827 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
828 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
829 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
833 fileio_close(&fileio
);
838 void flash_set_dirty(void)
843 /* set all flash to require erasing */
844 for (c
= flash_banks
; c
; c
= c
->next
)
846 for (i
= 0; i
< c
->num_sectors
; i
++)
848 c
->sectors
[i
].is_erased
= 0;
853 /* lookup flash bank by address */
854 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
858 /* cycle through bank list */
859 for (c
= flash_banks
; c
; c
= c
->next
)
862 retval
= c
->driver
->auto_probe(c
);
864 if (retval
!= ERROR_OK
)
866 LOG_ERROR("auto_probe failed %d\n", retval
);
869 /* check whether address belongs to this flash bank */
870 if ((addr
>= c
->base
) && (addr
< c
->base
+ c
->size
) && target
== c
->target
)
873 LOG_ERROR("No flash at address 0x%08x\n", addr
);
877 /* erase given flash region, selects proper bank according to target and address */
878 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
885 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
886 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
888 if (c
->size
== 0 || c
->num_sectors
== 0)
890 LOG_ERROR("Bank is invalid");
891 return ERROR_FLASH_BANK_INVALID
;
896 /* special case, erase whole bank when length is zero */
898 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
900 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
903 /* check whether it fits */
904 if (addr
+ length
> c
->base
+ c
->size
)
905 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
909 for (i
= 0; i
< c
->num_sectors
; i
++)
911 /* check whether sector overlaps with the given range and is not yet erased */
912 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
913 /* if first is not set yet then this is the first sector */
916 last
= i
; /* and it is the last one so far in any case */
920 if( first
== -1 || last
== -1 )
923 return flash_driver_erase(c
, first
, last
);
926 /* write (optional verify) an image to flash memory of the given target */
927 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
943 /* assume all sectors need erasing - stops any problems
944 * when flash_write is called multiple times */
949 /* loop until we reach end of the image */
950 while (section
< image
->num_sections
)
956 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
957 u32 run_size
= image
->sections
[section
].size
- section_offset
;
959 if (image
->sections
[section
].size
== 0)
961 LOG_WARNING("empty section %d", section
);
967 /* find the corresponding flash bank */
968 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
970 section
++; /* and skip it */
975 /* collect consecutive sections which fall into the same bank */
976 section_first
= section
;
977 section_last
= section
;
978 while ((run_address
+ run_size
< c
->base
+ c
->size
)
979 && (section_last
+ 1 < image
->num_sections
))
981 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
983 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
986 if (image
->sections
[section_last
+ 1].base_address
!= (run_address
+ run_size
))
988 run_size
+= image
->sections
[++section_last
].size
;
991 /* fit the run into bank constraints */
992 if (run_address
+ run_size
> c
->base
+ c
->size
)
993 run_size
= c
->base
+ c
->size
- run_address
;
995 /* allocate buffer */
996 buffer
= malloc(run_size
);
999 /* read sections to the buffer */
1000 while (buffer_size
< run_size
)
1004 if (buffer_size
- run_size
<= image
->sections
[section
].size
- section_offset
)
1005 size_read
= buffer_size
- run_size
;
1007 size_read
= image
->sections
[section
].size
- section_offset
;
1009 if ((retval
= image_read_section(image
, section
, section_offset
,
1010 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1017 buffer_size
+= size_read
;
1018 section_offset
+= size_read
;
1020 if (section_offset
>= image
->sections
[section
].size
)
1031 /* calculate and erase sectors */
1032 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1035 if (retval
== ERROR_OK
)
1037 /* write flash sectors */
1038 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1043 if (retval
!= ERROR_OK
)
1045 return retval
; /* abort operation */
1048 if (written
!= NULL
)
1049 *written
+= run_size
; /* add run size to total written counter */
1055 int handle_flash_auto_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1059 return ERROR_COMMAND_SYNTAX_ERROR
;
1062 if (strcmp(args
[0], "on") == 0)
1064 else if (strcmp(args
[0], "off") == 0)
1067 return ERROR_COMMAND_SYNTAX_ERROR
;
1073 int default_flash_blank_check(struct flash_bank_s
*bank
)
1075 target_t
*target
= bank
->target
;
1077 int buffer_size
=sizeof(buffer
);
1081 if (bank
->target
->state
!= TARGET_HALTED
)
1083 return ERROR_TARGET_NOT_HALTED
;
1088 working_area_t
*erase_check_algorithm
;
1090 /* FIX! doesn't work yet... */
1092 char test(char *a, int len, char t)
1096 for (i=0; i<len; i++)
1103 $ arm-elf-gcc -c -mthumb -O3 test.c
1105 $ arm-elf-objdump --disassemble test.o
1107 test.o: file format elf32-littlearm
1109 Disassembly of section .text:
1112 0: b510 push {r4, lr}
1113 2: 0612 lsl r2, r2, #24
1114 4: 1c04 mov r4, r0 (add r4, r0, #0)
1115 6: 0e10 lsr r0, r2, #24
1118 c: dd04 ble 18 <test+0x18>
1119 e: 5ca3 ldrb r3, [r4, r2]
1123 16: dbfa blt e <test+0xe>
1124 18: bd10 pop {r4, pc}
1125 1a: 46c0 nop (mov r8, r8)
1129 u16 erase_check_code
[] =
1131 0x0612,// lsl r2, r2, #24
1132 0x1c04,// mov r4, r0 (add r4, r0, #0)
1133 0x0e10,// lsr r0, r2, #24
1134 0x2200,// mov r2, #0
1135 0x2900,// cmp r1, #0
1136 0xdd04,// ble 18 <test+0x18>
1137 0x5ca3,// ldrb r3, [r4, r2]
1138 0x3201,// add r2, #1
1139 0x4018,// and r0, r3
1140 0x428a,// cmp r2, r1
1141 0xdbfa,// blt e <test+0xe>
1142 0x46c0,// nop (mov r8, r8)
1148 /* make sure we have a working area */
1149 if (target_alloc_working_area(target
, ((sizeof(erase_check_code
)+3)/4)*4, &erase_check_algorithm
) != ERROR_OK
)
1151 erase_check_algorithm
= NULL
;
1154 if (erase_check_algorithm
)
1156 u8 erase_check_code_buf
[((sizeof(erase_check_code
)+3)/4)*4];
1157 LOG_DEBUG("Running fast flash erase check");
1159 for (i
= 0; i
< sizeof(erase_check_code
)/sizeof(*erase_check_code
); i
++)
1160 target_buffer_set_u16(target
, erase_check_code_buf
+ (i
*2), erase_check_code
[i
]);
1162 /* write algorithm code to working area */
1163 if ((retval
=target
->type
->write_memory(target
, erase_check_algorithm
->address
, 2, sizeof(erase_check_code
)/sizeof(*erase_check_code
), erase_check_code_buf
))==ERROR_OK
)
1165 for (i
= 0; i
< bank
->num_sectors
; i
++)
1167 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1168 u32 size
= bank
->sectors
[i
].size
;
1170 reg_param_t reg_params
[3];
1171 armv7m_algorithm_t arm_info
;
1173 arm_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
1174 arm_info
.core_mode
= ARMV7M_MODE_ANY
;
1175 arm_info
.core_state
= ARMV7M_STATE_THUMB
;
1177 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
1178 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
1180 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
1181 buf_set_u32(reg_params
[1].value
, 0, 32, size
);
1183 init_reg_param(®_params
[2], "r2", 32, PARAM_IN_OUT
);
1184 buf_set_u32(reg_params
[2].value
, 0, 32, 0xff);
1186 if ((retval
= target
->type
->run_algorithm(target
, 0, NULL
, 3, reg_params
, erase_check_algorithm
->address
,
1187 erase_check_algorithm
->address
+ sizeof(erase_check_code
) - 2, 10000, &arm_info
)) != ERROR_OK
)
1190 if (buf_get_u32(reg_params
[2].value
, 0, 32) == 0xff)
1191 bank
->sectors
[i
].is_erased
= 1;
1193 bank
->sectors
[i
].is_erased
= 0;
1195 destroy_reg_param(®_params
[0]);
1196 destroy_reg_param(®_params
[1]);
1197 destroy_reg_param(®_params
[2]);
1199 if (i
== bank
->num_sectors
)
1204 target_free_working_area(target
, erase_check_algorithm
);
1209 /* try ARM7 instead */
1211 u32 erase_check_code
[] =
1213 0xe4d03001, /* ldrb r3, [r0], #1 */
1214 0xe0022003, /* and r2, r2, r3 */
1215 0xe2511001, /* subs r1, r1, #1 */
1216 0x1afffffb, /* b -4 */
1217 0xeafffffe /* b 0 */
1220 /* make sure we have a working area */
1221 if (target_alloc_working_area(target
, 20, &erase_check_algorithm
) == ERROR_OK
)
1223 u8 erase_check_code_buf
[5 * 4];
1225 for (i
= 0; i
< 5; i
++)
1226 target_buffer_set_u32(target
, erase_check_code_buf
+ (i
*4), erase_check_code
[i
]);
1228 /* write algorithm code to working area */
1229 if ((retval
=target
->type
->write_memory(target
, erase_check_algorithm
->address
, 4, 5, erase_check_code_buf
))==ERROR_OK
)
1231 for (i
= 0; i
< bank
->num_sectors
; i
++)
1233 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1234 u32 size
= bank
->sectors
[i
].size
;
1236 reg_param_t reg_params
[3];
1237 armv4_5_algorithm_t armv4_5_info
;
1239 armv4_5_info
.common_magic
= ARMV4_5_COMMON_MAGIC
;
1240 armv4_5_info
.core_mode
= ARMV4_5_MODE_SVC
;
1241 armv4_5_info
.core_state
= ARMV4_5_STATE_ARM
;
1243 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
1244 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
1246 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
1247 buf_set_u32(reg_params
[1].value
, 0, 32, size
);
1249 init_reg_param(®_params
[2], "r2", 32, PARAM_IN_OUT
);
1250 buf_set_u32(reg_params
[2].value
, 0, 32, 0xff);
1252 if ((retval
= target
->type
->run_algorithm(target
, 0, NULL
, 3, reg_params
,
1253 erase_check_algorithm
->address
, erase_check_algorithm
->address
+ 0x10, 10000, &armv4_5_info
)) != ERROR_OK
)
1256 if (buf_get_u32(reg_params
[2].value
, 0, 32) == 0xff)
1257 bank
->sectors
[i
].is_erased
= 1;
1259 bank
->sectors
[i
].is_erased
= 0;
1261 destroy_reg_param(®_params
[0]);
1262 destroy_reg_param(®_params
[1]);
1263 destroy_reg_param(®_params
[2]);
1265 if (i
== bank
->num_sectors
)
1270 target_free_working_area(target
, erase_check_algorithm
);
1277 LOG_USER("Running slow fallback erase check - add working memory");
1278 for (i
= 0; i
< bank
->num_sectors
; i
++)
1281 bank
->sectors
[i
].is_erased
= 1;
1283 for (j
=0; j
<bank
->sectors
[i
].size
; j
+=buffer_size
)
1288 if (chunk
>(j
-bank
->sectors
[i
].size
))
1290 chunk
=(j
-bank
->sectors
[i
].size
);
1293 retval
=target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1294 if (retval
!=ERROR_OK
)
1297 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1299 if (buffer
[nBytes
] != 0xFF)
1301 bank
->sectors
[i
].is_erased
= 0;
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)