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 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
);
62 extern flash_driver_t lpc2000_flash
;
63 extern flash_driver_t cfi_flash
;
64 extern flash_driver_t at91sam7_flash
;
65 extern flash_driver_t str7x_flash
;
66 extern flash_driver_t str9x_flash
;
67 extern flash_driver_t stellaris_flash
;
68 extern flash_driver_t str9xpec_flash
;
69 extern flash_driver_t stm32x_flash
;
70 extern flash_driver_t tms470_flash
;
71 extern flash_driver_t ecosflash_flash
;
72 extern flash_driver_t lpc288x_flash
;
74 flash_driver_t
*flash_drivers
[] =
90 flash_bank_t
*flash_banks
;
91 static command_t
*flash_cmd
;
93 /* wafer thin wrapper for invoking the flash driver */
94 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
98 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
101 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
107 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
111 retval
=bank
->driver
->erase(bank
, first
, last
);
112 if (retval
!=ERROR_OK
)
114 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
120 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
124 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
125 if (retval
!=ERROR_OK
)
127 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
134 int flash_register_commands(struct command_context_s
*cmd_ctx
)
136 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
138 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 ...]");
142 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
146 register_command(cmd_ctx
, flash_cmd
, "banks", handle_flash_banks_command
, COMMAND_EXEC
,
147 "list configured flash banks ");
148 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
149 "print info about flash bank <num>");
150 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
151 "identify flash bank <num>");
152 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
153 "check erase state of sectors in flash bank <num>");
154 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
155 "check protection state of sectors in flash bank <num>");
156 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
157 "erase sectors at <bank> <first> <last>");
158 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
159 "erase address range <address> <length>");
161 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
162 "fill with pattern <address> <word_pattern> <count>");
163 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
164 "fill with pattern <address> <halfword_pattern> <count>");
165 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
166 "fill with pattern <address> <byte_pattern> <count>");
168 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
169 "write binary data to <bank> <file> <offset>");
170 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
171 "write_image [erase] <file> [offset] [type]");
172 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
173 "set protection of sectors at <bank> <first> <last> <on|off>");
179 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
184 for (p
= flash_banks
; p
; p
= p
->next
)
191 LOG_ERROR("flash bank %d does not exist", num
);
195 int flash_get_bank_count()
199 for (p
= flash_banks
; p
; p
= p
->next
)
206 flash_bank_t
*get_flash_bank_by_num(int num
)
208 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
214 retval
= p
->driver
->auto_probe(p
);
216 if (retval
!= ERROR_OK
)
218 LOG_ERROR("auto_probe failed %d\n", retval
);
224 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
232 return ERROR_COMMAND_SYNTAX_ERROR
;
235 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
237 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
241 for (i
= 0; flash_drivers
[i
]; i
++)
243 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
247 /* register flash specific commands */
248 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
250 LOG_ERROR("couldn't register '%s' commands", args
[0]);
254 c
= malloc(sizeof(flash_bank_t
));
256 c
->driver
= flash_drivers
[i
];
257 c
->driver_priv
= NULL
;
258 c
->base
= strtoul(args
[1], NULL
, 0);
259 c
->size
= strtoul(args
[2], NULL
, 0);
260 c
->chip_width
= strtoul(args
[3], NULL
, 0);
261 c
->bus_width
= strtoul(args
[4], NULL
, 0);
266 if (flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
) != ERROR_OK
)
268 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
273 /* put flash bank in linked list */
276 /* find last flash bank */
277 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
290 /* no matching flash driver found */
293 LOG_ERROR("flash driver '%s' not found", args
[0]);
300 int handle_flash_banks_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
307 command_print(cmd_ctx
, "no flash banks configured");
311 for (p
= flash_banks
; p
; p
= p
->next
)
313 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
314 i
++, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
320 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
329 return ERROR_COMMAND_SYNTAX_ERROR
;
332 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
334 if (i
== strtoul(args
[0], NULL
, 0))
338 /* attempt auto probe */
339 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
342 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
343 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
344 for (j
= 0; j
< p
->num_sectors
; j
++)
348 if (p
->sectors
[j
].is_protected
== 0)
349 protect_state
= "not protected";
350 else if (p
->sectors
[j
].is_protected
== 1)
351 protect_state
= "protected";
353 protect_state
= "protection state unknown";
355 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
356 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
360 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
361 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
362 command_print(cmd_ctx
, "%s", buf
);
363 if (retval
!= ERROR_OK
)
364 LOG_ERROR("error retrieving flash info (%d)", retval
);
371 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
378 return ERROR_COMMAND_SYNTAX_ERROR
;
381 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
384 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
386 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
388 else if (retval
== ERROR_FLASH_BANK_INVALID
)
390 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
395 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
401 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
407 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
414 return ERROR_COMMAND_SYNTAX_ERROR
;
417 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
421 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
423 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
427 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
431 for (j
= 0; j
< p
->num_sectors
; j
++)
435 if (p
->sectors
[j
].is_erased
== 0)
436 erase_state
= "not erased";
437 else if (p
->sectors
[j
].is_erased
== 1)
438 erase_state
= "erased";
440 erase_state
= "erase state unknown";
442 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
443 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
452 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
461 target_t
*target
= get_current_target(cmd_ctx
);
465 return ERROR_COMMAND_SYNTAX_ERROR
;
468 address
= strtoul(args
[0], NULL
, 0);
469 length
= strtoul(args
[1], NULL
, 0);
472 command_print(cmd_ctx
, "Length must be >0");
473 return ERROR_COMMAND_SYNTAX_ERROR
;
476 p
= get_flash_bank_by_addr(target
, address
);
479 return ERROR_COMMAND_SYNTAX_ERROR
;
482 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
485 duration_start_measure(&duration
);
487 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
489 duration_stop_measure(&duration
, &duration_text
);
490 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
497 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
504 return ERROR_COMMAND_SYNTAX_ERROR
;
507 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
510 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
512 command_print(cmd_ctx
, "successfully checked protect state");
514 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
516 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
520 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
525 return ERROR_COMMAND_SYNTAX_ERROR
;
531 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
535 int first
= strtoul(args
[1], NULL
, 0);
536 int last
= strtoul(args
[2], NULL
, 0);
538 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
542 duration_start_measure(&duration
);
546 return ERROR_COMMAND_SYNTAX_ERROR
;
549 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
551 duration_stop_measure(&duration
, &duration_text
);
553 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
559 return ERROR_COMMAND_SYNTAX_ERROR
;
565 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
569 int first
= strtoul(args
[1], NULL
, 0);
570 int last
= strtoul(args
[2], NULL
, 0);
573 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
576 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
580 if (strcmp(args
[3], "on") == 0)
582 else if (strcmp(args
[3], "off") == 0)
586 return ERROR_COMMAND_SYNTAX_ERROR
;
589 retval
= flash_driver_protect(p
, set
, first
, last
);
590 if (retval
== ERROR_OK
)
592 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));
597 return ERROR_COMMAND_SYNTAX_ERROR
;
604 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
606 target_t
*target
= get_current_target(cmd_ctx
);
618 return ERROR_COMMAND_SYNTAX_ERROR
;
621 /* flash auto-erase is disabled by default*/
624 if (strcmp(args
[0], "erase")==0)
629 command_print(cmd_ctx
, "auto erase enabled");
635 return ERROR_COMMAND_SYNTAX_ERROR
;
640 LOG_ERROR("no target selected");
644 duration_start_measure(&duration
);
648 image
.base_address_set
= 1;
649 image
.base_address
= strtoul(args
[1], NULL
, 0);
653 image
.base_address_set
= 0;
654 image
.base_address
= 0x0;
657 image
.start_address_set
= 0;
659 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
660 if (retval
!= ERROR_OK
)
665 retval
= flash_write(target
, &image
, &written
, auto_erase
);
666 if (retval
!= ERROR_OK
)
672 duration_stop_measure(&duration
, &duration_text
);
673 if (retval
== ERROR_OK
)
675 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
676 written
, args
[0], duration_text
,
677 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
686 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
697 target_t
*target
= get_current_target(cmd_ctx
);
703 return ERROR_COMMAND_SYNTAX_ERROR
;
706 address
= strtoul(args
[0], NULL
, 0);
707 pattern
= strtoul(args
[1], NULL
, 0);
708 count
= strtoul(args
[2], NULL
, 0);
726 return ERROR_COMMAND_SYNTAX_ERROR
;
729 chunk_count
= MIN(count
, (1024 / wordsize
));
733 for(i
= 0; i
< chunk_count
; i
++)
735 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
739 for(i
= 0; i
< chunk_count
; i
++)
741 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
745 memset(chunk
, pattern
, chunk_count
);
748 LOG_ERROR("BUG: can't happen");
752 duration_start_measure(&duration
);
755 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
758 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
760 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
764 bank
= get_flash_bank_by_addr(target
, address
);
770 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
778 duration_stop_measure(&duration
, &duration_text
);
783 speed
=wrote
/ 1024.0;
784 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
785 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
786 count
*wordsize
, address
, duration_text
,
793 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
809 return ERROR_COMMAND_SYNTAX_ERROR
;
812 duration_start_measure(&duration
);
814 offset
= strtoul(args
[2], NULL
, 0);
815 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
818 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
822 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
827 buffer
= malloc(fileio
.size
);
828 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
833 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
837 duration_stop_measure(&duration
, &duration_text
);
838 if (retval
!=ERROR_OK
)
840 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
841 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
842 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
846 fileio_close(&fileio
);
851 void flash_set_dirty(void)
856 /* set all flash to require erasing */
857 for (c
= flash_banks
; c
; c
= c
->next
)
859 for (i
= 0; i
< c
->num_sectors
; i
++)
861 c
->sectors
[i
].is_erased
= 0;
866 /* lookup flash bank by address */
867 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
871 /* cycle through bank list */
872 for (c
= flash_banks
; c
; c
= c
->next
)
875 retval
= c
->driver
->auto_probe(c
);
877 if (retval
!= ERROR_OK
)
879 LOG_ERROR("auto_probe failed %d\n", retval
);
882 /* check whether address belongs to this flash bank */
883 if ((addr
>= c
->base
) && (addr
< c
->base
+ c
->size
) && target
== c
->target
)
886 LOG_ERROR("No flash at address 0x%08x\n", addr
);
890 /* erase given flash region, selects proper bank according to target and address */
891 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
898 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
899 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
901 if (c
->size
== 0 || c
->num_sectors
== 0)
903 LOG_ERROR("Bank is invalid");
904 return ERROR_FLASH_BANK_INVALID
;
909 /* special case, erase whole bank when length is zero */
911 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
913 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
916 /* check whether it fits */
917 if (addr
+ length
> c
->base
+ c
->size
)
918 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
922 for (i
= 0; i
< c
->num_sectors
; i
++)
924 /* check whether sector overlaps with the given range and is not yet erased */
925 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
926 /* if first is not set yet then this is the first sector */
929 last
= i
; /* and it is the last one so far in any case */
933 if( first
== -1 || last
== -1 )
936 return flash_driver_erase(c
, first
, last
);
939 /* write (optional verify) an image to flash memory of the given target */
940 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
956 /* assume all sectors need erasing - stops any problems
957 * when flash_write is called multiple times */
962 /* loop until we reach end of the image */
963 while (section
< image
->num_sections
)
969 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
970 u32 run_size
= image
->sections
[section
].size
- section_offset
;
972 if (image
->sections
[section
].size
== 0)
974 LOG_WARNING("empty section %d", section
);
980 /* find the corresponding flash bank */
981 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
983 section
++; /* and skip it */
988 /* collect consecutive sections which fall into the same bank */
989 section_first
= section
;
990 section_last
= section
;
991 while ((run_address
+ run_size
< c
->base
+ c
->size
)
992 && (section_last
+ 1 < image
->num_sections
))
994 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
996 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
999 if (image
->sections
[section_last
+ 1].base_address
!= (run_address
+ run_size
))
1001 run_size
+= image
->sections
[++section_last
].size
;
1004 /* fit the run into bank constraints */
1005 if (run_address
+ run_size
> c
->base
+ c
->size
)
1006 run_size
= c
->base
+ c
->size
- run_address
;
1008 /* allocate buffer */
1009 buffer
= malloc(run_size
);
1012 /* read sections to the buffer */
1013 while (buffer_size
< run_size
)
1017 if (buffer_size
- run_size
<= image
->sections
[section
].size
- section_offset
)
1018 size_read
= buffer_size
- run_size
;
1020 size_read
= image
->sections
[section
].size
- section_offset
;
1022 if ((retval
= image_read_section(image
, section
, section_offset
,
1023 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1030 buffer_size
+= size_read
;
1031 section_offset
+= size_read
;
1033 if (section_offset
>= image
->sections
[section
].size
)
1044 /* calculate and erase sectors */
1045 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1048 if (retval
== ERROR_OK
)
1050 /* write flash sectors */
1051 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1056 if (retval
!= ERROR_OK
)
1058 return retval
; /* abort operation */
1061 if (written
!= NULL
)
1062 *written
+= run_size
; /* add run size to total written counter */
1068 int default_flash_blank_check(struct flash_bank_s
*bank
)
1070 target_t
*target
= bank
->target
;
1072 int buffer_size
=sizeof(buffer
);
1076 if (bank
->target
->state
!= TARGET_HALTED
)
1078 return ERROR_TARGET_NOT_HALTED
;
1083 working_area_t
*erase_check_algorithm
;
1085 /* FIX! doesn't work yet... */
1087 char test(char *a, int len, char t)
1091 for (i=0; i<len; i++)
1098 $ arm-elf-gcc -c -mthumb -O3 test.c
1100 $ arm-elf-objdump --disassemble test.o
1102 test.o: file format elf32-littlearm
1104 Disassembly of section .text:
1107 0: b510 push {r4, lr}
1108 2: 0612 lsl r2, r2, #24
1109 4: 1c04 mov r4, r0 (add r4, r0, #0)
1110 6: 0e10 lsr r0, r2, #24
1113 c: dd04 ble 18 <test+0x18>
1114 e: 5ca3 ldrb r3, [r4, r2]
1118 16: dbfa blt e <test+0xe>
1119 18: bd10 pop {r4, pc}
1120 1a: 46c0 nop (mov r8, r8)
1124 u16 erase_check_code
[] =
1126 0x0612,// lsl r2, r2, #24
1127 0x1c04,// mov r4, r0 (add r4, r0, #0)
1128 0x0e10,// lsr r0, r2, #24
1129 0x2200,// mov r2, #0
1130 0x2900,// cmp r1, #0
1131 0xdd04,// ble 18 <test+0x18>
1132 0x5ca3,// ldrb r3, [r4, r2]
1133 0x3201,// add r2, #1
1134 0x4018,// and r0, r3
1135 0x428a,// cmp r2, r1
1136 0xdbfa,// blt e <test+0xe>
1137 0x46c0,// nop (mov r8, r8)
1143 /* make sure we have a working area */
1144 if (target_alloc_working_area(target
, ((sizeof(erase_check_code
)+3)/4)*4, &erase_check_algorithm
) != ERROR_OK
)
1146 erase_check_algorithm
= NULL
;
1149 if (erase_check_algorithm
)
1151 u8 erase_check_code_buf
[((sizeof(erase_check_code
)+3)/4)*4];
1152 LOG_DEBUG("Running fast flash erase check");
1154 for (i
= 0; i
< sizeof(erase_check_code
)/sizeof(*erase_check_code
); i
++)
1155 target_buffer_set_u16(target
, erase_check_code_buf
+ (i
*2), erase_check_code
[i
]);
1157 /* write algorithm code to working area */
1158 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
)
1160 for (i
= 0; i
< bank
->num_sectors
; i
++)
1162 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1163 u32 size
= bank
->sectors
[i
].size
;
1165 reg_param_t reg_params
[3];
1166 armv7m_algorithm_t arm_info
;
1168 arm_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
1169 arm_info
.core_mode
= ARMV7M_MODE_ANY
;
1170 arm_info
.core_state
= ARMV7M_STATE_THUMB
;
1172 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
1173 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
1175 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
1176 buf_set_u32(reg_params
[1].value
, 0, 32, size
);
1178 init_reg_param(®_params
[2], "r2", 32, PARAM_IN_OUT
);
1179 buf_set_u32(reg_params
[2].value
, 0, 32, 0xff);
1181 if ((retval
= target
->type
->run_algorithm(target
, 0, NULL
, 3, reg_params
, erase_check_algorithm
->address
,
1182 erase_check_algorithm
->address
+ sizeof(erase_check_code
) - 2, 10000, &arm_info
)) != ERROR_OK
)
1185 if (buf_get_u32(reg_params
[2].value
, 0, 32) == 0xff)
1186 bank
->sectors
[i
].is_erased
= 1;
1188 bank
->sectors
[i
].is_erased
= 0;
1190 destroy_reg_param(®_params
[0]);
1191 destroy_reg_param(®_params
[1]);
1192 destroy_reg_param(®_params
[2]);
1194 if (i
== bank
->num_sectors
)
1199 target_free_working_area(target
, erase_check_algorithm
);
1204 /* try ARM7 instead */
1206 u32 erase_check_code
[] =
1208 0xe4d03001, /* ldrb r3, [r0], #1 */
1209 0xe0022003, /* and r2, r2, r3 */
1210 0xe2511001, /* subs r1, r1, #1 */
1211 0x1afffffb, /* b -4 */
1212 0xeafffffe /* b 0 */
1215 /* make sure we have a working area */
1216 if (target_alloc_working_area(target
, 20, &erase_check_algorithm
) == ERROR_OK
)
1218 u8 erase_check_code_buf
[5 * 4];
1220 for (i
= 0; i
< 5; i
++)
1221 target_buffer_set_u32(target
, erase_check_code_buf
+ (i
*4), erase_check_code
[i
]);
1223 /* write algorithm code to working area */
1224 if ((retval
=target
->type
->write_memory(target
, erase_check_algorithm
->address
, 4, 5, erase_check_code_buf
))==ERROR_OK
)
1226 for (i
= 0; i
< bank
->num_sectors
; i
++)
1228 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1229 u32 size
= bank
->sectors
[i
].size
;
1231 reg_param_t reg_params
[3];
1232 armv4_5_algorithm_t armv4_5_info
;
1234 armv4_5_info
.common_magic
= ARMV4_5_COMMON_MAGIC
;
1235 armv4_5_info
.core_mode
= ARMV4_5_MODE_SVC
;
1236 armv4_5_info
.core_state
= ARMV4_5_STATE_ARM
;
1238 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
1239 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
1241 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
1242 buf_set_u32(reg_params
[1].value
, 0, 32, size
);
1244 init_reg_param(®_params
[2], "r2", 32, PARAM_IN_OUT
);
1245 buf_set_u32(reg_params
[2].value
, 0, 32, 0xff);
1247 if ((retval
= target
->type
->run_algorithm(target
, 0, NULL
, 3, reg_params
,
1248 erase_check_algorithm
->address
, erase_check_algorithm
->address
+ 0x10, 10000, &armv4_5_info
)) != ERROR_OK
)
1251 if (buf_get_u32(reg_params
[2].value
, 0, 32) == 0xff)
1252 bank
->sectors
[i
].is_erased
= 1;
1254 bank
->sectors
[i
].is_erased
= 0;
1256 destroy_reg_param(®_params
[0]);
1257 destroy_reg_param(®_params
[1]);
1258 destroy_reg_param(®_params
[2]);
1260 if (i
== bank
->num_sectors
)
1265 target_free_working_area(target
, erase_check_algorithm
);
1272 LOG_USER("Running slow fallback erase check - add working memory");
1273 for (i
= 0; i
< bank
->num_sectors
; i
++)
1276 bank
->sectors
[i
].is_erased
= 1;
1278 for (j
=0; j
<bank
->sectors
[i
].size
; j
+=buffer_size
)
1283 if (chunk
>(j
-bank
->sectors
[i
].size
))
1285 chunk
=(j
-bank
->sectors
[i
].size
);
1288 retval
=target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1289 if (retval
!=ERROR_OK
)
1292 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1294 if (buffer
[nBytes
] != 0xFF)
1296 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)