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> *
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
;
530 /* assume all sectors need erasing - stops any problems
531 * when flash_write is called multiple times */
536 /* allocate padding array */
537 padding
= calloc(image
->num_sections
, sizeof(*padding
));
539 /* loop until we reach end of the image */
540 while (section
< image
->num_sections
)
542 uint32_t buffer_size
;
546 uint32_t run_address
= image
->sections
[section
].base_address
+ section_offset
;
547 uint32_t run_size
= image
->sections
[section
].size
- section_offset
;
550 if (image
->sections
[section
].size
== 0)
552 LOG_WARNING("empty section %d", section
);
558 /* find the corresponding flash bank */
559 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
561 section
++; /* and skip it */
566 /* collect consecutive sections which fall into the same bank */
567 section_first
= section
;
568 section_last
= section
;
569 padding
[section
] = 0;
570 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
571 && (section_last
+ 1 < image
->num_sections
))
573 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
575 LOG_DEBUG("section %d out of order "
576 "(surprising, but supported)",
578 /* REVISIT this can break with autoerase ...
579 * clobbering data after it's written.
584 /* FIXME This needlessly touches sectors BETWEEN the
585 * sections it's writing. Without auto erase, it just
586 * writes ones. That WILL INVALIDATE data in cases
587 * like Stellaris Tempest chips, corrupting internal
588 * ECC codes; and at least FreeScale suggests issues
589 * with that approach (in HC11 documentation).
591 * With auto erase enabled, data in those sectors will
592 * be needlessly destroyed; and some of the limited
593 * number of flash erase cycles will be wasted...
595 * In both cases, the extra writes slow things down.
598 /* if we have multiple sections within our image,
599 * flash programming could fail due to alignment issues
600 * attempt to rebuild a consecutive buffer for the flash loader */
601 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
602 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
604 padding
[section_last
] = pad_bytes
;
605 run_size
+= image
->sections
[++section_last
].size
;
606 run_size
+= pad_bytes
;
609 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
612 /* fit the run into bank constraints */
613 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
615 /* REVISIT isn't this superfluous, given the while()
616 * loop conditions above??
618 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
619 (int)(c
->base
+ c
->size
- run_address
), (int)(run_size
), (int)(c
->size
));
620 run_size
= c
->base
+ c
->size
- run_address
;
623 /* If we're applying any sector automagic, then pad this
624 * (maybe-combined) segment to the end of its last sector.
626 if (unlock
|| erase
) {
628 uint32_t offset_start
= run_address
- c
->base
;
629 uint32_t offset_end
= offset_start
+ run_size
;
630 uint32_t end
= offset_end
, delta
;
632 for (sector
= 0; sector
< c
->num_sectors
; sector
++) {
633 end
= c
->sectors
[sector
].offset
634 + c
->sectors
[sector
].size
;
635 if (offset_end
<= end
)
639 delta
= end
- offset_end
;
640 padding
[section_last
] += delta
;
644 /* allocate buffer */
645 buffer
= malloc(run_size
);
648 /* read sections to the buffer */
649 while (buffer_size
< run_size
)
653 size_read
= run_size
- buffer_size
;
654 if (size_read
> image
->sections
[section
].size
- section_offset
)
655 size_read
= image
->sections
[section
].size
- section_offset
;
657 if ((retval
= image_read_section(image
, section
, section_offset
,
658 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
665 /* see if we need to pad the section */
666 while (padding
[section
]--)
667 (buffer
+ buffer_size
)[size_read
++] = 0xff;
669 buffer_size
+= size_read
;
670 section_offset
+= size_read
;
672 if (section_offset
>= image
->sections
[section
].size
)
683 retval
= flash_unlock_address_range(target
, run_address
, run_size
);
685 if (retval
== ERROR_OK
)
689 /* calculate and erase sectors */
690 retval
= flash_erase_address_range(target
,
691 true, run_address
, run_size
);
695 if (retval
== ERROR_OK
)
697 /* write flash sectors */
698 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
703 if (retval
!= ERROR_OK
)
706 return retval
; /* abort operation */
710 *written
+= run_size
; /* add run size to total written counter */
718 int flash_write(struct target
*target
, struct image
*image
,
719 uint32_t *written
, int erase
)
721 return flash_write_unlock(target
, image
, written
, erase
, false);
725 * Invalidates cached flash state which a target can change as it runs.
727 * @param target The target being resumed
729 * OpenOCD caches some flash state for brief periods. For example, a sector
730 * that is protected must be unprotected before OpenOCD tries to write it,
731 * Also, a sector that's not erased must be erased before it's written.
733 * As a rule, OpenOCD and target firmware can both modify the flash, so when
734 * a target starts running, OpenOCD needs to invalidate its cached state.
736 void nor_resume(struct target
*target
)
738 struct flash_bank
*bank
;
740 for (bank
= flash_banks
; bank
; bank
= bank
->next
) {
743 if (bank
->target
!= target
)
746 for (i
= 0; i
< bank
->num_sectors
; i
++) {
747 struct flash_sector
*sector
= bank
->sectors
+ i
;
749 sector
->is_erased
= -1;
750 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)