1873deede567e56ef93caf230040cabded7fb40a
[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, uint32_t addr, uint32_t length,
285 int (*callback)(struct flash_bank *bank, int first, int last))
286 {
287 struct flash_bank *c;
288 uint32_t last_addr = addr + length; /* first address AFTER end */
289 int first = -1;
290 int last = -1;
291 int i;
292
293 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
294 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
295
296 if (c->size == 0 || c->num_sectors == 0)
297 {
298 LOG_ERROR("Bank is invalid");
299 return ERROR_FLASH_BANK_INVALID;
300 }
301
302 if (length == 0)
303 {
304 /* special case, erase whole bank when length is zero */
305 if (addr != c->base)
306 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
307
308 return callback(c, 0, c->num_sectors - 1);
309 }
310
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;
314
315 /** @todo: handle erasures that cross into adjacent banks */
316
317 addr -= c->base;
318
319 for (i = 0; i < c->num_sectors; i++)
320 {
321 struct flash_sector *f = c->sectors + i;
322
323 /* start only on a sector boundary */
324 if (first < 0) {
325 /* is this the first sector? */
326 if (addr == f->offset)
327 first = i;
328 else if (addr < f->offset)
329 break;
330 }
331
332 /* is this (also?) the last sector? */
333 if (last_addr == f->offset + f->size) {
334 last = i;
335 break;
336 }
337
338 /* MUST finish on a sector boundary */
339 if (last_addr <= f->offset)
340 break;
341 }
342
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;
350 }
351
352 /* The NOR driver may trim this range down, based on
353 * whether or not a given sector is already erased.
354 *
355 * REVISIT should *we* trim it... ?
356 */
357 return callback(c, first, last);
358 }
359
360 int flash_erase_address_range(struct target *target, uint32_t addr, uint32_t length)
361 {
362 return flash_iterate_address_range(target,
363 addr, length, &flash_driver_erase);
364 }
365
366 static int flash_driver_unprotect(struct flash_bank *bank, int first, int last)
367 {
368 return flash_driver_protect(bank, 0, first, last);
369 }
370
371 static int flash_unlock_address_range(struct target *target, uint32_t addr, uint32_t length)
372 {
373 return flash_iterate_address_range(target,
374 addr, length, &flash_driver_unprotect);
375 }
376
377 int flash_write_unlock(struct target *target, struct image *image,
378 uint32_t *written, int erase, bool unlock)
379 {
380 int retval = ERROR_OK;
381
382 int section;
383 uint32_t section_offset;
384 struct flash_bank *c;
385 int *padding;
386
387 section = 0;
388 section_offset = 0;
389
390 if (written)
391 *written = 0;
392
393 if (erase)
394 {
395 /* assume all sectors need erasing - stops any problems
396 * when flash_write is called multiple times */
397
398 flash_set_dirty();
399 }
400
401 /* allocate padding array */
402 padding = malloc(image->num_sections * sizeof(padding));
403
404 /* loop until we reach end of the image */
405 while (section < image->num_sections)
406 {
407 uint32_t buffer_size;
408 uint8_t *buffer;
409 int section_first;
410 int section_last;
411 uint32_t run_address = image->sections[section].base_address + section_offset;
412 uint32_t run_size = image->sections[section].size - section_offset;
413 int pad_bytes = 0;
414
415 if (image->sections[section].size == 0)
416 {
417 LOG_WARNING("empty section %d", section);
418 section++;
419 section_offset = 0;
420 continue;
421 }
422
423 /* find the corresponding flash bank */
424 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
425 {
426 section++; /* and skip it */
427 section_offset = 0;
428 continue;
429 }
430
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))
437 {
438 if (image->sections[section_last + 1].base_address < (run_address + run_size))
439 {
440 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
441 break;
442 }
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))
447 break;
448 padding[section_last] = pad_bytes;
449 run_size += image->sections[++section_last].size;
450 run_size += pad_bytes;
451 padding[section_last] = 0;
452
453 LOG_INFO("Padding image section %d with %d bytes", section_last-1, pad_bytes);
454 }
455
456 /* fit the run into bank constraints */
457 if (run_address + run_size - 1 > c->base + c->size - 1)
458 {
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;
462 }
463
464 /* allocate buffer */
465 buffer = malloc(run_size);
466 buffer_size = 0;
467
468 /* read sections to the buffer */
469 while (buffer_size < run_size)
470 {
471 size_t size_read;
472
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;
476
477 if ((retval = image_read_section(image, section, section_offset,
478 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
479 {
480 free(buffer);
481 free(padding);
482 return retval;
483 }
484
485 /* see if we need to pad the section */
486 while (padding[section]--)
487 (buffer + buffer_size)[size_read++] = 0xff;
488
489 buffer_size += size_read;
490 section_offset += size_read;
491
492 if (section_offset >= image->sections[section].size)
493 {
494 section++;
495 section_offset = 0;
496 }
497 }
498
499 retval = ERROR_OK;
500
501 if (unlock)
502 {
503 retval = flash_unlock_address_range(target, run_address, run_size);
504 }
505 if (retval == ERROR_OK)
506 {
507 if (erase)
508 {
509 /* calculate and erase sectors */
510 retval = flash_erase_address_range(target, run_address, run_size);
511 }
512 }
513
514 if (retval == ERROR_OK)
515 {
516 /* write flash sectors */
517 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
518 }
519
520 free(buffer);
521
522 if (retval != ERROR_OK)
523 {
524 free(padding);
525 return retval; /* abort operation */
526 }
527
528 if (written != NULL)
529 *written += run_size; /* add run size to total written counter */
530 }
531
532 free(padding);
533
534 return retval;
535 }
536
537 int flash_write(struct target *target, struct image *image,
538 uint32_t *written, int erase)
539 {
540 return flash_write_unlock(target, image, written, erase, false);
541 }