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
;
73 flash_driver_t
*flash_drivers
[] =
88 flash_bank_t
*flash_banks
;
89 static command_t
*flash_cmd
;
91 /* wafer thin wrapper for invoking the flash driver */
92 static int flash_driver_write(struct flash_bank_s
*bank
, u8
*buffer
, u32 offset
, u32 count
)
96 retval
=bank
->driver
->write(bank
, buffer
, offset
, count
);
99 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank
->base
, offset
, retval
);
105 static int flash_driver_erase(struct flash_bank_s
*bank
, int first
, int last
)
109 retval
=bank
->driver
->erase(bank
, first
, last
);
110 if (retval
!=ERROR_OK
)
112 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
118 int flash_driver_protect(struct flash_bank_s
*bank
, int set
, int first
, int last
)
122 retval
=bank
->driver
->protect(bank
, set
, first
, last
);
123 if (retval
!=ERROR_OK
)
125 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
132 int flash_register_commands(struct command_context_s
*cmd_ctx
)
134 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
136 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 ...]");
140 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
144 register_command(cmd_ctx
, flash_cmd
, "banks", handle_flash_banks_command
, COMMAND_EXEC
,
145 "list configured flash banks ");
146 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
147 "print info about flash bank <num>");
148 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
149 "identify flash bank <num>");
150 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
151 "check erase state of sectors in flash bank <num>");
152 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
153 "check protection state of sectors in flash bank <num>");
154 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
155 "erase sectors at <bank> <first> <last>");
156 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
157 "erase address range <address> <length>");
159 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
160 "fill with pattern <address> <word_pattern> <count>");
161 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
162 "fill with pattern <address> <halfword_pattern> <count>");
163 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
164 "fill with pattern <address> <byte_pattern> <count>");
166 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
167 "write binary data to <bank> <file> <offset>");
168 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
169 "write_image [erase] <file> [offset] [type]");
170 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
171 "set protection of sectors at <bank> <first> <last> <on|off>");
177 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
182 for (p
= flash_banks
; p
; p
= p
->next
)
189 LOG_ERROR("flash bank %d does not exist", num
);
193 int flash_get_bank_count()
197 for (p
= flash_banks
; p
; p
= p
->next
)
204 flash_bank_t
*get_flash_bank_by_num(int num
)
206 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
212 retval
= p
->driver
->auto_probe(p
);
214 if (retval
!= ERROR_OK
)
216 LOG_ERROR("auto_probe failed %d\n", retval
);
222 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
230 return ERROR_COMMAND_SYNTAX_ERROR
;
233 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
235 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
239 for (i
= 0; flash_drivers
[i
]; i
++)
241 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
245 /* register flash specific commands */
246 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
248 LOG_ERROR("couldn't register '%s' commands", args
[0]);
252 c
= malloc(sizeof(flash_bank_t
));
254 c
->driver
= flash_drivers
[i
];
255 c
->driver_priv
= NULL
;
256 c
->base
= strtoul(args
[1], NULL
, 0);
257 c
->size
= strtoul(args
[2], NULL
, 0);
258 c
->chip_width
= strtoul(args
[3], NULL
, 0);
259 c
->bus_width
= strtoul(args
[4], NULL
, 0);
264 if (flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
) != ERROR_OK
)
266 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
271 /* put flash bank in linked list */
274 /* find last flash bank */
275 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
288 /* no matching flash driver found */
291 LOG_ERROR("flash driver '%s' not found", args
[0]);
298 int handle_flash_banks_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
305 command_print(cmd_ctx
, "no flash banks configured");
309 for (p
= flash_banks
; p
; p
= p
->next
)
311 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
312 i
++, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
318 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
327 return ERROR_COMMAND_SYNTAX_ERROR
;
330 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
332 if (i
== strtoul(args
[0], NULL
, 0))
336 /* attempt auto probe */
337 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
340 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
341 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
342 for (j
= 0; j
< p
->num_sectors
; j
++)
346 if (p
->sectors
[j
].is_protected
== 0)
347 protect_state
= "not protected";
348 else if (p
->sectors
[j
].is_protected
== 1)
349 protect_state
= "protected";
351 protect_state
= "protection state unknown";
353 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
354 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
358 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
359 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
360 command_print(cmd_ctx
, "%s", buf
);
361 if (retval
!= ERROR_OK
)
362 LOG_ERROR("error retrieving flash info (%d)", retval
);
369 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
376 return ERROR_COMMAND_SYNTAX_ERROR
;
379 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
382 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
384 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
386 else if (retval
== ERROR_FLASH_BANK_INVALID
)
388 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
393 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
399 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
405 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
412 return ERROR_COMMAND_SYNTAX_ERROR
;
415 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
419 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
421 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
425 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
429 for (j
= 0; j
< p
->num_sectors
; j
++)
433 if (p
->sectors
[j
].is_erased
== 0)
434 erase_state
= "not erased";
435 else if (p
->sectors
[j
].is_erased
== 1)
436 erase_state
= "erased";
438 erase_state
= "erase state unknown";
440 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
441 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
450 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
459 target_t
*target
= get_current_target(cmd_ctx
);
463 return ERROR_COMMAND_SYNTAX_ERROR
;
466 address
= strtoul(args
[0], NULL
, 0);
467 length
= strtoul(args
[1], NULL
, 0);
470 command_print(cmd_ctx
, "Length must be >0");
471 return ERROR_COMMAND_SYNTAX_ERROR
;
474 p
= get_flash_bank_by_addr(target
, address
);
477 return ERROR_COMMAND_SYNTAX_ERROR
;
480 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
483 duration_start_measure(&duration
);
485 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
487 duration_stop_measure(&duration
, &duration_text
);
488 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
495 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
502 return ERROR_COMMAND_SYNTAX_ERROR
;
505 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
508 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
510 command_print(cmd_ctx
, "successfully checked protect state");
512 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
514 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
518 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
523 return ERROR_COMMAND_SYNTAX_ERROR
;
529 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
533 int first
= strtoul(args
[1], NULL
, 0);
534 int last
= strtoul(args
[2], NULL
, 0);
536 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
540 duration_start_measure(&duration
);
544 return ERROR_COMMAND_SYNTAX_ERROR
;
547 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
549 duration_stop_measure(&duration
, &duration_text
);
551 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
557 return ERROR_COMMAND_SYNTAX_ERROR
;
563 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
567 int first
= strtoul(args
[1], NULL
, 0);
568 int last
= strtoul(args
[2], NULL
, 0);
571 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
574 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
578 if (strcmp(args
[3], "on") == 0)
580 else if (strcmp(args
[3], "off") == 0)
584 return ERROR_COMMAND_SYNTAX_ERROR
;
587 retval
= flash_driver_protect(p
, set
, first
, last
);
588 if (retval
== ERROR_OK
)
590 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));
595 return ERROR_COMMAND_SYNTAX_ERROR
;
602 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
604 target_t
*target
= get_current_target(cmd_ctx
);
616 return ERROR_COMMAND_SYNTAX_ERROR
;
619 /* flash auto-erase is disabled by default*/
622 if (strcmp(args
[0], "erase")==0)
627 command_print(cmd_ctx
, "auto erase enabled");
633 return ERROR_COMMAND_SYNTAX_ERROR
;
638 LOG_ERROR("no target selected");
642 duration_start_measure(&duration
);
646 image
.base_address_set
= 1;
647 image
.base_address
= strtoul(args
[1], NULL
, 0);
651 image
.base_address_set
= 0;
652 image
.base_address
= 0x0;
655 image
.start_address_set
= 0;
657 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
658 if (retval
!= ERROR_OK
)
663 retval
= flash_write(target
, &image
, &written
, auto_erase
);
664 if (retval
!= ERROR_OK
)
670 duration_stop_measure(&duration
, &duration_text
);
671 if (retval
== ERROR_OK
)
673 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
674 written
, args
[0], duration_text
,
675 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
684 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
695 target_t
*target
= get_current_target(cmd_ctx
);
701 return ERROR_COMMAND_SYNTAX_ERROR
;
704 address
= strtoul(args
[0], NULL
, 0);
705 pattern
= strtoul(args
[1], NULL
, 0);
706 count
= strtoul(args
[2], NULL
, 0);
724 return ERROR_COMMAND_SYNTAX_ERROR
;
727 chunk_count
= MIN(count
, (1024 / wordsize
));
731 for(i
= 0; i
< chunk_count
; i
++)
733 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
737 for(i
= 0; i
< chunk_count
; i
++)
739 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
743 memset(chunk
, pattern
, chunk_count
);
746 LOG_ERROR("BUG: can't happen");
750 duration_start_measure(&duration
);
753 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
756 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
758 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
762 bank
= get_flash_bank_by_addr(target
, address
);
768 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
776 duration_stop_measure(&duration
, &duration_text
);
781 speed
=wrote
/ 1024.0;
782 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
783 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
784 count
*wordsize
, address
, duration_text
,
791 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
807 return ERROR_COMMAND_SYNTAX_ERROR
;
810 duration_start_measure(&duration
);
812 offset
= strtoul(args
[2], NULL
, 0);
813 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
816 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
820 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
825 buffer
= malloc(fileio
.size
);
826 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
831 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
835 duration_stop_measure(&duration
, &duration_text
);
836 if (retval
!=ERROR_OK
)
838 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
839 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
840 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
844 fileio_close(&fileio
);
849 void flash_set_dirty(void)
854 /* set all flash to require erasing */
855 for (c
= flash_banks
; c
; c
= c
->next
)
857 for (i
= 0; i
< c
->num_sectors
; i
++)
859 c
->sectors
[i
].is_erased
= 0;
864 /* lookup flash bank by address */
865 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
869 /* cycle through bank list */
870 for (c
= flash_banks
; c
; c
= c
->next
)
873 retval
= c
->driver
->auto_probe(c
);
875 if (retval
!= ERROR_OK
)
877 LOG_ERROR("auto_probe failed %d\n", retval
);
880 /* check whether address belongs to this flash bank */
881 if ((addr
>= c
->base
) && (addr
< c
->base
+ c
->size
) && target
== c
->target
)
884 LOG_ERROR("No flash at address 0x%08x\n", addr
);
888 /* erase given flash region, selects proper bank according to target and address */
889 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
896 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
897 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
899 if (c
->size
== 0 || c
->num_sectors
== 0)
901 LOG_ERROR("Bank is invalid");
902 return ERROR_FLASH_BANK_INVALID
;
907 /* special case, erase whole bank when length is zero */
909 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
911 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
914 /* check whether it fits */
915 if (addr
+ length
> c
->base
+ c
->size
)
916 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
920 for (i
= 0; i
< c
->num_sectors
; i
++)
922 /* check whether sector overlaps with the given range and is not yet erased */
923 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
924 /* if first is not set yet then this is the first sector */
927 last
= i
; /* and it is the last one so far in any case */
931 if( first
== -1 || last
== -1 )
934 return flash_driver_erase(c
, first
, last
);
937 /* write (optional verify) an image to flash memory of the given target */
938 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
954 /* assume all sectors need erasing - stops any problems
955 * when flash_write is called multiple times */
960 /* loop until we reach end of the image */
961 while (section
< image
->num_sections
)
967 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
968 u32 run_size
= image
->sections
[section
].size
- section_offset
;
970 if (image
->sections
[section
].size
== 0)
972 LOG_WARNING("empty section %d", section
);
978 /* find the corresponding flash bank */
979 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
981 section
++; /* and skip it */
986 /* collect consecutive sections which fall into the same bank */
987 section_first
= section
;
988 section_last
= section
;
989 while ((run_address
+ run_size
< c
->base
+ c
->size
)
990 && (section_last
+ 1 < image
->num_sections
))
992 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
994 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
997 if (image
->sections
[section_last
+ 1].base_address
!= (run_address
+ run_size
))
999 run_size
+= image
->sections
[++section_last
].size
;
1002 /* fit the run into bank constraints */
1003 if (run_address
+ run_size
> c
->base
+ c
->size
)
1004 run_size
= c
->base
+ c
->size
- run_address
;
1006 /* allocate buffer */
1007 buffer
= malloc(run_size
);
1010 /* read sections to the buffer */
1011 while (buffer_size
< run_size
)
1015 if (buffer_size
- run_size
<= image
->sections
[section
].size
- section_offset
)
1016 size_read
= buffer_size
- run_size
;
1018 size_read
= image
->sections
[section
].size
- section_offset
;
1020 if ((retval
= image_read_section(image
, section
, section_offset
,
1021 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1028 buffer_size
+= size_read
;
1029 section_offset
+= size_read
;
1031 if (section_offset
>= image
->sections
[section
].size
)
1042 /* calculate and erase sectors */
1043 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1046 if (retval
== ERROR_OK
)
1048 /* write flash sectors */
1049 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1054 if (retval
!= ERROR_OK
)
1056 return retval
; /* abort operation */
1059 if (written
!= NULL
)
1060 *written
+= run_size
; /* add run size to total written counter */
1066 int default_flash_blank_check(struct flash_bank_s
*bank
)
1068 target_t
*target
= bank
->target
;
1070 int buffer_size
=sizeof(buffer
);
1074 if (bank
->target
->state
!= TARGET_HALTED
)
1076 return ERROR_TARGET_NOT_HALTED
;
1081 working_area_t
*erase_check_algorithm
;
1083 /* FIX! doesn't work yet... */
1085 char test(char *a, int len, char t)
1089 for (i=0; i<len; i++)
1096 $ arm-elf-gcc -c -mthumb -O3 test.c
1098 $ arm-elf-objdump --disassemble test.o
1100 test.o: file format elf32-littlearm
1102 Disassembly of section .text:
1105 0: b510 push {r4, lr}
1106 2: 0612 lsl r2, r2, #24
1107 4: 1c04 mov r4, r0 (add r4, r0, #0)
1108 6: 0e10 lsr r0, r2, #24
1111 c: dd04 ble 18 <test+0x18>
1112 e: 5ca3 ldrb r3, [r4, r2]
1116 16: dbfa blt e <test+0xe>
1117 18: bd10 pop {r4, pc}
1118 1a: 46c0 nop (mov r8, r8)
1122 u16 erase_check_code
[] =
1124 0x0612,// lsl r2, r2, #24
1125 0x1c04,// mov r4, r0 (add r4, r0, #0)
1126 0x0e10,// lsr r0, r2, #24
1127 0x2200,// mov r2, #0
1128 0x2900,// cmp r1, #0
1129 0xdd04,// ble 18 <test+0x18>
1130 0x5ca3,// ldrb r3, [r4, r2]
1131 0x3201,// add r2, #1
1132 0x4018,// and r0, r3
1133 0x428a,// cmp r2, r1
1134 0xdbfa,// blt e <test+0xe>
1135 0x46c0,// nop (mov r8, r8)
1141 /* make sure we have a working area */
1142 if (target_alloc_working_area(target
, ((sizeof(erase_check_code
)+3)/4)*4, &erase_check_algorithm
) != ERROR_OK
)
1144 erase_check_algorithm
= NULL
;
1147 if (erase_check_algorithm
)
1149 u8 erase_check_code_buf
[((sizeof(erase_check_code
)+3)/4)*4];
1150 LOG_DEBUG("Running fast flash erase check");
1152 for (i
= 0; i
< sizeof(erase_check_code
)/sizeof(*erase_check_code
); i
++)
1153 target_buffer_set_u16(target
, erase_check_code_buf
+ (i
*2), erase_check_code
[i
]);
1155 /* write algorithm code to working area */
1156 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
)
1158 for (i
= 0; i
< bank
->num_sectors
; i
++)
1160 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1161 u32 size
= bank
->sectors
[i
].size
;
1163 reg_param_t reg_params
[3];
1164 armv7m_algorithm_t arm_info
;
1166 arm_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
1167 arm_info
.core_mode
= ARMV7M_MODE_ANY
;
1168 arm_info
.core_state
= ARMV7M_STATE_THUMB
;
1170 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
1171 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
1173 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
1174 buf_set_u32(reg_params
[1].value
, 0, 32, size
);
1176 init_reg_param(®_params
[2], "r2", 32, PARAM_IN_OUT
);
1177 buf_set_u32(reg_params
[2].value
, 0, 32, 0xff);
1179 if ((retval
= target
->type
->run_algorithm(target
, 0, NULL
, 3, reg_params
, erase_check_algorithm
->address
,
1180 erase_check_algorithm
->address
+ sizeof(erase_check_code
) - 2, 10000, &arm_info
)) != ERROR_OK
)
1183 if (buf_get_u32(reg_params
[2].value
, 0, 32) == 0xff)
1184 bank
->sectors
[i
].is_erased
= 1;
1186 bank
->sectors
[i
].is_erased
= 0;
1188 destroy_reg_param(®_params
[0]);
1189 destroy_reg_param(®_params
[1]);
1190 destroy_reg_param(®_params
[2]);
1192 if (i
== bank
->num_sectors
)
1197 target_free_working_area(target
, erase_check_algorithm
);
1202 /* try ARM7 instead */
1204 u32 erase_check_code
[] =
1206 0xe4d03001, /* ldrb r3, [r0], #1 */
1207 0xe0022003, /* and r2, r2, r3 */
1208 0xe2511001, /* subs r1, r1, #1 */
1209 0x1afffffb, /* b -4 */
1210 0xeafffffe /* b 0 */
1213 /* make sure we have a working area */
1214 if (target_alloc_working_area(target
, 20, &erase_check_algorithm
) == ERROR_OK
)
1216 u8 erase_check_code_buf
[5 * 4];
1218 for (i
= 0; i
< 5; i
++)
1219 target_buffer_set_u32(target
, erase_check_code_buf
+ (i
*4), erase_check_code
[i
]);
1221 /* write algorithm code to working area */
1222 if ((retval
=target
->type
->write_memory(target
, erase_check_algorithm
->address
, 4, 5, erase_check_code_buf
))==ERROR_OK
)
1224 for (i
= 0; i
< bank
->num_sectors
; i
++)
1226 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1227 u32 size
= bank
->sectors
[i
].size
;
1229 reg_param_t reg_params
[3];
1230 armv4_5_algorithm_t armv4_5_info
;
1232 armv4_5_info
.common_magic
= ARMV4_5_COMMON_MAGIC
;
1233 armv4_5_info
.core_mode
= ARMV4_5_MODE_SVC
;
1234 armv4_5_info
.core_state
= ARMV4_5_STATE_ARM
;
1236 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
1237 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
1239 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
1240 buf_set_u32(reg_params
[1].value
, 0, 32, size
);
1242 init_reg_param(®_params
[2], "r2", 32, PARAM_IN_OUT
);
1243 buf_set_u32(reg_params
[2].value
, 0, 32, 0xff);
1245 if ((retval
= target
->type
->run_algorithm(target
, 0, NULL
, 3, reg_params
,
1246 erase_check_algorithm
->address
, erase_check_algorithm
->address
+ 0x10, 10000, &armv4_5_info
)) != ERROR_OK
)
1249 if (buf_get_u32(reg_params
[2].value
, 0, 32) == 0xff)
1250 bank
->sectors
[i
].is_erased
= 1;
1252 bank
->sectors
[i
].is_erased
= 0;
1254 destroy_reg_param(®_params
[0]);
1255 destroy_reg_param(®_params
[1]);
1256 destroy_reg_param(®_params
[2]);
1258 if (i
== bank
->num_sectors
)
1263 target_free_working_area(target
, erase_check_algorithm
);
1270 LOG_USER("Running slow fallback erase check - add working memory");
1271 for (i
= 0; i
< bank
->num_sectors
; i
++)
1274 bank
->sectors
[i
].is_erased
= 1;
1276 for (j
=0; j
<bank
->sectors
[i
].size
; j
+=buffer_size
)
1281 if (chunk
>(j
-bank
->sectors
[i
].size
))
1283 chunk
=(j
-bank
->sectors
[i
].size
);
1286 retval
=target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1287 if (retval
!=ERROR_OK
)
1290 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1292 if (buffer
[nBytes
] != 0xFF)
1294 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)