1 /* SPDX-License-Identifier: GPL-2.0-or-later */
3 /***************************************************************************
4 * Copyright (C) 2005 by Dominic Rath <Dominic.Rath@gmx.de> *
5 * Copyright (C) 2007-2010 Øyvind Harboe <oyvind.harboe@zylin.com> *
6 * Copyright (C) 2008 by Spencer Oliver <spen@spen-soft.co.uk> *
7 * Copyright (C) 2009 Zachary T Welch <zw@superlucidity.net> *
8 * Copyright (C) 2010 by Antonio Borneo <borneo.antonio@gmail.com> *
9 * Copyright (C) 2017-2018 Tomas Vanek <vanekt@fbl.cz> *
10 ***************************************************************************/
15 #include <flash/common.h>
16 #include <flash/nor/core.h>
17 #include <flash/nor/imp.h>
18 #include <target/image.h>
22 * Upper level of NOR flash framework.
23 * The lower level interfaces are to drivers. These upper level ones
24 * primarily support access from Tcl scripts or from GDB.
27 static struct flash_bank
*flash_banks
;
29 int flash_driver_erase(struct flash_bank
*bank
, unsigned int first
,
34 retval
= bank
->driver
->erase(bank
, first
, last
);
35 if (retval
!= ERROR_OK
)
36 LOG_ERROR("failed erasing sectors %u to %u", first
, last
);
41 int flash_driver_protect(struct flash_bank
*bank
, int set
, unsigned int first
,
45 unsigned int num_blocks
;
47 if (bank
->num_prot_blocks
)
48 num_blocks
= bank
->num_prot_blocks
;
50 num_blocks
= bank
->num_sectors
;
53 /* callers may not supply illegal parameters ... */
54 if (first
> last
|| last
>= num_blocks
) {
55 LOG_ERROR("illegal protection block range");
59 /* force "set" to 0/1 */
62 if (!bank
->driver
->protect
) {
63 LOG_ERROR("Flash protection is not supported.");
64 return ERROR_FLASH_OPER_UNSUPPORTED
;
69 * We must not use any cached information about protection state!!!!
71 * There are a million things that could change the protect state:
73 * the target could have reset, power cycled, been hot plugged,
74 * the application could have run, etc.
76 * Drivers only receive valid protection block range.
78 retval
= bank
->driver
->protect(bank
, set
, first
, last
);
79 if (retval
!= ERROR_OK
)
80 LOG_ERROR("failed setting protection for blocks %u to %u", first
, last
);
85 int flash_driver_write(struct flash_bank
*bank
,
86 const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
90 retval
= bank
->driver
->write(bank
, buffer
, offset
, count
);
91 if (retval
!= ERROR_OK
) {
93 "error writing to flash at address " TARGET_ADDR_FMT
94 " at offset 0x%8.8" PRIx32
,
102 int flash_driver_read(struct flash_bank
*bank
,
103 uint8_t *buffer
, uint32_t offset
, uint32_t count
)
107 LOG_DEBUG("call flash_driver_read()");
109 retval
= bank
->driver
->read(bank
, buffer
, offset
, count
);
110 if (retval
!= ERROR_OK
) {
112 "error reading to flash at address " TARGET_ADDR_FMT
113 " at offset 0x%8.8" PRIx32
,
121 int default_flash_read(struct flash_bank
*bank
,
122 uint8_t *buffer
, uint32_t offset
, uint32_t count
)
124 return target_read_buffer(bank
->target
, offset
+ bank
->base
, count
, buffer
);
127 int flash_driver_verify(struct flash_bank
*bank
,
128 const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
132 retval
= bank
->driver
->verify
? bank
->driver
->verify(bank
, buffer
, offset
, count
) :
133 default_flash_verify(bank
, buffer
, offset
, count
);
134 if (retval
!= ERROR_OK
) {
135 LOG_ERROR("verify failed in bank at " TARGET_ADDR_FMT
" starting at 0x%8.8" PRIx32
,
142 int default_flash_verify(struct flash_bank
*bank
,
143 const uint8_t *buffer
, uint32_t offset
, uint32_t count
)
145 uint32_t target_crc
, image_crc
;
148 retval
= image_calculate_checksum(buffer
, count
, &image_crc
);
149 if (retval
!= ERROR_OK
)
152 retval
= target_checksum_memory(bank
->target
, offset
+ bank
->base
, count
, &target_crc
);
153 if (retval
!= ERROR_OK
)
156 LOG_DEBUG("addr " TARGET_ADDR_FMT
", len 0x%08" PRIx32
", crc 0x%08" PRIx32
" 0x%08" PRIx32
,
157 offset
+ bank
->base
, count
, ~image_crc
, ~target_crc
);
158 if (target_crc
== image_crc
)
164 void flash_bank_add(struct flash_bank
*bank
)
166 /* put flash bank in linked list */
167 unsigned bank_num
= 0;
169 /* find last flash bank */
170 struct flash_bank
*p
= flash_banks
;
180 bank
->bank_number
= bank_num
;
183 struct flash_bank
*flash_bank_list(void)
188 struct flash_bank
*get_flash_bank_by_num_noprobe(unsigned int num
)
190 struct flash_bank
*p
;
193 for (p
= flash_banks
; p
; p
= p
->next
) {
197 LOG_ERROR("flash bank %d does not exist", num
);
201 unsigned int flash_get_bank_count(void)
203 struct flash_bank
*p
;
205 for (p
= flash_banks
; p
; p
= p
->next
)
210 void default_flash_free_driver_priv(struct flash_bank
*bank
)
212 free(bank
->driver_priv
);
213 bank
->driver_priv
= NULL
;
216 void flash_free_all_banks(void)
218 struct flash_bank
*bank
= flash_banks
;
220 struct flash_bank
*next
= bank
->next
;
221 if (bank
->driver
->free_driver_priv
)
222 bank
->driver
->free_driver_priv(bank
);
224 LOG_WARNING("Flash driver of %s does not support free_driver_priv()", bank
->name
);
226 /* For 'virtual' flash driver bank->sectors and bank->prot_blocks pointers are copied from
227 * master flash_bank structure. They point to memory locations allocated by master flash driver
228 * so master driver is responsible for releasing them.
229 * Avoid UB caused by double-free memory corruption if flash bank is 'virtual'. */
231 if (strcmp(bank
->driver
->name
, "virtual") != 0) {
233 free(bank
->prot_blocks
);
243 struct flash_bank
*get_flash_bank_by_name_noprobe(const char *name
)
245 unsigned requested
= get_flash_name_index(name
);
248 struct flash_bank
*bank
;
249 for (bank
= flash_banks
; bank
; bank
= bank
->next
) {
250 if (strcmp(bank
->name
, name
) == 0)
252 if (!flash_driver_name_matches(bank
->driver
->name
, name
))
254 if (++found
< requested
)
261 int get_flash_bank_by_name(const char *name
, struct flash_bank
**bank_result
)
263 struct flash_bank
*bank
;
266 bank
= get_flash_bank_by_name_noprobe(name
);
268 retval
= bank
->driver
->auto_probe(bank
);
270 if (retval
!= ERROR_OK
) {
271 LOG_ERROR("auto_probe failed");
280 int get_flash_bank_by_num(unsigned int num
, struct flash_bank
**bank
)
282 struct flash_bank
*p
= get_flash_bank_by_num_noprobe(num
);
288 retval
= p
->driver
->auto_probe(p
);
290 if (retval
!= ERROR_OK
) {
291 LOG_ERROR("auto_probe failed");
298 /* lookup flash bank by address, bank not found is success, but
299 * result_bank is set to NULL. */
300 int get_flash_bank_by_addr(struct target
*target
,
303 struct flash_bank
**result_bank
)
305 struct flash_bank
*c
;
307 /* cycle through bank list */
308 for (c
= flash_banks
; c
; c
= c
->next
) {
309 if (c
->target
!= target
)
313 retval
= c
->driver
->auto_probe(c
);
315 if (retval
!= ERROR_OK
) {
316 LOG_ERROR("auto_probe failed");
319 /* check whether address belongs to this flash bank */
320 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1))) {
327 LOG_ERROR("No flash at address " TARGET_ADDR_FMT
, addr
);
333 static int default_flash_mem_blank_check(struct flash_bank
*bank
)
335 struct target
*target
= bank
->target
;
336 const int buffer_size
= 1024;
338 int retval
= ERROR_OK
;
340 if (bank
->target
->state
!= TARGET_HALTED
) {
341 LOG_ERROR("Target not halted");
342 return ERROR_TARGET_NOT_HALTED
;
345 uint8_t *buffer
= malloc(buffer_size
);
347 for (unsigned int i
= 0; i
< bank
->num_sectors
; i
++) {
349 bank
->sectors
[i
].is_erased
= 1;
351 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
) {
354 if (chunk
> (bank
->sectors
[i
].size
- j
))
355 chunk
= (bank
->sectors
[i
].size
- j
);
357 retval
= target_read_memory(target
,
358 bank
->base
+ bank
->sectors
[i
].offset
+ j
,
362 if (retval
!= ERROR_OK
)
365 for (n_bytes
= 0; n_bytes
< chunk
; n_bytes
++) {
366 if (buffer
[n_bytes
] != bank
->erased_value
) {
367 bank
->sectors
[i
].is_erased
= 0;
380 int default_flash_blank_check(struct flash_bank
*bank
)
382 struct target
*target
= bank
->target
;
385 if (bank
->target
->state
!= TARGET_HALTED
) {
386 LOG_ERROR("Target not halted");
387 return ERROR_TARGET_NOT_HALTED
;
390 struct target_memory_check_block
*block_array
;
391 block_array
= malloc(bank
->num_sectors
* sizeof(struct target_memory_check_block
));
393 return default_flash_mem_blank_check(bank
);
395 for (unsigned int i
= 0; i
< bank
->num_sectors
; i
++) {
396 block_array
[i
].address
= bank
->base
+ bank
->sectors
[i
].offset
;
397 block_array
[i
].size
= bank
->sectors
[i
].size
;
398 block_array
[i
].result
= UINT32_MAX
; /* erase state unknown */
401 bool fast_check
= true;
402 for (unsigned int i
= 0; i
< bank
->num_sectors
; ) {
403 retval
= target_blank_check_memory(target
,
404 block_array
+ i
, bank
->num_sectors
- i
,
407 /* Run slow fallback if the first run gives no result
408 * otherwise use possibly incomplete results */
413 i
+= retval
; /* add number of blocks done this round */
417 for (unsigned int i
= 0; i
< bank
->num_sectors
; i
++)
418 bank
->sectors
[i
].is_erased
= block_array
[i
].result
;
421 if (retval
== ERROR_NOT_IMPLEMENTED
)
422 LOG_USER("Running slow fallback erase check");
424 LOG_USER("Running slow fallback erase check - add working memory");
426 retval
= default_flash_mem_blank_check(bank
);
433 /* Manipulate given flash region, selecting the bank according to target
434 * and address. Maps an address range to a set of sectors, and issues
435 * the callback() on that set ... e.g. to erase or unprotect its members.
437 * Parameter iterate_protect_blocks switches iteration of protect block
438 * instead of erase sectors. If there is no protect blocks array, sectors
439 * are used in iteration, so compatibility for old flash drivers is retained.
441 * The "pad_reason" parameter is a kind of boolean: when it's NULL, the
442 * range must fit those sectors exactly. This is clearly safe; it can't
443 * erase data which the caller said to leave alone, for example. If it's
444 * non-NULL, rather than failing, extra data in the first and/or last
445 * sectors will be added to the range, and that reason string is used when
446 * warning about those additions.
448 static int flash_iterate_address_range_inner(struct target
*target
,
449 char *pad_reason
, target_addr_t addr
, uint32_t length
,
450 bool iterate_protect_blocks
,
451 int (*callback
)(struct flash_bank
*bank
, unsigned int first
,
454 struct flash_bank
*c
;
455 struct flash_sector
*block_array
;
456 target_addr_t last_addr
= addr
+ length
- 1; /* the last address of range */
462 int retval
= get_flash_bank_by_addr(target
, addr
, true, &c
);
463 if (retval
!= ERROR_OK
)
466 if (c
->size
== 0 || c
->num_sectors
== 0) {
467 LOG_ERROR("Bank is invalid");
468 return ERROR_FLASH_BANK_INVALID
;
472 /* special case, erase whole bank when length is zero */
473 if (addr
!= c
->base
) {
474 LOG_ERROR("Whole bank access must start at beginning of bank.");
475 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
478 return callback(c
, 0, c
->num_sectors
- 1);
481 /* check whether it all fits in this bank */
482 if (last_addr
> c
->base
+ c
->size
- 1) {
483 LOG_ERROR("Flash access does not fit into bank.");
484 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
487 if (!c
->prot_blocks
|| c
->num_prot_blocks
== 0) {
488 /* flash driver does not define protect blocks, use sectors instead */
489 iterate_protect_blocks
= false;
492 if (iterate_protect_blocks
) {
493 block_array
= c
->prot_blocks
;
494 num_blocks
= c
->num_prot_blocks
;
496 block_array
= c
->sectors
;
497 num_blocks
= c
->num_sectors
;
500 for (i
= 0; i
< num_blocks
; i
++) {
501 struct flash_sector
*f
= &block_array
[i
];
502 target_addr_t sector_addr
= c
->base
+ f
->offset
;
503 target_addr_t sector_last_addr
= sector_addr
+ f
->size
- 1;
505 /* start only on a sector boundary */
507 /* scanned past the first sector? */
508 if (addr
< sector_addr
)
511 /* is this the first sector? */
512 if (addr
== sector_addr
)
515 /* Does this need head-padding? If so, pad and warn;
516 * or else force an error.
518 * Such padding can make trouble, since *WE* can't
519 * ever know if that data was in use. The warning
520 * should help users sort out messes later.
522 else if (addr
<= sector_last_addr
&& pad_reason
) {
523 /* FIXME say how many bytes (e.g. 80 KB) */
524 LOG_WARNING("Adding extra %s range, "
525 TARGET_ADDR_FMT
" .. " TARGET_ADDR_FMT
,
534 /* is this (also?) the last sector? */
535 if (last_addr
== sector_last_addr
) {
540 /* Does this need tail-padding? If so, pad and warn;
541 * or else force an error.
543 if (last_addr
< sector_last_addr
&& pad_reason
) {
544 /* FIXME say how many bytes (e.g. 80 KB) */
545 LOG_WARNING("Adding extra %s range, "
546 TARGET_ADDR_FMT
" .. " TARGET_ADDR_FMT
,
554 /* MUST finish on a sector boundary */
555 if (last_addr
< sector_addr
)
559 /* invalid start or end address? */
560 if (first
== -1 || last
== -1) {
561 LOG_ERROR("address range " TARGET_ADDR_FMT
" .. " TARGET_ADDR_FMT
562 " is not sector-aligned",
565 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
568 /* The NOR driver may trim this range down, based on what
569 * sectors are already erased/unprotected. GDB currently
570 * blocks such optimizations.
572 return callback(c
, first
, last
);
575 /* The inner fn only handles a single bank, we could be spanning
578 static int flash_iterate_address_range(struct target
*target
,
579 char *pad_reason
, target_addr_t addr
, uint32_t length
,
580 bool iterate_protect_blocks
,
581 int (*callback
)(struct flash_bank
*bank
, unsigned int first
,
584 struct flash_bank
*c
;
585 int retval
= ERROR_OK
;
587 /* Danger! zero-length iterations means entire bank! */
589 retval
= get_flash_bank_by_addr(target
, addr
, true, &c
);
590 if (retval
!= ERROR_OK
)
593 uint32_t cur_length
= length
;
594 /* check whether it all fits in this bank */
595 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1) {
596 LOG_DEBUG("iterating over more than one flash bank.");
597 cur_length
= c
->base
+ c
->size
- addr
;
599 retval
= flash_iterate_address_range_inner(target
,
600 pad_reason
, addr
, cur_length
,
601 iterate_protect_blocks
,
603 if (retval
!= ERROR_OK
)
606 length
-= cur_length
;
608 } while (length
> 0);
613 int flash_erase_address_range(struct target
*target
,
614 bool pad
, target_addr_t addr
, uint32_t length
)
616 return flash_iterate_address_range(target
, pad
? "erase" : NULL
,
617 addr
, length
, false, &flash_driver_erase
);
620 static int flash_driver_unprotect(struct flash_bank
*bank
, unsigned int first
,
623 return flash_driver_protect(bank
, 0, first
, last
);
626 int flash_unlock_address_range(struct target
*target
, target_addr_t addr
,
629 /* By default, pad to sector boundaries ... the real issue here
630 * is that our (only) caller *permanently* removes protection,
631 * and doesn't restore it.
633 return flash_iterate_address_range(target
, "unprotect",
634 addr
, length
, true, &flash_driver_unprotect
);
637 static int compare_section(const void *a
, const void *b
)
639 struct imagesection
*b1
, *b2
;
640 b1
= *((struct imagesection
**)a
);
641 b2
= *((struct imagesection
**)b
);
643 if (b1
->base_address
== b2
->base_address
)
645 else if (b1
->base_address
> b2
->base_address
)
652 * Get aligned start address of a flash write region
654 target_addr_t
flash_write_align_start(struct flash_bank
*bank
, target_addr_t addr
)
656 if (addr
< bank
->base
|| addr
>= bank
->base
+ bank
->size
657 || bank
->write_start_alignment
<= 1)
660 if (bank
->write_start_alignment
== FLASH_WRITE_ALIGN_SECTOR
) {
661 uint32_t offset
= addr
- bank
->base
;
662 uint32_t aligned
= 0;
663 for (unsigned int sect
= 0; sect
< bank
->num_sectors
; sect
++) {
664 if (bank
->sectors
[sect
].offset
> offset
)
667 aligned
= bank
->sectors
[sect
].offset
;
669 return bank
->base
+ aligned
;
672 return addr
& ~(bank
->write_start_alignment
- 1);
676 * Get aligned end address of a flash write region
678 target_addr_t
flash_write_align_end(struct flash_bank
*bank
, target_addr_t addr
)
680 if (addr
< bank
->base
|| addr
>= bank
->base
+ bank
->size
681 || bank
->write_end_alignment
<= 1)
684 if (bank
->write_end_alignment
== FLASH_WRITE_ALIGN_SECTOR
) {
685 uint32_t offset
= addr
- bank
->base
;
686 uint32_t aligned
= 0;
687 for (unsigned int sect
= 0; sect
< bank
->num_sectors
; sect
++) {
688 aligned
= bank
->sectors
[sect
].offset
+ bank
->sectors
[sect
].size
- 1;
689 if (aligned
>= offset
)
692 return bank
->base
+ aligned
;
695 return addr
| (bank
->write_end_alignment
- 1);
699 * Check if gap between sections is bigger than minimum required to discontinue flash write
701 static bool flash_write_check_gap(struct flash_bank
*bank
,
702 target_addr_t addr1
, target_addr_t addr2
)
704 if (bank
->minimal_write_gap
== FLASH_WRITE_CONTINUOUS
705 || addr1
< bank
->base
|| addr1
>= bank
->base
+ bank
->size
706 || addr2
< bank
->base
|| addr2
>= bank
->base
+ bank
->size
)
709 if (bank
->minimal_write_gap
== FLASH_WRITE_GAP_SECTOR
) {
711 uint32_t offset1
= addr1
- bank
->base
;
712 /* find the sector following the one containing addr1 */
713 for (sect
= 0; sect
< bank
->num_sectors
; sect
++) {
714 if (bank
->sectors
[sect
].offset
> offset1
)
717 if (sect
>= bank
->num_sectors
)
720 uint32_t offset2
= addr2
- bank
->base
;
721 return bank
->sectors
[sect
].offset
+ bank
->sectors
[sect
].size
<= offset2
;
724 target_addr_t aligned1
= flash_write_align_end(bank
, addr1
);
725 target_addr_t aligned2
= flash_write_align_start(bank
, addr2
);
726 return aligned1
+ bank
->minimal_write_gap
< aligned2
;
730 int flash_write_unlock_verify(struct target
*target
, struct image
*image
,
731 uint32_t *written
, bool erase
, bool unlock
, bool write
, bool verify
)
733 int retval
= ERROR_OK
;
735 unsigned int section
;
736 uint32_t section_offset
;
737 struct flash_bank
*c
;
747 /* assume all sectors need erasing - stops any problems
748 * when flash_write is called multiple times */
753 /* allocate padding array */
754 padding
= calloc(image
->num_sections
, sizeof(*padding
));
756 /* This fn requires all sections to be in ascending order of addresses,
757 * whereas an image can have sections out of order. */
758 struct imagesection
**sections
= malloc(sizeof(struct imagesection
*) *
759 image
->num_sections
);
761 for (unsigned int i
= 0; i
< image
->num_sections
; i
++)
762 sections
[i
] = &image
->sections
[i
];
764 qsort(sections
, image
->num_sections
, sizeof(struct imagesection
*),
767 /* loop until we reach end of the image */
768 while (section
< image
->num_sections
) {
771 unsigned int section_last
;
772 target_addr_t run_address
= sections
[section
]->base_address
+ section_offset
;
773 uint32_t run_size
= sections
[section
]->size
- section_offset
;
776 if (sections
[section
]->size
== 0) {
777 LOG_WARNING("empty section %d", section
);
783 /* find the corresponding flash bank */
784 retval
= get_flash_bank_by_addr(target
, run_address
, false, &c
);
785 if (retval
!= ERROR_OK
)
788 LOG_WARNING("no flash bank found for address " TARGET_ADDR_FMT
, run_address
);
789 section
++; /* and skip it */
794 /* collect consecutive sections which fall into the same bank */
795 section_last
= section
;
796 padding
[section
] = 0;
797 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1) &&
798 (section_last
+ 1 < image
->num_sections
)) {
799 /* sections are sorted */
800 assert(sections
[section_last
+ 1]->base_address
>= c
->base
);
801 if (sections
[section_last
+ 1]->base_address
>= (c
->base
+ c
->size
)) {
802 /* Done with this bank */
806 /* if we have multiple sections within our image,
807 * flash programming could fail due to alignment issues
808 * attempt to rebuild a consecutive buffer for the flash loader */
809 target_addr_t run_next_addr
= run_address
+ run_size
;
810 target_addr_t next_section_base
= sections
[section_last
+ 1]->base_address
;
811 if (next_section_base
< run_next_addr
) {
812 LOG_ERROR("Section at " TARGET_ADDR_FMT
813 " overlaps section ending at " TARGET_ADDR_FMT
,
814 next_section_base
, run_next_addr
);
815 LOG_ERROR("Flash write aborted.");
820 pad_bytes
= next_section_base
- run_next_addr
;
822 if (flash_write_check_gap(c
, run_next_addr
- 1, next_section_base
)) {
823 LOG_INFO("Flash write discontinued at " TARGET_ADDR_FMT
824 ", next section at " TARGET_ADDR_FMT
,
825 run_next_addr
, next_section_base
);
830 LOG_INFO("Padding image section %d at " TARGET_ADDR_FMT
832 section_last
, run_next_addr
, pad_bytes
);
834 padding
[section_last
] = pad_bytes
;
835 run_size
+= pad_bytes
;
836 run_size
+= sections
[++section_last
]->size
;
839 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1) {
840 /* If we have more than one flash chip back to back, then we limit
841 * the current write operation to the current chip.
843 LOG_DEBUG("Truncate flash run size to the current flash chip.");
845 run_size
= c
->base
+ c
->size
- run_address
;
846 assert(run_size
> 0);
849 uint32_t padding_at_start
= 0;
850 if (c
->write_start_alignment
|| c
->write_end_alignment
) {
851 /* align write region according to bank requirements */
852 target_addr_t aligned_start
= flash_write_align_start(c
, run_address
);
853 padding_at_start
= run_address
- aligned_start
;
854 if (padding_at_start
> 0) {
855 LOG_WARNING("Section start address " TARGET_ADDR_FMT
856 " breaks the required alignment of flash bank %s",
857 run_address
, c
->name
);
858 LOG_WARNING("Padding %" PRIu32
" bytes from " TARGET_ADDR_FMT
,
859 padding_at_start
, aligned_start
);
861 run_address
-= padding_at_start
;
862 run_size
+= padding_at_start
;
865 target_addr_t run_end
= run_address
+ run_size
- 1;
866 target_addr_t aligned_end
= flash_write_align_end(c
, run_end
);
867 pad_bytes
= aligned_end
- run_end
;
869 LOG_INFO("Padding image section %d at " TARGET_ADDR_FMT
870 " with %d bytes (bank write end alignment)",
871 section_last
, run_end
+ 1, pad_bytes
);
873 padding
[section_last
] += pad_bytes
;
874 run_size
+= pad_bytes
;
877 } else if (unlock
|| erase
) {
878 /* If we're applying any sector automagic, then pad this
879 * (maybe-combined) segment to the end of its last sector.
881 uint32_t offset_start
= run_address
- c
->base
;
882 uint32_t offset_end
= offset_start
+ run_size
;
883 uint32_t end
= offset_end
, delta
;
885 for (unsigned int sector
= 0; sector
< c
->num_sectors
; sector
++) {
886 end
= c
->sectors
[sector
].offset
887 + c
->sectors
[sector
].size
;
888 if (offset_end
<= end
)
892 delta
= end
- offset_end
;
893 padding
[section_last
] += delta
;
897 /* allocate buffer */
898 buffer
= malloc(run_size
);
900 LOG_ERROR("Out of memory for flash bank buffer");
905 if (padding_at_start
)
906 memset(buffer
, c
->default_padded_value
, padding_at_start
);
908 buffer_idx
= padding_at_start
;
910 /* read sections to the buffer */
911 while (buffer_idx
< run_size
) {
914 size_read
= run_size
- buffer_idx
;
915 if (size_read
> sections
[section
]->size
- section_offset
)
916 size_read
= sections
[section
]->size
- section_offset
;
920 * #¤%#"%¤% we have to figure out the section # from the sorted
921 * list of pointers to sections to invoke image_read_section()...
923 intptr_t diff
= (intptr_t)sections
[section
] - (intptr_t)image
->sections
;
924 int t_section_num
= diff
/ sizeof(struct imagesection
);
926 LOG_DEBUG("image_read_section: section = %d, t_section_num = %d, "
927 "section_offset = %"PRIu32
", buffer_idx = %"PRIu32
", size_read = %zu",
928 section
, t_section_num
, section_offset
,
929 buffer_idx
, size_read
);
930 retval
= image_read_section(image
, t_section_num
, section_offset
,
931 size_read
, buffer
+ buffer_idx
, &size_read
);
932 if (retval
!= ERROR_OK
|| size_read
== 0) {
937 buffer_idx
+= size_read
;
938 section_offset
+= size_read
;
940 /* see if we need to pad the section */
941 if (padding
[section
]) {
942 memset(buffer
+ buffer_idx
, c
->default_padded_value
, padding
[section
]);
943 buffer_idx
+= padding
[section
];
946 if (section_offset
>= sections
[section
]->size
) {
955 retval
= flash_unlock_address_range(target
, run_address
, run_size
);
956 if (retval
== ERROR_OK
) {
958 /* calculate and erase sectors */
959 retval
= flash_erase_address_range(target
,
960 true, run_address
, run_size
);
964 if (retval
== ERROR_OK
) {
966 /* write flash sectors */
967 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
971 if (retval
== ERROR_OK
) {
973 /* verify flash sectors */
974 retval
= flash_driver_verify(c
, buffer
, run_address
- c
->base
, run_size
);
980 if (retval
!= ERROR_OK
) {
981 /* abort operation */
986 *written
+= run_size
; /* add run size to total written counter */
996 int flash_write(struct target
*target
, struct image
*image
,
997 uint32_t *written
, bool erase
)
999 return flash_write_unlock_verify(target
, image
, written
, erase
, false, true, false);
1002 struct flash_sector
*alloc_block_array(uint32_t offset
, uint32_t size
,
1003 unsigned int num_blocks
)
1005 struct flash_sector
*array
= calloc(num_blocks
, sizeof(struct flash_sector
));
1009 for (unsigned int i
= 0; i
< num_blocks
; i
++) {
1010 array
[i
].offset
= offset
;
1011 array
[i
].size
= size
;
1012 array
[i
].is_erased
= -1;
1013 array
[i
].is_protected
= -1;
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)