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
;
91 static int auto_erase
= 0;
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 ...]");
139 register_command(cmd_ctx
, flash_cmd
, "auto_erase", handle_flash_auto_erase_command
, COMMAND_ANY
,
140 "auto erase flash sectors <on|off>");
144 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
148 register_command(cmd_ctx
, flash_cmd
, "banks", handle_flash_banks_command
, COMMAND_EXEC
,
149 "list configured flash banks ");
150 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
151 "print info about flash bank <num>");
152 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
153 "identify flash bank <num>");
154 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
155 "check erase state of sectors in flash bank <num>");
156 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
157 "check protection state of sectors in flash bank <num>");
158 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
159 "erase sectors at <bank> <first> <last>");
160 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
161 "erase address range <address> <length>");
163 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
164 "fill with pattern <address> <word_pattern> <count>");
165 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
166 "fill with pattern <address> <halfword_pattern> <count>");
167 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
168 "fill with pattern <address> <byte_pattern> <count>");
170 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
171 "write binary data to <bank> <file> <offset>");
172 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
173 "write_image <file> [offset] [type]");
174 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
175 "set protection of sectors at <bank> <first> <last> <on|off>");
181 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
186 for (p
= flash_banks
; p
; p
= p
->next
)
193 LOG_ERROR("flash bank %d does not exist", num
);
197 int flash_get_bank_count()
201 for (p
= flash_banks
; p
; p
= p
->next
)
208 flash_bank_t
*get_flash_bank_by_num(int num
)
210 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
216 retval
= p
->driver
->auto_probe(p
);
218 if (retval
!= ERROR_OK
)
220 LOG_ERROR("auto_probe failed %d\n", retval
);
226 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
234 return ERROR_COMMAND_SYNTAX_ERROR
;
237 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
239 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
243 for (i
= 0; flash_drivers
[i
]; i
++)
245 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
249 /* register flash specific commands */
250 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
252 LOG_ERROR("couldn't register '%s' commands", args
[0]);
256 c
= malloc(sizeof(flash_bank_t
));
258 c
->driver
= flash_drivers
[i
];
259 c
->driver_priv
= NULL
;
260 c
->base
= strtoul(args
[1], NULL
, 0);
261 c
->size
= strtoul(args
[2], NULL
, 0);
262 c
->chip_width
= strtoul(args
[3], NULL
, 0);
263 c
->bus_width
= strtoul(args
[4], NULL
, 0);
268 if (flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
) != ERROR_OK
)
270 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
275 /* put flash bank in linked list */
278 /* find last flash bank */
279 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
292 /* no matching flash driver found */
295 LOG_ERROR("flash driver '%s' not found", args
[0]);
302 int handle_flash_banks_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
309 command_print(cmd_ctx
, "no flash banks configured");
313 for (p
= flash_banks
; p
; p
= p
->next
)
315 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
316 i
++, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
322 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
331 return ERROR_COMMAND_SYNTAX_ERROR
;
334 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
336 if (i
== strtoul(args
[0], NULL
, 0))
340 /* attempt auto probe */
341 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
344 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
345 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
346 for (j
= 0; j
< p
->num_sectors
; j
++)
350 if (p
->sectors
[j
].is_protected
== 0)
351 protect_state
= "not protected";
352 else if (p
->sectors
[j
].is_protected
== 1)
353 protect_state
= "protected";
355 protect_state
= "protection state unknown";
357 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
358 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
362 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
363 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
364 command_print(cmd_ctx
, "%s", buf
);
365 if (retval
!= ERROR_OK
)
366 LOG_ERROR("error retrieving flash info (%d)", retval
);
373 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
380 return ERROR_COMMAND_SYNTAX_ERROR
;
383 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
386 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
388 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
390 else if (retval
== ERROR_FLASH_BANK_INVALID
)
392 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
397 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
403 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
409 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
416 return ERROR_COMMAND_SYNTAX_ERROR
;
419 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
423 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
425 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
429 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
433 for (j
= 0; j
< p
->num_sectors
; j
++)
437 if (p
->sectors
[j
].is_erased
== 0)
438 erase_state
= "not erased";
439 else if (p
->sectors
[j
].is_erased
== 1)
440 erase_state
= "erased";
442 erase_state
= "erase state unknown";
444 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
445 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
454 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
463 target_t
*target
= get_current_target(cmd_ctx
);
467 return ERROR_COMMAND_SYNTAX_ERROR
;
470 address
= strtoul(args
[0], NULL
, 0);
471 length
= strtoul(args
[1], NULL
, 0);
474 command_print(cmd_ctx
, "Length must be >0");
475 return ERROR_COMMAND_SYNTAX_ERROR
;
478 p
= get_flash_bank_by_addr(target
, address
);
481 return ERROR_COMMAND_SYNTAX_ERROR
;
484 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
487 duration_start_measure(&duration
);
489 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
491 duration_stop_measure(&duration
, &duration_text
);
492 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
499 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
506 return ERROR_COMMAND_SYNTAX_ERROR
;
509 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
512 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
514 command_print(cmd_ctx
, "successfully checked protect state");
516 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
518 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
522 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
527 return ERROR_COMMAND_SYNTAX_ERROR
;
533 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
537 int first
= strtoul(args
[1], NULL
, 0);
538 int last
= strtoul(args
[2], NULL
, 0);
540 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
544 duration_start_measure(&duration
);
548 return ERROR_COMMAND_SYNTAX_ERROR
;
551 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
553 duration_stop_measure(&duration
, &duration_text
);
555 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
561 return ERROR_COMMAND_SYNTAX_ERROR
;
567 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
571 int first
= strtoul(args
[1], NULL
, 0);
572 int last
= strtoul(args
[2], NULL
, 0);
575 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
578 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
582 if (strcmp(args
[3], "on") == 0)
584 else if (strcmp(args
[3], "off") == 0)
588 return ERROR_COMMAND_SYNTAX_ERROR
;
591 retval
= flash_driver_protect(p
, set
, first
, last
);
592 if (retval
== ERROR_OK
)
594 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));
599 return ERROR_COMMAND_SYNTAX_ERROR
;
606 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
608 target_t
*target
= get_current_target(cmd_ctx
);
620 return ERROR_COMMAND_SYNTAX_ERROR
;
625 LOG_ERROR("no target selected");
629 duration_start_measure(&duration
);
633 image
.base_address_set
= 1;
634 image
.base_address
= strtoul(args
[1], NULL
, 0);
638 image
.base_address_set
= 0;
639 image
.base_address
= 0x0;
642 image
.start_address_set
= 0;
644 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
645 if (retval
!= ERROR_OK
)
650 retval
= flash_write(target
, &image
, &written
, auto_erase
);
651 if (retval
!= ERROR_OK
)
657 duration_stop_measure(&duration
, &duration_text
);
658 if (retval
== ERROR_OK
)
660 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
661 written
, args
[0], duration_text
,
662 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
671 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
682 target_t
*target
= get_current_target(cmd_ctx
);
688 return ERROR_COMMAND_SYNTAX_ERROR
;
691 address
= strtoul(args
[0], NULL
, 0);
692 pattern
= strtoul(args
[1], NULL
, 0);
693 count
= strtoul(args
[2], NULL
, 0);
711 return ERROR_COMMAND_SYNTAX_ERROR
;
714 chunk_count
= MIN(count
, (1024 / wordsize
));
718 for(i
= 0; i
< chunk_count
; i
++)
720 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
724 for(i
= 0; i
< chunk_count
; i
++)
726 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
730 memset(chunk
, pattern
, chunk_count
);
733 LOG_ERROR("BUG: can't happen");
737 duration_start_measure(&duration
);
740 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
743 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
745 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
749 bank
= get_flash_bank_by_addr(target
, address
);
755 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
763 duration_stop_measure(&duration
, &duration_text
);
768 speed
=wrote
/ 1024.0;
769 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
770 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
771 count
*wordsize
, address
, duration_text
,
778 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
794 return ERROR_COMMAND_SYNTAX_ERROR
;
797 duration_start_measure(&duration
);
799 offset
= strtoul(args
[2], NULL
, 0);
800 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
803 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
807 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
812 buffer
= malloc(fileio
.size
);
813 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
818 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
822 duration_stop_measure(&duration
, &duration_text
);
823 if (retval
!=ERROR_OK
)
825 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
826 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
827 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
831 fileio_close(&fileio
);
836 void flash_set_dirty(void)
841 /* set all flash to require erasing */
842 for (c
= flash_banks
; c
; c
= c
->next
)
844 for (i
= 0; i
< c
->num_sectors
; i
++)
846 c
->sectors
[i
].is_erased
= 0;
851 /* lookup flash bank by address */
852 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
856 /* cycle through bank list */
857 for (c
= flash_banks
; c
; c
= c
->next
)
860 retval
= c
->driver
->auto_probe(c
);
862 if (retval
!= ERROR_OK
)
864 LOG_ERROR("auto_probe failed %d\n", retval
);
867 /* check whether address belongs to this flash bank */
868 if ((addr
>= c
->base
) && (addr
< c
->base
+ c
->size
) && target
== c
->target
)
871 LOG_ERROR("No flash at address 0x%08x\n", addr
);
875 /* erase given flash region, selects proper bank according to target and address */
876 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
883 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
884 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
886 if (c
->size
== 0 || c
->num_sectors
== 0)
888 LOG_ERROR("Bank is invalid");
889 return ERROR_FLASH_BANK_INVALID
;
894 /* special case, erase whole bank when length is zero */
896 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
898 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
901 /* check whether it fits */
902 if (addr
+ length
> c
->base
+ c
->size
)
903 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
907 for (i
= 0; i
< c
->num_sectors
; i
++)
909 /* check whether sector overlaps with the given range and is not yet erased */
910 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
911 /* if first is not set yet then this is the first sector */
914 last
= i
; /* and it is the last one so far in any case */
918 if( first
== -1 || last
== -1 )
921 return flash_driver_erase(c
, first
, last
);
924 /* write (optional verify) an image to flash memory of the given target */
925 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
941 /* assume all sectors need erasing - stops any problems
942 * when flash_write is called multiple times */
947 /* loop until we reach end of the image */
948 while (section
< image
->num_sections
)
954 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
955 u32 run_size
= image
->sections
[section
].size
- section_offset
;
957 if (image
->sections
[section
].size
== 0)
959 LOG_WARNING("empty section %d", section
);
965 /* find the corresponding flash bank */
966 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
968 section
++; /* and skip it */
973 /* collect consecutive sections which fall into the same bank */
974 section_first
= section
;
975 section_last
= section
;
976 while ((run_address
+ run_size
< c
->base
+ c
->size
)
977 && (section_last
+ 1 < image
->num_sections
))
979 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
981 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
984 if (image
->sections
[section_last
+ 1].base_address
!= (run_address
+ run_size
))
986 run_size
+= image
->sections
[++section_last
].size
;
989 /* fit the run into bank constraints */
990 if (run_address
+ run_size
> c
->base
+ c
->size
)
991 run_size
= c
->base
+ c
->size
- run_address
;
993 /* allocate buffer */
994 buffer
= malloc(run_size
);
997 /* read sections to the buffer */
998 while (buffer_size
< run_size
)
1002 if (buffer_size
- run_size
<= image
->sections
[section
].size
- section_offset
)
1003 size_read
= buffer_size
- run_size
;
1005 size_read
= image
->sections
[section
].size
- section_offset
;
1007 if ((retval
= image_read_section(image
, section
, section_offset
,
1008 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1015 buffer_size
+= size_read
;
1016 section_offset
+= size_read
;
1018 if (section_offset
>= image
->sections
[section
].size
)
1029 /* calculate and erase sectors */
1030 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1033 if (retval
== ERROR_OK
)
1035 /* write flash sectors */
1036 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1041 if (retval
!= ERROR_OK
)
1043 return retval
; /* abort operation */
1046 if (written
!= NULL
)
1047 *written
+= run_size
; /* add run size to total written counter */
1053 int handle_flash_auto_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
1057 return ERROR_COMMAND_SYNTAX_ERROR
;
1060 if (strcmp(args
[0], "on") == 0)
1062 else if (strcmp(args
[0], "off") == 0)
1065 return ERROR_COMMAND_SYNTAX_ERROR
;
1071 int default_flash_blank_check(struct flash_bank_s
*bank
)
1073 target_t
*target
= bank
->target
;
1075 int buffer_size
=sizeof(buffer
);
1079 if (bank
->target
->state
!= TARGET_HALTED
)
1081 return ERROR_TARGET_NOT_HALTED
;
1086 working_area_t
*erase_check_algorithm
;
1088 /* FIX! doesn't work yet... */
1090 char test(char *a, int len, char t)
1094 for (i=0; i<len; i++)
1101 $ arm-elf-gcc -c -mthumb -O3 test.c
1103 $ arm-elf-objdump --disassemble test.o
1105 test.o: file format elf32-littlearm
1107 Disassembly of section .text:
1110 0: b510 push {r4, lr}
1111 2: 0612 lsl r2, r2, #24
1112 4: 1c04 mov r4, r0 (add r4, r0, #0)
1113 6: 0e10 lsr r0, r2, #24
1116 c: dd04 ble 18 <test+0x18>
1117 e: 5ca3 ldrb r3, [r4, r2]
1121 16: dbfa blt e <test+0xe>
1122 18: bd10 pop {r4, pc}
1123 1a: 46c0 nop (mov r8, r8)
1127 u16 erase_check_code
[] =
1129 0x0612,// lsl r2, r2, #24
1130 0x1c04,// mov r4, r0 (add r4, r0, #0)
1131 0x0e10,// lsr r0, r2, #24
1132 0x2200,// mov r2, #0
1133 0x2900,// cmp r1, #0
1134 0xdd04,// ble 18 <test+0x18>
1135 0x5ca3,// ldrb r3, [r4, r2]
1136 0x3201,// add r2, #1
1137 0x4018,// and r0, r3
1138 0x428a,// cmp r2, r1
1139 0xdbfa,// blt e <test+0xe>
1140 0x46c0,// nop (mov r8, r8)
1146 /* make sure we have a working area */
1147 if (target_alloc_working_area(target
, ((sizeof(erase_check_code
)+3)/4)*4, &erase_check_algorithm
) != ERROR_OK
)
1149 erase_check_algorithm
= NULL
;
1152 if (erase_check_algorithm
)
1154 u8 erase_check_code_buf
[((sizeof(erase_check_code
)+3)/4)*4];
1155 LOG_DEBUG("Running fast flash erase check");
1157 for (i
= 0; i
< sizeof(erase_check_code
)/sizeof(*erase_check_code
); i
++)
1158 target_buffer_set_u16(target
, erase_check_code_buf
+ (i
*2), erase_check_code
[i
]);
1160 /* write algorithm code to working area */
1161 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
)
1163 for (i
= 0; i
< bank
->num_sectors
; i
++)
1165 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1166 u32 size
= bank
->sectors
[i
].size
;
1168 reg_param_t reg_params
[3];
1169 armv7m_algorithm_t arm_info
;
1171 arm_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
1172 arm_info
.core_mode
= ARMV7M_MODE_ANY
;
1173 arm_info
.core_state
= ARMV7M_STATE_THUMB
;
1175 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
1176 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
1178 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
1179 buf_set_u32(reg_params
[1].value
, 0, 32, size
);
1181 init_reg_param(®_params
[2], "r2", 32, PARAM_IN_OUT
);
1182 buf_set_u32(reg_params
[2].value
, 0, 32, 0xff);
1184 if ((retval
= target
->type
->run_algorithm(target
, 0, NULL
, 3, reg_params
, erase_check_algorithm
->address
,
1185 erase_check_algorithm
->address
+ sizeof(erase_check_code
) - 2, 10000, &arm_info
)) != ERROR_OK
)
1188 if (buf_get_u32(reg_params
[2].value
, 0, 32) == 0xff)
1189 bank
->sectors
[i
].is_erased
= 1;
1191 bank
->sectors
[i
].is_erased
= 0;
1193 destroy_reg_param(®_params
[0]);
1194 destroy_reg_param(®_params
[1]);
1195 destroy_reg_param(®_params
[2]);
1197 if (i
== bank
->num_sectors
)
1202 target_free_working_area(target
, erase_check_algorithm
);
1207 /* try ARM7 instead */
1209 u32 erase_check_code
[] =
1211 0xe4d03001, /* ldrb r3, [r0], #1 */
1212 0xe0022003, /* and r2, r2, r3 */
1213 0xe2511001, /* subs r1, r1, #1 */
1214 0x1afffffb, /* b -4 */
1215 0xeafffffe /* b 0 */
1218 /* make sure we have a working area */
1219 if (target_alloc_working_area(target
, 20, &erase_check_algorithm
) == ERROR_OK
)
1221 u8 erase_check_code_buf
[5 * 4];
1223 for (i
= 0; i
< 5; i
++)
1224 target_buffer_set_u32(target
, erase_check_code_buf
+ (i
*4), erase_check_code
[i
]);
1226 /* write algorithm code to working area */
1227 if ((retval
=target
->type
->write_memory(target
, erase_check_algorithm
->address
, 4, 5, erase_check_code_buf
))==ERROR_OK
)
1229 for (i
= 0; i
< bank
->num_sectors
; i
++)
1231 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1232 u32 size
= bank
->sectors
[i
].size
;
1234 reg_param_t reg_params
[3];
1235 armv4_5_algorithm_t armv4_5_info
;
1237 armv4_5_info
.common_magic
= ARMV4_5_COMMON_MAGIC
;
1238 armv4_5_info
.core_mode
= ARMV4_5_MODE_SVC
;
1239 armv4_5_info
.core_state
= ARMV4_5_STATE_ARM
;
1241 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
1242 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
1244 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
1245 buf_set_u32(reg_params
[1].value
, 0, 32, size
);
1247 init_reg_param(®_params
[2], "r2", 32, PARAM_IN_OUT
);
1248 buf_set_u32(reg_params
[2].value
, 0, 32, 0xff);
1250 if ((retval
= target
->type
->run_algorithm(target
, 0, NULL
, 3, reg_params
,
1251 erase_check_algorithm
->address
, erase_check_algorithm
->address
+ 0x10, 10000, &armv4_5_info
)) != ERROR_OK
)
1254 if (buf_get_u32(reg_params
[2].value
, 0, 32) == 0xff)
1255 bank
->sectors
[i
].is_erased
= 1;
1257 bank
->sectors
[i
].is_erased
= 0;
1259 destroy_reg_param(®_params
[0]);
1260 destroy_reg_param(®_params
[1]);
1261 destroy_reg_param(®_params
[2]);
1263 if (i
== bank
->num_sectors
)
1268 target_free_working_area(target
, erase_check_algorithm
);
1275 LOG_USER("Running slow fallback erase check - add working memory");
1276 for (i
= 0; i
< bank
->num_sectors
; i
++)
1279 bank
->sectors
[i
].is_erased
= 1;
1281 for (j
=0; j
<bank
->sectors
[i
].size
; j
+=buffer_size
)
1286 if (chunk
>(j
-bank
->sectors
[i
].size
))
1288 chunk
=(j
-bank
->sectors
[i
].size
);
1291 retval
=target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1292 if (retval
!=ERROR_OK
)
1295 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1297 if (buffer
[nBytes
] != 0xFF)
1299 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)