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>
32 struct flash_bank
*flash_banks
;
34 int flash_driver_erase(struct flash_bank
*bank
, int first
, int last
)
38 retval
= bank
->driver
->erase(bank
, first
, last
);
39 if (retval
!= ERROR_OK
)
41 LOG_ERROR("failed erasing sectors %d to %d (%d)", first
, last
, retval
);
47 int flash_driver_protect(struct flash_bank
*bank
, int set
, int first
, int last
)
51 retval
= bank
->driver
->protect(bank
, set
, first
, last
);
52 if (retval
!= ERROR_OK
)
54 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first
, last
, retval
);
60 int flash_driver_write(struct flash_bank
*bank
,
61 uint8_t *buffer
, uint32_t offset
, uint32_t count
)
65 retval
= bank
->driver
->write(bank
, buffer
, offset
, count
);
66 if (retval
!= ERROR_OK
)
68 LOG_ERROR("error writing to flash at address 0x%08" PRIx32
" at offset 0x%8.8" PRIx32
" (%d)",
69 bank
->base
, offset
, retval
);
75 void flash_bank_add(struct flash_bank
*bank
)
77 /* put flash bank in linked list */
78 unsigned bank_num
= 0;
81 /* find last flash bank */
82 struct flash_bank
*p
= flash_banks
;
83 while (NULL
!= p
->next
)
94 bank
->bank_number
= bank_num
;
97 struct flash_bank
*flash_bank_list(void)
102 struct flash_bank
*get_flash_bank_by_num_noprobe(int num
)
104 struct flash_bank
*p
;
107 for (p
= flash_banks
; p
; p
= p
->next
)
114 LOG_ERROR("flash bank %d does not exist", num
);
118 int flash_get_bank_count(void)
120 struct flash_bank
*p
;
122 for (p
= flash_banks
; p
; p
= p
->next
)
129 struct flash_bank
*get_flash_bank_by_name(const char *name
)
131 unsigned requested
= get_flash_name_index(name
);
134 struct flash_bank
*bank
;
135 for (bank
= flash_banks
; NULL
!= bank
; bank
= bank
->next
)
137 if (strcmp(bank
->name
, name
) == 0)
139 if (!flash_driver_name_matches(bank
->driver
->name
, name
))
141 if (++found
< requested
)
148 struct flash_bank
*get_flash_bank_by_num(int num
)
150 struct flash_bank
*p
= get_flash_bank_by_num_noprobe(num
);
156 retval
= p
->driver
->auto_probe(p
);
158 if (retval
!= ERROR_OK
)
160 LOG_ERROR("auto_probe failed %d\n", retval
);
166 /* lookup flash bank by address */
167 struct flash_bank
*get_flash_bank_by_addr(struct target
*target
, uint32_t addr
)
169 struct flash_bank
*c
;
171 /* cycle through bank list */
172 for (c
= flash_banks
; c
; c
= c
->next
)
175 retval
= c
->driver
->auto_probe(c
);
177 if (retval
!= ERROR_OK
)
179 LOG_ERROR("auto_probe failed %d\n", retval
);
182 /* check whether address belongs to this flash bank */
183 if ((addr
>= c
->base
) && (addr
<= c
->base
+ (c
->size
- 1)) && target
== c
->target
)
186 LOG_ERROR("No flash at address 0x%08" PRIx32
"\n", addr
);
190 int default_flash_mem_blank_check(struct flash_bank
*bank
)
192 struct target
*target
= bank
->target
;
193 const int buffer_size
= 1024;
196 int retval
= ERROR_OK
;
198 if (bank
->target
->state
!= TARGET_HALTED
)
200 LOG_ERROR("Target not halted");
201 return ERROR_TARGET_NOT_HALTED
;
204 uint8_t *buffer
= malloc(buffer_size
);
206 for (i
= 0; i
< bank
->num_sectors
; i
++)
209 bank
->sectors
[i
].is_erased
= 1;
211 for (j
= 0; j
< bank
->sectors
[i
].size
; j
+= buffer_size
)
215 if (chunk
> (j
- bank
->sectors
[i
].size
))
217 chunk
= (j
- bank
->sectors
[i
].size
);
220 retval
= target_read_memory(target
, bank
->base
+ bank
->sectors
[i
].offset
+ j
, 4, chunk
/4, buffer
);
221 if (retval
!= ERROR_OK
)
226 for (nBytes
= 0; nBytes
< chunk
; nBytes
++)
228 if (buffer
[nBytes
] != 0xFF)
230 bank
->sectors
[i
].is_erased
= 0;
243 int default_flash_blank_check(struct flash_bank
*bank
)
245 struct target
*target
= bank
->target
;
251 if (bank
->target
->state
!= TARGET_HALTED
)
253 LOG_ERROR("Target not halted");
254 return ERROR_TARGET_NOT_HALTED
;
257 for (i
= 0; i
< bank
->num_sectors
; i
++)
259 uint32_t address
= bank
->base
+ bank
->sectors
[i
].offset
;
260 uint32_t size
= bank
->sectors
[i
].size
;
262 if ((retval
= target_blank_check_memory(target
, address
, size
, &blank
)) != ERROR_OK
)
268 bank
->sectors
[i
].is_erased
= 1;
270 bank
->sectors
[i
].is_erased
= 0;
276 LOG_USER("Running slow fallback erase check - add working memory");
277 return default_flash_mem_blank_check(bank
);
283 /* erase given flash region, selects proper bank according to target and address */
284 static int flash_iterate_address_range(struct target
*target
, uint32_t addr
, uint32_t length
,
285 int (*callback
)(struct flash_bank
*bank
, int first
, int last
))
287 struct flash_bank
*c
;
288 uint32_t last_addr
= addr
+ length
; /* first address AFTER end */
293 if ((c
= get_flash_bank_by_addr(target
, addr
)) == NULL
)
294 return ERROR_FLASH_DST_OUT_OF_BANK
; /* no corresponding bank found */
296 if (c
->size
== 0 || c
->num_sectors
== 0)
298 LOG_ERROR("Bank is invalid");
299 return ERROR_FLASH_BANK_INVALID
;
304 /* special case, erase whole bank when length is zero */
306 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
308 return callback(c
, 0, c
->num_sectors
- 1);
311 /* check whether it all fits in this bank */
312 if (addr
+ length
- 1 > c
->base
+ c
->size
- 1)
313 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
315 /** @todo: handle erasures that cross into adjacent banks */
319 for (i
= 0; i
< c
->num_sectors
; i
++)
321 struct flash_sector
*f
= c
->sectors
+ i
;
323 /* start only on a sector boundary */
325 /* is this the first sector? */
326 if (addr
== f
->offset
)
328 else if (addr
< f
->offset
)
332 /* is this (also?) the last sector? */
333 if (last_addr
== f
->offset
+ f
->size
) {
338 /* MUST finish on a sector boundary */
339 if (last_addr
<= f
->offset
)
343 /* invalid start or end address? */
344 if (first
== -1 || last
== -1) {
345 LOG_ERROR("address range 0x%8.8x .. 0x%8.8x "
346 "is not sector-aligned",
347 (unsigned) c
->base
+ addr
,
348 (unsigned) last_addr
- 1);
349 return ERROR_FLASH_DST_BREAKS_ALIGNMENT
;
352 /* The NOR driver may trim this range down, based on
353 * whether or not a given sector is already erased.
355 * REVISIT should *we* trim it... ?
357 return callback(c
, first
, last
);
360 int flash_erase_address_range(struct target
*target
, uint32_t addr
, uint32_t length
)
362 return flash_iterate_address_range(target
,
363 addr
, length
, &flash_driver_erase
);
366 static int flash_driver_unprotect(struct flash_bank
*bank
, int first
, int last
)
368 return flash_driver_protect(bank
, 0, first
, last
);
371 static int flash_unlock_address_range(struct target
*target
, uint32_t addr
, uint32_t length
)
373 return flash_iterate_address_range(target
,
374 addr
, length
, &flash_driver_unprotect
);
377 int flash_write_unlock(struct target
*target
, struct image
*image
,
378 uint32_t *written
, int erase
, bool unlock
)
380 int retval
= ERROR_OK
;
383 uint32_t section_offset
;
384 struct flash_bank
*c
;
395 /* assume all sectors need erasing - stops any problems
396 * when flash_write is called multiple times */
401 /* allocate padding array */
402 padding
= malloc(image
->num_sections
* sizeof(padding
));
404 /* loop until we reach end of the image */
405 while (section
< image
->num_sections
)
407 uint32_t buffer_size
;
411 uint32_t run_address
= image
->sections
[section
].base_address
+ section_offset
;
412 uint32_t run_size
= image
->sections
[section
].size
- section_offset
;
415 if (image
->sections
[section
].size
== 0)
417 LOG_WARNING("empty section %d", section
);
423 /* find the corresponding flash bank */
424 if ((c
= get_flash_bank_by_addr(target
, run_address
)) == NULL
)
426 section
++; /* and skip it */
431 /* collect consecutive sections which fall into the same bank */
432 section_first
= section
;
433 section_last
= section
;
434 padding
[section
] = 0;
435 while ((run_address
+ run_size
- 1 < c
->base
+ c
->size
- 1)
436 && (section_last
+ 1 < image
->num_sections
))
438 if (image
->sections
[section_last
+ 1].base_address
< (run_address
+ run_size
))
440 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last
+ 1);
443 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
444 * attempt to rebuild a consecutive buffer for the flash loader */
445 pad_bytes
= (image
->sections
[section_last
+ 1].base_address
) - (run_address
+ run_size
);
446 if ((run_address
+ run_size
+ pad_bytes
) > (c
->base
+ c
->size
))
448 padding
[section_last
] = pad_bytes
;
449 run_size
+= image
->sections
[++section_last
].size
;
450 run_size
+= pad_bytes
;
451 padding
[section_last
] = 0;
453 LOG_INFO("Padding image section %d with %d bytes", section_last
-1, pad_bytes
);
456 /* fit the run into bank constraints */
457 if (run_address
+ run_size
- 1 > c
->base
+ c
->size
- 1)
459 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
460 (int)(c
->base
+ c
->size
- run_address
), (int)(run_size
), (int)(c
->size
));
461 run_size
= c
->base
+ c
->size
- run_address
;
464 /* allocate buffer */
465 buffer
= malloc(run_size
);
468 /* read sections to the buffer */
469 while (buffer_size
< run_size
)
473 size_read
= run_size
- buffer_size
;
474 if (size_read
> image
->sections
[section
].size
- section_offset
)
475 size_read
= image
->sections
[section
].size
- section_offset
;
477 if ((retval
= image_read_section(image
, section
, section_offset
,
478 size_read
, buffer
+ buffer_size
, &size_read
)) != ERROR_OK
|| size_read
== 0)
485 /* see if we need to pad the section */
486 while (padding
[section
]--)
487 (buffer
+ buffer_size
)[size_read
++] = 0xff;
489 buffer_size
+= size_read
;
490 section_offset
+= size_read
;
492 if (section_offset
>= image
->sections
[section
].size
)
503 retval
= flash_unlock_address_range(target
, run_address
, run_size
);
505 if (retval
== ERROR_OK
)
509 /* calculate and erase sectors */
510 retval
= flash_erase_address_range(target
, run_address
, run_size
);
514 if (retval
== ERROR_OK
)
516 /* write flash sectors */
517 retval
= flash_driver_write(c
, buffer
, run_address
- c
->base
, run_size
);
522 if (retval
!= ERROR_OK
)
525 return retval
; /* abort operation */
529 *written
+= run_size
; /* add run size to total written counter */
537 int flash_write(struct target
*target
, struct image
*image
,
538 uint32_t *written
, int erase
)
540 return flash_write_unlock(target
, image
, written
, erase
, false);