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
);
136 int flash_register_commands(struct command_context_s
*cmd_ctx
)
138 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash", NULL
, COMMAND_ANY
, NULL
);
140 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 ...]");
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 [erase] <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
);
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
;
623 /* flash auto-erase is disabled by default*/
626 if (strcmp(args
[0], "erase")==0)
631 command_print(cmd_ctx
, "auto erase enabled");
637 return ERROR_COMMAND_SYNTAX_ERROR
;
642 LOG_ERROR("no target selected");
646 duration_start_measure(&duration
);
650 image
.base_address_set
= 1;
651 image
.base_address
= strtoul(args
[1], NULL
, 0);
655 image
.base_address_set
= 0;
656 image
.base_address
= 0x0;
659 image
.start_address_set
= 0;
661 retval
= image_open(&image
, args
[0], (argc
== 3) ? args
[2] : NULL
);
662 if (retval
!= ERROR_OK
)
667 retval
= flash_write(target
, &image
, &written
, auto_erase
);
668 if (retval
!= ERROR_OK
)
674 duration_stop_measure(&duration
, &duration_text
);
675 if (retval
== ERROR_OK
)
677 command_print(cmd_ctx
, "wrote %u byte from file %s in %s (%f kb/s)",
678 written
, args
[0], duration_text
,
679 (float)written
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
688 int handle_flash_fill_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
699 target_t
*target
= get_current_target(cmd_ctx
);
705 return ERROR_COMMAND_SYNTAX_ERROR
;
708 address
= strtoul(args
[0], NULL
, 0);
709 pattern
= strtoul(args
[1], NULL
, 0);
710 count
= strtoul(args
[2], NULL
, 0);
728 return ERROR_COMMAND_SYNTAX_ERROR
;
731 chunk_count
= MIN(count
, (1024 / wordsize
));
735 for(i
= 0; i
< chunk_count
; i
++)
737 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
741 for(i
= 0; i
< chunk_count
; i
++)
743 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
747 memset(chunk
, pattern
, chunk_count
);
750 LOG_ERROR("BUG: can't happen");
754 duration_start_measure(&duration
);
757 err
= flash_erase_address_range( target
, address
, count
*wordsize
);
760 for (wrote
=0; wrote
<(count
*wordsize
); wrote
+=sizeof(chunk
))
762 int cur_size
= MIN( (count
*wordsize
- wrote
) , 1024 );
766 bank
= get_flash_bank_by_addr(target
, address
);
772 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
780 duration_stop_measure(&duration
, &duration_text
);
785 speed
=wrote
/ 1024.0;
786 speed
/=((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0));
787 command_print(cmd_ctx
, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
788 count
*wordsize
, address
, duration_text
,
795 int handle_flash_write_bank_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
811 return ERROR_COMMAND_SYNTAX_ERROR
;
814 duration_start_measure(&duration
);
816 offset
= strtoul(args
[2], NULL
, 0);
817 p
= get_flash_bank_by_num(strtoul(args
[0], NULL
, 0));
820 command_print(cmd_ctx
, "flash bank '#%s' is out of bounds", args
[0]);
824 if (fileio_open(&fileio
, args
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
829 buffer
= malloc(fileio
.size
);
830 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
835 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
839 duration_stop_measure(&duration
, &duration_text
);
840 if (retval
!=ERROR_OK
)
842 command_print(cmd_ctx
, "wrote %"PRIi64
" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
843 fileio
.size
, args
[1], strtoul(args
[0], NULL
, 0), offset
, duration_text
,
844 (float)fileio
.size
/ 1024.0 / ((float)duration
.duration
.tv_sec
+ ((float)duration
.duration
.tv_usec
/ 1000000.0)));
848 fileio_close(&fileio
);
853 void flash_set_dirty(void)
858 /* set all flash to require erasing */
859 for (c
= flash_banks
; c
; c
= c
->next
)
861 for (i
= 0; i
< c
->num_sectors
; i
++)
863 c
->sectors
[i
].is_erased
= 0;
868 /* lookup flash bank by address */
869 flash_bank_t
*get_flash_bank_by_addr(target_t
*target
, u32 addr
)
873 /* cycle through bank list */
874 for (c
= flash_banks
; c
; c
= c
->next
)
877 retval
= c
->driver
->auto_probe(c
);
879 if (retval
!= ERROR_OK
)
881 LOG_ERROR("auto_probe failed %d\n", retval
);
884 /* check whether address belongs to this flash bank */
885 if ((addr
>= c
->base
) && (addr
< c
->base
+ c
->size
) && target
== c
->target
)
888 LOG_ERROR("No flash at address 0x%08x\n", addr
);
892 /* erase given flash region, selects proper bank according to target and address */
893 int flash_erase_address_range(target_t
*target
, u32 addr
, u32 length
)
900 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
901 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
903 if (c
->size
== 0 || c
->num_sectors
== 0)
905 LOG_ERROR("Bank is invalid");
906 return ERROR_FLASH_BANK_INVALID
;
911 /* special case, erase whole bank when length is zero */
913 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
915 return flash_driver_erase(c
, 0, c
->num_sectors
- 1);
918 /* check whether it fits */
919 if (addr
+ length
> c
->base
+ c
->size
)
920 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
924 for (i
= 0; i
< c
->num_sectors
; i
++)
926 /* check whether sector overlaps with the given range and is not yet erased */
927 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
928 /* if first is not set yet then this is the first sector */
931 last
= i
; /* and it is the last one so far in any case */
935 if( first
== -1 || last
== -1 )
938 return flash_driver_erase(c
, first
, last
);
941 /* write (optional verify) an image to flash memory of the given target */
942 int flash_write(target_t
*target
, image_t
*image
, u32
*written
, int erase
)
958 /* assume all sectors need erasing - stops any problems
959 * when flash_write is called multiple times */
964 /* loop until we reach end of the image */
965 while (section
< image
->num_sections
)
971 u32 run_address
= image
->sections
[section
].base_address
+ section_offset
;
972 u32 run_size
= image
->sections
[section
].size
- section_offset
;
974 if (image
->sections
[section
].size
== 0)
976 LOG_WARNING("empty section %d", section
);
982 /* find the corresponding flash bank */
983 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
985 section
++; /* and skip it */
990 /* collect consecutive sections which fall into the same bank */
991 section_first
= section
;
992 section_last
= section
;
993 while ((run_address
+ run_size
< c
->base
+ c
->size
)
994 && (section_last
+ 1 < image
->num_sections
))
996 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
998 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1001 if (image
->sections
[section_last
+ 1].base_address
!= (run_address
+ run_size
))
1003 run_size
+= image
->sections
[++section_last
].size
;
1006 /* fit the run into bank constraints */
1007 if (run_address
+ run_size
> c
->base
+ c
->size
)
1008 run_size
= c
->base
+ c
->size
- run_address
;
1010 /* allocate buffer */
1011 buffer
= malloc(run_size
);
1014 /* read sections to the buffer */
1015 while (buffer_size
< run_size
)
1019 if (buffer_size
- run_size
<= image
->sections
[section
].size
- section_offset
)
1020 size_read
= buffer_size
- run_size
;
1022 size_read
= image
->sections
[section
].size
- section_offset
;
1024 if ((retval
= image_read_section(image
, section
, section_offset
,
1025 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1032 buffer_size
+= size_read
;
1033 section_offset
+= size_read
;
1035 if (section_offset
>= image
->sections
[section
].size
)
1046 /* calculate and erase sectors */
1047 retval
= flash_erase_address_range( target
, run_address
, run_size
);
1050 if (retval
== ERROR_OK
)
1052 /* write flash sectors */
1053 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1058 if (retval
!= ERROR_OK
)
1060 return retval
; /* abort operation */
1063 if (written
!= NULL
)
1064 *written
+= run_size
; /* add run size to total written counter */
1070 int default_flash_blank_check(struct flash_bank_s
*bank
)
1072 target_t
*target
= bank
->target
;
1074 int buffer_size
=sizeof(buffer
);
1078 if (bank
->target
->state
!= TARGET_HALTED
)
1080 return ERROR_TARGET_NOT_HALTED
;
1085 working_area_t
*erase_check_algorithm
;
1087 /* FIX! doesn't work yet... */
1089 char test(char *a, int len, char t)
1093 for (i=0; i<len; i++)
1100 $ arm-elf-gcc -c -mthumb -O3 test.c
1102 $ arm-elf-objdump --disassemble test.o
1104 test.o: file format elf32-littlearm
1106 Disassembly of section .text:
1109 0: b510 push {r4, lr}
1110 2: 0612 lsl r2, r2, #24
1111 4: 1c04 mov r4, r0 (add r4, r0, #0)
1112 6: 0e10 lsr r0, r2, #24
1115 c: dd04 ble 18 <test+0x18>
1116 e: 5ca3 ldrb r3, [r4, r2]
1120 16: dbfa blt e <test+0xe>
1121 18: bd10 pop {r4, pc}
1122 1a: 46c0 nop (mov r8, r8)
1126 u16 erase_check_code
[] =
1128 0x0612,// lsl r2, r2, #24
1129 0x1c04,// mov r4, r0 (add r4, r0, #0)
1130 0x0e10,// lsr r0, r2, #24
1131 0x2200,// mov r2, #0
1132 0x2900,// cmp r1, #0
1133 0xdd04,// ble 18 <test+0x18>
1134 0x5ca3,// ldrb r3, [r4, r2]
1135 0x3201,// add r2, #1
1136 0x4018,// and r0, r3
1137 0x428a,// cmp r2, r1
1138 0xdbfa,// blt e <test+0xe>
1139 0x46c0,// nop (mov r8, r8)
1145 /* make sure we have a working area */
1146 if (target_alloc_working_area(target
, ((sizeof(erase_check_code
)+3)/4)*4, &erase_check_algorithm
) != ERROR_OK
)
1148 erase_check_algorithm
= NULL
;
1151 if (erase_check_algorithm
)
1153 u8 erase_check_code_buf
[((sizeof(erase_check_code
)+3)/4)*4];
1154 LOG_DEBUG("Running fast flash erase check");
1156 for (i
= 0; i
< sizeof(erase_check_code
)/sizeof(*erase_check_code
); i
++)
1157 target_buffer_set_u16(target
, erase_check_code_buf
+ (i
*2), erase_check_code
[i
]);
1159 /* write algorithm code to working area */
1160 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
)
1162 for (i
= 0; i
< bank
->num_sectors
; i
++)
1164 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1165 u32 size
= bank
->sectors
[i
].size
;
1167 reg_param_t reg_params
[3];
1168 armv7m_algorithm_t arm_info
;
1170 arm_info
.common_magic
= ARMV7M_COMMON_MAGIC
;
1171 arm_info
.core_mode
= ARMV7M_MODE_ANY
;
1172 arm_info
.core_state
= ARMV7M_STATE_THUMB
;
1174 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
1175 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
1177 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
1178 buf_set_u32(reg_params
[1].value
, 0, 32, size
);
1180 init_reg_param(®_params
[2], "r2", 32, PARAM_IN_OUT
);
1181 buf_set_u32(reg_params
[2].value
, 0, 32, 0xff);
1183 if ((retval
= target
->type
->run_algorithm(target
, 0, NULL
, 3, reg_params
, erase_check_algorithm
->address
,
1184 erase_check_algorithm
->address
+ sizeof(erase_check_code
) - 2, 10000, &arm_info
)) != ERROR_OK
)
1187 if (buf_get_u32(reg_params
[2].value
, 0, 32) == 0xff)
1188 bank
->sectors
[i
].is_erased
= 1;
1190 bank
->sectors
[i
].is_erased
= 0;
1192 destroy_reg_param(®_params
[0]);
1193 destroy_reg_param(®_params
[1]);
1194 destroy_reg_param(®_params
[2]);
1196 if (i
== bank
->num_sectors
)
1201 target_free_working_area(target
, erase_check_algorithm
);
1206 /* try ARM7 instead */
1208 u32 erase_check_code
[] =
1210 0xe4d03001, /* ldrb r3, [r0], #1 */
1211 0xe0022003, /* and r2, r2, r3 */
1212 0xe2511001, /* subs r1, r1, #1 */
1213 0x1afffffb, /* b -4 */
1214 0xeafffffe /* b 0 */
1217 /* make sure we have a working area */
1218 if (target_alloc_working_area(target
, 20, &erase_check_algorithm
) == ERROR_OK
)
1220 u8 erase_check_code_buf
[5 * 4];
1222 for (i
= 0; i
< 5; i
++)
1223 target_buffer_set_u32(target
, erase_check_code_buf
+ (i
*4), erase_check_code
[i
]);
1225 /* write algorithm code to working area */
1226 if ((retval
=target
->type
->write_memory(target
, erase_check_algorithm
->address
, 4, 5, erase_check_code_buf
))==ERROR_OK
)
1228 for (i
= 0; i
< bank
->num_sectors
; i
++)
1230 u32 address
= bank
->base
+ bank
->sectors
[i
].offset
;
1231 u32 size
= bank
->sectors
[i
].size
;
1233 reg_param_t reg_params
[3];
1234 armv4_5_algorithm_t armv4_5_info
;
1236 armv4_5_info
.common_magic
= ARMV4_5_COMMON_MAGIC
;
1237 armv4_5_info
.core_mode
= ARMV4_5_MODE_SVC
;
1238 armv4_5_info
.core_state
= ARMV4_5_STATE_ARM
;
1240 init_reg_param(®_params
[0], "r0", 32, PARAM_OUT
);
1241 buf_set_u32(reg_params
[0].value
, 0, 32, address
);
1243 init_reg_param(®_params
[1], "r1", 32, PARAM_OUT
);
1244 buf_set_u32(reg_params
[1].value
, 0, 32, size
);
1246 init_reg_param(®_params
[2], "r2", 32, PARAM_IN_OUT
);
1247 buf_set_u32(reg_params
[2].value
, 0, 32, 0xff);
1249 if ((retval
= target
->type
->run_algorithm(target
, 0, NULL
, 3, reg_params
,
1250 erase_check_algorithm
->address
, erase_check_algorithm
->address
+ 0x10, 10000, &armv4_5_info
)) != ERROR_OK
)
1253 if (buf_get_u32(reg_params
[2].value
, 0, 32) == 0xff)
1254 bank
->sectors
[i
].is_erased
= 1;
1256 bank
->sectors
[i
].is_erased
= 0;
1258 destroy_reg_param(®_params
[0]);
1259 destroy_reg_param(®_params
[1]);
1260 destroy_reg_param(®_params
[2]);
1262 if (i
== bank
->num_sectors
)
1267 target_free_working_area(target
, erase_check_algorithm
);
1274 LOG_USER("Running slow fallback erase check - add working memory");
1275 for (i
= 0; i
< bank
->num_sectors
; i
++)
1278 bank
->sectors
[i
].is_erased
= 1;
1280 for (j
=0; j
<bank
->sectors
[i
].size
; j
+=buffer_size
)
1285 if (chunk
>(j
-bank
->sectors
[i
].size
))
1287 chunk
=(j
-bank
->sectors
[i
].size
);
1290 retval
=target
->type
->read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1291 if (retval
!=ERROR_OK
)
1294 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1296 if (buffer
[nBytes
] != 0xFF)
1298 bank
->sectors
[i
].is_erased
= 0;