1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath <Dominic.Rath@gmx.de> *
3 * Copyright (C) 2007,2008 Ø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> *
7 * This program is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation; either version 2 of the License, or *
10 * (at your option) any later version. *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
17 * You should have received a copy of the GNU General Public License *
18 * along with this program; if not, write to the *
19 * Free Software Foundation, Inc., *
20 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
21 ***************************************************************************/
26 #include <flash/common.h>
27 #include <flash/nor/core.h>
28 #include <flash/nor/imp.h>
29 #include <target/image.h>
34 * Upper level of NOR flash framework.
35 * The lower level interfaces are to drivers. These upper level ones
36 * primarily support access from Tcl scripts or from GDB.
39 static struct flash_bank
*flash_banks
;
41 int flash_driver_erase(struct flash_bank
*bank
, int first
, int last
)
45 retval
= bank
->driver
->erase(bank
, first
, last
);
46 if (retval
!= ERROR_OK
)
48 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
54 int flash_driver_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
59 /* NOTE: "first == last" means (un?)protect just that sector.
60 code including Lower level ddrivers may rely on this "first <= last"
64 /* callers may not supply illegal parameters ... */
65 if (first
< 0 || first
> last
|| last
>= bank
->num_sectors
)
68 /* force "set" to 0/1 */
72 * Filter out what trivial nonsense we can, so drivers don't have to.
74 * Don't tell drivers to change to the current state... it's needless,
75 * and reducing the amount of work to be done (potentially to nothing)
76 * speeds at least some things up.
79 for (int i
= first
; i
<= last
; i
++) {
80 struct flash_sector
*sector
= bank
->sectors
+ i
;
82 /* Only filter requests to protect the already-protected, or
83 * to unprotect the already-unprotected. Changing from the
84 * unknown state (-1) to a known one is unwise but allowed;
85 * protection status is best checked first.
87 if (sector
->is_protected
!= set
)
90 /* Shrink this range of sectors from the start; don't overrun
91 * the end. Also shrink from the end; don't overun the start.
93 * REVISIT we could handle discontiguous regions by issuing
94 * more than one driver request. How much would that matter?
96 if (i
== first
&& i
!= last
) {
99 } else if (i
== last
&& i
!= first
) {
105 /* updating the range affects the tests in the scan loop above; so
106 * re-scan, to make sure we didn't miss anything.
113 /* Single sector, already protected? Nothing to do!
114 * We may have trimmed our parameters into this degenerate case.
116 * FIXME repeating the "is_protected==set" test is a giveaway that
117 * this fast-exit belongs earlier, in the trim-it-down loop; mve.
119 if (first
== last
&& bank
->sectors
[first
].is_protected
== set
)
123 /* Note that we don't pass illegal parameters to drivers; any
124 * trimming just turns one valid range into another one.
126 retval
= bank
->driver
->protect(bank
, set
, first
, last
);
127 if (retval
!= ERROR_OK
)
129 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
135 int flash_driver_write(struct flash_bank
*bank
,
136 uint8_t *buffer
, uint32_t offset
, uint32_t count
)
140 retval
= bank
->driver
->write(bank
, buffer
, offset
, count
);
141 if (retval
!= ERROR_OK
)
143 LOG_ERROR("error writing to flash at address 0x%08" PRIx32
" at offset 0x%8.8" PRIx32
" (%d)",
144 bank
->base
, offset
, retval
);
150 void flash_bank_add(struct flash_bank
*bank
)
152 /* put flash bank in linked list */
153 unsigned bank_num
= 0;
156 /* find last flash bank */
157 struct flash_bank
*p
= flash_banks
;
158 while (NULL
!= p
->next
)
169 bank
->bank_number
= bank_num
;
172 struct flash_bank
*flash_bank_list(void)
177 struct flash_bank
*get_flash_bank_by_num_noprobe(int num
)
179 struct flash_bank
*p
;
182 for (p
= flash_banks
; p
; p
= p
->next
)
189 LOG_ERROR("flash bank %d does not exist", num
);
193 int flash_get_bank_count(void)
195 struct flash_bank
*p
;
197 for (p
= flash_banks
; p
; p
= p
->next
)
204 struct flash_bank
*get_flash_bank_by_name(const char *name
)
206 unsigned requested
= get_flash_name_index(name
);
209 struct flash_bank
*bank
;
210 for (bank
= flash_banks
; NULL
!= bank
; bank
= bank
->next
)
212 if (strcmp(bank
->name
, name
) == 0)
214 if (!flash_driver_name_matches(bank
->driver
->name
, name
))
216 if (++found
< requested
)
223 struct flash_bank
*get_flash_bank_by_num(int num
)
225 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 %d\n", retval
);
241 /* lookup flash bank by address */
242 struct flash_bank
*get_flash_bank_by_addr(struct target
*target
, uint32_t addr
)
244 struct flash_bank
*c
;
246 /* cycle through bank list */
247 for (c
= flash_banks
; c
; c
= c
->next
)
250 retval
= c
->driver
->auto_probe(c
);
252 if (retval
!= ERROR_OK
)
254 LOG_ERROR("auto_probe failed %d\n", retval
);
257 /* check whether address belongs to this flash bank */
258 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
261 LOG_ERROR("No flash at address 0x%08" PRIx32
"\n", addr
);
265 int default_flash_mem_blank_check(struct flash_bank
*bank
)
267 struct target
*target
= bank
->target
;
268 const int buffer_size
= 1024;
271 int retval
= ERROR_OK
;
273 if (bank
->target
->state
!= TARGET_HALTED
)
275 LOG_ERROR("Target not halted");
276 return ERROR_TARGET_NOT_HALTED
;
279 uint8_t *buffer
= malloc(buffer_size
);
281 for (i
= 0; i
< bank
->num_sectors
; i
++)
284 bank
->sectors
[i
].is_erased
= 1;
286 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
290 if (chunk
> (j
- bank
->sectors
[i
].size
))
292 chunk
= (j
- bank
->sectors
[i
].size
);
295 retval
= target_read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
296 if (retval
!= ERROR_OK
)
301 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
303 if (buffer
[nBytes
] != 0xFF)
305 bank
->sectors
[i
].is_erased
= 0;
318 int default_flash_blank_check(struct flash_bank
*bank
)
320 struct target
*target
= bank
->target
;
326 if (bank
->target
->state
!= TARGET_HALTED
)
328 LOG_ERROR("Target not halted");
329 return ERROR_TARGET_NOT_HALTED
;
332 for (i
= 0; i
< bank
->num_sectors
; i
++)
334 uint32_t address
= bank
->base
+ bank
->sectors
[i
].offset
;
335 uint32_t size
= bank
->sectors
[i
].size
;
337 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
343 bank
->sectors
[i
].is_erased
= 1;
345 bank
->sectors
[i
].is_erased
= 0;
351 LOG_USER("Running slow fallback erase check - add working memory");
352 return default_flash_mem_blank_check(bank
);
358 /* Manipulate given flash region, selecting the bank according to target
359 * and address. Maps an address range to a set of sectors, and issues
360 * the callback() on that set ... e.g. to erase or unprotect its members.
362 * (Note a current bad assumption: that protection operates on the same
363 * size sectors as erase operations use.)
365 * The "pad_reason" parameter is a kind of boolean: when it's NULL, the
366 * range must fit those sectors exactly. This is clearly safe; it can't
367 * erase data which the caller said to leave alone, for example. If it's
368 * non-NULL, rather than failing, extra data in the first and/or last
369 * sectors will be added to the range, and that reason string is used when
370 * warning about those additions.
372 static int flash_iterate_address_range(struct target
*target
,
373 char *pad_reason
, uint32_t addr
, uint32_t length
,
374 int (*callback
)(struct flash_bank
*bank
, int first
, int last
))
376 struct flash_bank
*c
;
377 uint32_t last_addr
= addr
+ length
; /* first address AFTER end */
382 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
383 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
385 if (c
->size
== 0 || c
->num_sectors
== 0)
387 LOG_ERROR("Bank is invalid");
388 return ERROR_FLASH_BANK_INVALID
;
393 /* special case, erase whole bank when length is zero */
396 LOG_ERROR("Whole bank access must start at beginning of bank.");
397 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
400 return callback(c
, 0, c
->num_sectors
- 1);
403 /* check whether it all fits in this bank */
404 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
406 LOG_ERROR("Flash access does not fit into bank.");
407 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
410 /** @todo: handle erasures that cross into adjacent banks */
413 last_addr
-= c
->base
;
415 for (i
= 0; i
< c
->num_sectors
; i
++)
417 struct flash_sector
*f
= c
->sectors
+ i
;
418 uint32_t end
= f
->offset
+ f
->size
;
420 /* start only on a sector boundary */
422 /* scanned past the first sector? */
423 if (addr
< f
->offset
)
426 /* is this the first sector? */
427 if (addr
== f
->offset
)
430 /* Does this need head-padding? If so, pad and warn;
431 * or else force an error.
433 * Such padding can make trouble, since *WE* can't
434 * ever know if that data was in use. The warning
435 * should help users sort out messes later.
437 else if (addr
< end
&& pad_reason
) {
438 /* FIXME say how many bytes (e.g. 80 KB) */
439 LOG_WARNING("Adding extra %s range, "
442 (unsigned) f
->offset
,
443 (unsigned) addr
- 1);
449 /* is this (also?) the last sector? */
450 if (last_addr
== end
) {
455 /* Does this need tail-padding? If so, pad and warn;
456 * or else force an error.
458 if (last_addr
< end
&& pad_reason
) {
459 /* FIXME say how many bytes (e.g. 80 KB) */
460 LOG_WARNING("Adding extra %s range, "
463 (unsigned) last_addr
,
469 /* MUST finish on a sector boundary */
470 if (last_addr
<= f
->offset
)
474 /* invalid start or end address? */
475 if (first
== -1 || last
== -1) {
476 LOG_ERROR("address range 0x%8.8x .. 0x%8.8x "
477 "is not sector-aligned",
478 (unsigned) (c
->base
+ addr
),
479 (unsigned) (c
->base
+ last_addr
- 1));
480 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
483 /* The NOR driver may trim this range down, based on what
484 * sectors are already erased/unprotected. GDB currently
485 * blocks such optimizations.
487 return callback(c
, first
, last
);
490 int flash_erase_address_range(struct target
*target
,
491 bool pad
, uint32_t addr
, uint32_t length
)
493 return flash_iterate_address_range(target
, pad
? "erase" : NULL
,
494 addr
, length
, &flash_driver_erase
);
497 static int flash_driver_unprotect(struct flash_bank
*bank
, int first
, int last
)
499 return flash_driver_protect(bank
, 0, first
, last
);
502 static int flash_unlock_address_range(struct target
*target
, uint32_t addr
, uint32_t length
)
504 /* By default, pad to sector boundaries ... the real issue here
505 * is that our (only) caller *permanently* removes protection,
506 * and doesn't restore it.
508 return flash_iterate_address_range(target
, "unprotect",
509 addr
, length
, &flash_driver_unprotect
);
512 int flash_write_unlock(struct target
*target
, struct image
*image
,
513 uint32_t *written
, int erase
, bool unlock
)
515 int retval
= ERROR_OK
;
518 uint32_t section_offset
;
519 struct flash_bank
*c
;
522 /* REVISIT do_pad should perhaps just be another parameter.
523 * GDB wouldn't ever need it, since it erases separately.
524 * But "flash write_image" commands might want that option.
536 /* assume all sectors need erasing - stops any problems
537 * when flash_write is called multiple times */
542 /* allocate padding array */
543 padding
= calloc(image
->num_sections
, sizeof(*padding
));
545 /* loop until we reach end of the image */
546 while (section
< image
->num_sections
)
548 uint32_t buffer_size
;
552 uint32_t run_address
= image
->sections
[section
].base_address
+ section_offset
;
553 uint32_t run_size
= image
->sections
[section
].size
- section_offset
;
556 if (image
->sections
[section
].size
== 0)
558 LOG_WARNING("empty section %d", section
);
564 /* find the corresponding flash bank */
565 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
567 section
++; /* and skip it */
572 /* collect consecutive sections which fall into the same bank */
573 section_first
= section
;
574 section_last
= section
;
575 padding
[section
] = 0;
576 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
577 && (section_last
+ 1 < image
->num_sections
))
579 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
581 LOG_DEBUG("section %d out of order "
582 "(surprising, but supported)",
584 /* REVISIT this can break with autoerase ...
585 * clobbering data after it's written.
590 /* FIXME This needlessly touches sectors BETWEEN the
591 * sections it's writing. Without auto erase, it just
592 * writes ones. That WILL INVALIDATE data in cases
593 * like Stellaris Tempest chips, corrupting internal
594 * ECC codes; and at least FreeScale suggests issues
595 * with that approach (in HC11 documentation).
597 * With auto erase enabled, data in those sectors will
598 * be needlessly destroyed; and some of the limited
599 * number of flash erase cycles will be wasted...
601 * In both cases, the extra writes slow things down.
604 /* if we have multiple sections within our image,
605 * flash programming could fail due to alignment issues
606 * attempt to rebuild a consecutive buffer for the flash loader */
607 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
608 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
610 padding
[section_last
] = pad_bytes
;
611 run_size
+= image
->sections
[++section_last
].size
;
612 run_size
+= pad_bytes
;
614 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
617 /* fit the run into bank constraints */
618 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
620 /* REVISIT isn't this superfluous, given the while()
621 * loop conditions above??
623 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
624 (int)(c
->base
+ c
->size
- run_address
), (int)(run_size
), (int)(c
->size
));
625 run_size
= c
->base
+ c
->size
- run_address
;
628 /* If we're applying any sector automagic, then pad this
629 * (maybe-combined) segment to the end of its last sector.
631 if (unlock
|| erase
) {
633 uint32_t offset_start
= run_address
- c
->base
;
634 uint32_t offset_end
= offset_start
+ run_size
;
635 uint32_t end
= offset_end
, delta
;
637 for (sector
= 0; sector
< c
->num_sectors
; sector
++) {
638 end
= c
->sectors
[sector
].offset
639 + c
->sectors
[sector
].size
;
640 if (offset_end
<= end
)
644 delta
= end
- offset_end
;
645 padding
[section_last
] += delta
;
649 /* allocate buffer */
650 buffer
= malloc(run_size
);
653 /* read sections to the buffer */
654 while (buffer_size
< run_size
)
658 size_read
= run_size
- buffer_size
;
659 if (size_read
> image
->sections
[section
].size
- section_offset
)
660 size_read
= image
->sections
[section
].size
- section_offset
;
662 if ((retval
= image_read_section(image
, section
, section_offset
,
663 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
670 /* see if we need to pad the section */
671 while (padding
[section
]--)
672 (buffer
+ buffer_size
)[size_read
++] = 0xff;
674 buffer_size
+= size_read
;
675 section_offset
+= size_read
;
677 if (section_offset
>= image
->sections
[section
].size
)
688 retval
= flash_unlock_address_range(target
, run_address
, run_size
);
690 if (retval
== ERROR_OK
)
694 /* calculate and erase sectors */
695 retval
= flash_erase_address_range(target
,
696 do_pad
, run_address
, run_size
);
700 if (retval
== ERROR_OK
)
702 /* write flash sectors */
703 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
708 if (retval
!= ERROR_OK
)
711 return retval
; /* abort operation */
715 *written
+= run_size
; /* add run size to total written counter */
723 int flash_write(struct target
*target
, struct image
*image
,
724 uint32_t *written
, int erase
)
726 return flash_write_unlock(target
, image
, written
, erase
, false);
730 * Invalidates cached flash state which a target can change as it runs.
732 * @param target The target being resumed
734 * OpenOCD caches some flash state for brief periods. For example, a sector
735 * that is protected must be unprotected before OpenOCD tries to write it,
736 * Also, a sector that's not erased must be erased before it's written.
738 * As a rule, OpenOCD and target firmware can both modify the flash, so when
739 * a target starts running, OpenOCD needs to invalidate its cached state.
741 void nor_resume(struct target
*target
)
743 struct flash_bank
*bank
;
745 for (bank
= flash_banks
; bank
; bank
= bank
->next
) {
748 if (bank
->target
!= target
)
751 for (i
= 0; i
< bank
->num_sectors
; i
++) {
752 struct flash_sector
*sector
= bank
->sectors
+ i
;
754 sector
->is_erased
= -1;
755 sector
->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)