1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath <Dominic.Rath@gmx.de> *
3 * Copyright (C) 2007-2010 Øyvind Harboe <oyvind.harboe@zylin.com> *
4 * Copyright (C) 2008 by Spencer Oliver <spen@spen-soft.co.uk> *
5 * Copyright (C) 2009 Zachary T Welch <zw@superlucidity.net> *
6 * Copyright (C) 2010 by Antonio Borneo <borneo.antonio@gmail.com> *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
27 #include <flash/common.h>
28 #include <flash/nor/core.h>
29 #include <flash/nor/imp.h>
30 #include <target/image.h>
35 * Upper level of NOR flash framework.
36 * The lower level interfaces are to drivers. These upper level ones
37 * primarily support access from Tcl scripts or from GDB.
40 static struct flash_bank
*flash_banks
;
42 int flash_driver_erase(struct flash_bank
*bank
, int first
, int last
)
46 retval
= bank
->driver
->erase(bank
, first
, last
);
47 if (retval
!= ERROR_OK
)
49 LOG_ERROR("failed erasing sectors %d to %d", first
, last
);
55 int flash_driver_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
59 /* callers may not supply illegal parameters ... */
60 if (first
< 0 || first
> last
|| last
>= bank
->num_sectors
)
62 LOG_ERROR("illegal sector range");
66 /* force "set" to 0/1 */
71 * We must not use any cached information about protection state!!!!
73 * There are a million things that could change the protect state:
75 * the target could have reset, power cycled, been hot plugged,
76 * the application could have run, etc.
78 * Drivers only receive valid sector range.
80 retval
= bank
->driver
->protect(bank
, set
, first
, last
);
81 if (retval
!= ERROR_OK
)
83 LOG_ERROR("failed setting protection for areas %d to %d", first
, last
);
89 int flash_driver_write(struct flash_bank
*bank
,
90 uint8_t *buffer
, uint32_t offset
, uint32_t count
)
94 retval
= bank
->driver
->write(bank
, buffer
, offset
, count
);
95 if (retval
!= ERROR_OK
)
97 LOG_ERROR("error writing to flash at address 0x%08" PRIx32
" at offset 0x%8.8" PRIx32
,
104 int flash_driver_read(struct flash_bank
*bank
,
105 uint8_t *buffer
, uint32_t offset
, uint32_t count
)
109 LOG_DEBUG("call flash_driver_read()");
111 retval
= bank
->driver
->read(bank
, buffer
, offset
, count
);
112 if (retval
!= ERROR_OK
)
114 LOG_ERROR("error reading to flash at address 0x%08" PRIx32
" 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 void flash_bank_add(struct flash_bank
*bank
)
129 /* put flash bank in linked list */
130 unsigned bank_num
= 0;
133 /* find last flash bank */
134 struct flash_bank
*p
= flash_banks
;
135 while (NULL
!= p
->next
)
146 bank
->bank_number
= bank_num
;
149 struct flash_bank
*flash_bank_list(void)
154 struct flash_bank
*get_flash_bank_by_num_noprobe(int num
)
156 struct flash_bank
*p
;
159 for (p
= flash_banks
; p
; p
= p
->next
)
166 LOG_ERROR("flash bank %d does not exist", num
);
170 int flash_get_bank_count(void)
172 struct flash_bank
*p
;
174 for (p
= flash_banks
; p
; p
= p
->next
)
181 struct flash_bank
*get_flash_bank_by_name_noprobe(const char *name
)
183 unsigned requested
= get_flash_name_index(name
);
186 struct flash_bank
*bank
;
187 for (bank
= flash_banks
; NULL
!= bank
; bank
= bank
->next
)
189 if (strcmp(bank
->name
, name
) == 0)
191 if (!flash_driver_name_matches(bank
->driver
->name
, name
))
193 if (++found
< requested
)
200 int get_flash_bank_by_name(const char *name
, struct flash_bank
**bank_result
)
202 struct flash_bank
*bank
;
205 bank
= get_flash_bank_by_name_noprobe(name
);
208 retval
= bank
->driver
->auto_probe(bank
);
210 if (retval
!= ERROR_OK
)
212 LOG_ERROR("auto_probe failed");
221 int get_flash_bank_by_num(int num
, struct flash_bank
**bank
)
223 struct flash_bank
*p
= get_flash_bank_by_num_noprobe(num
);
231 retval
= p
->driver
->auto_probe(p
);
233 if (retval
!= ERROR_OK
)
235 LOG_ERROR("auto_probe failed");
242 /* lookup flash bank by address, bank not found is success, but
243 * result_bank is set to NULL. */
244 int get_flash_bank_by_addr(struct target
*target
, uint32_t addr
, bool check
, struct flash_bank
**result_bank
)
246 struct flash_bank
*c
;
248 /* cycle through bank list */
249 for (c
= flash_banks
; c
; c
= c
->next
)
252 retval
= c
->driver
->auto_probe(c
);
254 if (retval
!= ERROR_OK
)
256 LOG_ERROR("auto_probe failed");
259 /* check whether address belongs to this flash bank */
260 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
269 LOG_ERROR("No flash at address 0x%08" PRIx32
, addr
);
275 int default_flash_mem_blank_check(struct flash_bank
*bank
)
277 struct target
*target
= bank
->target
;
278 const int buffer_size
= 1024;
281 int retval
= ERROR_OK
;
283 if (bank
->target
->state
!= TARGET_HALTED
)
285 LOG_ERROR("Target not halted");
286 return ERROR_TARGET_NOT_HALTED
;
289 uint8_t *buffer
= malloc(buffer_size
);
291 for (i
= 0; i
< bank
->num_sectors
; i
++)
294 bank
->sectors
[i
].is_erased
= 1;
296 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
300 if (chunk
> (j
- bank
->sectors
[i
].size
))
302 chunk
= (j
- bank
->sectors
[i
].size
);
305 retval
= target_read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
306 if (retval
!= ERROR_OK
)
311 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
313 if (buffer
[nBytes
] != 0xFF)
315 bank
->sectors
[i
].is_erased
= 0;
328 int default_flash_blank_check(struct flash_bank
*bank
)
330 struct target
*target
= bank
->target
;
336 if (bank
->target
->state
!= TARGET_HALTED
)
338 LOG_ERROR("Target not halted");
339 return ERROR_TARGET_NOT_HALTED
;
342 for (i
= 0; i
< bank
->num_sectors
; i
++)
344 uint32_t address
= bank
->base
+ bank
->sectors
[i
].offset
;
345 uint32_t size
= bank
->sectors
[i
].size
;
347 retval
= target_blank_check_memory(target
, address
, size
, &blank
);
348 if (retval
!= ERROR_OK
)
354 bank
->sectors
[i
].is_erased
= 1;
356 bank
->sectors
[i
].is_erased
= 0;
362 LOG_USER("Running slow fallback erase check - add working memory");
363 return default_flash_mem_blank_check(bank
);
369 /* Manipulate given flash region, selecting the bank according to target
370 * and address. Maps an address range to a set of sectors, and issues
371 * the callback() on that set ... e.g. to erase or unprotect its members.
373 * (Note a current bad assumption: that protection operates on the same
374 * size sectors as erase operations use.)
376 * The "pad_reason" parameter is a kind of boolean: when it's NULL, the
377 * range must fit those sectors exactly. This is clearly safe; it can't
378 * erase data which the caller said to leave alone, for example. If it's
379 * non-NULL, rather than failing, extra data in the first and/or last
380 * sectors will be added to the range, and that reason string is used when
381 * warning about those additions.
383 static int flash_iterate_address_range_inner(struct target
*target
,
384 char *pad_reason
, uint32_t addr
, uint32_t length
,
385 int (*callback
)(struct flash_bank
*bank
, int first
, int last
))
387 struct flash_bank
*c
;
388 uint32_t last_addr
= addr
+ length
; /* first address AFTER end */
393 int retval
= get_flash_bank_by_addr(target
, addr
, true, &c
);
394 if (retval
!= ERROR_OK
)
397 if (c
->size
== 0 || c
->num_sectors
== 0)
399 LOG_ERROR("Bank is invalid");
400 return ERROR_FLASH_BANK_INVALID
;
405 /* special case, erase whole bank when length is zero */
408 LOG_ERROR("Whole bank access must start at beginning of bank.");
409 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
412 return callback(c
, 0, c
->num_sectors
- 1);
415 /* check whether it all fits in this bank */
416 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
418 LOG_ERROR("Flash access does not fit into bank.");
419 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
422 /** @todo: handle erasures that cross into adjacent banks */
425 last_addr
-= c
->base
;
427 for (i
= 0; i
< c
->num_sectors
; i
++)
429 struct flash_sector
*f
= c
->sectors
+ i
;
430 uint32_t end
= f
->offset
+ f
->size
;
432 /* start only on a sector boundary */
434 /* scanned past the first sector? */
435 if (addr
< f
->offset
)
438 /* is this the first sector? */
439 if (addr
== f
->offset
)
442 /* Does this need head-padding? If so, pad and warn;
443 * or else force an error.
445 * Such padding can make trouble, since *WE* can't
446 * ever know if that data was in use. The warning
447 * should help users sort out messes later.
449 else if (addr
< end
&& pad_reason
) {
450 /* FIXME say how many bytes (e.g. 80 KB) */
451 LOG_WARNING("Adding extra %s range, "
454 (unsigned) f
->offset
,
455 (unsigned) addr
- 1);
461 /* is this (also?) the last sector? */
462 if (last_addr
== end
) {
467 /* Does this need tail-padding? If so, pad and warn;
468 * or else force an error.
470 if (last_addr
< end
&& pad_reason
) {
471 /* FIXME say how many bytes (e.g. 80 KB) */
472 LOG_WARNING("Adding extra %s range, "
475 (unsigned) last_addr
,
481 /* MUST finish on a sector boundary */
482 if (last_addr
<= f
->offset
)
486 /* invalid start or end address? */
487 if (first
== -1 || last
== -1) {
488 LOG_ERROR("address range 0x%8.8x .. 0x%8.8x "
489 "is not sector-aligned",
490 (unsigned) (c
->base
+ addr
),
491 (unsigned) (c
->base
+ last_addr
- 1));
492 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
495 /* The NOR driver may trim this range down, based on what
496 * sectors are already erased/unprotected. GDB currently
497 * blocks such optimizations.
499 return callback(c
, first
, last
);
502 /* The inner fn only handles a single bank, we could be spanning
505 static int flash_iterate_address_range(struct target
*target
,
506 char *pad_reason
, uint32_t addr
, uint32_t length
,
507 int (*callback
)(struct flash_bank
*bank
, int first
, int last
))
509 struct flash_bank
*c
;
510 int retval
= ERROR_OK
;
512 /* Danger! zero-length iterations means entire bank! */
515 retval
= get_flash_bank_by_addr(target
, addr
, true, &c
);
516 if (retval
!= ERROR_OK
)
519 uint32_t cur_length
= length
;
520 /* check whether it all fits in this bank */
521 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
523 LOG_DEBUG("iterating over more than one flash bank.");
524 cur_length
= c
->base
+ c
->size
- addr
;
526 retval
= flash_iterate_address_range_inner(target
,
527 pad_reason
, addr
, cur_length
,
529 if (retval
!= ERROR_OK
)
532 length
-= cur_length
;
534 } while (length
> 0);
539 int flash_erase_address_range(struct target
*target
,
540 bool pad
, uint32_t addr
, uint32_t length
)
542 return flash_iterate_address_range(target
, pad
? "erase" : NULL
,
543 addr
, length
, &flash_driver_erase
);
546 static int flash_driver_unprotect(struct flash_bank
*bank
, int first
, int last
)
548 return flash_driver_protect(bank
, 0, first
, last
);
551 int flash_unlock_address_range(struct target
*target
, uint32_t addr
, uint32_t length
)
553 /* By default, pad to sector boundaries ... the real issue here
554 * is that our (only) caller *permanently* removes protection,
555 * and doesn't restore it.
557 return flash_iterate_address_range(target
, "unprotect",
558 addr
, length
, &flash_driver_unprotect
);
561 static int compare_section (const void * a
, const void * b
)
563 struct imagesection
*b1
, *b2
;
564 b1
=*((struct imagesection
**)a
);
565 b2
=*((struct imagesection
**)b
);
567 if (b1
->base_address
== b2
->base_address
)
570 } else if (b1
->base_address
> b2
->base_address
)
580 int flash_write_unlock(struct target
*target
, struct image
*image
,
581 uint32_t *written
, int erase
, bool unlock
)
583 int retval
= ERROR_OK
;
586 uint32_t section_offset
;
587 struct flash_bank
*c
;
598 /* assume all sectors need erasing - stops any problems
599 * when flash_write is called multiple times */
604 /* allocate padding array */
605 padding
= calloc(image
->num_sections
, sizeof(*padding
));
607 /* This fn requires all sections to be in ascending order of addresses,
608 * whereas an image can have sections out of order. */
609 struct imagesection
**sections
= malloc(sizeof(struct imagesection
*) *
610 image
->num_sections
);
612 for (i
= 0; i
< image
->num_sections
; i
++)
614 sections
[i
] = &image
->sections
[i
];
617 qsort(sections
, image
->num_sections
, sizeof(struct imagesection
*),
620 /* loop until we reach end of the image */
621 while (section
< image
->num_sections
)
623 uint32_t buffer_size
;
626 uint32_t run_address
= sections
[section
]->base_address
+ section_offset
;
627 uint32_t run_size
= sections
[section
]->size
- section_offset
;
630 if (sections
[section
]->size
== 0)
632 LOG_WARNING("empty section %d", section
);
638 /* find the corresponding flash bank */
639 retval
= get_flash_bank_by_addr(target
, run_address
, false, &c
);
640 if (retval
!= ERROR_OK
)
646 section
++; /* and skip it */
651 /* collect consecutive sections which fall into the same bank */
652 section_last
= section
;
653 padding
[section
] = 0;
654 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
655 && (section_last
+ 1 < image
->num_sections
))
657 /* sections are sorted */
658 assert(sections
[section_last
+ 1]->base_address
>= c
->base
);
659 if (sections
[section_last
+ 1]->base_address
>= (c
->base
+ c
->size
))
661 /* Done with this bank */
665 /* FIXME This needlessly touches sectors BETWEEN the
666 * sections it's writing. Without auto erase, it just
667 * writes ones. That WILL INVALIDATE data in cases
668 * like Stellaris Tempest chips, corrupting internal
669 * ECC codes; and at least FreeScale suggests issues
670 * with that approach (in HC11 documentation).
672 * With auto erase enabled, data in those sectors will
673 * be needlessly destroyed; and some of the limited
674 * number of flash erase cycles will be wasted...
676 * In both cases, the extra writes slow things down.
679 /* if we have multiple sections within our image,
680 * flash programming could fail due to alignment issues
681 * attempt to rebuild a consecutive buffer for the flash loader */
682 pad_bytes
= (sections
[section_last
+ 1]->base_address
) - (run_address
+ run_size
);
683 padding
[section_last
] = pad_bytes
;
684 run_size
+= sections
[++section_last
]->size
;
685 run_size
+= pad_bytes
;
688 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
691 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
693 /* If we have more than one flash chip back to back, then we limit
694 * the current write operation to the current chip.
696 LOG_DEBUG("Truncate flash run size to the current flash chip.");
698 run_size
= c
->base
+ c
->size
- run_address
;
699 assert(run_size
> 0);
702 /* If we're applying any sector automagic, then pad this
703 * (maybe-combined) segment to the end of its last sector.
705 if (unlock
|| erase
) {
707 uint32_t offset_start
= run_address
- c
->base
;
708 uint32_t offset_end
= offset_start
+ run_size
;
709 uint32_t end
= offset_end
, delta
;
711 for (sector
= 0; sector
< c
->num_sectors
; sector
++) {
712 end
= c
->sectors
[sector
].offset
713 + c
->sectors
[sector
].size
;
714 if (offset_end
<= end
)
718 delta
= end
- offset_end
;
719 padding
[section_last
] += delta
;
723 /* allocate buffer */
724 buffer
= malloc(run_size
);
727 LOG_ERROR("Out of memory for flash bank buffer");
733 /* read sections to the buffer */
734 while (buffer_size
< run_size
)
738 size_read
= run_size
- buffer_size
;
739 if (size_read
> sections
[section
]->size
- section_offset
)
740 size_read
= sections
[section
]->size
- section_offset
;
744 * #¤%#"%¤% we have to figure out the section # from the sorted
745 * list of pointers to sections to invoke image_read_section()...
747 intptr_t diff
= (intptr_t)sections
[section
] - (intptr_t)image
->sections
;
748 int t_section_num
= diff
/ sizeof(struct imagesection
);
750 LOG_DEBUG("image_read_section: section = %d, t_section_num = %d, section_offset = %d, buffer_size = %d, size_read = %d",
752 (int)t_section_num
, (int)section_offset
, (int)buffer_size
, (int)size_read
);
753 if ((retval
= image_read_section(image
, t_section_num
, section_offset
,
754 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
760 /* see if we need to pad the section */
761 while (padding
[section
]--)
762 (buffer
+ buffer_size
)[size_read
++] = 0xff;
764 buffer_size
+= size_read
;
765 section_offset
+= size_read
;
767 if (section_offset
>= sections
[section
]->size
)
778 retval
= flash_unlock_address_range(target
, run_address
, run_size
);
780 if (retval
== ERROR_OK
)
784 /* calculate and erase sectors */
785 retval
= flash_erase_address_range(target
,
786 true, run_address
, run_size
);
790 if (retval
== ERROR_OK
)
792 /* write flash sectors */
793 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
798 if (retval
!= ERROR_OK
)
800 /* abort operation */
805 *written
+= run_size
; /* add run size to total written counter */
816 int flash_write(struct target
*target
, struct image
*image
,
817 uint32_t *written
, int erase
)
819 return flash_write_unlock(target
, image
, written
, erase
, false);
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)