?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
flash: factor init to 'flash init'
[openocd/ztw.git] / src / flash / flash.c
blob1e5ac9a355c909de777f8e3aacc585cc19ee3be2
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * Copyright (C) 2008 by Spencer Oliver *
9 * spen@spen-soft.co.uk *
10 * *
11 * This program is free software; you can redistribute it and/or modify *
12 * it under the terms of the GNU General Public License as published by *
13 * the Free Software Foundation; either version 2 of the License, or *
14 * (at your option) any later version. *
15 * *
16 * This program is distributed in the hope that it will be useful, *
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
19 * GNU General Public License for more details. *
20 * *
21 * You should have received a copy of the GNU General Public License *
22 * along with this program; if not, write to the *
23 * Free Software Foundation, Inc., *
24 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
25 ***************************************************************************/
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29
30 #include "flash.h"
31 #include "common.h"
32 #include "image.h"
33 #include "time_support.h"
34
35 static int flash_write_unlock(struct target *target, struct image *image, uint32_t *written, int erase, bool unlock);
36
37 /* flash drivers
38 */
39 extern struct flash_driver lpc2000_flash;
40 extern struct flash_driver lpc288x_flash;
41 extern struct flash_driver lpc2900_flash;
42 extern struct flash_driver cfi_flash;
43 extern struct flash_driver at91sam3_flash;
44 extern struct flash_driver at91sam7_flash;
45 extern struct flash_driver str7x_flash;
46 extern struct flash_driver str9x_flash;
47 extern struct flash_driver aduc702x_flash;
48 extern struct flash_driver stellaris_flash;
49 extern struct flash_driver str9xpec_flash;
50 extern struct flash_driver stm32x_flash;
51 extern struct flash_driver tms470_flash;
52 extern struct flash_driver ecosflash_flash;
53 extern struct flash_driver ocl_flash;
54 extern struct flash_driver pic32mx_flash;
55 extern struct flash_driver avr_flash;
56 extern struct flash_driver faux_flash;
57
58 struct flash_driver *flash_drivers[] = {
59 &lpc2000_flash,
60 &lpc288x_flash,
61 &lpc2900_flash,
62 &cfi_flash,
63 &at91sam7_flash,
64 &at91sam3_flash,
65 &str7x_flash,
66 &str9x_flash,
67 &aduc702x_flash,
68 &stellaris_flash,
69 &str9xpec_flash,
70 &stm32x_flash,
71 &tms470_flash,
72 &ecosflash_flash,
73 &ocl_flash,
74 &pic32mx_flash,
75 &avr_flash,
76 &faux_flash,
77 NULL,
78 };
79
80 struct flash_bank *flash_banks;
81
82 /* wafer thin wrapper for invoking the flash driver */
83 static int flash_driver_write(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
84 {
85 int retval;
86
87 retval = bank->driver->write(bank, buffer, offset, count);
88 if (retval != ERROR_OK)
89 {
90 LOG_ERROR("error writing to flash at address 0x%08" PRIx32 " at offset 0x%8.8" PRIx32 " (%d)",
91 bank->base, offset, retval);
92 }
93
94 return retval;
95 }
96
97 static int flash_driver_erase(struct flash_bank *bank, int first, int last)
98 {
99 int retval;
100
101 retval = bank->driver->erase(bank, first, last);
102 if (retval != ERROR_OK)
103 {
104 LOG_ERROR("failed erasing sectors %d to %d (%d)", first, last, retval);
105 }
106
107 return retval;
108 }
109
110 int flash_driver_protect(struct flash_bank *bank, int set, int first, int last)
111 {
112 int retval;
113
114 retval = bank->driver->protect(bank, set, first, last);
115 if (retval != ERROR_OK)
116 {
117 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first, last, retval);
118 }
119
120 return retval;
121 }
122
123 static int jim_flash_banks(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
124 {
125 struct flash_bank *p;
126
127 if (argc != 1) {
128 Jim_WrongNumArgs(interp, 1, argv, "no arguments to flash_banks command");
129 return JIM_ERR;
130 }
131
132 Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
133 for (p = flash_banks; p; p = p->next)
134 {
135 Jim_Obj *elem = Jim_NewListObj(interp, NULL, 0);
136
137 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "name", -1));
138 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, p->driver->name, -1));
139 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "base", -1));
140 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->base));
141 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "size", -1));
142 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->size));
143 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "bus_width", -1));
144 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->bus_width));
145 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "chip_width", -1));
146 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->chip_width));
147
148 Jim_ListAppendElement(interp, list, elem);
149 }
150
151 Jim_SetResult(interp, list);
152
153 return JIM_OK;
154 }
155
156 struct flash_bank *get_flash_bank_by_num_noprobe(int num)
157 {
158 struct flash_bank *p;
159 int i = 0;
160
161 for (p = flash_banks; p; p = p->next)
162 {
163 if (i++ == num)
164 {
165 return p;
166 }
167 }
168 LOG_ERROR("flash bank %d does not exist", num);
169 return NULL;
170 }
171
172 int flash_get_bank_count(void)
173 {
174 struct flash_bank *p;
175 int i = 0;
176 for (p = flash_banks; p; p = p->next)
177 {
178 i++;
179 }
180 return i;
181 }
182
183 struct flash_bank *get_flash_bank_by_name(const char *name)
184 {
185 unsigned requested = get_flash_name_index(name);
186 unsigned found = 0;
187
188 struct flash_bank *bank;
189 for (bank = flash_banks; NULL != bank; bank = bank->next)
190 {
191 if (strcmp(bank->name, name) == 0)
192 return bank;
193 if (!flash_driver_name_matches(bank->driver->name, name))
194 continue;
195 if (++found < requested)
196 continue;
197 return bank;
198 }
199 return NULL;
200 }
201
202 struct flash_bank *get_flash_bank_by_num(int num)
203 {
204 struct flash_bank *p = get_flash_bank_by_num_noprobe(num);
205 int retval;
206
207 if (p == NULL)
208 return NULL;
209
210 retval = p->driver->auto_probe(p);
211
212 if (retval != ERROR_OK)
213 {
214 LOG_ERROR("auto_probe failed %d\n", retval);
215 return NULL;
216 }
217 return p;
218 }
219
220 COMMAND_HELPER(flash_command_get_bank, unsigned name_index,
221 struct flash_bank **bank)
222 {
223 const char *name = CMD_ARGV[name_index];
224 *bank = get_flash_bank_by_name(name);
225 if (*bank)
226 return ERROR_OK;
227
228 unsigned bank_num;
229 COMMAND_PARSE_NUMBER(uint, name, bank_num);
230
231 *bank = get_flash_bank_by_num(bank_num);
232 if (!*bank)
233 {
234 command_print(CMD_CTX, "flash bank '%s' not found", name);
235 return ERROR_INVALID_ARGUMENTS;
236 }
237 return ERROR_OK;
238 }
239
240
241 COMMAND_HANDLER(handle_flash_bank_command)
242 {
243 if (CMD_ARGC < 7)
244 {
245 LOG_ERROR("usage: flash bank <name> <driver> "
246 "<base> <size> <chip_width> <bus_width>");
247 return ERROR_COMMAND_SYNTAX_ERROR;
248 }
249 // save bank name and advance arguments for compatibility
250 const char *bank_name = *CMD_ARGV++;
251 CMD_ARGC--;
252
253 struct target *target;
254 if ((target = get_target(CMD_ARGV[5])) == NULL)
255 {
256 LOG_ERROR("target '%s' not defined", CMD_ARGV[5]);
257 return ERROR_FAIL;
258 }
259
260 const char *driver_name = CMD_ARGV[0];
261 for (unsigned i = 0; flash_drivers[i]; i++)
262 {
263 if (strcmp(driver_name, flash_drivers[i]->name) != 0)
264 continue;
265
266 /* register flash specific commands */
267 if (NULL != flash_drivers[i]->commands)
268 {
269 int retval = register_commands(CMD_CTX, NULL,
270 flash_drivers[i]->commands);
271 if (ERROR_OK != retval)
272 {
273 LOG_ERROR("couldn't register '%s' commands",
274 driver_name);
275 return ERROR_FAIL;
276 }
277 }
278
279 struct flash_bank *p, *c;
280 c = malloc(sizeof(struct flash_bank));
281 c->name = strdup(bank_name);
282 c->target = target;
283 c->driver = flash_drivers[i];
284 c->driver_priv = NULL;
285 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], c->base);
286 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], c->size);
287 COMMAND_PARSE_NUMBER(int, CMD_ARGV[3], c->chip_width);
288 COMMAND_PARSE_NUMBER(int, CMD_ARGV[4], c->bus_width);
289 c->num_sectors = 0;
290 c->sectors = NULL;
291 c->next = NULL;
292
293 int retval;
294 retval = CALL_COMMAND_HANDLER(flash_drivers[i]->flash_bank_command, c);
295 if (ERROR_OK != retval)
296 {
297 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32,
298 driver_name, c->base);
299 free(c);
300 return retval;
301 }
302
303 /* put flash bank in linked list */
304 if (flash_banks)
305 {
306 int bank_num = 0;
307 /* find last flash bank */
308 for (p = flash_banks; p && p->next; p = p->next) bank_num++;
309 if (p)
310 p->next = c;
311 c->bank_number = bank_num + 1;
312 }
313 else
314 {
315 flash_banks = c;
316 c->bank_number = 0;
317 }
318
319 return ERROR_OK;
320 }
321
322 /* no matching flash driver found */
323 LOG_ERROR("flash driver '%s' not found", driver_name);
324 return ERROR_FAIL;
325 }
326
327 COMMAND_HANDLER(handle_flash_info_command)
328 {
329 struct flash_bank *p;
330 uint32_t i = 0;
331 int j = 0;
332 int retval;
333
334 if (CMD_ARGC != 1)
335 return ERROR_COMMAND_SYNTAX_ERROR;
336
337 unsigned bank_nr;
338 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], bank_nr);
339
340 for (p = flash_banks; p; p = p->next, i++)
341 {
342 if (i != bank_nr)
343 continue;
344
345 char buf[1024];
346
347 /* attempt auto probe */
348 if ((retval = p->driver->auto_probe(p)) != ERROR_OK)
349 return retval;
350
351 command_print(CMD_CTX,
352 "#%" PRIi32 " : %s at 0x%8.8" PRIx32 ", size 0x%8.8" PRIx32 ", buswidth %i, chipwidth %i",
353 i,
354 p->driver->name,
355 p->base,
356 p->size,
357 p->bus_width,
358 p->chip_width);
359 for (j = 0; j < p->num_sectors; j++)
360 {
361 char *protect_state;
362
363 if (p->sectors[j].is_protected == 0)
364 protect_state = "not protected";
365 else if (p->sectors[j].is_protected == 1)
366 protect_state = "protected";
367 else
368 protect_state = "protection state unknown";
369
370 command_print(CMD_CTX,
371 "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
372 j,
373 p->sectors[j].offset,
374 p->sectors[j].size,
375 p->sectors[j].size >> 10,
376 protect_state);
377 }
378
379 *buf = '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
380 retval = p->driver->info(p, buf, sizeof(buf));
381 command_print(CMD_CTX, "%s", buf);
382 if (retval != ERROR_OK)
383 LOG_ERROR("error retrieving flash info (%d)", retval);
384 }
385
386 return ERROR_OK;
387 }
388
389 COMMAND_HANDLER(handle_flash_probe_command)
390 {
391 int retval;
392
393 if (CMD_ARGC != 1)
394 {
395 return ERROR_COMMAND_SYNTAX_ERROR;
396 }
397
398 unsigned bank_nr;
399 COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], bank_nr);
400 struct flash_bank *p = get_flash_bank_by_num_noprobe(bank_nr);
401 if (p)
402 {
403 if ((retval = p->driver->probe(p)) == ERROR_OK)
404 {
405 command_print(CMD_CTX, "flash '%s' found at 0x%8.8" PRIx32, p->driver->name, p->base);
406 }
407 else if (retval == ERROR_FLASH_BANK_INVALID)
408 {
409 command_print(CMD_CTX, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32,
410 CMD_ARGV[0], p->base);
411 }
412 else
413 {
414 command_print(CMD_CTX, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32,
415 CMD_ARGV[0], p->base);
416 }
417 }
418 else
419 {
420 command_print(CMD_CTX, "flash bank '#%s' is out of bounds", CMD_ARGV[0]);
421 }
422
423 return ERROR_OK;
424 }
425
426 COMMAND_HANDLER(handle_flash_erase_check_command)
427 {
428 if (CMD_ARGC != 1)
429 {
430 return ERROR_COMMAND_SYNTAX_ERROR;
431 }
432
433 struct flash_bank *p;
434 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
435 if (ERROR_OK != retval)
436 return retval;
437
438 int j;
439 if ((retval = p->driver->erase_check(p)) == ERROR_OK)
440 {
441 command_print(CMD_CTX, "successfully checked erase state");
442 }
443 else
444 {
445 command_print(CMD_CTX, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32,
446 CMD_ARGV[0], p->base);
447 }
448
449 for (j = 0; j < p->num_sectors; j++)
450 {
451 char *erase_state;
452
453 if (p->sectors[j].is_erased == 0)
454 erase_state = "not erased";
455 else if (p->sectors[j].is_erased == 1)
456 erase_state = "erased";
457 else
458 erase_state = "erase state unknown";
459
460 command_print(CMD_CTX,
461 "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
462 j,
463 p->sectors[j].offset,
464 p->sectors[j].size,
465 p->sectors[j].size >> 10,
466 erase_state);
467 }
468
469 return ERROR_OK;
470 }
471
472 COMMAND_HANDLER(handle_flash_erase_address_command)
473 {
474 struct flash_bank *p;
475 int retval;
476 int address;
477 int length;
478
479 struct target *target = get_current_target(CMD_CTX);
480
481 if (CMD_ARGC != 2)
482 return ERROR_COMMAND_SYNTAX_ERROR;
483
484 COMMAND_PARSE_NUMBER(int, CMD_ARGV[0], address);
485 COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], length);
486 if (length <= 0)
487 {
488 command_print(CMD_CTX, "Length must be >0");
489 return ERROR_COMMAND_SYNTAX_ERROR;
490 }
491
492 p = get_flash_bank_by_addr(target, address);
493 if (p == NULL)
494 {
495 return ERROR_FAIL;
496 }
497
498 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
499 flash_set_dirty();
500
501 struct duration bench;
502 duration_start(&bench);
503
504 retval = flash_erase_address_range(target, address, length);
505
506 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
507 {
508 command_print(CMD_CTX, "erased address 0x%8.8x (length %i)"
509 " in %fs (%0.3f kb/s)", address, length,
510 duration_elapsed(&bench), duration_kbps(&bench, length));
511 }
512
513 return retval;
514 }
515
516 COMMAND_HANDLER(handle_flash_protect_check_command)
517 {
518 if (CMD_ARGC != 1)
519 return ERROR_COMMAND_SYNTAX_ERROR;
520
521 struct flash_bank *p;
522 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
523 if (ERROR_OK != retval)
524 return retval;
525
526 if ((retval = p->driver->protect_check(p)) == ERROR_OK)
527 {
528 command_print(CMD_CTX, "successfully checked protect state");
529 }
530 else if (retval == ERROR_FLASH_OPERATION_FAILED)
531 {
532 command_print(CMD_CTX, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32, CMD_ARGV[0], p->base);
533 }
534 else
535 {
536 command_print(CMD_CTX, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32, CMD_ARGV[0], p->base);
537 }
538
539 return ERROR_OK;
540 }
541
542 static int flash_check_sector_parameters(struct command_context *cmd_ctx,
543 uint32_t first, uint32_t last, uint32_t num_sectors)
544 {
545 if (!(first <= last)) {
546 command_print(cmd_ctx, "ERROR: "
547 "first sector must be <= last sector");
548 return ERROR_FAIL;
549 }
550
551 if (!(last <= (num_sectors - 1))) {
552 command_print(cmd_ctx, "ERROR: last sector must be <= %d",
553 (int) num_sectors - 1);
554 return ERROR_FAIL;
555 }
556
557 return ERROR_OK;
558 }
559
560 COMMAND_HANDLER(handle_flash_erase_command)
561 {
562 if (CMD_ARGC != 3)
563 return ERROR_COMMAND_SYNTAX_ERROR;
564
565 uint32_t bank_nr;
566 uint32_t first;
567 uint32_t last;
568
569 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], bank_nr);
570 struct flash_bank *p = get_flash_bank_by_num(bank_nr);
571 if (!p)
572 return ERROR_OK;
573
574 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first);
575 if (strcmp(CMD_ARGV[2], "last") == 0)
576 last = p->num_sectors - 1;
577 else
578 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
579
580 int retval;
581 if ((retval = flash_check_sector_parameters(CMD_CTX,
582 first, last, p->num_sectors)) != ERROR_OK)
583 return retval;
584
585 struct duration bench;
586 duration_start(&bench);
587
588 retval = flash_driver_erase(p, first, last);
589
590 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
591 {
592 command_print(CMD_CTX, "erased sectors %" PRIu32 " "
593 "through %" PRIu32" on flash bank %" PRIu32 " "
594 "in %fs", first, last, bank_nr, duration_elapsed(&bench));
595 }
596
597 return ERROR_OK;
598 }
599
600 COMMAND_HANDLER(handle_flash_protect_command)
601 {
602 if (CMD_ARGC != 4)
603 return ERROR_COMMAND_SYNTAX_ERROR;
604
605 uint32_t bank_nr;
606 uint32_t first;
607 uint32_t last;
608
609 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], bank_nr);
610 struct flash_bank *p = get_flash_bank_by_num(bank_nr);
611 if (!p)
612 return ERROR_OK;
613
614 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first);
615 if (strcmp(CMD_ARGV[2], "last") == 0)
616 last = p->num_sectors - 1;
617 else
618 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
619
620 bool set;
621 COMMAND_PARSE_ON_OFF(CMD_ARGV[3], set);
622
623 int retval;
624 if ((retval = flash_check_sector_parameters(CMD_CTX,
625 first, last, p->num_sectors)) != ERROR_OK)
626 return retval;
627
628 retval = flash_driver_protect(p, set, first, last);
629 if (retval == ERROR_OK) {
630 command_print(CMD_CTX, "%s protection for sectors %i "
631 "through %i on flash bank %i",
632 (set) ? "set" : "cleared", (int) first,
633 (int) last, (int) bank_nr);
634 }
635
636 return ERROR_OK;
637 }
638
639 COMMAND_HANDLER(handle_flash_write_image_command)
640 {
641 struct target *target = get_current_target(CMD_CTX);
642
643 struct image image;
644 uint32_t written;
645
646 int retval;
647
648 if (CMD_ARGC < 1)
649 {
650 return ERROR_COMMAND_SYNTAX_ERROR;
651 }
652
653 /* flash auto-erase is disabled by default*/
654 int auto_erase = 0;
655 bool auto_unlock = false;
656
657 for (;;)
658 {
659 if (strcmp(CMD_ARGV[0], "erase") == 0)
660 {
661 auto_erase = 1;
662 CMD_ARGV++;
663 CMD_ARGC--;
664 command_print(CMD_CTX, "auto erase enabled");
665 } else if (strcmp(CMD_ARGV[0], "unlock") == 0)
666 {
667 auto_unlock = true;
668 CMD_ARGV++;
669 CMD_ARGC--;
670 command_print(CMD_CTX, "auto unlock enabled");
671 } else
672 {
673 break;
674 }
675 }
676
677 if (CMD_ARGC < 1)
678 {
679 return ERROR_COMMAND_SYNTAX_ERROR;
680 }
681
682 if (!target)
683 {
684 LOG_ERROR("no target selected");
685 return ERROR_FAIL;
686 }
687
688 struct duration bench;
689 duration_start(&bench);
690
691 if (CMD_ARGC >= 2)
692 {
693 image.base_address_set = 1;
694 COMMAND_PARSE_NUMBER(int, CMD_ARGV[1], image.base_address);
695 }
696 else
697 {
698 image.base_address_set = 0;
699 image.base_address = 0x0;
700 }
701
702 image.start_address_set = 0;
703
704 retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL);
705 if (retval != ERROR_OK)
706 {
707 return retval;
708 }
709
710 retval = flash_write_unlock(target, &image, &written, auto_erase, auto_unlock);
711 if (retval != ERROR_OK)
712 {
713 image_close(&image);
714 return retval;
715 }
716
717 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
718 {
719 command_print(CMD_CTX, "wrote %" PRIu32 " byte from file %s "
720 "in %fs (%0.3f kb/s)", written, CMD_ARGV[0],
721 duration_elapsed(&bench), duration_kbps(&bench, written));
722 }
723
724 image_close(&image);
725
726 return retval;
727 }
728
729 COMMAND_HANDLER(handle_flash_fill_command)
730 {
731 int err = ERROR_OK;
732 uint32_t address;
733 uint32_t pattern;
734 uint32_t count;
735 uint32_t wrote = 0;
736 uint32_t cur_size = 0;
737 uint32_t chunk_count;
738 struct target *target = get_current_target(CMD_CTX);
739 uint32_t i;
740 uint32_t wordsize;
741 int retval = ERROR_OK;
742
743 static size_t const chunksize = 1024;
744 uint8_t *chunk = malloc(chunksize);
745 if (chunk == NULL)
746 return ERROR_FAIL;
747
748 uint8_t *readback = malloc(chunksize);
749 if (readback == NULL)
750 {
751 free(chunk);
752 return ERROR_FAIL;
753 }
754
755
756 if (CMD_ARGC != 3)
757 {
758 retval = ERROR_COMMAND_SYNTAX_ERROR;
759 goto done;
760 }
761
762
763 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], address);
764 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], pattern);
765 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], count);
766
767 if (count == 0)
768 goto done;
769
770 switch (CMD_NAME[4])
771 {
772 case 'w':
773 wordsize = 4;
774 break;
775 case 'h':
776 wordsize = 2;
777 break;
778 case 'b':
779 wordsize = 1;
780 break;
781 default:
782 retval = ERROR_COMMAND_SYNTAX_ERROR;
783 goto done;
784 }
785
786 chunk_count = MIN(count, (chunksize / wordsize));
787 switch (wordsize)
788 {
789 case 4:
790 for (i = 0; i < chunk_count; i++)
791 {
792 target_buffer_set_u32(target, chunk + i * wordsize, pattern);
793 }
794 break;
795 case 2:
796 for (i = 0; i < chunk_count; i++)
797 {
798 target_buffer_set_u16(target, chunk + i * wordsize, pattern);
799 }
800 break;
801 case 1:
802 memset(chunk, pattern, chunk_count);
803 break;
804 default:
805 LOG_ERROR("BUG: can't happen");
806 exit(-1);
807 }
808
809 struct duration bench;
810 duration_start(&bench);
811
812 for (wrote = 0; wrote < (count*wordsize); wrote += cur_size)
813 {
814 cur_size = MIN((count*wordsize - wrote), sizeof(chunk));
815 struct flash_bank *bank;
816 bank = get_flash_bank_by_addr(target, address);
817 if (bank == NULL)
818 {
819 retval = ERROR_FAIL;
820 goto done;
821 }
822 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
823 if (err != ERROR_OK)
824 {
825 retval = err;
826 goto done;
827 }
828
829 err = target_read_buffer(target, address + wrote, cur_size, readback);
830 if (err != ERROR_OK)
831 {
832 retval = err;
833 goto done;
834 }
835
836 unsigned i;
837 for (i = 0; i < cur_size; i++)
838 {
839 if (readback[i]!=chunk[i])
840 {
841 LOG_ERROR("Verfication error address 0x%08" PRIx32 ", read back 0x%02x, expected 0x%02x",
842 address + wrote + i, readback[i], chunk[i]);
843 retval = ERROR_FAIL;
844 goto done;
845 }
846 }
847 }
848
849 if (duration_measure(&bench) == ERROR_OK)
850 {
851 command_print(CMD_CTX, "wrote %" PRIu32 " bytes to 0x%8.8" PRIx32
852 " in %fs (%0.3f kb/s)", wrote, address,
853 duration_elapsed(&bench), duration_kbps(&bench, wrote));
854 }
855
856 done:
857 free(readback);
858 free(chunk);
859
860 return retval;
861 }
862
863 COMMAND_HANDLER(handle_flash_write_bank_command)
864 {
865 uint32_t offset;
866 uint8_t *buffer;
867 struct fileio fileio;
868
869 if (CMD_ARGC != 3)
870 return ERROR_COMMAND_SYNTAX_ERROR;
871
872 struct duration bench;
873 duration_start(&bench);
874
875 struct flash_bank *p;
876 int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
877 if (ERROR_OK != retval)
878 return retval;
879
880 COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], offset);
881
882 if (fileio_open(&fileio, CMD_ARGV[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
883 {
884 return ERROR_OK;
885 }
886
887 buffer = malloc(fileio.size);
888 size_t buf_cnt;
889 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
890 {
891 free(buffer);
892 fileio_close(&fileio);
893 return ERROR_OK;
894 }
895
896 retval = flash_driver_write(p, buffer, offset, buf_cnt);
897
898 free(buffer);
899 buffer = NULL;
900
901 if ((ERROR_OK == retval) && (duration_measure(&bench) == ERROR_OK))
902 {
903 command_print(CMD_CTX, "wrote %zu byte from file %s to flash bank %u"
904 " at offset 0x%8.8" PRIx32 " in %fs (%0.3f kb/s)",
905 fileio.size, CMD_ARGV[1], p->bank_number, offset,
906 duration_elapsed(&bench), duration_kbps(&bench, fileio.size));
907 }
908
909 fileio_close(&fileio);
910
911 return retval;
912 }
913
914 void flash_set_dirty(void)
915 {
916 struct flash_bank *c;
917 int i;
918
919 /* set all flash to require erasing */
920 for (c = flash_banks; c; c = c->next)
921 {
922 for (i = 0; i < c->num_sectors; i++)
923 {
924 c->sectors[i].is_erased = 0;
925 }
926 }
927 }
928
929 /* lookup flash bank by address */
930 struct flash_bank *get_flash_bank_by_addr(struct target *target, uint32_t addr)
931 {
932 struct flash_bank *c;
933
934 /* cycle through bank list */
935 for (c = flash_banks; c; c = c->next)
936 {
937 int retval;
938 retval = c->driver->auto_probe(c);
939
940 if (retval != ERROR_OK)
941 {
942 LOG_ERROR("auto_probe failed %d\n", retval);
943 return NULL;
944 }
945 /* check whether address belongs to this flash bank */
946 if ((addr >= c->base) && (addr <= c->base + (c->size - 1)) && target == c->target)
947 return c;
948 }
949 LOG_ERROR("No flash at address 0x%08" PRIx32 "\n", addr);
950 return NULL;
951 }
952
953 /* erase given flash region, selects proper bank according to target and address */
954 static int flash_iterate_address_range(struct target *target, uint32_t addr, uint32_t length,
955 int (*callback)(struct flash_bank *bank, int first, int last))
956 {
957 struct flash_bank *c;
958 int first = -1;
959 int last = -1;
960 int i;
961
962 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
963 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
964
965 if (c->size == 0 || c->num_sectors == 0)
966 {
967 LOG_ERROR("Bank is invalid");
968 return ERROR_FLASH_BANK_INVALID;
969 }
970
971 if (length == 0)
972 {
973 /* special case, erase whole bank when length is zero */
974 if (addr != c->base)
975 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
976
977 return callback(c, 0, c->num_sectors - 1);
978 }
979
980 /* check whether it fits */
981 if (addr + length - 1 > c->base + c->size - 1)
982 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
983
984 addr -= c->base;
985
986 for (i = 0; i < c->num_sectors; i++)
987 {
988 /* check whether sector overlaps with the given range and is not yet erased */
989 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
990 /* if first is not set yet then this is the first sector */
991 if (first == -1)
992 first = i;
993 last = i; /* and it is the last one so far in any case */
994 }
995 }
996
997 if (first == -1 || last == -1)
998 return ERROR_OK;
999
1000 return callback(c, first, last);
1001 }
1002
1003
1004
1005 int flash_erase_address_range(struct target *target, uint32_t addr, uint32_t length)
1006 {
1007 return flash_iterate_address_range(target, addr, length, &flash_driver_erase);
1008 }
1009
1010 static int flash_driver_unprotect(struct flash_bank *bank, int first, int last)
1011 {
1012 return flash_driver_protect(bank, 0, first, last);
1013 }
1014
1015 static int flash_unlock_address_range(struct target *target, uint32_t addr, uint32_t length)
1016 {
1017 return flash_iterate_address_range(target, addr, length, &flash_driver_unprotect);
1018 }
1019
1020
1021 /* write (optional verify) an image to flash memory of the given target */
1022 static int flash_write_unlock(struct target *target, struct image *image, uint32_t *written, int erase, bool unlock)
1023 {
1024 int retval = ERROR_OK;
1025
1026 int section;
1027 uint32_t section_offset;
1028 struct flash_bank *c;
1029 int *padding;
1030
1031 section = 0;
1032 section_offset = 0;
1033
1034 if (written)
1035 *written = 0;
1036
1037 if (erase)
1038 {
1039 /* assume all sectors need erasing - stops any problems
1040 * when flash_write is called multiple times */
1041
1042 flash_set_dirty();
1043 }
1044
1045 /* allocate padding array */
1046 padding = malloc(image->num_sections * sizeof(padding));
1047
1048 /* loop until we reach end of the image */
1049 while (section < image->num_sections)
1050 {
1051 uint32_t buffer_size;
1052 uint8_t *buffer;
1053 int section_first;
1054 int section_last;
1055 uint32_t run_address = image->sections[section].base_address + section_offset;
1056 uint32_t run_size = image->sections[section].size - section_offset;
1057 int pad_bytes = 0;
1058
1059 if (image->sections[section].size == 0)
1060 {
1061 LOG_WARNING("empty section %d", section);
1062 section++;
1063 section_offset = 0;
1064 continue;
1065 }
1066
1067 /* find the corresponding flash bank */
1068 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
1069 {
1070 section++; /* and skip it */
1071 section_offset = 0;
1072 continue;
1073 }
1074
1075 /* collect consecutive sections which fall into the same bank */
1076 section_first = section;
1077 section_last = section;
1078 padding[section] = 0;
1079 while ((run_address + run_size - 1 < c->base + c->size - 1)
1080 && (section_last + 1 < image->num_sections))
1081 {
1082 if (image->sections[section_last + 1].base_address < (run_address + run_size))
1083 {
1084 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
1085 break;
1086 }
1087 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1088 * attempt to rebuild a consecutive buffer for the flash loader */
1089 pad_bytes = (image->sections[section_last + 1].base_address) - (run_address + run_size);
1090 if ((run_address + run_size + pad_bytes) > (c->base + c->size))
1091 break;
1092 padding[section_last] = pad_bytes;
1093 run_size += image->sections[++section_last].size;
1094 run_size += pad_bytes;
1095 padding[section_last] = 0;
1096
1097 LOG_INFO("Padding image section %d with %d bytes", section_last-1, pad_bytes);
1098 }
1099
1100 /* fit the run into bank constraints */
1101 if (run_address + run_size - 1 > c->base + c->size - 1)
1102 {
1103 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1104 (int)(c->base + c->size - run_address), (int)(run_size), (int)(c->size));
1105 run_size = c->base + c->size - run_address;
1106 }
1107
1108 /* allocate buffer */
1109 buffer = malloc(run_size);
1110 buffer_size = 0;
1111
1112 /* read sections to the buffer */
1113 while (buffer_size < run_size)
1114 {
1115 size_t size_read;
1116
1117 size_read = run_size - buffer_size;
1118 if (size_read > image->sections[section].size - section_offset)
1119 size_read = image->sections[section].size - section_offset;
1120
1121 if ((retval = image_read_section(image, section, section_offset,
1122 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
1123 {
1124 free(buffer);
1125 free(padding);
1126 return retval;
1127 }
1128
1129 /* see if we need to pad the section */
1130 while (padding[section]--)
1131 (buffer + buffer_size)[size_read++] = 0xff;
1132
1133 buffer_size += size_read;
1134 section_offset += size_read;
1135
1136 if (section_offset >= image->sections[section].size)
1137 {
1138 section++;
1139 section_offset = 0;
1140 }
1141 }
1142
1143 retval = ERROR_OK;
1144
1145 if (unlock)
1146 {
1147 retval = flash_unlock_address_range(target, run_address, run_size);
1148 }
1149 if (retval == ERROR_OK)
1150 {
1151 if (erase)
1152 {
1153 /* calculate and erase sectors */
1154 retval = flash_erase_address_range(target, run_address, run_size);
1155 }
1156 }
1157
1158 if (retval == ERROR_OK)
1159 {
1160 /* write flash sectors */
1161 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
1162 }
1163
1164 free(buffer);
1165
1166 if (retval != ERROR_OK)
1167 {
1168 free(padding);
1169 return retval; /* abort operation */
1170 }
1171
1172 if (written != NULL)
1173 *written += run_size; /* add run size to total written counter */
1174 }
1175
1176 free(padding);
1177
1178 return retval;
1179 }
1180
1181 int flash_write(struct target *target, struct image *image, uint32_t *written, int erase)
1182 {
1183 return flash_write_unlock(target, image, written, erase, false);
1184 }
1185
1186 int default_flash_mem_blank_check(struct flash_bank *bank)
1187 {
1188 struct target *target = bank->target;
1189 const int buffer_size = 1024;
1190 int i;
1191 uint32_t nBytes;
1192 int retval = ERROR_OK;
1193
1194 if (bank->target->state != TARGET_HALTED)
1195 {
1196 LOG_ERROR("Target not halted");
1197 return ERROR_TARGET_NOT_HALTED;
1198 }
1199
1200 uint8_t *buffer = malloc(buffer_size);
1201
1202 for (i = 0; i < bank->num_sectors; i++)
1203 {
1204 uint32_t j;
1205 bank->sectors[i].is_erased = 1;
1206
1207 for (j = 0; j < bank->sectors[i].size; j += buffer_size)
1208 {
1209 uint32_t chunk;
1210 chunk = buffer_size;
1211 if (chunk > (j - bank->sectors[i].size))
1212 {
1213 chunk = (j - bank->sectors[i].size);
1214 }
1215
1216 retval = target_read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
1217 if (retval != ERROR_OK)
1218 {
1219 goto done;
1220 }
1221
1222 for (nBytes = 0; nBytes < chunk; nBytes++)
1223 {
1224 if (buffer[nBytes] != 0xFF)
1225 {
1226 bank->sectors[i].is_erased = 0;
1227 break;
1228 }
1229 }
1230 }
1231 }
1232
1233 done:
1234 free(buffer);
1235
1236 return retval;
1237 }
1238
1239 int default_flash_blank_check(struct flash_bank *bank)
1240 {
1241 struct target *target = bank->target;
1242 int i;
1243 int retval;
1244 int fast_check = 0;
1245 uint32_t blank;
1246
1247 if (bank->target->state != TARGET_HALTED)
1248 {
1249 LOG_ERROR("Target not halted");
1250 return ERROR_TARGET_NOT_HALTED;
1251 }
1252
1253 for (i = 0; i < bank->num_sectors; i++)
1254 {
1255 uint32_t address = bank->base + bank->sectors[i].offset;
1256 uint32_t size = bank->sectors[i].size;
1257
1258 if ((retval = target_blank_check_memory(target, address, size, &blank)) != ERROR_OK)
1259 {
1260 fast_check = 0;
1261 break;
1262 }
1263 if (blank == 0xFF)
1264 bank->sectors[i].is_erased = 1;
1265 else
1266 bank->sectors[i].is_erased = 0;
1267 fast_check = 1;
1268 }
1269
1270 if (!fast_check)
1271 {
1272 LOG_USER("Running slow fallback erase check - add working memory");
1273 return default_flash_mem_blank_check(bank);
1274 }
1275
1276 return ERROR_OK;
1277 }
1278
1279 static const struct command_registration flash_exec_command_handlers[] = {
1280 {
1281 .name = "probe",
1282 .handler = &handle_flash_probe_command,
1283 .mode = COMMAND_EXEC,
1284 .usage = "<bank>",
1285 .help = "identify flash bank",
1286 },
1287 {
1288 .name = "info",
1289 .handler = &handle_flash_info_command,
1290 .mode = COMMAND_EXEC,
1291 .usage = "<bank>",
1292 .help = "print bank information",
1293 },
1294 {
1295 .name = "erase_check",
1296 .handler = &handle_flash_erase_check_command,
1297 .mode = COMMAND_EXEC,
1298 .usage = "<bank>",
1299 .help = "check erase state of sectors",
1300 },
1301 {
1302 .name = "protect_check",
1303 .handler = &handle_flash_protect_check_command,
1304 .mode = COMMAND_EXEC,
1305 .usage = "<bank>",
1306 .help = "check protection state of sectors",
1307 },
1308 {
1309 .name = "erase_sector",
1310 .handler = &handle_flash_erase_command,
1311 .mode = COMMAND_EXEC,
1312 .usage = "<bank> <first> <last>",
1313 .help = "erase sectors",
1314 },
1315 {
1316 .name = "erase_address",
1317 .handler = &handle_flash_erase_address_command,
1318 .mode = COMMAND_EXEC,
1319 .usage = "<address> <length>",
1320 .help = "erase address range",
1321
1322 },
1323 {
1324 .name = "fillw",
1325 .handler = &handle_flash_fill_command,
1326 .mode = COMMAND_EXEC,
1327 .usage = "<bank> <address> <word_pattern> <count>",
1328 .help = "fill with pattern (no autoerase)",
1329 },
1330 {
1331 .name = "fillh",
1332 .handler = &handle_flash_fill_command,
1333 .mode = COMMAND_EXEC,
1334 .usage = "<bank> <address> <halfword_pattern> <count>",
1335 .help = "fill with pattern",
1336 },
1337 {
1338 .name = "fillb",
1339 .handler = &handle_flash_fill_command,
1340 .mode = COMMAND_EXEC,
1341 .usage = "<bank> <address> <byte_pattern> <count>",
1342 .help = "fill with pattern",
1343
1344 },
1345 {
1346 .name = "write_bank",
1347 .handler = &handle_flash_write_bank_command,
1348 .mode = COMMAND_EXEC,
1349 .usage = "<bank> <file> <offset>",
1350 .help = "write binary data",
1351 },
1352 {
1353 .name = "write_image",
1354 .handler = &handle_flash_write_image_command,
1355 .mode = COMMAND_EXEC,
1356 .usage = "<bank> [erase] [unlock] <file> [offset] [type]",
1357 .help = "write an image to flash"
1358 },
1359 {
1360 .name = "protect",
1361 .handler = &handle_flash_protect_command,
1362 .mode = COMMAND_EXEC,
1363 .usage = "<bank> <first> <last> <on | off>",
1364 .help = "set protection of sectors",
1365 },
1366 COMMAND_REGISTRATION_DONE
1367 };
1368
1369 int flash_init_drivers(struct command_context *cmd_ctx)
1370 {
1371 if (!flash_banks)
1372 return ERROR_OK;
1373
1374 struct command *parent = command_find_in_context(cmd_ctx, "flash");
1375 return register_commands(cmd_ctx, parent, flash_exec_command_handlers);
1376 }
1377
1378 COMMAND_HANDLER(handle_flash_init_command)
1379 {
1380 if (CMD_ARGC != 0)
1381 return ERROR_COMMAND_SYNTAX_ERROR;
1382
1383 static bool flash_initialized = false;
1384 if (flash_initialized)
1385 {
1386 LOG_INFO("'flash init' has already been called");
1387 return ERROR_OK;
1388 }
1389 flash_initialized = true;
1390
1391 LOG_DEBUG("Initializing flash devices...");
1392 return flash_init_drivers(CMD_CTX);
1393 }
1394
1395 static const struct command_registration flash_config_command_handlers[] = {
1396 {
1397 .name = "bank",
1398 .handler = &handle_flash_bank_command,
1399 .mode = COMMAND_CONFIG,
1400 .usage = "<name> <driver> <base> <size> "
1401 "<chip_width> <bus_width> <target> "
1402 "[driver_options ...]",
1403 .help = "Define a new bank with the given name, "
1404 "using the specified NOR flash driver.",
1405 },
1406 {
1407 .name = "init",
1408 .mode = COMMAND_CONFIG,
1409 .handler = &handle_flash_init_command,
1410 .help = "initialize flash devices",
1411 },
1412 {
1413 .name = "banks",
1414 .mode = COMMAND_ANY,
1415 .jim_handler = &jim_flash_banks,
1416 .help = "return information about the flash banks",
1417 },
1418 COMMAND_REGISTRATION_DONE
1419 };
1420 static const struct command_registration flash_command_handlers[] = {
1421 {
1422 .name = "flash",
1423 .mode = COMMAND_ANY,
1424 .help = "NOR flash command group",
1425 .chain = flash_config_command_handlers,
1426 },
1427 COMMAND_REGISTRATION_DONE
1428 };
1429
1430 int flash_register_commands(struct command_context *cmd_ctx)
1431 {
1432 return register_commands(cmd_ctx, NULL, flash_command_handlers);
1433 }
Zach's Unofficial Testing Repository