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 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
)
58 retval
= bank
->driver
->protect(bank
, set
, first
, last
);
59 if (retval
!= ERROR_OK
)
61 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
67 int flash_driver_write(struct flash_bank
*bank
,
68 uint8_t *buffer
, uint32_t offset
, uint32_t count
)
72 retval
= bank
->driver
->write(bank
, buffer
, offset
, count
);
73 if (retval
!= ERROR_OK
)
75 LOG_ERROR("error writing to flash at address 0x%08" PRIx32
" at offset 0x%8.8" PRIx32
" (%d)",
76 bank
->base
, offset
, retval
);
82 void flash_bank_add(struct flash_bank
*bank
)
84 /* put flash bank in linked list */
85 unsigned bank_num
= 0;
88 /* find last flash bank */
89 struct flash_bank
*p
= flash_banks
;
90 while (NULL
!= p
->next
)
101 bank
->bank_number
= bank_num
;
104 struct flash_bank
*flash_bank_list(void)
109 struct flash_bank
*get_flash_bank_by_num_noprobe(int num
)
111 struct flash_bank
*p
;
114 for (p
= flash_banks
; p
; p
= p
->next
)
121 LOG_ERROR("flash bank %d does not exist", num
);
125 int flash_get_bank_count(void)
127 struct flash_bank
*p
;
129 for (p
= flash_banks
; p
; p
= p
->next
)
136 struct flash_bank
*get_flash_bank_by_name(const char *name
)
138 unsigned requested
= get_flash_name_index(name
);
141 struct flash_bank
*bank
;
142 for (bank
= flash_banks
; NULL
!= bank
; bank
= bank
->next
)
144 if (strcmp(bank
->name
, name
) == 0)
146 if (!flash_driver_name_matches(bank
->driver
->name
, name
))
148 if (++found
< requested
)
155 struct flash_bank
*get_flash_bank_by_num(int num
)
157 struct flash_bank
*p
= get_flash_bank_by_num_noprobe(num
);
163 retval
= p
->driver
->auto_probe(p
);
165 if (retval
!= ERROR_OK
)
167 LOG_ERROR("auto_probe failed %d\n", retval
);
173 /* lookup flash bank by address */
174 struct flash_bank
*get_flash_bank_by_addr(struct target
*target
, uint32_t addr
)
176 struct flash_bank
*c
;
178 /* cycle through bank list */
179 for (c
= flash_banks
; c
; c
= c
->next
)
182 retval
= c
->driver
->auto_probe(c
);
184 if (retval
!= ERROR_OK
)
186 LOG_ERROR("auto_probe failed %d\n", retval
);
189 /* check whether address belongs to this flash bank */
190 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
193 LOG_ERROR("No flash at address 0x%08" PRIx32
"\n", addr
);
197 int default_flash_mem_blank_check(struct flash_bank
*bank
)
199 struct target
*target
= bank
->target
;
200 const int buffer_size
= 1024;
203 int retval
= ERROR_OK
;
205 if (bank
->target
->state
!= TARGET_HALTED
)
207 LOG_ERROR("Target not halted");
208 return ERROR_TARGET_NOT_HALTED
;
211 uint8_t *buffer
= malloc(buffer_size
);
213 for (i
= 0; i
< bank
->num_sectors
; i
++)
216 bank
->sectors
[i
].is_erased
= 1;
218 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
222 if (chunk
> (j
- bank
->sectors
[i
].size
))
224 chunk
= (j
- bank
->sectors
[i
].size
);
227 retval
= target_read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
228 if (retval
!= ERROR_OK
)
233 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
235 if (buffer
[nBytes
] != 0xFF)
237 bank
->sectors
[i
].is_erased
= 0;
250 int default_flash_blank_check(struct flash_bank
*bank
)
252 struct target
*target
= bank
->target
;
258 if (bank
->target
->state
!= TARGET_HALTED
)
260 LOG_ERROR("Target not halted");
261 return ERROR_TARGET_NOT_HALTED
;
264 for (i
= 0; i
< bank
->num_sectors
; i
++)
266 uint32_t address
= bank
->base
+ bank
->sectors
[i
].offset
;
267 uint32_t size
= bank
->sectors
[i
].size
;
269 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
275 bank
->sectors
[i
].is_erased
= 1;
277 bank
->sectors
[i
].is_erased
= 0;
283 LOG_USER("Running slow fallback erase check - add working memory");
284 return default_flash_mem_blank_check(bank
);
290 /* Manipulate given flash region, selecting the bank according to target
291 * and address. Maps an address range to a set of sectors, and issues
292 * the callback() on that set ... e.g. to erase or unprotect its members.
294 * (Note a current bad assumption: that protection operates on the same
295 * size sectors as erase operations use.)
297 * The "pad_reason" parameter is a kind of boolean: when it's NULL, the
298 * range must fit those sectors exactly. This is clearly safe; it can't
299 * erase data which the caller said to leave alone, for example. If it's
300 * non-NULL, rather than failing, extra data in the first and/or last
301 * sectors will be added to the range, and that reason string is used when
302 * warning about those additions.
304 static int flash_iterate_address_range(struct target
*target
,
305 char *pad_reason
, uint32_t addr
, uint32_t length
,
306 int (*callback
)(struct flash_bank
*bank
, int first
, int last
))
308 struct flash_bank
*c
;
309 uint32_t last_addr
= addr
+ length
; /* first address AFTER end */
314 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
315 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
317 if (c
->size
== 0 || c
->num_sectors
== 0)
319 LOG_ERROR("Bank is invalid");
320 return ERROR_FLASH_BANK_INVALID
;
325 /* special case, erase whole bank when length is zero */
327 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
329 return callback(c
, 0, c
->num_sectors
- 1);
332 /* check whether it all fits in this bank */
333 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
334 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
336 /** @todo: handle erasures that cross into adjacent banks */
339 last_addr
-= c
->base
;
341 for (i
= 0; i
< c
->num_sectors
; i
++)
343 struct flash_sector
*f
= c
->sectors
+ i
;
344 uint32_t end
= f
->offset
+ f
->size
;
346 /* start only on a sector boundary */
348 /* scanned past the first sector? */
349 if (addr
< f
->offset
)
352 /* is this the first sector? */
353 if (addr
== f
->offset
)
356 /* Does this need head-padding? If so, pad and warn;
357 * or else force an error.
359 * Such padding can make trouble, since *WE* can't
360 * ever know if that data was in use. The warning
361 * should help users sort out messes later.
363 else if (addr
< end
&& pad_reason
) {
364 /* FIXME say how many bytes (e.g. 80 KB) */
365 LOG_WARNING("Adding extra %s range, "
368 (unsigned) f
->offset
,
369 (unsigned) addr
- 1);
375 /* is this (also?) the last sector? */
376 if (last_addr
== end
) {
381 /* Does this need tail-padding? If so, pad and warn;
382 * or else force an error.
384 if (last_addr
< end
&& pad_reason
) {
385 /* FIXME say how many bytes (e.g. 80 KB) */
386 LOG_WARNING("Adding extra %s range, "
389 (unsigned) last_addr
,
395 /* MUST finish on a sector boundary */
396 if (last_addr
<= f
->offset
)
400 /* invalid start or end address? */
401 if (first
== -1 || last
== -1) {
402 LOG_ERROR("address range 0x%8.8x .. 0x%8.8x "
403 "is not sector-aligned",
404 (unsigned) (c
->base
+ addr
),
405 (unsigned) (last_addr
- 1));
406 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
409 /* The NOR driver may trim this range down, based on what
410 * sectors are already erased/unprotected. GDB currently
411 * blocks such optimizations.
413 return callback(c
, first
, last
);
416 int flash_erase_address_range(struct target
*target
,
417 bool pad
, uint32_t addr
, uint32_t length
)
419 return flash_iterate_address_range(target
, pad
? "erase" : NULL
,
420 addr
, length
, &flash_driver_erase
);
423 static int flash_driver_unprotect(struct flash_bank
*bank
, int first
, int last
)
425 return flash_driver_protect(bank
, 0, first
, last
);
428 static int flash_unlock_address_range(struct target
*target
, uint32_t addr
, uint32_t length
)
430 /* By default, pad to sector boundaries ... the real issue here
431 * is that our (only) caller *permanently* removes protection,
432 * and doesn't restore it.
434 return flash_iterate_address_range(target
, "unprotect",
435 addr
, length
, &flash_driver_unprotect
);
438 int flash_write_unlock(struct target
*target
, struct image
*image
,
439 uint32_t *written
, int erase
, bool unlock
)
441 int retval
= ERROR_OK
;
444 uint32_t section_offset
;
445 struct flash_bank
*c
;
448 /* REVISIT do_pad should perhaps just be another parameter.
449 * GDB wouldn't ever need it, since it erases separately.
450 * But "flash write_image" commands might want that option.
462 /* assume all sectors need erasing - stops any problems
463 * when flash_write is called multiple times */
468 /* allocate padding array */
469 padding
= calloc(image
->num_sections
, sizeof(*padding
));
471 /* loop until we reach end of the image */
472 while (section
< image
->num_sections
)
474 uint32_t buffer_size
;
478 uint32_t run_address
= image
->sections
[section
].base_address
+ section_offset
;
479 uint32_t run_size
= image
->sections
[section
].size
- section_offset
;
482 if (image
->sections
[section
].size
== 0)
484 LOG_WARNING("empty section %d", section
);
490 /* find the corresponding flash bank */
491 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
493 section
++; /* and skip it */
498 /* collect consecutive sections which fall into the same bank */
499 section_first
= section
;
500 section_last
= section
;
501 padding
[section
] = 0;
502 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
503 && (section_last
+ 1 < image
->num_sections
))
505 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
507 LOG_DEBUG("section %d out of order "
508 "(surprising, but supported)",
510 /* REVISIT this can break with autoerase ...
511 * clobbering data after it's written.
516 /* FIXME This needlessly touches sectors BETWEEN the
517 * sections it's writing. Without auto erase, it just
518 * writes ones. That WILL INVALIDATE data in cases
519 * like Stellaris Tempest chips, corrupting internal
520 * ECC codes; and at least FreeScale suggests issues
521 * with that approach (in HC11 documentation).
523 * With auto erase enabled, data in those sectors will
524 * be needlessly destroyed; and some of the limited
525 * number of flash erase cycles will be wasted...
527 * In both cases, the extra writes slow things down.
530 /* if we have multiple sections within our image,
531 * flash programming could fail due to alignment issues
532 * attempt to rebuild a consecutive buffer for the flash loader */
533 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
534 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
536 padding
[section_last
] = pad_bytes
;
537 run_size
+= image
->sections
[++section_last
].size
;
538 run_size
+= pad_bytes
;
540 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
543 /* fit the run into bank constraints */
544 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
546 /* REVISIT isn't this superfluous, given the while()
547 * loop conditions above??
549 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
550 (int)(c
->base
+ c
->size
- run_address
), (int)(run_size
), (int)(c
->size
));
551 run_size
= c
->base
+ c
->size
- run_address
;
554 /* If we're applying any sector automagic, then pad this
555 * (maybe-combined) segment to the end of its last sector.
557 if (unlock
|| erase
) {
559 uint32_t offset_start
= run_address
- c
->base
;
560 uint32_t offset_end
= offset_start
+ run_size
;
561 uint32_t end
= offset_end
, delta
;
563 for (sector
= 0; sector
< c
->num_sectors
; sector
++) {
564 end
= c
->sectors
[sector
].offset
565 + c
->sectors
[sector
].size
;
566 if (offset_end
<= end
)
570 delta
= end
- offset_end
;
571 padding
[section_last
] += delta
;
575 /* allocate buffer */
576 buffer
= malloc(run_size
);
579 /* read sections to the buffer */
580 while (buffer_size
< run_size
)
584 size_read
= run_size
- buffer_size
;
585 if (size_read
> image
->sections
[section
].size
- section_offset
)
586 size_read
= image
->sections
[section
].size
- section_offset
;
588 if ((retval
= image_read_section(image
, section
, section_offset
,
589 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
596 /* see if we need to pad the section */
597 while (padding
[section
]--)
598 (buffer
+ buffer_size
)[size_read
++] = 0xff;
600 buffer_size
+= size_read
;
601 section_offset
+= size_read
;
603 if (section_offset
>= image
->sections
[section
].size
)
614 retval
= flash_unlock_address_range(target
, run_address
, run_size
);
616 if (retval
== ERROR_OK
)
620 /* calculate and erase sectors */
621 retval
= flash_erase_address_range(target
,
622 do_pad
, run_address
, run_size
);
626 if (retval
== ERROR_OK
)
628 /* write flash sectors */
629 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
634 if (retval
!= ERROR_OK
)
637 return retval
; /* abort operation */
641 *written
+= run_size
; /* add run size to total written counter */
649 int flash_write(struct target
*target
, struct image
*image
,
650 uint32_t *written
, int erase
)
652 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)