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 (%d)", first
, last
, retval
);
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 (%d)", first
, last
, retval
);
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
" (%d)",
98 bank
->base
, offset
, retval
);
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
" (%d)",
115 bank
->base
, offset
, retval
);
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 %d\n", retval
);
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 %d\n", retval
);
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 %d\n", retval
);
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
"\n", 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 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
353 bank
->sectors
[i
].is_erased
= 1;
355 bank
->sectors
[i
].is_erased
= 0;
361 LOG_USER("Running slow fallback erase check - add working memory");
362 return default_flash_mem_blank_check(bank
);
368 /* Manipulate given flash region, selecting the bank according to target
369 * and address. Maps an address range to a set of sectors, and issues
370 * the callback() on that set ... e.g. to erase or unprotect its members.
372 * (Note a current bad assumption: that protection operates on the same
373 * size sectors as erase operations use.)
375 * The "pad_reason" parameter is a kind of boolean: when it's NULL, the
376 * range must fit those sectors exactly. This is clearly safe; it can't
377 * erase data which the caller said to leave alone, for example. If it's
378 * non-NULL, rather than failing, extra data in the first and/or last
379 * sectors will be added to the range, and that reason string is used when
380 * warning about those additions.
382 static int flash_iterate_address_range(struct target
*target
,
383 char *pad_reason
, uint32_t addr
, uint32_t length
,
384 int (*callback
)(struct flash_bank
*bank
, int first
, int last
))
386 struct flash_bank
*c
;
387 uint32_t last_addr
= addr
+ length
; /* first address AFTER end */
392 int retval
= get_flash_bank_by_addr(target
, addr
, true, &c
);
393 if (retval
!= ERROR_OK
)
396 if (c
->size
== 0 || c
->num_sectors
== 0)
398 LOG_ERROR("Bank is invalid");
399 return ERROR_FLASH_BANK_INVALID
;
404 /* special case, erase whole bank when length is zero */
407 LOG_ERROR("Whole bank access must start at beginning of bank.");
408 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
411 return callback(c
, 0, c
->num_sectors
- 1);
414 /* check whether it all fits in this bank */
415 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
417 LOG_ERROR("Flash access does not fit into bank.");
418 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
421 /** @todo: handle erasures that cross into adjacent banks */
424 last_addr
-= c
->base
;
426 for (i
= 0; i
< c
->num_sectors
; i
++)
428 struct flash_sector
*f
= c
->sectors
+ i
;
429 uint32_t end
= f
->offset
+ f
->size
;
431 /* start only on a sector boundary */
433 /* scanned past the first sector? */
434 if (addr
< f
->offset
)
437 /* is this the first sector? */
438 if (addr
== f
->offset
)
441 /* Does this need head-padding? If so, pad and warn;
442 * or else force an error.
444 * Such padding can make trouble, since *WE* can't
445 * ever know if that data was in use. The warning
446 * should help users sort out messes later.
448 else if (addr
< end
&& pad_reason
) {
449 /* FIXME say how many bytes (e.g. 80 KB) */
450 LOG_WARNING("Adding extra %s range, "
453 (unsigned) f
->offset
,
454 (unsigned) addr
- 1);
460 /* is this (also?) the last sector? */
461 if (last_addr
== end
) {
466 /* Does this need tail-padding? If so, pad and warn;
467 * or else force an error.
469 if (last_addr
< end
&& pad_reason
) {
470 /* FIXME say how many bytes (e.g. 80 KB) */
471 LOG_WARNING("Adding extra %s range, "
474 (unsigned) last_addr
,
480 /* MUST finish on a sector boundary */
481 if (last_addr
<= f
->offset
)
485 /* invalid start or end address? */
486 if (first
== -1 || last
== -1) {
487 LOG_ERROR("address range 0x%8.8x .. 0x%8.8x "
488 "is not sector-aligned",
489 (unsigned) (c
->base
+ addr
),
490 (unsigned) (c
->base
+ last_addr
- 1));
491 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
494 /* The NOR driver may trim this range down, based on what
495 * sectors are already erased/unprotected. GDB currently
496 * blocks such optimizations.
498 return callback(c
, first
, last
);
501 int flash_erase_address_range(struct target
*target
,
502 bool pad
, uint32_t addr
, uint32_t length
)
504 return flash_iterate_address_range(target
, pad
? "erase" : NULL
,
505 addr
, length
, &flash_driver_erase
);
508 static int flash_driver_unprotect(struct flash_bank
*bank
, int first
, int last
)
510 return flash_driver_protect(bank
, 0, first
, last
);
513 int flash_unlock_address_range(struct target
*target
, uint32_t addr
, uint32_t length
)
515 /* By default, pad to sector boundaries ... the real issue here
516 * is that our (only) caller *permanently* removes protection,
517 * and doesn't restore it.
519 return flash_iterate_address_range(target
, "unprotect",
520 addr
, length
, &flash_driver_unprotect
);
523 static int compare_section (const void * a
, const void * b
)
525 struct imagesection
*b1
, *b2
;
526 b1
=*((struct imagesection
**)a
);
527 b2
=*((struct imagesection
**)b
);
529 if (b1
->base_address
== b2
->base_address
)
532 } else if (b1
->base_address
> b2
->base_address
)
542 int flash_write_unlock(struct target
*target
, struct image
*image
,
543 uint32_t *written
, int erase
, bool unlock
)
545 int retval
= ERROR_OK
;
548 uint32_t section_offset
;
549 struct flash_bank
*c
;
560 /* assume all sectors need erasing - stops any problems
561 * when flash_write is called multiple times */
566 /* allocate padding array */
567 padding
= calloc(image
->num_sections
, sizeof(*padding
));
569 /* This fn requires all sections to be in ascending order of addresses,
570 * whereas an image can have sections out of order. */
571 struct imagesection
**sections
= malloc(sizeof(struct imagesection
*) *
572 image
->num_sections
);
574 for (i
= 0; i
< image
->num_sections
; i
++)
576 sections
[i
] = &image
->sections
[i
];
579 qsort(sections
, image
->num_sections
, sizeof(struct imagesection
*),
582 /* loop until we reach end of the image */
583 while (section
< image
->num_sections
)
585 uint32_t buffer_size
;
589 uint32_t run_address
= sections
[section
]->base_address
+ section_offset
;
590 uint32_t run_size
= sections
[section
]->size
- section_offset
;
593 if (sections
[section
]->size
== 0)
595 LOG_WARNING("empty section %d", section
);
601 /* find the corresponding flash bank */
602 retval
= get_flash_bank_by_addr(target
, run_address
, false, &c
);
603 if (retval
!= ERROR_OK
)
609 section
++; /* and skip it */
614 /* collect consecutive sections which fall into the same bank */
615 section_first
= section
;
616 section_last
= section
;
617 padding
[section
] = 0;
618 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
619 && (section_last
+ 1 < image
->num_sections
))
621 /* sections are sorted */
622 assert(sections
[section_last
+ 1]->base_address
>= c
->base
);
623 if (sections
[section_last
+ 1]->base_address
>= (c
->base
+ c
->size
))
625 /* Done with this bank */
629 /* FIXME This needlessly touches sectors BETWEEN the
630 * sections it's writing. Without auto erase, it just
631 * writes ones. That WILL INVALIDATE data in cases
632 * like Stellaris Tempest chips, corrupting internal
633 * ECC codes; and at least FreeScale suggests issues
634 * with that approach (in HC11 documentation).
636 * With auto erase enabled, data in those sectors will
637 * be needlessly destroyed; and some of the limited
638 * number of flash erase cycles will be wasted...
640 * In both cases, the extra writes slow things down.
643 /* if we have multiple sections within our image,
644 * flash programming could fail due to alignment issues
645 * attempt to rebuild a consecutive buffer for the flash loader */
646 pad_bytes
= (sections
[section_last
+ 1]->base_address
) - (run_address
+ run_size
);
647 padding
[section_last
] = pad_bytes
;
648 run_size
+= sections
[++section_last
]->size
;
649 run_size
+= pad_bytes
;
652 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
655 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
657 /* If we have more than one flash chip back to back, then we limit
658 * the current write operation to the current chip.
660 LOG_DEBUG("Truncate flash run size to the current flash chip.");
662 run_size
= c
->base
+ c
->size
- run_address
;
663 assert(run_size
> 0);
666 /* If we're applying any sector automagic, then pad this
667 * (maybe-combined) segment to the end of its last sector.
669 if (unlock
|| erase
) {
671 uint32_t offset_start
= run_address
- c
->base
;
672 uint32_t offset_end
= offset_start
+ run_size
;
673 uint32_t end
= offset_end
, delta
;
675 for (sector
= 0; sector
< c
->num_sectors
; sector
++) {
676 end
= c
->sectors
[sector
].offset
677 + c
->sectors
[sector
].size
;
678 if (offset_end
<= end
)
682 delta
= end
- offset_end
;
683 padding
[section_last
] += delta
;
687 /* allocate buffer */
688 buffer
= malloc(run_size
);
691 LOG_ERROR("Out of memory for flash bank buffer");
697 /* read sections to the buffer */
698 while (buffer_size
< run_size
)
702 size_read
= run_size
- buffer_size
;
703 if (size_read
> sections
[section
]->size
- section_offset
)
704 size_read
= sections
[section
]->size
- section_offset
;
708 * #¤%#"%¤% we have to figure out the section # from the sorted
709 * list of pointers to sections to invoke image_read_section()...
711 intptr_t diff
= (intptr_t)sections
[section
] - (intptr_t)image
->sections
;
712 int t_section_num
= diff
/ sizeof(struct imagesection
);
714 LOG_DEBUG("image_read_section: section = %d, t_section_num = %d, section_offset = %d, buffer_size = %d, size_read = %d",
716 (int)t_section_num
, (int)section_offset
, (int)buffer_size
, (int)size_read
);
717 if ((retval
= image_read_section(image
, t_section_num
, section_offset
,
718 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
724 /* see if we need to pad the section */
725 while (padding
[section
]--)
726 (buffer
+ buffer_size
)[size_read
++] = 0xff;
728 buffer_size
+= size_read
;
729 section_offset
+= size_read
;
731 if (section_offset
>= sections
[section
]->size
)
742 retval
= flash_unlock_address_range(target
, run_address
, run_size
);
744 if (retval
== ERROR_OK
)
748 /* calculate and erase sectors */
749 retval
= flash_erase_address_range(target
,
750 true, run_address
, run_size
);
754 if (retval
== ERROR_OK
)
756 /* write flash sectors */
757 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
762 if (retval
!= ERROR_OK
)
764 /* abort operation */
769 *written
+= run_size
; /* add run size to total written counter */
780 int flash_write(struct target
*target
, struct image
*image
,
781 uint32_t *written
, int erase
)
783 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)