1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
33 #include "time_support.h"
35 static int flash_write_unlock(struct target
*target
, struct image
*image
, uint32_t *written
, int erase
, bool unlock
);
39 extern struct flash_driver lpc2000_flash
;
40 extern struct flash_driver lpc288x_flash
;
41 extern struct flash_driver lpc2900_flash
;
42 extern struct flash_driver cfi_flash
;
43 extern struct flash_driver at91sam3_flash
;
44 extern struct flash_driver at91sam7_flash
;
45 extern struct flash_driver str7x_flash
;
46 extern struct flash_driver str9x_flash
;
47 extern struct flash_driver aduc702x_flash
;
48 extern struct flash_driver stellaris_flash
;
49 extern struct flash_driver str9xpec_flash
;
50 extern struct flash_driver stm32x_flash
;
51 extern struct flash_driver tms470_flash
;
52 extern struct flash_driver ecosflash_flash
;
53 extern struct flash_driver ocl_flash
;
54 extern struct flash_driver pic32mx_flash
;
55 extern struct flash_driver avr_flash
;
56 extern struct flash_driver faux_flash
;
58 struct flash_driver
*flash_drivers
[] = {
80 struct flash_bank
*flash_banks
;
81 static struct command
*flash_cmd
;
83 /* wafer thin wrapper for invoking the flash driver */
84 static int flash_driver_write(struct flash_bank
*bank
, uint8_t *buffer
, uint32_t offset
, uint32_t count
)
88 retval
= bank
->driver
->write(bank
, buffer
, offset
, count
);
89 if (retval
!= ERROR_OK
)
91 LOG_ERROR("error writing to flash at address 0x%08" PRIx32
" at offset 0x%8.8" PRIx32
" (%d)",
92 bank
->base
, offset
, retval
);
98 static int flash_driver_erase(struct flash_bank
*bank
, int first
, int last
)
102 retval
= bank
->driver
->erase(bank
, first
, last
);
103 if (retval
!= ERROR_OK
)
105 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
111 int flash_driver_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
115 retval
= bank
->driver
->protect(bank
, set
, first
, last
);
116 if (retval
!= ERROR_OK
)
118 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
124 static int jim_flash_banks(Jim_Interp
*interp
, int argc
, Jim_Obj
*const *argv
)
126 struct flash_bank
*p
;
129 Jim_WrongNumArgs(interp
, 1, argv
, "no arguments to flash_banks command");
133 Jim_Obj
*list
= Jim_NewListObj(interp
, NULL
, 0);
134 for (p
= flash_banks
; p
; p
= p
->next
)
136 Jim_Obj
*elem
= Jim_NewListObj(interp
, NULL
, 0);
138 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "name", -1));
139 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, p
->driver
->name
, -1));
140 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "base", -1));
141 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->base
));
142 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "size", -1));
143 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->size
));
144 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "bus_width", -1));
145 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->bus_width
));
146 Jim_ListAppendElement(interp
, elem
, Jim_NewStringObj(interp
, "chip_width", -1));
147 Jim_ListAppendElement(interp
, elem
, Jim_NewIntObj(interp
, p
->chip_width
));
149 Jim_ListAppendElement(interp
, list
, elem
);
152 Jim_SetResult(interp
, list
);
157 struct flash_bank
*get_flash_bank_by_num_noprobe(int num
)
159 struct flash_bank
*p
;
162 for (p
= flash_banks
; p
; p
= p
->next
)
169 LOG_ERROR("flash bank %d does not exist", num
);
173 int flash_get_bank_count(void)
175 struct flash_bank
*p
;
177 for (p
= flash_banks
; p
; p
= p
->next
)
184 struct flash_bank
*get_flash_bank_by_name(const char *name
)
186 unsigned requested
= get_flash_name_index(name
);
189 struct flash_bank
*bank
;
190 for (bank
= flash_banks
; NULL
!= bank
; bank
= bank
->next
)
192 if (!flash_driver_name_matches(bank
->driver
->name
, name
))
194 if (++found
< requested
)
201 struct flash_bank
*get_flash_bank_by_num(int num
)
203 struct flash_bank
*p
= get_flash_bank_by_num_noprobe(num
);
209 retval
= p
->driver
->auto_probe(p
);
211 if (retval
!= ERROR_OK
)
213 LOG_ERROR("auto_probe failed %d\n", retval
);
219 COMMAND_HELPER(flash_command_get_bank
, unsigned name_index
,
220 struct flash_bank
**bank
)
222 const char *name
= CMD_ARGV
[name_index
];
223 *bank
= get_flash_bank_by_name(name
);
228 COMMAND_PARSE_NUMBER(uint
, name
, bank_num
);
230 *bank
= get_flash_bank_by_num(bank_num
);
233 command_print(CMD_CTX
, "flash bank '%s' not found", name
);
234 return ERROR_INVALID_ARGUMENTS
;
240 COMMAND_HANDLER(handle_flash_bank_command
)
244 LOG_ERROR("usage: flash bank <driver> "
245 "<base> <size> <chip_width> <bus_width>");
246 return ERROR_COMMAND_SYNTAX_ERROR
;
249 struct target
*target
;
250 if ((target
= get_target(CMD_ARGV
[5])) == NULL
)
252 LOG_ERROR("target '%s' not defined", CMD_ARGV
[5]);
256 const char *driver_name
= CMD_ARGV
[0];
257 for (unsigned i
= 0; flash_drivers
[i
]; i
++)
259 if (strcmp(driver_name
, flash_drivers
[i
]->name
) != 0)
262 struct flash_bank
*p
, *c
;
264 /* register flash specific commands */
265 if (flash_drivers
[i
]->register_commands(CMD_CTX
) != ERROR_OK
)
267 LOG_ERROR("couldn't register '%s' commands", driver_name
);
271 c
= malloc(sizeof(struct flash_bank
));
273 c
->driver
= flash_drivers
[i
];
274 c
->driver_priv
= NULL
;
275 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], c
->base
);
276 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], c
->size
);
277 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[3], c
->chip_width
);
278 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[4], c
->bus_width
);
284 retval
= CALL_COMMAND_HANDLER(flash_drivers
[i
]->flash_bank_command
, c
);
285 if (ERROR_OK
!= retval
)
287 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32
,
288 driver_name
, c
->base
);
293 /* put flash bank in linked list */
297 /* find last flash bank */
298 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
) bank_num
++;
301 c
->bank_number
= bank_num
+ 1;
312 /* no matching flash driver found */
313 LOG_ERROR("flash driver '%s' not found", driver_name
);
317 COMMAND_HANDLER(handle_flash_info_command
)
319 struct flash_bank
*p
;
325 return ERROR_COMMAND_SYNTAX_ERROR
;
328 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], bank_nr
);
330 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
337 /* attempt auto probe */
338 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
341 command_print(CMD_CTX
,
342 "#%" PRIi32
" : %s at 0x%8.8" PRIx32
", size 0x%8.8" PRIx32
", buswidth %i, chipwidth %i",
349 for (j
= 0; j
< p
->num_sectors
; j
++)
353 if (p
->sectors
[j
].is_protected
== 0)
354 protect_state
= "not protected";
355 else if (p
->sectors
[j
].is_protected
== 1)
356 protect_state
= "protected";
358 protect_state
= "protection state unknown";
360 command_print(CMD_CTX
,
361 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
363 p
->sectors
[j
].offset
,
365 p
->sectors
[j
].size
>> 10,
369 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
370 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
371 command_print(CMD_CTX
, "%s", buf
);
372 if (retval
!= ERROR_OK
)
373 LOG_ERROR("error retrieving flash info (%d)", retval
);
379 COMMAND_HANDLER(handle_flash_probe_command
)
385 return ERROR_COMMAND_SYNTAX_ERROR
;
389 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], bank_nr
);
390 struct flash_bank
*p
= get_flash_bank_by_num_noprobe(bank_nr
);
393 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
395 command_print(CMD_CTX
, "flash '%s' found at 0x%8.8" PRIx32
, p
->driver
->name
, p
->base
);
397 else if (retval
== ERROR_FLASH_BANK_INVALID
)
399 command_print(CMD_CTX
, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32
,
400 CMD_ARGV
[0], p
->base
);
404 command_print(CMD_CTX
, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32
,
405 CMD_ARGV
[0], p
->base
);
410 command_print(CMD_CTX
, "flash bank '#%s' is out of bounds", CMD_ARGV
[0]);
416 COMMAND_HANDLER(handle_flash_erase_check_command
)
420 return ERROR_COMMAND_SYNTAX_ERROR
;
423 struct flash_bank
*p
;
424 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &p
);
425 if (ERROR_OK
!= retval
)
429 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
431 command_print(CMD_CTX
, "successfully checked erase state");
435 command_print(CMD_CTX
, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32
,
436 CMD_ARGV
[0], p
->base
);
439 for (j
= 0; j
< p
->num_sectors
; j
++)
443 if (p
->sectors
[j
].is_erased
== 0)
444 erase_state
= "not erased";
445 else if (p
->sectors
[j
].is_erased
== 1)
446 erase_state
= "erased";
448 erase_state
= "erase state unknown";
450 command_print(CMD_CTX
,
451 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
453 p
->sectors
[j
].offset
,
455 p
->sectors
[j
].size
>> 10,
462 COMMAND_HANDLER(handle_flash_erase_address_command
)
464 struct flash_bank
*p
;
469 struct target
*target
= get_current_target(CMD_CTX
);
472 return ERROR_COMMAND_SYNTAX_ERROR
;
474 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[0], address
);
475 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[1], length
);
478 command_print(CMD_CTX
, "Length must be >0");
479 return ERROR_COMMAND_SYNTAX_ERROR
;
482 p
= get_flash_bank_by_addr(target
, address
);
488 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
491 struct duration bench
;
492 duration_start(&bench
);
494 retval
= flash_erase_address_range(target
, address
, length
);
496 if ((ERROR_OK
== retval
) && (duration_measure(&bench
) == ERROR_OK
))
498 command_print(CMD_CTX
, "erased address 0x%8.8x (length %i)"
499 " in %fs (%0.3f kb/s)", address
, length
,
500 duration_elapsed(&bench
), duration_kbps(&bench
, length
));
506 COMMAND_HANDLER(handle_flash_protect_check_command
)
509 return ERROR_COMMAND_SYNTAX_ERROR
;
511 struct flash_bank
*p
;
512 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &p
);
513 if (ERROR_OK
!= retval
)
516 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
518 command_print(CMD_CTX
, "successfully checked protect state");
520 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
522 command_print(CMD_CTX
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32
, CMD_ARGV
[0], p
->base
);
526 command_print(CMD_CTX
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32
, CMD_ARGV
[0], p
->base
);
532 static int flash_check_sector_parameters(struct command_context
*cmd_ctx
,
533 uint32_t first
, uint32_t last
, uint32_t num_sectors
)
535 if (!(first
<= last
)) {
536 command_print(cmd_ctx
, "ERROR: "
537 "first sector must be <= last sector");
541 if (!(last
<= (num_sectors
- 1))) {
542 command_print(cmd_ctx
, "ERROR: last sector must be <= %d",
543 (int) num_sectors
- 1);
550 COMMAND_HANDLER(handle_flash_erase_command
)
553 return ERROR_COMMAND_SYNTAX_ERROR
;
559 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], bank_nr
);
560 struct flash_bank
*p
= get_flash_bank_by_num(bank_nr
);
564 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], first
);
565 if (strcmp(CMD_ARGV
[2], "last") == 0)
566 last
= p
->num_sectors
- 1;
568 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], last
);
571 if ((retval
= flash_check_sector_parameters(CMD_CTX
,
572 first
, last
, p
->num_sectors
)) != ERROR_OK
)
575 struct duration bench
;
576 duration_start(&bench
);
578 retval
= flash_driver_erase(p
, first
, last
);
580 if ((ERROR_OK
== retval
) && (duration_measure(&bench
) == ERROR_OK
))
582 command_print(CMD_CTX
, "erased sectors %" PRIu32
" "
583 "through %" PRIu32
" on flash bank %" PRIu32
" "
584 "in %fs", first
, last
, bank_nr
, duration_elapsed(&bench
));
590 COMMAND_HANDLER(handle_flash_protect_command
)
593 return ERROR_COMMAND_SYNTAX_ERROR
;
599 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], bank_nr
);
600 struct flash_bank
*p
= get_flash_bank_by_num(bank_nr
);
604 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], first
);
605 if (strcmp(CMD_ARGV
[2], "last") == 0)
606 last
= p
->num_sectors
- 1;
608 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], last
);
611 COMMAND_PARSE_ON_OFF(CMD_ARGV
[3], set
);
614 if ((retval
= flash_check_sector_parameters(CMD_CTX
,
615 first
, last
, p
->num_sectors
)) != ERROR_OK
)
618 retval
= flash_driver_protect(p
, set
, first
, last
);
619 if (retval
== ERROR_OK
) {
620 command_print(CMD_CTX
, "%s protection for sectors %i "
621 "through %i on flash bank %i",
622 (set
) ? "set" : "cleared", (int) first
,
623 (int) last
, (int) bank_nr
);
629 COMMAND_HANDLER(handle_flash_write_image_command
)
631 struct target
*target
= get_current_target(CMD_CTX
);
640 return ERROR_COMMAND_SYNTAX_ERROR
;
643 /* flash auto-erase is disabled by default*/
645 bool auto_unlock
= false;
649 if (strcmp(CMD_ARGV
[0], "erase") == 0)
654 command_print(CMD_CTX
, "auto erase enabled");
655 } else if (strcmp(CMD_ARGV
[0], "unlock") == 0)
660 command_print(CMD_CTX
, "auto unlock enabled");
669 return ERROR_COMMAND_SYNTAX_ERROR
;
674 LOG_ERROR("no target selected");
678 struct duration bench
;
679 duration_start(&bench
);
683 image
.base_address_set
= 1;
684 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[1], image
.base_address
);
688 image
.base_address_set
= 0;
689 image
.base_address
= 0x0;
692 image
.start_address_set
= 0;
694 retval
= image_open(&image
, CMD_ARGV
[0], (CMD_ARGC
== 3) ? CMD_ARGV
[2] : NULL
);
695 if (retval
!= ERROR_OK
)
700 retval
= flash_write_unlock(target
, &image
, &written
, auto_erase
, auto_unlock
);
701 if (retval
!= ERROR_OK
)
707 if ((ERROR_OK
== retval
) && (duration_measure(&bench
) == ERROR_OK
))
709 command_print(CMD_CTX
, "wrote %" PRIu32
" byte from file %s "
710 "in %fs (%0.3f kb/s)", written
, CMD_ARGV
[0],
711 duration_elapsed(&bench
), duration_kbps(&bench
, written
));
719 COMMAND_HANDLER(handle_flash_fill_command
)
726 uint8_t readback
[1024];
728 uint32_t cur_size
= 0;
729 uint32_t chunk_count
;
730 struct target
*target
= get_current_target(CMD_CTX
);
735 return ERROR_COMMAND_SYNTAX_ERROR
;
737 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], address
);
738 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], pattern
);
739 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], count
);
756 return ERROR_COMMAND_SYNTAX_ERROR
;
759 chunk_count
= MIN(count
, (1024 / wordsize
));
763 for (i
= 0; i
< chunk_count
; i
++)
765 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
769 for (i
= 0; i
< chunk_count
; i
++)
771 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
775 memset(chunk
, pattern
, chunk_count
);
778 LOG_ERROR("BUG: can't happen");
782 struct duration bench
;
783 duration_start(&bench
);
785 for (wrote
= 0; wrote
< (count
*wordsize
); wrote
+= cur_size
)
787 cur_size
= MIN((count
*wordsize
- wrote
), sizeof(chunk
));
788 struct flash_bank
*bank
;
789 bank
= get_flash_bank_by_addr(target
, address
);
794 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
798 err
= target_read_buffer(target
, address
+ wrote
, cur_size
, readback
);
803 for (i
= 0; i
< cur_size
; i
++)
805 if (readback
[i
]!=chunk
[i
])
807 LOG_ERROR("Verfication error address 0x%08" PRIx32
", read back 0x%02x, expected 0x%02x",
808 address
+ wrote
+ i
, readback
[i
], chunk
[i
]);
814 if (duration_measure(&bench
) == ERROR_OK
)
816 command_print(CMD_CTX
, "wrote %" PRIu32
" bytes to 0x%8.8" PRIx32
817 " in %fs (%0.3f kb/s)", wrote
, address
,
818 duration_elapsed(&bench
), duration_kbps(&bench
, wrote
));
823 COMMAND_HANDLER(handle_flash_write_bank_command
)
827 struct fileio fileio
;
830 return ERROR_COMMAND_SYNTAX_ERROR
;
832 struct duration bench
;
833 duration_start(&bench
);
835 struct flash_bank
*p
;
836 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank
, 0, &p
);
837 if (ERROR_OK
!= retval
)
840 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], offset
);
842 if (fileio_open(&fileio
, CMD_ARGV
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
847 buffer
= malloc(fileio
.size
);
849 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
852 fileio_close(&fileio
);
856 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
861 if ((ERROR_OK
== retval
) && (duration_measure(&bench
) == ERROR_OK
))
863 command_print(CMD_CTX
, "wrote %zu byte from file %s to flash bank %u"
864 " at offset 0x%8.8" PRIx32
" in %fs (%0.3f kb/s)",
865 fileio
.size
, CMD_ARGV
[1], p
->bank_number
, offset
,
866 duration_elapsed(&bench
), duration_kbps(&bench
, fileio
.size
));
869 fileio_close(&fileio
);
874 void flash_set_dirty(void)
876 struct flash_bank
*c
;
879 /* set all flash to require erasing */
880 for (c
= flash_banks
; c
; c
= c
->next
)
882 for (i
= 0; i
< c
->num_sectors
; i
++)
884 c
->sectors
[i
].is_erased
= 0;
889 /* lookup flash bank by address */
890 struct flash_bank
*get_flash_bank_by_addr(struct target
*target
, uint32_t addr
)
892 struct flash_bank
*c
;
894 /* cycle through bank list */
895 for (c
= flash_banks
; c
; c
= c
->next
)
898 retval
= c
->driver
->auto_probe(c
);
900 if (retval
!= ERROR_OK
)
902 LOG_ERROR("auto_probe failed %d\n", retval
);
905 /* check whether address belongs to this flash bank */
906 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
909 LOG_ERROR("No flash at address 0x%08" PRIx32
"\n", addr
);
913 /* erase given flash region, selects proper bank according to target and address */
914 static int flash_iterate_address_range(struct target
*target
, uint32_t addr
, uint32_t length
,
915 int (*callback
)(struct flash_bank
*bank
, int first
, int last
))
917 struct flash_bank
*c
;
922 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
923 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
925 if (c
->size
== 0 || c
->num_sectors
== 0)
927 LOG_ERROR("Bank is invalid");
928 return ERROR_FLASH_BANK_INVALID
;
933 /* special case, erase whole bank when length is zero */
935 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
937 return callback(c
, 0, c
->num_sectors
- 1);
940 /* check whether it fits */
941 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
942 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
946 for (i
= 0; i
< c
->num_sectors
; i
++)
948 /* check whether sector overlaps with the given range and is not yet erased */
949 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
950 /* if first is not set yet then this is the first sector */
953 last
= i
; /* and it is the last one so far in any case */
957 if (first
== -1 || last
== -1)
960 return callback(c
, first
, last
);
965 int flash_erase_address_range(struct target
*target
, uint32_t addr
, uint32_t length
)
967 return flash_iterate_address_range(target
, addr
, length
, &flash_driver_erase
);
970 static int flash_driver_unprotect(struct flash_bank
*bank
, int first
, int last
)
972 return flash_driver_protect(bank
, 0, first
, last
);
975 static int flash_unlock_address_range(struct target
*target
, uint32_t addr
, uint32_t length
)
977 return flash_iterate_address_range(target
, addr
, length
, &flash_driver_unprotect
);
981 /* write (optional verify) an image to flash memory of the given target */
982 static int flash_write_unlock(struct target
*target
, struct image
*image
, uint32_t *written
, int erase
, bool unlock
)
984 int retval
= ERROR_OK
;
987 uint32_t section_offset
;
988 struct flash_bank
*c
;
999 /* assume all sectors need erasing - stops any problems
1000 * when flash_write is called multiple times */
1005 /* allocate padding array */
1006 padding
= malloc(image
->num_sections
* sizeof(padding
));
1008 /* loop until we reach end of the image */
1009 while (section
< image
->num_sections
)
1011 uint32_t buffer_size
;
1015 uint32_t run_address
= image
->sections
[section
].base_address
+ section_offset
;
1016 uint32_t run_size
= image
->sections
[section
].size
- section_offset
;
1019 if (image
->sections
[section
].size
== 0)
1021 LOG_WARNING("empty section %d", section
);
1027 /* find the corresponding flash bank */
1028 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1030 section
++; /* and skip it */
1035 /* collect consecutive sections which fall into the same bank */
1036 section_first
= section
;
1037 section_last
= section
;
1038 padding
[section
] = 0;
1039 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
1040 && (section_last
+ 1 < image
->num_sections
))
1042 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1044 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1047 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1048 * attempt to rebuild a consecutive buffer for the flash loader */
1049 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1050 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1052 padding
[section_last
] = pad_bytes
;
1053 run_size
+= image
->sections
[++section_last
].size
;
1054 run_size
+= pad_bytes
;
1055 padding
[section_last
] = 0;
1057 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1060 /* fit the run into bank constraints */
1061 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
1063 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1064 (int)(c
->base
+ c
->size
- run_address
), (int)(run_size
), (int)(c
->size
));
1065 run_size
= c
->base
+ c
->size
- run_address
;
1068 /* allocate buffer */
1069 buffer
= malloc(run_size
);
1072 /* read sections to the buffer */
1073 while (buffer_size
< run_size
)
1077 size_read
= run_size
- buffer_size
;
1078 if (size_read
> image
->sections
[section
].size
- section_offset
)
1079 size_read
= image
->sections
[section
].size
- section_offset
;
1081 if ((retval
= image_read_section(image
, section
, section_offset
,
1082 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1089 /* see if we need to pad the section */
1090 while (padding
[section
]--)
1091 (buffer
+ buffer_size
)[size_read
++] = 0xff;
1093 buffer_size
+= size_read
;
1094 section_offset
+= size_read
;
1096 if (section_offset
>= image
->sections
[section
].size
)
1107 retval
= flash_unlock_address_range(target
, run_address
, run_size
);
1109 if (retval
== ERROR_OK
)
1113 /* calculate and erase sectors */
1114 retval
= flash_erase_address_range(target
, run_address
, run_size
);
1118 if (retval
== ERROR_OK
)
1120 /* write flash sectors */
1121 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1126 if (retval
!= ERROR_OK
)
1129 return retval
; /* abort operation */
1132 if (written
!= NULL
)
1133 *written
+= run_size
; /* add run size to total written counter */
1141 int flash_write(struct target
*target
, struct image
*image
, uint32_t *written
, int erase
)
1143 return flash_write_unlock(target
, image
, written
, erase
, false);
1146 int default_flash_mem_blank_check(struct flash_bank
*bank
)
1148 struct target
*target
= bank
->target
;
1149 uint8_t buffer
[1024];
1150 int buffer_size
= sizeof(buffer
);
1154 if (bank
->target
->state
!= TARGET_HALTED
)
1156 LOG_ERROR("Target not halted");
1157 return ERROR_TARGET_NOT_HALTED
;
1160 for (i
= 0; i
< bank
->num_sectors
; i
++)
1163 bank
->sectors
[i
].is_erased
= 1;
1165 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1169 chunk
= buffer_size
;
1170 if (chunk
> (j
- bank
->sectors
[i
].size
))
1172 chunk
= (j
- bank
->sectors
[i
].size
);
1175 retval
= target_read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1176 if (retval
!= ERROR_OK
)
1179 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1181 if (buffer
[nBytes
] != 0xFF)
1183 bank
->sectors
[i
].is_erased
= 0;
1193 int default_flash_blank_check(struct flash_bank
*bank
)
1195 struct target
*target
= bank
->target
;
1201 if (bank
->target
->state
!= TARGET_HALTED
)
1203 LOG_ERROR("Target not halted");
1204 return ERROR_TARGET_NOT_HALTED
;
1207 for (i
= 0; i
< bank
->num_sectors
; i
++)
1209 uint32_t address
= bank
->base
+ bank
->sectors
[i
].offset
;
1210 uint32_t size
= bank
->sectors
[i
].size
;
1212 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1218 bank
->sectors
[i
].is_erased
= 1;
1220 bank
->sectors
[i
].is_erased
= 0;
1226 LOG_USER("Running slow fallback erase check - add working memory");
1227 return default_flash_mem_blank_check(bank
);
1233 int flash_init_drivers(struct command_context
*cmd_ctx
)
1235 register_jim(cmd_ctx
, "ocd_flash_banks",
1236 jim_flash_banks
, "return information about the flash banks");
1241 register_command(cmd_ctx
, flash_cmd
, "info",
1242 handle_flash_info_command
, COMMAND_EXEC
,
1243 "print info about flash bank <num>");
1244 register_command(cmd_ctx
, flash_cmd
, "probe",
1245 handle_flash_probe_command
, COMMAND_EXEC
,
1246 "identify flash bank <num>");
1247 register_command(cmd_ctx
, flash_cmd
, "erase_check",
1248 handle_flash_erase_check_command
, COMMAND_EXEC
,
1249 "check erase state of sectors in flash bank <num>");
1250 register_command(cmd_ctx
, flash_cmd
, "protect_check",
1251 handle_flash_protect_check_command
, COMMAND_EXEC
,
1252 "check protection state of sectors in flash bank <num>");
1253 register_command(cmd_ctx
, flash_cmd
, "erase_sector",
1254 handle_flash_erase_command
, COMMAND_EXEC
,
1255 "erase sectors at <bank> <first> <last>");
1256 register_command(cmd_ctx
, flash_cmd
, "erase_address",
1257 handle_flash_erase_address_command
, COMMAND_EXEC
,
1258 "erase address range <address> <length>");
1260 register_command(cmd_ctx
, flash_cmd
, "fillw",
1261 handle_flash_fill_command
, COMMAND_EXEC
,
1262 "fill with pattern (no autoerase) <address> <word_pattern> <count>");
1263 register_command(cmd_ctx
, flash_cmd
, "fillh",
1264 handle_flash_fill_command
, COMMAND_EXEC
,
1265 "fill with pattern <address> <halfword_pattern> <count>");
1266 register_command(cmd_ctx
, flash_cmd
, "fillb",
1267 handle_flash_fill_command
, COMMAND_EXEC
,
1268 "fill with pattern <address> <byte_pattern> <count>");
1270 register_command(cmd_ctx
, flash_cmd
, "write_bank",
1271 handle_flash_write_bank_command
, COMMAND_EXEC
,
1272 "write binary data to <bank> <file> <offset>");
1273 register_command(cmd_ctx
, flash_cmd
, "write_image",
1274 handle_flash_write_image_command
, COMMAND_EXEC
,
1275 "write_image [erase] [unlock] <file> [offset] [type]");
1276 register_command(cmd_ctx
, flash_cmd
, "protect",
1277 handle_flash_protect_command
, COMMAND_EXEC
,
1278 "set protection of sectors at <bank> <first> <last> <on | off>");
1283 int flash_register_commands(struct command_context
*cmd_ctx
)
1285 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash",
1286 NULL
, COMMAND_ANY
, NULL
);
1288 register_command(cmd_ctx
, flash_cmd
, "bank",
1289 handle_flash_bank_command
, COMMAND_CONFIG
,
1290 "flash bank <driver> <base> <size> "
1291 "<chip_width> <bus_width> <target> [driver_options ...]");
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)