cygwin build fixes
[openocd.git] / src / flash / nor / core.c
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> *
6 * *
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. *
11 * *
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. *
16 * *
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 ***************************************************************************/
22
23 #ifdef HAVE_CONFIG_H
24 #include <config.h>
25 #endif
26 #include <flash/common.h>
27 #include <flash/nor/core.h>
28 #include <flash/nor/imp.h>
29 #include <target/image.h>
30
31
32 struct flash_bank *flash_banks;
33
34 int flash_driver_erase(struct flash_bank *bank, int first, int last)
35 {
36 int retval;
37
38 retval = bank->driver->erase(bank, first, last);
39 if (retval != ERROR_OK)
40 {
41 LOG_ERROR("failed erasing sectors %d to %d (%d)", first, last, retval);
42 }
43
44 return retval;
45 }
46
47 int flash_driver_protect(struct flash_bank *bank, int set, int first, int last)
48 {
49 int retval;
50
51 retval = bank->driver->protect(bank, set, first, last);
52 if (retval != ERROR_OK)
53 {
54 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first, last, retval);
55 }
56
57 return retval;
58 }
59
60 int flash_driver_write(struct flash_bank *bank,
61 uint8_t *buffer, uint32_t offset, uint32_t count)
62 {
63 int retval;
64
65 retval = bank->driver->write(bank, buffer, offset, count);
66 if (retval != ERROR_OK)
67 {
68 LOG_ERROR("error writing to flash at address 0x%08" PRIx32 " at offset 0x%8.8" PRIx32 " (%d)",
69 bank->base, offset, retval);
70 }
71
72 return retval;
73 }
74
75 void flash_bank_add(struct flash_bank *bank)
76 {
77 /* put flash bank in linked list */
78 unsigned bank_num = 0;
79 if (flash_banks)
80 {
81 /* find last flash bank */
82 struct flash_bank *p = flash_banks;
83 while (NULL != p->next)
84 {
85 bank_num += 1;
86 p = p->next;
87 }
88 p->next = bank;
89 bank_num += 1;
90 }
91 else
92 flash_banks = bank;
93
94 bank->bank_number = bank_num;
95 }
96
97 struct flash_bank *flash_bank_list(void)
98 {
99 return flash_banks;
100 }
101
102 struct flash_bank *get_flash_bank_by_num_noprobe(int num)
103 {
104 struct flash_bank *p;
105 int i = 0;
106
107 for (p = flash_banks; p; p = p->next)
108 {
109 if (i++ == num)
110 {
111 return p;
112 }
113 }
114 LOG_ERROR("flash bank %d does not exist", num);
115 return NULL;
116 }
117
118 int flash_get_bank_count(void)
119 {
120 struct flash_bank *p;
121 int i = 0;
122 for (p = flash_banks; p; p = p->next)
123 {
124 i++;
125 }
126 return i;
127 }
128
129 struct flash_bank *get_flash_bank_by_name(const char *name)
130 {
131 unsigned requested = get_flash_name_index(name);
132 unsigned found = 0;
133
134 struct flash_bank *bank;
135 for (bank = flash_banks; NULL != bank; bank = bank->next)
136 {
137 if (strcmp(bank->name, name) == 0)
138 return bank;
139 if (!flash_driver_name_matches(bank->driver->name, name))
140 continue;
141 if (++found < requested)
142 continue;
143 return bank;
144 }
145 return NULL;
146 }
147
148 struct flash_bank *get_flash_bank_by_num(int num)
149 {
150 struct flash_bank *p = get_flash_bank_by_num_noprobe(num);
151 int retval;
152
153 if (p == NULL)
154 return NULL;
155
156 retval = p->driver->auto_probe(p);
157
158 if (retval != ERROR_OK)
159 {
160 LOG_ERROR("auto_probe failed %d\n", retval);
161 return NULL;
162 }
163 return p;
164 }
165
166 /* lookup flash bank by address */
167 struct flash_bank *get_flash_bank_by_addr(struct target *target, uint32_t addr)
168 {
169 struct flash_bank *c;
170
171 /* cycle through bank list */
172 for (c = flash_banks; c; c = c->next)
173 {
174 int retval;
175 retval = c->driver->auto_probe(c);
176
177 if (retval != ERROR_OK)
178 {
179 LOG_ERROR("auto_probe failed %d\n", retval);
180 return NULL;
181 }
182 /* check whether address belongs to this flash bank */
183 if ((addr >= c->base) && (addr <= c->base + (c->size - 1)) && target == c->target)
184 return c;
185 }
186 LOG_ERROR("No flash at address 0x%08" PRIx32 "\n", addr);
187 return NULL;
188 }
189
190 int default_flash_mem_blank_check(struct flash_bank *bank)
191 {
192 struct target *target = bank->target;
193 const int buffer_size = 1024;
194 int i;
195 uint32_t nBytes;
196 int retval = ERROR_OK;
197
198 if (bank->target->state != TARGET_HALTED)
199 {
200 LOG_ERROR("Target not halted");
201 return ERROR_TARGET_NOT_HALTED;
202 }
203
204 uint8_t *buffer = malloc(buffer_size);
205
206 for (i = 0; i < bank->num_sectors; i++)
207 {
208 uint32_t j;
209 bank->sectors[i].is_erased = 1;
210
211 for (j = 0; j < bank->sectors[i].size; j += buffer_size)
212 {
213 uint32_t chunk;
214 chunk = buffer_size;
215 if (chunk > (j - bank->sectors[i].size))
216 {
217 chunk = (j - bank->sectors[i].size);
218 }
219
220 retval = target_read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
221 if (retval != ERROR_OK)
222 {
223 goto done;
224 }
225
226 for (nBytes = 0; nBytes < chunk; nBytes++)
227 {
228 if (buffer[nBytes] != 0xFF)
229 {
230 bank->sectors[i].is_erased = 0;
231 break;
232 }
233 }
234 }
235 }
236
237 done:
238 free(buffer);
239
240 return retval;
241 }
242
243 int default_flash_blank_check(struct flash_bank *bank)
244 {
245 struct target *target = bank->target;
246 int i;
247 int retval;
248 int fast_check = 0;
249 uint32_t blank;
250
251 if (bank->target->state != TARGET_HALTED)
252 {
253 LOG_ERROR("Target not halted");
254 return ERROR_TARGET_NOT_HALTED;
255 }
256
257 for (i = 0; i < bank->num_sectors; i++)
258 {
259 uint32_t address = bank->base + bank->sectors[i].offset;
260 uint32_t size = bank->sectors[i].size;
261
262 if ((retval = target_blank_check_memory(target, address, size, &blank)) != ERROR_OK)
263 {
264 fast_check = 0;
265 break;
266 }
267 if (blank == 0xFF)
268 bank->sectors[i].is_erased = 1;
269 else
270 bank->sectors[i].is_erased = 0;
271 fast_check = 1;
272 }
273
274 if (!fast_check)
275 {
276 LOG_USER("Running slow fallback erase check - add working memory");
277 return default_flash_mem_blank_check(bank);
278 }
279
280 return ERROR_OK;
281 }
282
283 /* erase given flash region, selects proper bank according to target and address */
284 static int flash_iterate_address_range(struct target *target,
285 uint32_t addr, uint32_t length,
286 int (*callback)(struct flash_bank *bank, int first, int last))
287 {
288 struct flash_bank *c;
289 uint32_t last_addr = addr + length; /* first address AFTER end */
290 int first = -1;
291 int last = -1;
292 int i;
293
294 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
295 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
296
297 if (c->size == 0 || c->num_sectors == 0)
298 {
299 LOG_ERROR("Bank is invalid");
300 return ERROR_FLASH_BANK_INVALID;
301 }
302
303 if (length == 0)
304 {
305 /* special case, erase whole bank when length is zero */
306 if (addr != c->base)
307 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
308
309 return callback(c, 0, c->num_sectors - 1);
310 }
311
312 /* check whether it all fits in this bank */
313 if (addr + length - 1 > c->base + c->size - 1)
314 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
315
316 /** @todo: handle erasures that cross into adjacent banks */
317
318 addr -= c->base;
319
320 for (i = 0; i < c->num_sectors; i++)
321 {
322 struct flash_sector *f = c->sectors + i;
323
324 /* start only on a sector boundary */
325 if (first < 0) {
326 /* is this the first sector? */
327 if (addr == f->offset)
328 first = i;
329 else if (addr < f->offset)
330 break;
331 }
332
333 /* is this (also?) the last sector? */
334 if (last_addr == f->offset + f->size) {
335 last = i;
336 break;
337 }
338
339 /* MUST finish on a sector boundary */
340 if (last_addr <= f->offset)
341 break;
342 }
343
344 /* invalid start or end address? */
345 if (first == -1 || last == -1) {
346 LOG_ERROR("address range 0x%8.8x .. 0x%8.8x "
347 "is not sector-aligned",
348 (unsigned) (c->base + addr),
349 (unsigned) (last_addr - 1));
350 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
351 }
352
353 /* The NOR driver may trim this range down, based on
354 * whether or not a given sector is already erased.
355 *
356 * REVISIT should *we* trim it... ?
357 */
358 return callback(c, first, last);
359 }
360
361 int flash_erase_address_range(struct target *target,
362 uint32_t addr, uint32_t length)
363 {
364 return flash_iterate_address_range(target,
365 addr, length, &flash_driver_erase);
366 }
367
368 static int flash_driver_unprotect(struct flash_bank *bank, int first, int last)
369 {
370 return flash_driver_protect(bank, 0, first, last);
371 }
372
373 static int flash_unlock_address_range(struct target *target, uint32_t addr, uint32_t length)
374 {
375 return flash_iterate_address_range(target,
376 addr, length, &flash_driver_unprotect);
377 }
378
379 int flash_write_unlock(struct target *target, struct image *image,
380 uint32_t *written, int erase, bool unlock)
381 {
382 int retval = ERROR_OK;
383
384 int section;
385 uint32_t section_offset;
386 struct flash_bank *c;
387 int *padding;
388
389 section = 0;
390 section_offset = 0;
391
392 if (written)
393 *written = 0;
394
395 if (erase)
396 {
397 /* assume all sectors need erasing - stops any problems
398 * when flash_write is called multiple times */
399
400 flash_set_dirty();
401 }
402
403 /* allocate padding array */
404 padding = malloc(image->num_sections * sizeof(padding));
405
406 /* loop until we reach end of the image */
407 while (section < image->num_sections)
408 {
409 uint32_t buffer_size;
410 uint8_t *buffer;
411 int section_first;
412 int section_last;
413 uint32_t run_address = image->sections[section].base_address + section_offset;
414 uint32_t run_size = image->sections[section].size - section_offset;
415 int pad_bytes = 0;
416
417 if (image->sections[section].size == 0)
418 {
419 LOG_WARNING("empty section %d", section);
420 section++;
421 section_offset = 0;
422 continue;
423 }
424
425 /* find the corresponding flash bank */
426 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
427 {
428 section++; /* and skip it */
429 section_offset = 0;
430 continue;
431 }
432
433 /* collect consecutive sections which fall into the same bank */
434 section_first = section;
435 section_last = section;
436 padding[section] = 0;
437 while ((run_address + run_size - 1 < c->base + c->size - 1)
438 && (section_last + 1 < image->num_sections))
439 {
440 if (image->sections[section_last + 1].base_address < (run_address + run_size))
441 {
442 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
443 break;
444 }
445 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
446 * attempt to rebuild a consecutive buffer for the flash loader */
447 pad_bytes = (image->sections[section_last + 1].base_address) - (run_address + run_size);
448 if ((run_address + run_size + pad_bytes) > (c->base + c->size))
449 break;
450 padding[section_last] = pad_bytes;
451 run_size += image->sections[++section_last].size;
452 run_size += pad_bytes;
453 padding[section_last] = 0;
454
455 LOG_INFO("Padding image section %d with %d bytes", section_last-1, pad_bytes);
456 }
457
458 /* fit the run into bank constraints */
459 if (run_address + run_size - 1 > c->base + c->size - 1)
460 {
461 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
462 (int)(c->base + c->size - run_address), (int)(run_size), (int)(c->size));
463 run_size = c->base + c->size - run_address;
464 }
465
466 /* allocate buffer */
467 buffer = malloc(run_size);
468 buffer_size = 0;
469
470 /* read sections to the buffer */
471 while (buffer_size < run_size)
472 {
473 size_t size_read;
474
475 size_read = run_size - buffer_size;
476 if (size_read > image->sections[section].size - section_offset)
477 size_read = image->sections[section].size - section_offset;
478
479 if ((retval = image_read_section(image, section, section_offset,
480 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
481 {
482 free(buffer);
483 free(padding);
484 return retval;
485 }
486
487 /* see if we need to pad the section */
488 while (padding[section]--)
489 (buffer + buffer_size)[size_read++] = 0xff;
490
491 buffer_size += size_read;
492 section_offset += size_read;
493
494 if (section_offset >= image->sections[section].size)
495 {
496 section++;
497 section_offset = 0;
498 }
499 }
500
501 retval = ERROR_OK;
502
503 if (unlock)
504 {
505 retval = flash_unlock_address_range(target, run_address, run_size);
506 }
507 if (retval == ERROR_OK)
508 {
509 if (erase)
510 {
511 /* calculate and erase sectors */
512 retval = flash_erase_address_range(target, run_address, run_size);
513 }
514 }
515
516 if (retval == ERROR_OK)
517 {
518 /* write flash sectors */
519 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
520 }
521
522 free(buffer);
523
524 if (retval != ERROR_OK)
525 {
526 free(padding);
527 return retval; /* abort operation */
528 }
529
530 if (written != NULL)
531 *written += run_size; /* add run size to total written counter */
532 }
533
534 free(padding);
535
536 return retval;
537 }
538
539 int flash_write(struct target *target, struct image *image,
540 uint32_t *written, int erase)
541 {
542 return flash_write_unlock(target, image, written, erase, false);
543 }