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
;
73 extern flash_driver_t ocl_flash
;
75 flash_driver_t
*flash_drivers
[] =
92 flash_bank_t
*flash_banks
;
93 static command_t
*flash_cmd
;
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
);
135 int flash_register_commands(struct command_context_s
*cmd_ctx
)
137 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
139 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 ...]");
143 int flash_init_drivers(struct command_context_s
*cmd_ctx
)
147 register_command(cmd_ctx
, flash_cmd
, "banks", handle_flash_banks_command
, COMMAND_EXEC
,
148 "list configured flash banks ");
149 register_command(cmd_ctx
, flash_cmd
, "info", handle_flash_info_command
, COMMAND_EXEC
,
150 "print info about flash bank <num>");
151 register_command(cmd_ctx
, flash_cmd
, "probe", handle_flash_probe_command
, COMMAND_EXEC
,
152 "identify flash bank <num>");
153 register_command(cmd_ctx
, flash_cmd
, "erase_check", handle_flash_erase_check_command
, COMMAND_EXEC
,
154 "check erase state of sectors in flash bank <num>");
155 register_command(cmd_ctx
, flash_cmd
, "protect_check", handle_flash_protect_check_command
, COMMAND_EXEC
,
156 "check protection state of sectors in flash bank <num>");
157 register_command(cmd_ctx
, flash_cmd
, "erase_sector", handle_flash_erase_command
, COMMAND_EXEC
,
158 "erase sectors at <bank> <first> <last>");
159 register_command(cmd_ctx
, flash_cmd
, "erase_address", handle_flash_erase_address_command
, COMMAND_EXEC
,
160 "erase address range <address> <length>");
162 register_command(cmd_ctx
, flash_cmd
, "fillw", handle_flash_fill_command
, COMMAND_EXEC
,
163 "fill with pattern <address> <word_pattern> <count>");
164 register_command(cmd_ctx
, flash_cmd
, "fillh", handle_flash_fill_command
, COMMAND_EXEC
,
165 "fill with pattern <address> <halfword_pattern> <count>");
166 register_command(cmd_ctx
, flash_cmd
, "fillb", handle_flash_fill_command
, COMMAND_EXEC
,
167 "fill with pattern <address> <byte_pattern> <count>");
169 register_command(cmd_ctx
, flash_cmd
, "write_bank", handle_flash_write_bank_command
, COMMAND_EXEC
,
170 "write binary data to <bank> <file> <offset>");
171 register_command(cmd_ctx
, flash_cmd
, "write_image", handle_flash_write_image_command
, COMMAND_EXEC
,
172 "write_image [erase] <file> [offset] [type]");
173 register_command(cmd_ctx
, flash_cmd
, "protect", handle_flash_protect_command
, COMMAND_EXEC
,
174 "set protection of sectors at <bank> <first> <last> <on|off>");
180 flash_bank_t
*get_flash_bank_by_num_noprobe(int num
)
185 for (p
= flash_banks
; p
; p
= p
->next
)
192 LOG_ERROR("flash bank %d does not exist", num
);
196 int flash_get_bank_count()
200 for (p
= flash_banks
; p
; p
= p
->next
)
207 flash_bank_t
*get_flash_bank_by_num(int num
)
209 flash_bank_t
*p
= get_flash_bank_by_num_noprobe(num
);
215 retval
= p
->driver
->auto_probe(p
);
217 if (retval
!= ERROR_OK
)
219 LOG_ERROR("auto_probe failed %d\n", retval
);
225 int handle_flash_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
233 return ERROR_COMMAND_SYNTAX_ERROR
;
236 if ((target
= get_target_by_num(strtoul(args
[5], NULL
, 0))) == NULL
)
238 LOG_ERROR("target %lu not defined", strtoul(args
[5], NULL
, 0));
242 for (i
= 0; flash_drivers
[i
]; i
++)
244 if (strcmp(args
[0], flash_drivers
[i
]->name
) == 0)
248 /* register flash specific commands */
249 if (flash_drivers
[i
]->register_commands(cmd_ctx
) != ERROR_OK
)
251 LOG_ERROR("couldn't register '%s' commands", args
[0]);
255 c
= malloc(sizeof(flash_bank_t
));
257 c
->driver
= flash_drivers
[i
];
258 c
->driver_priv
= NULL
;
259 c
->base
= strtoul(args
[1], NULL
, 0);
260 c
->size
= strtoul(args
[2], NULL
, 0);
261 c
->chip_width
= strtoul(args
[3], NULL
, 0);
262 c
->bus_width
= strtoul(args
[4], NULL
, 0);
267 if (flash_drivers
[i
]->flash_bank_command(cmd_ctx
, cmd
, args
, argc
, c
) != ERROR_OK
)
269 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args
[0], c
->base
);
274 /* put flash bank in linked list */
277 /* find last flash bank */
278 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
);
291 /* no matching flash driver found */
294 LOG_ERROR("flash driver '%s' not found", args
[0]);
301 int handle_flash_banks_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
308 command_print(cmd_ctx
, "no flash banks configured");
312 for (p
= flash_banks
; p
; p
= p
->next
)
314 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
315 i
++, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
321 int handle_flash_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
330 return ERROR_COMMAND_SYNTAX_ERROR
;
333 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
335 if (i
== strtoul(args
[0], NULL
, 0))
339 /* attempt auto probe */
340 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
343 command_print(cmd_ctx
, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
344 i
, p
->driver
->name
, p
->base
, p
->size
, p
->bus_width
, p
->chip_width
);
345 for (j
= 0; j
< p
->num_sectors
; j
++)
349 if (p
->sectors
[j
].is_protected
== 0)
350 protect_state
= "not protected";
351 else if (p
->sectors
[j
].is_protected
== 1)
352 protect_state
= "protected";
354 protect_state
= "protection state unknown";
356 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
357 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
361 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
362 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
363 command_print(cmd_ctx
, "%s", buf
);
364 if (retval
!= ERROR_OK
)
365 LOG_ERROR("error retrieving flash info (%d)", retval
);
372 int handle_flash_probe_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
379 return ERROR_COMMAND_SYNTAX_ERROR
;
382 p
= get_flash_bank_by_num_noprobe(strtoul(args
[0], NULL
, 0));
385 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
387 command_print(cmd_ctx
, "flash '%s' found at 0x%8.8x", p
->driver
->name
, p
->base
);
389 else if (retval
== ERROR_FLASH_BANK_INVALID
)
391 command_print(cmd_ctx
, "probing failed for flash bank '#%s' at 0x%8.8x",
396 command_print(cmd_ctx
, "unknown error when probing flash bank '#%s' at 0x%8.8x",
402 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
408 int handle_flash_erase_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
415 return ERROR_COMMAND_SYNTAX_ERROR
;
418 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
422 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
424 command_print(cmd_ctx
, "successfully checked erase state", p
->driver
->name
, p
->base
);
428 command_print(cmd_ctx
, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
432 for (j
= 0; j
< p
->num_sectors
; j
++)
436 if (p
->sectors
[j
].is_erased
== 0)
437 erase_state
= "not erased";
438 else if (p
->sectors
[j
].is_erased
== 1)
439 erase_state
= "erased";
441 erase_state
= "erase state unknown";
443 command_print(cmd_ctx
, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
444 j
, p
->sectors
[j
].offset
, p
->sectors
[j
].size
, p
->sectors
[j
].size
>>10,
453 int handle_flash_erase_address_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
462 target_t
*target
= get_current_target(cmd_ctx
);
466 return ERROR_COMMAND_SYNTAX_ERROR
;
469 address
= strtoul(args
[0], NULL
, 0);
470 length
= strtoul(args
[1], NULL
, 0);
473 command_print(cmd_ctx
, "Length must be >0");
474 return ERROR_COMMAND_SYNTAX_ERROR
;
477 p
= get_flash_bank_by_addr(target
, address
);
483 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
486 duration_start_measure(&duration
);
488 if ((retval
= flash_erase_address_range(target
, address
, length
)) == ERROR_OK
)
490 duration_stop_measure(&duration
, &duration_text
);
491 command_print(cmd_ctx
, "erased address 0x%8.8x length %i in %s", address
, length
, duration_text
);
498 int handle_flash_protect_check_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
505 return ERROR_COMMAND_SYNTAX_ERROR
;
508 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
511 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
513 command_print(cmd_ctx
, "successfully checked protect state");
515 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
517 command_print(cmd_ctx
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args
[0], p
->base
);
521 command_print(cmd_ctx
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args
[0], p
->base
);
526 return ERROR_COMMAND_SYNTAX_ERROR
;
532 int handle_flash_erase_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
536 int first
= strtoul(args
[1], NULL
, 0);
537 int last
= strtoul(args
[2], NULL
, 0);
539 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
543 duration_start_measure(&duration
);
547 return ERROR_COMMAND_SYNTAX_ERROR
;
550 if ((retval
= flash_driver_erase(p
, first
, last
)) == ERROR_OK
)
552 duration_stop_measure(&duration
, &duration_text
);
554 command_print(cmd_ctx
, "erased sectors %i through %i on flash bank %i in %s", first
, last
, strtoul(args
[0], 0, 0), duration_text
);
560 return ERROR_COMMAND_SYNTAX_ERROR
;
566 int handle_flash_protect_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
570 int first
= strtoul(args
[1], NULL
, 0);
571 int last
= strtoul(args
[2], NULL
, 0);
574 flash_bank_t
*p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
577 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
581 if (strcmp(args
[3], "on") == 0)
583 else if (strcmp(args
[3], "off") == 0)
587 return ERROR_COMMAND_SYNTAX_ERROR
;
590 retval
= flash_driver_protect(p
, set
, first
, last
);
591 if (retval
== ERROR_OK
)
593 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));
598 return ERROR_COMMAND_SYNTAX_ERROR
;
605 int handle_flash_write_image_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
607 target_t
*target
= get_current_target(cmd_ctx
);
619 return ERROR_COMMAND_SYNTAX_ERROR
;
622 /* flash auto-erase is disabled by default*/
625 if (strcmp(args
[0], "erase")==0)
630 command_print(cmd_ctx
, "auto erase enabled");
636 return ERROR_COMMAND_SYNTAX_ERROR
;
641 LOG_ERROR("no target selected");
645 duration_start_measure(&duration
);
649 image
.base_address_set
= 1;
650 image
.base_address
= strtoul(args
[1], NULL
, 0);
654 image
.base_address_set
= 0;
655 image
.base_address
= 0x0;
658 image
.start_address_set
= 0;
660 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
661 if (retval
!= ERROR_OK
)
666 retval
= flash_write(target
, &image
, &written
, auto_erase
);
667 if (retval
!= ERROR_OK
)
673 duration_stop_measure(&duration
, &duration_text
);
674 if (retval
== ERROR_OK
)
676 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
677 written
, args
[0], duration_text
,
678 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
687 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
698 target_t
*target
= get_current_target(cmd_ctx
);
704 return ERROR_COMMAND_SYNTAX_ERROR
;
707 address
= strtoul(args
[0], NULL
, 0);
708 pattern
= strtoul(args
[1], NULL
, 0);
709 count
= strtoul(args
[2], NULL
, 0);
727 return ERROR_COMMAND_SYNTAX_ERROR
;
730 chunk_count
= MIN(count
, (1024 / wordsize
));
734 for(i
= 0; i
< chunk_count
; i
++)
736 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
740 for(i
= 0; i
< chunk_count
; i
++)
742 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
746 memset(chunk
, pattern
, chunk_count
);
749 LOG_ERROR("BUG: can't happen");
753 duration_start_measure(&duration
);
756 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
759 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
761 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
765 bank
= get_flash_bank_by_addr(target
, address
);
771 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
779 duration_stop_measure(&duration
, &duration_text
);
784 speed
=wrote
/ 1024.0;
785 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
786 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
787 count
*wordsize
, address
, duration_text
,
794 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
810 return ERROR_COMMAND_SYNTAX_ERROR
;
813 duration_start_measure(&duration
);
815 offset
= strtoul(args
[2], NULL
, 0);
816 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
819 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
823 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
828 buffer
= malloc(fileio
.size
);
829 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
832 fileio_close(&fileio
);
836 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
841 duration_stop_measure(&duration
, &duration_text
);
842 if (retval
!=ERROR_OK
)
844 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
845 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
846 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
850 fileio_close(&fileio
);
855 void flash_set_dirty(void)
860 /* set all flash to require erasing */
861 for (c
= flash_banks
; c
; c
= c
->next
)
863 for (i
= 0; i
< c
->num_sectors
; i
++)
865 c
->sectors
[i
].is_erased
= 0;
870 /* lookup flash bank by address */
871 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
875 /* cycle through bank list */
876 for (c
= flash_banks
; c
; c
= c
->next
)
879 retval
= c
->driver
->auto_probe(c
);
881 if (retval
!= ERROR_OK
)
883 LOG_ERROR("auto_probe failed %d\n", retval
);
886 /* check whether address belongs to this flash bank */
887 if ((addr
>= c
->base
) && (addr
< c
->base
+ c
->size
) && target
== c
->target
)
890 LOG_ERROR("No flash at address 0x%08x\n", addr
);
894 /* erase given flash region, selects proper bank according to target and address */
895 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
902 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
903 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
905 if (c
->size
== 0 || c
->num_sectors
== 0)
907 LOG_ERROR("Bank is invalid");
908 return ERROR_FLASH_BANK_INVALID
;
913 /* special case, erase whole bank when length is zero */
915 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
917 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
920 /* check whether it fits */
921 if (addr
+ length
> c
->base
+ c
->size
)
922 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
926 for (i
= 0; i
< c
->num_sectors
; i
++)
928 /* check whether sector overlaps with the given range and is not yet erased */
929 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
930 /* if first is not set yet then this is the first sector */
933 last
= i
; /* and it is the last one so far in any case */
937 if( first
== -1 || last
== -1 )
940 return flash_driver_erase(c
, first
, last
);
943 /* write (optional verify) an image to flash memory of the given target */
944 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
961 /* assume all sectors need erasing - stops any problems
962 * when flash_write is called multiple times */
967 /* allocate padding array */
968 padding
= malloc(image
->num_sections
* sizeof(padding
));
970 /* loop until we reach end of the image */
971 while (section
< image
->num_sections
)
977 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
978 u32 run_size
= image
->sections
[section
].size
- section_offset
;
981 if (image
->sections
[section
].size
== 0)
983 LOG_WARNING("empty section %d", section
);
989 /* find the corresponding flash bank */
990 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
992 section
++; /* and skip it */
997 /* collect consecutive sections which fall into the same bank */
998 section_first
= section
;
999 section_last
= section
;
1000 padding
[section
] = 0;
1001 while ((run_address
+ run_size
< c
->base
+ c
->size
)
1002 && (section_last
+ 1 < image
->num_sections
))
1004 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1006 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1009 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1010 * attempt to rebuild a consecutive buffer for the flash loader */
1011 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1012 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1014 padding
[section_last
] = pad_bytes
;
1015 run_size
+= image
->sections
[++section_last
].size
;
1016 run_size
+= pad_bytes
;
1017 padding
[section_last
] = 0;
1019 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1022 /* fit the run into bank constraints */
1023 if (run_address
+ run_size
> c
->base
+ c
->size
)
1024 run_size
= c
->base
+ c
->size
- run_address
;
1026 /* allocate buffer */
1027 buffer
= malloc(run_size
);
1030 /* read sections to the buffer */
1031 while (buffer_size
< run_size
)
1035 if (buffer_size
- run_size
<= image
->sections
[section
].size
- section_offset
)
1036 size_read
= buffer_size
- run_size
;
1038 size_read
= image
->sections
[section
].size
- section_offset
;
1040 if ((retval
= image_read_section(image
, section
, section_offset
,
1041 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1048 /* see if we need to pad the section */
1049 while (padding
[section
]--)
1050 buffer
[size_read
++] = 0xff;
1052 buffer_size
+= size_read
;
1053 section_offset
+= size_read
;
1055 if (section_offset
>= image
->sections
[section
].size
)
1066 /* calculate and erase sectors */
1067 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1070 if (retval
== ERROR_OK
)
1072 /* write flash sectors */
1073 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1078 if (retval
!= ERROR_OK
)
1081 return retval
; /* abort operation */
1084 if (written
!= NULL
)
1085 *written
+= run_size
; /* add run size to total written counter */
1093 int default_flash_blank_check(struct flash_bank_s
*bank
)
1095 target_t
*target
= bank
->target
;
1097 int buffer_size
=sizeof(buffer
);
1101 if (bank
->target
->state
!= TARGET_HALTED
)
1103 return ERROR_TARGET_NOT_HALTED
;
1108 working_area_t
*erase_check_algorithm
;
1110 /* FIX! doesn't work yet... */
1112 char test(char *a, int len, char t)
1116 for (i=0; i<len; i++)
1123 $ arm-elf-gcc -c -mthumb -O3 test.c
1125 $ arm-elf-objdump --disassemble test.o
1127 test.o: file format elf32-littlearm
1129 Disassembly of section .text:
1132 0: b510 push {r4, lr}
1133 2: 0612 lsl r2, r2, #24
1134 4: 1c04 mov r4, r0 (add r4, r0, #0)
1135 6: 0e10 lsr r0, r2, #24
1138 c: dd04 ble 18 <test+0x18>
1139 e: 5ca3 ldrb r3, [r4, r2]
1143 16: dbfa blt e <test+0xe>
1144 18: bd10 pop {r4, pc}
1145 1a: 46c0 nop (mov r8, r8)
1149 u16 erase_check_code
[] =
1151 0x0612,// lsl r2, r2, #24
1152 0x1c04,// mov r4, r0 (add r4, r0, #0)
1153 0x0e10,// lsr r0, r2, #24
1154 0x2200,// mov r2, #0
1155 0x2900,// cmp r1, #0
1156 0xdd04,// ble 18 <test+0x18>
1157 0x5ca3,// ldrb r3, [r4, r2]
1158 0x3201,// add r2, #1
1159 0x4018,// and r0, r3
1160 0x428a,// cmp r2, r1
1161 0xdbfa,// blt e <test+0xe>
1162 0x46c0,// nop (mov r8, r8)
1168 /* make sure we have a working area */
1169 if (target_alloc_working_area(target
, ((sizeof(erase_check_code
)+3)/4)*4, &erase_check_algorithm
) != ERROR_OK
)
1171 erase_check_algorithm
= NULL
;
1174 if (erase_check_algorithm
)
1176 u8 erase_check_code_buf
[((sizeof(erase_check_code
)+3)/4)*4];
1177 LOG_DEBUG("Running fast flash erase check");
1179 for (i
= 0; i
< sizeof(erase_check_code
)/sizeof(*erase_check_code
); i
++)
1180 target_buffer_set_u16(target
, erase_check_code_buf
+ (i
*2), erase_check_code
[i
]);
1182 /* write algorithm code to working area */
1183 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
)
1185 for (i
= 0; i
< bank
->num_sectors
; i
++)
1187 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1188 u32 size
= bank
->sectors
[i
].size
;
1190 reg_param_t reg_params
[3];
1191 armv7m_algorithm_t arm_info
;
1193 arm_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
1194 arm_info
.core_mode
= ARMV7M_MODE_ANY
;
1195 arm_info
.core_state
= ARMV7M_STATE_THUMB
;
1197 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
1198 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
1200 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
1201 buf_set_u32(reg_params
[1].value
, 0, 32, size
);
1203 init_reg_param(®_params
[2], "r2", 32, PARAM_IN_OUT
);
1204 buf_set_u32(reg_params
[2].value
, 0, 32, 0xff);
1206 if ((retval
= target
->type
->run_algorithm(target
, 0, NULL
, 3, reg_params
, erase_check_algorithm
->address
,
1207 erase_check_algorithm
->address
+ sizeof(erase_check_code
) - 2, 10000, &arm_info
)) != ERROR_OK
)
1210 if (buf_get_u32(reg_params
[2].value
, 0, 32) == 0xff)
1211 bank
->sectors
[i
].is_erased
= 1;
1213 bank
->sectors
[i
].is_erased
= 0;
1215 destroy_reg_param(®_params
[0]);
1216 destroy_reg_param(®_params
[1]);
1217 destroy_reg_param(®_params
[2]);
1219 if (i
== bank
->num_sectors
)
1224 target_free_working_area(target
, erase_check_algorithm
);
1229 /* try ARM7 instead */
1231 u32 erase_check_code
[] =
1233 0xe4d03001, /* ldrb r3, [r0], #1 */
1234 0xe0022003, /* and r2, r2, r3 */
1235 0xe2511001, /* subs r1, r1, #1 */
1236 0x1afffffb, /* b -4 */
1237 0xeafffffe /* b 0 */
1240 /* make sure we have a working area */
1241 if (target_alloc_working_area(target
, 20, &erase_check_algorithm
) == ERROR_OK
)
1243 u8 erase_check_code_buf
[5 * 4];
1245 for (i
= 0; i
< 5; i
++)
1246 target_buffer_set_u32(target
, erase_check_code_buf
+ (i
*4), erase_check_code
[i
]);
1248 /* write algorithm code to working area */
1249 if ((retval
=target
->type
->write_memory(target
, erase_check_algorithm
->address
, 4, 5, erase_check_code_buf
))==ERROR_OK
)
1251 for (i
= 0; i
< bank
->num_sectors
; i
++)
1253 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1254 u32 size
= bank
->sectors
[i
].size
;
1256 reg_param_t reg_params
[3];
1257 armv4_5_algorithm_t armv4_5_info
;
1259 armv4_5_info
.common_magic
= ARMV4_5_COMMON_MAGIC
;
1260 armv4_5_info
.core_mode
= ARMV4_5_MODE_SVC
;
1261 armv4_5_info
.core_state
= ARMV4_5_STATE_ARM
;
1263 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
1264 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
1266 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
1267 buf_set_u32(reg_params
[1].value
, 0, 32, size
);
1269 init_reg_param(®_params
[2], "r2", 32, PARAM_IN_OUT
);
1270 buf_set_u32(reg_params
[2].value
, 0, 32, 0xff);
1272 if ((retval
= target
->type
->run_algorithm(target
, 0, NULL
, 3, reg_params
,
1273 erase_check_algorithm
->address
, erase_check_algorithm
->address
+ 0x10, 10000, &armv4_5_info
)) != ERROR_OK
)
1276 if (buf_get_u32(reg_params
[2].value
, 0, 32) == 0xff)
1277 bank
->sectors
[i
].is_erased
= 1;
1279 bank
->sectors
[i
].is_erased
= 0;
1281 destroy_reg_param(®_params
[0]);
1282 destroy_reg_param(®_params
[1]);
1283 destroy_reg_param(®_params
[2]);
1285 if (i
== bank
->num_sectors
)
1290 target_free_working_area(target
, erase_check_algorithm
);
1297 LOG_USER("Running slow fallback erase check - add working memory");
1298 for (i
= 0; i
< bank
->num_sectors
; i
++)
1301 bank
->sectors
[i
].is_erased
= 1;
1303 for (j
=0; j
<bank
->sectors
[i
].size
; j
+=buffer_size
)
1308 if (chunk
>(j
-bank
->sectors
[i
].size
))
1310 chunk
=(j
-bank
->sectors
[i
].size
);
1313 retval
=target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1314 if (retval
!=ERROR_OK
)
1317 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1319 if (buffer
[nBytes
] != 0xFF)
1321 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)