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_by_num
, 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
)
245 struct target
*target
;
249 return ERROR_COMMAND_SYNTAX_ERROR
;
252 if ((target
= get_target(CMD_ARGV
[5])) == NULL
)
254 LOG_ERROR("target '%s' not defined", CMD_ARGV
[5]);
258 for (i
= 0; flash_drivers
[i
]; i
++)
260 if (strcmp(CMD_ARGV
[0], flash_drivers
[i
]->name
) != 0)
263 struct flash_bank
*p
, *c
;
265 /* register flash specific commands */
266 if (flash_drivers
[i
]->register_commands(CMD_CTX
) != ERROR_OK
)
268 LOG_ERROR("couldn't register '%s' commands", CMD_ARGV
[0]);
272 c
= malloc(sizeof(struct flash_bank
));
274 c
->driver
= flash_drivers
[i
];
275 c
->driver_priv
= NULL
;
276 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], c
->base
);
277 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], c
->size
);
278 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[3], c
->chip_width
);
279 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
, CMD_ARGV
[0], c
->base
);
292 /* put flash bank in linked list */
296 /* find last flash bank */
297 for (p
= flash_banks
; p
&& p
->next
; p
= p
->next
) bank_num
++;
300 c
->bank_number
= bank_num
+ 1;
311 /* no matching flash driver found */
314 LOG_ERROR("flash driver '%s' not found", CMD_ARGV
[0]);
321 COMMAND_HANDLER(handle_flash_info_command
)
323 struct flash_bank
*p
;
329 return ERROR_COMMAND_SYNTAX_ERROR
;
332 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], bank_nr
);
334 for (p
= flash_banks
; p
; p
= p
->next
, i
++)
341 /* attempt auto probe */
342 if ((retval
= p
->driver
->auto_probe(p
)) != ERROR_OK
)
345 command_print(CMD_CTX
,
346 "#%" PRIi32
" : %s at 0x%8.8" PRIx32
", size 0x%8.8" PRIx32
", buswidth %i, chipwidth %i",
353 for (j
= 0; j
< p
->num_sectors
; j
++)
357 if (p
->sectors
[j
].is_protected
== 0)
358 protect_state
= "not protected";
359 else if (p
->sectors
[j
].is_protected
== 1)
360 protect_state
= "protected";
362 protect_state
= "protection state unknown";
364 command_print(CMD_CTX
,
365 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
367 p
->sectors
[j
].offset
,
369 p
->sectors
[j
].size
>> 10,
373 *buf
= '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
374 retval
= p
->driver
->info(p
, buf
, sizeof(buf
));
375 command_print(CMD_CTX
, "%s", buf
);
376 if (retval
!= ERROR_OK
)
377 LOG_ERROR("error retrieving flash info (%d)", retval
);
383 COMMAND_HANDLER(handle_flash_probe_command
)
389 return ERROR_COMMAND_SYNTAX_ERROR
;
393 COMMAND_PARSE_NUMBER(uint
, CMD_ARGV
[0], bank_nr
);
394 struct flash_bank
*p
= get_flash_bank_by_num_noprobe(bank_nr
);
397 if ((retval
= p
->driver
->probe(p
)) == ERROR_OK
)
399 command_print(CMD_CTX
, "flash '%s' found at 0x%8.8" PRIx32
, p
->driver
->name
, p
->base
);
401 else if (retval
== ERROR_FLASH_BANK_INVALID
)
403 command_print(CMD_CTX
, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32
,
404 CMD_ARGV
[0], p
->base
);
408 command_print(CMD_CTX
, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32
,
409 CMD_ARGV
[0], p
->base
);
414 command_print(CMD_CTX
, "flash bank '#%s' is out of bounds", CMD_ARGV
[0]);
420 COMMAND_HANDLER(handle_flash_erase_check_command
)
424 return ERROR_COMMAND_SYNTAX_ERROR
;
427 struct flash_bank
*p
;
428 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank_by_num
, 0, &p
);
429 if (ERROR_OK
!= retval
)
433 if ((retval
= p
->driver
->erase_check(p
)) == ERROR_OK
)
435 command_print(CMD_CTX
, "successfully checked erase state");
439 command_print(CMD_CTX
, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32
,
440 CMD_ARGV
[0], p
->base
);
443 for (j
= 0; j
< p
->num_sectors
; j
++)
447 if (p
->sectors
[j
].is_erased
== 0)
448 erase_state
= "not erased";
449 else if (p
->sectors
[j
].is_erased
== 1)
450 erase_state
= "erased";
452 erase_state
= "erase state unknown";
454 command_print(CMD_CTX
,
455 "\t#%3i: 0x%8.8" PRIx32
" (0x%" PRIx32
" %" PRIi32
"kB) %s",
457 p
->sectors
[j
].offset
,
459 p
->sectors
[j
].size
>> 10,
466 COMMAND_HANDLER(handle_flash_erase_address_command
)
468 struct flash_bank
*p
;
473 struct target
*target
= get_current_target(CMD_CTX
);
476 return ERROR_COMMAND_SYNTAX_ERROR
;
478 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[0], address
);
479 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[1], length
);
482 command_print(CMD_CTX
, "Length must be >0");
483 return ERROR_COMMAND_SYNTAX_ERROR
;
486 p
= get_flash_bank_by_addr(target
, address
);
492 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
495 struct duration bench
;
496 duration_start(&bench
);
498 retval
= flash_erase_address_range(target
, address
, length
);
500 if ((ERROR_OK
== retval
) && (duration_measure(&bench
) == ERROR_OK
))
502 command_print(CMD_CTX
, "erased address 0x%8.8x (length %i)"
503 " in %fs (%0.3f kb/s)", address
, length
,
504 duration_elapsed(&bench
), duration_kbps(&bench
, length
));
510 COMMAND_HANDLER(handle_flash_protect_check_command
)
513 return ERROR_COMMAND_SYNTAX_ERROR
;
515 struct flash_bank
*p
;
516 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank_by_num
, 0, &p
);
517 if (ERROR_OK
!= retval
)
520 if ((retval
= p
->driver
->protect_check(p
)) == ERROR_OK
)
522 command_print(CMD_CTX
, "successfully checked protect state");
524 else if (retval
== ERROR_FLASH_OPERATION_FAILED
)
526 command_print(CMD_CTX
, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32
, CMD_ARGV
[0], p
->base
);
530 command_print(CMD_CTX
, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32
, CMD_ARGV
[0], p
->base
);
536 static int flash_check_sector_parameters(struct command_context
*cmd_ctx
,
537 uint32_t first
, uint32_t last
, uint32_t num_sectors
)
539 if (!(first
<= last
)) {
540 command_print(cmd_ctx
, "ERROR: "
541 "first sector must be <= last sector");
545 if (!(last
<= (num_sectors
- 1))) {
546 command_print(cmd_ctx
, "ERROR: last sector must be <= %d",
547 (int) num_sectors
- 1);
554 COMMAND_HANDLER(handle_flash_erase_command
)
557 return ERROR_COMMAND_SYNTAX_ERROR
;
563 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], bank_nr
);
564 struct flash_bank
*p
= get_flash_bank_by_num(bank_nr
);
568 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], first
);
569 if (strcmp(CMD_ARGV
[2], "last") == 0)
570 last
= p
->num_sectors
- 1;
572 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], last
);
575 if ((retval
= flash_check_sector_parameters(CMD_CTX
,
576 first
, last
, p
->num_sectors
)) != ERROR_OK
)
579 struct duration bench
;
580 duration_start(&bench
);
582 retval
= flash_driver_erase(p
, first
, last
);
584 if ((ERROR_OK
== retval
) && (duration_measure(&bench
) == ERROR_OK
))
586 command_print(CMD_CTX
, "erased sectors %" PRIu32
" "
587 "through %" PRIu32
" on flash bank %" PRIu32
" "
588 "in %fs", first
, last
, bank_nr
, duration_elapsed(&bench
));
594 COMMAND_HANDLER(handle_flash_protect_command
)
597 return ERROR_COMMAND_SYNTAX_ERROR
;
603 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], bank_nr
);
604 struct flash_bank
*p
= get_flash_bank_by_num(bank_nr
);
608 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], first
);
609 if (strcmp(CMD_ARGV
[2], "last") == 0)
610 last
= p
->num_sectors
- 1;
612 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], last
);
615 COMMAND_PARSE_ON_OFF(CMD_ARGV
[3], set
);
618 if ((retval
= flash_check_sector_parameters(CMD_CTX
,
619 first
, last
, p
->num_sectors
)) != ERROR_OK
)
622 retval
= flash_driver_protect(p
, set
, first
, last
);
623 if (retval
== ERROR_OK
) {
624 command_print(CMD_CTX
, "%s protection for sectors %i "
625 "through %i on flash bank %i",
626 (set
) ? "set" : "cleared", (int) first
,
627 (int) last
, (int) bank_nr
);
633 COMMAND_HANDLER(handle_flash_write_image_command
)
635 struct target
*target
= get_current_target(CMD_CTX
);
644 return ERROR_COMMAND_SYNTAX_ERROR
;
647 /* flash auto-erase is disabled by default*/
649 bool auto_unlock
= false;
653 if (strcmp(CMD_ARGV
[0], "erase") == 0)
658 command_print(CMD_CTX
, "auto erase enabled");
659 } else if (strcmp(CMD_ARGV
[0], "unlock") == 0)
664 command_print(CMD_CTX
, "auto unlock enabled");
673 return ERROR_COMMAND_SYNTAX_ERROR
;
678 LOG_ERROR("no target selected");
682 struct duration bench
;
683 duration_start(&bench
);
687 image
.base_address_set
= 1;
688 COMMAND_PARSE_NUMBER(int, CMD_ARGV
[1], image
.base_address
);
692 image
.base_address_set
= 0;
693 image
.base_address
= 0x0;
696 image
.start_address_set
= 0;
698 retval
= image_open(&image
, CMD_ARGV
[0], (CMD_ARGC
== 3) ? CMD_ARGV
[2] : NULL
);
699 if (retval
!= ERROR_OK
)
704 retval
= flash_write_unlock(target
, &image
, &written
, auto_erase
, auto_unlock
);
705 if (retval
!= ERROR_OK
)
711 if ((ERROR_OK
== retval
) && (duration_measure(&bench
) == ERROR_OK
))
713 command_print(CMD_CTX
, "wrote %" PRIu32
" byte from file %s "
714 "in %fs (%0.3f kb/s)", written
, CMD_ARGV
[0],
715 duration_elapsed(&bench
), duration_kbps(&bench
, written
));
723 COMMAND_HANDLER(handle_flash_fill_command
)
730 uint8_t readback
[1024];
732 uint32_t cur_size
= 0;
733 uint32_t chunk_count
;
734 struct target
*target
= get_current_target(CMD_CTX
);
739 return ERROR_COMMAND_SYNTAX_ERROR
;
741 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], address
);
742 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[1], pattern
);
743 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], count
);
760 return ERROR_COMMAND_SYNTAX_ERROR
;
763 chunk_count
= MIN(count
, (1024 / wordsize
));
767 for (i
= 0; i
< chunk_count
; i
++)
769 target_buffer_set_u32(target
, chunk
+ i
* wordsize
, pattern
);
773 for (i
= 0; i
< chunk_count
; i
++)
775 target_buffer_set_u16(target
, chunk
+ i
* wordsize
, pattern
);
779 memset(chunk
, pattern
, chunk_count
);
782 LOG_ERROR("BUG: can't happen");
786 struct duration bench
;
787 duration_start(&bench
);
789 for (wrote
= 0; wrote
< (count
*wordsize
); wrote
+= cur_size
)
791 cur_size
= MIN((count
*wordsize
- wrote
), sizeof(chunk
));
792 struct flash_bank
*bank
;
793 bank
= get_flash_bank_by_addr(target
, address
);
798 err
= flash_driver_write(bank
, chunk
, address
- bank
->base
+ wrote
, cur_size
);
802 err
= target_read_buffer(target
, address
+ wrote
, cur_size
, readback
);
807 for (i
= 0; i
< cur_size
; i
++)
809 if (readback
[i
]!=chunk
[i
])
811 LOG_ERROR("Verfication error address 0x%08" PRIx32
", read back 0x%02x, expected 0x%02x",
812 address
+ wrote
+ i
, readback
[i
], chunk
[i
]);
818 if (duration_measure(&bench
) == ERROR_OK
)
820 command_print(CMD_CTX
, "wrote %" PRIu32
" bytes to 0x%8.8" PRIx32
821 " in %fs (%0.3f kb/s)", wrote
, address
,
822 duration_elapsed(&bench
), duration_kbps(&bench
, wrote
));
827 COMMAND_HANDLER(handle_flash_write_bank_command
)
831 struct fileio fileio
;
834 return ERROR_COMMAND_SYNTAX_ERROR
;
836 struct duration bench
;
837 duration_start(&bench
);
839 struct flash_bank
*p
;
840 int retval
= CALL_COMMAND_HANDLER(flash_command_get_bank_by_num
, 0, &p
);
841 if (ERROR_OK
!= retval
)
844 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[2], offset
);
846 if (fileio_open(&fileio
, CMD_ARGV
[1], FILEIO_READ
, FILEIO_BINARY
) != ERROR_OK
)
851 buffer
= malloc(fileio
.size
);
853 if (fileio_read(&fileio
, fileio
.size
, buffer
, &buf_cnt
) != ERROR_OK
)
856 fileio_close(&fileio
);
860 retval
= flash_driver_write(p
, buffer
, offset
, buf_cnt
);
865 if ((ERROR_OK
== retval
) && (duration_measure(&bench
) == ERROR_OK
))
867 command_print(CMD_CTX
, "wrote %zu byte from file %s to flash bank %u"
868 " at offset 0x%8.8" PRIx32
" in %fs (%0.3f kb/s)",
869 fileio
.size
, CMD_ARGV
[1], p
->bank_number
, offset
,
870 duration_elapsed(&bench
), duration_kbps(&bench
, fileio
.size
));
873 fileio_close(&fileio
);
878 void flash_set_dirty(void)
880 struct flash_bank
*c
;
883 /* set all flash to require erasing */
884 for (c
= flash_banks
; c
; c
= c
->next
)
886 for (i
= 0; i
< c
->num_sectors
; i
++)
888 c
->sectors
[i
].is_erased
= 0;
893 /* lookup flash bank by address */
894 struct flash_bank
*get_flash_bank_by_addr(struct target
*target
, uint32_t addr
)
896 struct flash_bank
*c
;
898 /* cycle through bank list */
899 for (c
= flash_banks
; c
; c
= c
->next
)
902 retval
= c
->driver
->auto_probe(c
);
904 if (retval
!= ERROR_OK
)
906 LOG_ERROR("auto_probe failed %d\n", retval
);
909 /* check whether address belongs to this flash bank */
910 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
913 LOG_ERROR("No flash at address 0x%08" PRIx32
"\n", addr
);
917 /* erase given flash region, selects proper bank according to target and address */
918 static int flash_iterate_address_range(struct target
*target
, uint32_t addr
, uint32_t length
,
919 int (*callback
)(struct flash_bank
*bank
, int first
, int last
))
921 struct flash_bank
*c
;
926 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
927 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
929 if (c
->size
== 0 || c
->num_sectors
== 0)
931 LOG_ERROR("Bank is invalid");
932 return ERROR_FLASH_BANK_INVALID
;
937 /* special case, erase whole bank when length is zero */
939 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
941 return callback(c
, 0, c
->num_sectors
- 1);
944 /* check whether it fits */
945 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
946 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
950 for (i
= 0; i
< c
->num_sectors
; i
++)
952 /* check whether sector overlaps with the given range and is not yet erased */
953 if (addr
< c
->sectors
[i
].offset
+ c
->sectors
[i
].size
&& addr
+ length
> c
->sectors
[i
].offset
&& c
->sectors
[i
].is_erased
!= 1) {
954 /* if first is not set yet then this is the first sector */
957 last
= i
; /* and it is the last one so far in any case */
961 if (first
== -1 || last
== -1)
964 return callback(c
, first
, last
);
969 int flash_erase_address_range(struct target
*target
, uint32_t addr
, uint32_t length
)
971 return flash_iterate_address_range(target
, addr
, length
, &flash_driver_erase
);
974 static int flash_driver_unprotect(struct flash_bank
*bank
, int first
, int last
)
976 return flash_driver_protect(bank
, 0, first
, last
);
979 static int flash_unlock_address_range(struct target
*target
, uint32_t addr
, uint32_t length
)
981 return flash_iterate_address_range(target
, addr
, length
, &flash_driver_unprotect
);
985 /* write (optional verify) an image to flash memory of the given target */
986 static int flash_write_unlock(struct target
*target
, struct image
*image
, uint32_t *written
, int erase
, bool unlock
)
988 int retval
= ERROR_OK
;
991 uint32_t section_offset
;
992 struct flash_bank
*c
;
1003 /* assume all sectors need erasing - stops any problems
1004 * when flash_write is called multiple times */
1009 /* allocate padding array */
1010 padding
= malloc(image
->num_sections
* sizeof(padding
));
1012 /* loop until we reach end of the image */
1013 while (section
< image
->num_sections
)
1015 uint32_t buffer_size
;
1019 uint32_t run_address
= image
->sections
[section
].base_address
+ section_offset
;
1020 uint32_t run_size
= image
->sections
[section
].size
- section_offset
;
1023 if (image
->sections
[section
].size
== 0)
1025 LOG_WARNING("empty section %d", section
);
1031 /* find the corresponding flash bank */
1032 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
1034 section
++; /* and skip it */
1039 /* collect consecutive sections which fall into the same bank */
1040 section_first
= section
;
1041 section_last
= section
;
1042 padding
[section
] = 0;
1043 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
1044 && (section_last
+ 1 < image
->num_sections
))
1046 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
1048 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
1051 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1052 * attempt to rebuild a consecutive buffer for the flash loader */
1053 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
1054 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
1056 padding
[section_last
] = pad_bytes
;
1057 run_size
+= image
->sections
[++section_last
].size
;
1058 run_size
+= pad_bytes
;
1059 padding
[section_last
] = 0;
1061 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
1064 /* fit the run into bank constraints */
1065 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
1067 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1068 (int)(c
->base
+ c
->size
- run_address
), (int)(run_size
), (int)(c
->size
));
1069 run_size
= c
->base
+ c
->size
- run_address
;
1072 /* allocate buffer */
1073 buffer
= malloc(run_size
);
1076 /* read sections to the buffer */
1077 while (buffer_size
< run_size
)
1081 size_read
= run_size
- buffer_size
;
1082 if (size_read
> image
->sections
[section
].size
- section_offset
)
1083 size_read
= image
->sections
[section
].size
- section_offset
;
1085 if ((retval
= image_read_section(image
, section
, section_offset
,
1086 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
1093 /* see if we need to pad the section */
1094 while (padding
[section
]--)
1095 (buffer
+ buffer_size
)[size_read
++] = 0xff;
1097 buffer_size
+= size_read
;
1098 section_offset
+= size_read
;
1100 if (section_offset
>= image
->sections
[section
].size
)
1111 retval
= flash_unlock_address_range(target
, run_address
, run_size
);
1113 if (retval
== ERROR_OK
)
1117 /* calculate and erase sectors */
1118 retval
= flash_erase_address_range(target
, run_address
, run_size
);
1122 if (retval
== ERROR_OK
)
1124 /* write flash sectors */
1125 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
1130 if (retval
!= ERROR_OK
)
1133 return retval
; /* abort operation */
1136 if (written
!= NULL
)
1137 *written
+= run_size
; /* add run size to total written counter */
1145 int flash_write(struct target
*target
, struct image
*image
, uint32_t *written
, int erase
)
1147 return flash_write_unlock(target
, image
, written
, erase
, false);
1150 int default_flash_mem_blank_check(struct flash_bank
*bank
)
1152 struct target
*target
= bank
->target
;
1153 uint8_t buffer
[1024];
1154 int buffer_size
= sizeof(buffer
);
1158 if (bank
->target
->state
!= TARGET_HALTED
)
1160 LOG_ERROR("Target not halted");
1161 return ERROR_TARGET_NOT_HALTED
;
1164 for (i
= 0; i
< bank
->num_sectors
; i
++)
1167 bank
->sectors
[i
].is_erased
= 1;
1169 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
1173 chunk
= buffer_size
;
1174 if (chunk
> (j
- bank
->sectors
[i
].size
))
1176 chunk
= (j
- bank
->sectors
[i
].size
);
1179 retval
= target_read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
1180 if (retval
!= ERROR_OK
)
1183 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
1185 if (buffer
[nBytes
] != 0xFF)
1187 bank
->sectors
[i
].is_erased
= 0;
1197 int default_flash_blank_check(struct flash_bank
*bank
)
1199 struct target
*target
= bank
->target
;
1205 if (bank
->target
->state
!= TARGET_HALTED
)
1207 LOG_ERROR("Target not halted");
1208 return ERROR_TARGET_NOT_HALTED
;
1211 for (i
= 0; i
< bank
->num_sectors
; i
++)
1213 uint32_t address
= bank
->base
+ bank
->sectors
[i
].offset
;
1214 uint32_t size
= bank
->sectors
[i
].size
;
1216 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
1222 bank
->sectors
[i
].is_erased
= 1;
1224 bank
->sectors
[i
].is_erased
= 0;
1230 LOG_USER("Running slow fallback erase check - add working memory");
1231 return default_flash_mem_blank_check(bank
);
1237 int flash_init_drivers(struct command_context
*cmd_ctx
)
1239 register_jim(cmd_ctx
, "ocd_flash_banks",
1240 jim_flash_banks
, "return information about the flash banks");
1245 register_command(cmd_ctx
, flash_cmd
, "info",
1246 handle_flash_info_command
, COMMAND_EXEC
,
1247 "print info about flash bank <num>");
1248 register_command(cmd_ctx
, flash_cmd
, "probe",
1249 handle_flash_probe_command
, COMMAND_EXEC
,
1250 "identify flash bank <num>");
1251 register_command(cmd_ctx
, flash_cmd
, "erase_check",
1252 handle_flash_erase_check_command
, COMMAND_EXEC
,
1253 "check erase state of sectors in flash bank <num>");
1254 register_command(cmd_ctx
, flash_cmd
, "protect_check",
1255 handle_flash_protect_check_command
, COMMAND_EXEC
,
1256 "check protection state of sectors in flash bank <num>");
1257 register_command(cmd_ctx
, flash_cmd
, "erase_sector",
1258 handle_flash_erase_command
, COMMAND_EXEC
,
1259 "erase sectors at <bank> <first> <last>");
1260 register_command(cmd_ctx
, flash_cmd
, "erase_address",
1261 handle_flash_erase_address_command
, COMMAND_EXEC
,
1262 "erase address range <address> <length>");
1264 register_command(cmd_ctx
, flash_cmd
, "fillw",
1265 handle_flash_fill_command
, COMMAND_EXEC
,
1266 "fill with pattern (no autoerase) <address> <word_pattern> <count>");
1267 register_command(cmd_ctx
, flash_cmd
, "fillh",
1268 handle_flash_fill_command
, COMMAND_EXEC
,
1269 "fill with pattern <address> <halfword_pattern> <count>");
1270 register_command(cmd_ctx
, flash_cmd
, "fillb",
1271 handle_flash_fill_command
, COMMAND_EXEC
,
1272 "fill with pattern <address> <byte_pattern> <count>");
1274 register_command(cmd_ctx
, flash_cmd
, "write_bank",
1275 handle_flash_write_bank_command
, COMMAND_EXEC
,
1276 "write binary data to <bank> <file> <offset>");
1277 register_command(cmd_ctx
, flash_cmd
, "write_image",
1278 handle_flash_write_image_command
, COMMAND_EXEC
,
1279 "write_image [erase] [unlock] <file> [offset] [type]");
1280 register_command(cmd_ctx
, flash_cmd
, "protect",
1281 handle_flash_protect_command
, COMMAND_EXEC
,
1282 "set protection of sectors at <bank> <first> <last> <on | off>");
1287 int flash_register_commands(struct command_context
*cmd_ctx
)
1289 flash_cmd
= register_command(cmd_ctx
, NULL
, "flash",
1290 NULL
, COMMAND_ANY
, NULL
);
1292 register_command(cmd_ctx
, flash_cmd
, "bank",
1293 handle_flash_bank_command
, COMMAND_CONFIG
,
1294 "flash bank <driver> <base> <size> "
1295 "<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)