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_mem_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
;
1106 for (i
= 0; i
< bank
->num_sectors
; i
++)
1109 bank
->sectors
[i
].is_erased
= 1;
1111 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1115 chunk
= buffer_size
;
1116 if (chunk
> (j
- bank
->sectors
[i
].size
))
1118 chunk
= (j
- bank
->sectors
[i
].size
);
1121 retval
= target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1122 if (retval
!= ERROR_OK
)
1125 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1127 if (buffer
[nBytes
] != 0xFF)
1129 bank
->sectors
[i
].is_erased
= 0;
1139 int default_flash_blank_check(struct flash_bank_s
*bank
)
1141 target_t
*target
= bank
->target
;
1147 if (bank
->target
->state
!= TARGET_HALTED
)
1149 return ERROR_TARGET_NOT_HALTED
;
1152 for (i
= 0; i
< bank
->num_sectors
; i
++)
1154 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1155 u32 size
= bank
->sectors
[i
].size
;
1157 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1163 bank
->sectors
[i
].is_erased
= 1;
1165 bank
->sectors
[i
].is_erased
= 0;
1171 LOG_USER("Running slow fallback erase check - add working memory");
1172 return default_flash_mem_blank_check(bank
);
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)