02505b038a6422bee49b307e019d4c6973510868
[openocd.git] / src / flash / flash.c
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 "image.h"
32 #include "time_support.h"
33
34 /* command handlers */
35 static int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
36 static int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
37 static int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
38 static int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
39 static int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
40 static int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
41 static int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
42 static int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
43 static int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
44 static int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
45 static int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
46
47 /* flash drivers
48 */
49 extern flash_driver_t lpc2000_flash;
50 extern flash_driver_t cfi_flash;
51 extern flash_driver_t at91sam7_flash;
52 extern flash_driver_t str7x_flash;
53 extern flash_driver_t str9x_flash;
54 extern flash_driver_t aduc702x_flash;
55 extern flash_driver_t stellaris_flash;
56 extern flash_driver_t str9xpec_flash;
57 extern flash_driver_t stm32x_flash;
58 extern flash_driver_t tms470_flash;
59 extern flash_driver_t ecosflash_flash;
60 extern flash_driver_t lpc288x_flash;
61 extern flash_driver_t ocl_flash;
62 extern flash_driver_t pic32mx_flash;
63 extern flash_driver_t avr_flash;
64
65 flash_driver_t *flash_drivers[] = {
66 &lpc2000_flash,
67 &cfi_flash,
68 &at91sam7_flash,
69 &str7x_flash,
70 &str9x_flash,
71 &aduc702x_flash,
72 &stellaris_flash,
73 &str9xpec_flash,
74 &stm32x_flash,
75 &tms470_flash,
76 &ecosflash_flash,
77 &lpc288x_flash,
78 &ocl_flash,
79 &pic32mx_flash,
80 &avr_flash,
81 NULL,
82 };
83
84 flash_bank_t *flash_banks;
85 static command_t *flash_cmd;
86
87 /* wafer thin wrapper for invoking the flash driver */
88 static int flash_driver_write(struct flash_bank_s *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
89 {
90 int retval;
91
92 retval=bank->driver->write(bank, buffer, offset, count);
93 if (retval!=ERROR_OK)
94 {
95 LOG_ERROR("error writing to flash at address 0x%08" PRIx32 " at offset 0x%8.8" PRIx32 " (%d)",
96 bank->base, offset, retval);
97 }
98
99 return retval;
100 }
101
102 static int flash_driver_erase(struct flash_bank_s *bank, int first, int last)
103 {
104 int retval;
105
106 retval=bank->driver->erase(bank, first, last);
107 if (retval!=ERROR_OK)
108 {
109 LOG_ERROR("failed erasing sectors %d to %d (%d)", first, last, retval);
110 }
111
112 return retval;
113 }
114
115 int flash_driver_protect(struct flash_bank_s *bank, int set, int first, int last)
116 {
117 int retval;
118
119 retval=bank->driver->protect(bank, set, first, last);
120 if (retval!=ERROR_OK)
121 {
122 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first, last, retval);
123 }
124
125 return retval;
126 }
127
128 int flash_register_commands(struct command_context_s *cmd_ctx)
129 {
130 flash_cmd = register_command(cmd_ctx, NULL, "flash", NULL, COMMAND_ANY, NULL);
131
132 register_command(cmd_ctx, flash_cmd, "bank", handle_flash_bank_command, COMMAND_CONFIG, "flash bank <driver> <base> <size> <chip_width> <bus_width> <target> [driver_options ...]");
133 return ERROR_OK;
134 }
135
136 static int jim_flash_banks(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
137 {
138 flash_bank_t *p;
139
140 if (argc != 1) {
141 Jim_WrongNumArgs(interp, 1, argv, "no arguments to flash_banks command");
142 return JIM_ERR;
143 }
144
145 Jim_Obj *list=Jim_NewListObj(interp, NULL, 0);
146 for (p = flash_banks; p; p = p->next)
147 {
148 Jim_Obj *elem=Jim_NewListObj(interp, NULL, 0);
149
150 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "name", -1));
151 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, p->driver->name, -1));
152 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "base", -1));
153 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->base));
154 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "size", -1));
155 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->size));
156 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "bus_width", -1));
157 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->bus_width));
158 Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "chip_width", -1));
159 Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->chip_width));
160
161 Jim_ListAppendElement(interp, list, elem);
162 }
163
164 Jim_SetResult(interp, list);
165
166 return JIM_OK;
167 }
168
169 int flash_init_drivers(struct command_context_s *cmd_ctx)
170 {
171 register_jim(cmd_ctx, "ocd_flash_banks", jim_flash_banks, "return information about the flash banks");
172
173 if (flash_banks)
174 {
175 register_command(cmd_ctx, flash_cmd, "info", handle_flash_info_command, COMMAND_EXEC,
176 "print info about flash bank <num>");
177 register_command(cmd_ctx, flash_cmd, "probe", handle_flash_probe_command, COMMAND_EXEC,
178 "identify flash bank <num>");
179 register_command(cmd_ctx, flash_cmd, "erase_check", handle_flash_erase_check_command, COMMAND_EXEC,
180 "check erase state of sectors in flash bank <num>");
181 register_command(cmd_ctx, flash_cmd, "protect_check", handle_flash_protect_check_command, COMMAND_EXEC,
182 "check protection state of sectors in flash bank <num>");
183 register_command(cmd_ctx, flash_cmd, "erase_sector", handle_flash_erase_command, COMMAND_EXEC,
184 "erase sectors at <bank> <first> <last>");
185 register_command(cmd_ctx, flash_cmd, "erase_address", handle_flash_erase_address_command, COMMAND_EXEC,
186 "erase address range <address> <length>");
187
188 register_command(cmd_ctx, flash_cmd, "fillw", handle_flash_fill_command, COMMAND_EXEC,
189 "fill with pattern (no autoerase) <address> <word_pattern> <count>");
190 register_command(cmd_ctx, flash_cmd, "fillh", handle_flash_fill_command, COMMAND_EXEC,
191 "fill with pattern <address> <halfword_pattern> <count>");
192 register_command(cmd_ctx, flash_cmd, "fillb", handle_flash_fill_command, COMMAND_EXEC,
193 "fill with pattern <address> <byte_pattern> <count>");
194
195 register_command(cmd_ctx, flash_cmd, "write_bank", handle_flash_write_bank_command, COMMAND_EXEC,
196 "write binary data to <bank> <file> <offset>");
197 register_command(cmd_ctx, flash_cmd, "write_image", handle_flash_write_image_command, COMMAND_EXEC,
198 "write_image [erase] <file> [offset] [type]");
199 register_command(cmd_ctx, flash_cmd, "protect", handle_flash_protect_command, COMMAND_EXEC,
200 "set protection of sectors at <bank> <first> <last> <on|off>");
201 }
202
203 return ERROR_OK;
204 }
205
206 flash_bank_t *get_flash_bank_by_num_noprobe(int num)
207 {
208 flash_bank_t *p;
209 int i = 0;
210
211 for (p = flash_banks; p; p = p->next)
212 {
213 if (i++ == num)
214 {
215 return p;
216 }
217 }
218 LOG_ERROR("flash bank %d does not exist", num);
219 return NULL;
220 }
221
222 int flash_get_bank_count(void)
223 {
224 flash_bank_t *p;
225 int i = 0;
226 for (p = flash_banks; p; p = p->next)
227 {
228 i++;
229 }
230 return i;
231 }
232
233 flash_bank_t *get_flash_bank_by_num(int num)
234 {
235 flash_bank_t *p = get_flash_bank_by_num_noprobe(num);
236 int retval;
237
238 if (p == NULL)
239 return NULL;
240
241 retval = p->driver->auto_probe(p);
242
243 if (retval != ERROR_OK)
244 {
245 LOG_ERROR("auto_probe failed %d\n", retval);
246 return NULL;
247 }
248 return p;
249 }
250
251 static int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
252 {
253 int retval;
254 int i;
255 int found = 0;
256 target_t *target;
257
258 if (argc < 6)
259 {
260 return ERROR_COMMAND_SYNTAX_ERROR;
261 }
262
263 if ((target = get_target(args[5])) == NULL)
264 {
265 LOG_ERROR("target '%s' not defined", args[5]);
266 return ERROR_FAIL;
267 }
268
269 for (i = 0; flash_drivers[i]; i++)
270 {
271 if (strcmp(args[0], flash_drivers[i]->name) == 0)
272 {
273 flash_bank_t *p, *c;
274
275 /* register flash specific commands */
276 if (flash_drivers[i]->register_commands(cmd_ctx) != ERROR_OK)
277 {
278 LOG_ERROR("couldn't register '%s' commands", args[0]);
279 return ERROR_FAIL;
280 }
281
282 c = malloc(sizeof(flash_bank_t));
283 c->target = target;
284 c->driver = flash_drivers[i];
285 c->driver_priv = NULL;
286 c->base = strtoul(args[1], NULL, 0);
287 c->size = strtoul(args[2], NULL, 0);
288 c->chip_width = strtoul(args[3], NULL, 0);
289 c->bus_width = strtoul(args[4], NULL, 0);
290 c->num_sectors = 0;
291 c->sectors = NULL;
292 c->next = NULL;
293
294 if ((retval=flash_drivers[i]->flash_bank_command(cmd_ctx, cmd, args, argc, c)) != ERROR_OK)
295 {
296 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8" PRIx32 , args[0], c->base);
297 free(c);
298 return retval;
299 }
300
301 /* put flash bank in linked list */
302 if (flash_banks)
303 {
304 int bank_num = 0;
305 /* find last flash bank */
306 for (p = flash_banks; p && p->next; p = p->next) bank_num++;
307 if (p)
308 p->next = c;
309 c->bank_number = bank_num + 1;
310 }
311 else
312 {
313 flash_banks = c;
314 c->bank_number = 0;
315 }
316
317 found = 1;
318 }
319 }
320
321 /* no matching flash driver found */
322 if (!found)
323 {
324 LOG_ERROR("flash driver '%s' not found", args[0]);
325 return ERROR_FAIL;
326 }
327
328 return ERROR_OK;
329 }
330
331 static int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
332 {
333 flash_bank_t *p;
334 uint32_t i = 0;
335 int j = 0;
336 int retval;
337
338 if (argc != 1)
339 {
340 return ERROR_COMMAND_SYNTAX_ERROR;
341 }
342
343 for (p = flash_banks; p; p = p->next, i++)
344 {
345 if (i == strtoul(args[0], NULL, 0))
346 {
347 char buf[1024];
348
349 /* attempt auto probe */
350 if ((retval = p->driver->auto_probe(p)) != ERROR_OK)
351 return retval;
352
353 command_print(cmd_ctx,
354 "#%" PRIi32 " : %s at 0x%8.8" PRIx32 ", size 0x%8.8" PRIx32 ", buswidth %i, chipwidth %i",
355 i,
356 p->driver->name,
357 p->base,
358 p->size,
359 p->bus_width,
360 p->chip_width);
361 for (j = 0; j < p->num_sectors; j++)
362 {
363 char *protect_state;
364
365 if (p->sectors[j].is_protected == 0)
366 protect_state = "not protected";
367 else if (p->sectors[j].is_protected == 1)
368 protect_state = "protected";
369 else
370 protect_state = "protection state unknown";
371
372 command_print(cmd_ctx,
373 "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
374 j,
375 p->sectors[j].offset,
376 p->sectors[j].size,
377 p->sectors[j].size>>10,
378 protect_state);
379 }
380
381 *buf = '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
382 retval = p->driver->info(p, buf, sizeof(buf));
383 command_print(cmd_ctx, "%s", buf);
384 if (retval != ERROR_OK)
385 LOG_ERROR("error retrieving flash info (%d)", retval);
386 }
387 }
388
389 return ERROR_OK;
390 }
391
392 static int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
393 {
394 flash_bank_t *p;
395 int retval;
396
397 if (argc != 1)
398 {
399 return ERROR_COMMAND_SYNTAX_ERROR;
400 }
401
402 p = get_flash_bank_by_num_noprobe(strtoul(args[0], NULL, 0));
403 if (p)
404 {
405 if ((retval = p->driver->probe(p)) == ERROR_OK)
406 {
407 command_print(cmd_ctx, "flash '%s' found at 0x%8.8" PRIx32, p->driver->name, p->base);
408 }
409 else if (retval == ERROR_FLASH_BANK_INVALID)
410 {
411 command_print(cmd_ctx, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32,
412 args[0], p->base);
413 }
414 else
415 {
416 command_print(cmd_ctx, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32,
417 args[0], p->base);
418 }
419 }
420 else
421 {
422 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
423 }
424
425 return ERROR_OK;
426 }
427
428 static int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
429 {
430 flash_bank_t *p;
431 int retval;
432
433 if (argc != 1)
434 {
435 return ERROR_COMMAND_SYNTAX_ERROR;
436 }
437
438 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
439 if (p)
440 {
441 int j;
442 if ((retval = p->driver->erase_check(p)) == ERROR_OK)
443 {
444 command_print(cmd_ctx, "successfully checked erase state");
445 }
446 else
447 {
448 command_print(cmd_ctx, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32,
449 args[0], p->base);
450 }
451
452 for (j = 0; j < p->num_sectors; j++)
453 {
454 char *erase_state;
455
456 if (p->sectors[j].is_erased == 0)
457 erase_state = "not erased";
458 else if (p->sectors[j].is_erased == 1)
459 erase_state = "erased";
460 else
461 erase_state = "erase state unknown";
462
463 command_print(cmd_ctx,
464 "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
465 j,
466 p->sectors[j].offset,
467 p->sectors[j].size,
468 p->sectors[j].size>>10,
469 erase_state);
470 }
471 }
472
473 return ERROR_OK;
474 }
475
476 static int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
477 {
478 flash_bank_t *p;
479 int retval;
480 int address;
481 int length;
482 duration_t duration;
483 char *duration_text;
484
485 target_t *target = get_current_target(cmd_ctx);
486
487 if (argc != 2)
488 {
489 return ERROR_COMMAND_SYNTAX_ERROR;
490 }
491
492 address = strtoul(args[0], NULL, 0);
493 length = strtoul(args[1], NULL, 0);
494 if (length <= 0)
495 {
496 command_print(cmd_ctx, "Length must be >0");
497 return ERROR_COMMAND_SYNTAX_ERROR;
498 }
499
500 p = get_flash_bank_by_addr(target, address);
501 if (p == NULL)
502 {
503 return ERROR_FAIL;
504 }
505
506 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
507 flash_set_dirty();
508
509 duration_start_measure(&duration);
510
511 if ((retval = flash_erase_address_range(target, address, length)) == ERROR_OK)
512 {
513 if ((retval = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
514 {
515 return retval;
516 }
517 command_print(cmd_ctx, "erased address 0x%8.8x length %i in %s", address, length, duration_text);
518 free(duration_text);
519 }
520
521 return retval;
522 }
523
524 static int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
525 {
526 flash_bank_t *p;
527 int retval;
528
529 if (argc != 1)
530 {
531 return ERROR_COMMAND_SYNTAX_ERROR;
532 }
533
534 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
535 if (p)
536 {
537 if ((retval = p->driver->protect_check(p)) == ERROR_OK)
538 {
539 command_print(cmd_ctx, "successfully checked protect state");
540 }
541 else if (retval == ERROR_FLASH_OPERATION_FAILED)
542 {
543 command_print(cmd_ctx, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32, args[0], p->base);
544 }
545 else
546 {
547 command_print(cmd_ctx, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32, args[0], p->base);
548 }
549 }
550 else
551 {
552 return ERROR_COMMAND_SYNTAX_ERROR;
553 }
554
555 return ERROR_OK;
556 }
557
558 static int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
559 {
560 if (argc > 2)
561 {
562 int first = strtoul(args[1], NULL, 0);
563 int last = strtoul(args[2], NULL, 0);
564 int retval;
565 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
566 duration_t duration;
567 char *duration_text;
568
569 duration_start_measure(&duration);
570
571 if (!p)
572 {
573 return ERROR_COMMAND_SYNTAX_ERROR;
574 }
575
576 if ((retval = flash_driver_erase(p, first, last)) == ERROR_OK)
577 {
578 if ((retval = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
579 {
580 return retval;
581 }
582
583 command_print(cmd_ctx, "erased sectors %i through %i on flash bank %li in %s",
584 first, last, strtoul(args[0], 0, 0), duration_text);
585 free(duration_text);
586 }
587 }
588 else
589 {
590 return ERROR_COMMAND_SYNTAX_ERROR;
591 }
592
593 return ERROR_OK;
594 }
595
596 static int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
597 {
598 if (argc > 3)
599 {
600 int first = strtoul(args[1], NULL, 0);
601 int last = strtoul(args[2], NULL, 0);
602 int set;
603 int retval;
604 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
605 if (!p)
606 {
607 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
608 return ERROR_OK;
609 }
610
611 if (strcmp(args[3], "on") == 0)
612 set = 1;
613 else if (strcmp(args[3], "off") == 0)
614 set = 0;
615 else
616 {
617 return ERROR_COMMAND_SYNTAX_ERROR;
618 }
619
620 retval = flash_driver_protect(p, set, first, last);
621 if (retval == ERROR_OK)
622 {
623 command_print(cmd_ctx, "%s protection for sectors %i through %i on flash bank %li",
624 (set) ? "set" : "cleared", first,
625 last, strtoul(args[0], 0, 0));
626 }
627 }
628 else
629 {
630 return ERROR_COMMAND_SYNTAX_ERROR;
631
632 }
633
634 return ERROR_OK;
635 }
636
637 static int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
638 {
639 target_t *target = get_current_target(cmd_ctx);
640
641 image_t image;
642 uint32_t written;
643
644 duration_t duration;
645 char *duration_text;
646
647 int retval, retvaltemp;
648
649 if (argc < 1)
650 {
651 return ERROR_COMMAND_SYNTAX_ERROR;
652 }
653
654 /* flash auto-erase is disabled by default*/
655 int auto_erase = 0;
656
657 if (strcmp(args[0], "erase")==0)
658 {
659 auto_erase = 1;
660 args++;
661 argc--;
662 command_print(cmd_ctx, "auto erase enabled");
663 }
664
665 if (argc < 1)
666 {
667 return ERROR_COMMAND_SYNTAX_ERROR;
668 }
669
670 if (!target)
671 {
672 LOG_ERROR("no target selected");
673 return ERROR_FAIL;
674 }
675
676 duration_start_measure(&duration);
677
678 if (argc >= 2)
679 {
680 image.base_address_set = 1;
681 image.base_address = strtoul(args[1], NULL, 0);
682 }
683 else
684 {
685 image.base_address_set = 0;
686 image.base_address = 0x0;
687 }
688
689 image.start_address_set = 0;
690
691 retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL);
692 if (retval != ERROR_OK)
693 {
694 return retval;
695 }
696
697 retval = flash_write(target, &image, &written, auto_erase);
698 if (retval != ERROR_OK)
699 {
700 image_close(&image);
701 return retval;
702 }
703
704 if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
705 {
706 image_close(&image);
707 return retvaltemp;
708 }
709 if (retval == ERROR_OK)
710 {
711 command_print(cmd_ctx,
712 "wrote %" PRIu32 " byte from file %s in %s (%f kb/s)",
713 written,
714 args[0],
715 duration_text,
716 (float)written / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
717 }
718 free(duration_text);
719
720 image_close(&image);
721
722 return retval;
723 }
724
725 static int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
726 {
727 int err = ERROR_OK, retval;
728 uint32_t address;
729 uint32_t pattern;
730 uint32_t count;
731 uint8_t chunk[1024];
732 uint8_t readback[1024];
733 uint32_t wrote = 0;
734 uint32_t cur_size = 0;
735 uint32_t chunk_count;
736 char *duration_text;
737 duration_t duration;
738 target_t *target = get_current_target(cmd_ctx);
739 uint32_t i;
740 uint32_t wordsize;
741
742 if (argc != 3)
743 {
744 return ERROR_COMMAND_SYNTAX_ERROR;
745 }
746
747 address = strtoul(args[0], NULL, 0);
748 pattern = strtoul(args[1], NULL, 0);
749 count = strtoul(args[2], NULL, 0);
750
751 if (count == 0)
752 return ERROR_OK;
753
754 switch (cmd[4])
755 {
756 case 'w':
757 wordsize=4;
758 break;
759 case 'h':
760 wordsize=2;
761 break;
762 case 'b':
763 wordsize=1;
764 break;
765 default:
766 return ERROR_COMMAND_SYNTAX_ERROR;
767 }
768
769 chunk_count = MIN(count, (1024 / wordsize));
770 switch (wordsize)
771 {
772 case 4:
773 for(i = 0; i < chunk_count; i++)
774 {
775 target_buffer_set_u32(target, chunk + i * wordsize, pattern);
776 }
777 break;
778 case 2:
779 for(i = 0; i < chunk_count; i++)
780 {
781 target_buffer_set_u16(target, chunk + i * wordsize, pattern);
782 }
783 break;
784 case 1:
785 memset(chunk, pattern, chunk_count);
786 break;
787 default:
788 LOG_ERROR("BUG: can't happen");
789 exit(-1);
790 }
791
792 duration_start_measure(&duration);
793
794 for (wrote=0; wrote<(count*wordsize); wrote += cur_size)
795 {
796 cur_size = MIN( (count*wordsize - wrote), sizeof(chunk) );
797 flash_bank_t *bank;
798 bank = get_flash_bank_by_addr(target, address);
799 if (bank == NULL)
800 {
801 return ERROR_FAIL;
802 }
803 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
804 if (err!=ERROR_OK)
805 return err;
806
807 err = target_read_buffer(target, address + wrote, cur_size, readback);
808 if (err!=ERROR_OK)
809 return err;
810
811 unsigned i;
812 for (i=0; i<cur_size; i++)
813 {
814 if (readback[i]!=chunk[i])
815 {
816 LOG_ERROR("Verfication error address 0x%08" PRIx32 ", read back 0x%02x, expected 0x%02x",
817 address + wrote + i, readback[i], chunk[i]);
818 return ERROR_FAIL;
819 }
820 }
821
822 }
823
824 if ((retval = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
825 {
826 return retval;
827 }
828
829 if (err == ERROR_OK)
830 {
831 float speed;
832 speed=wrote / 1024.0;
833 speed/=((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0));
834 command_print(cmd_ctx,
835 "wrote %" PRId32 " bytes to 0x%8.8" PRIx32 " in %s (%f kb/s)",
836 count*wordsize,
837 address,
838 duration_text,
839 speed);
840 }
841 free(duration_text);
842 return ERROR_OK;
843 }
844
845 static int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
846 {
847 uint32_t offset;
848 uint8_t *buffer;
849 uint32_t buf_cnt;
850
851 fileio_t fileio;
852
853 duration_t duration;
854 char *duration_text;
855
856 int retval, retvaltemp;
857 flash_bank_t *p;
858
859 if (argc != 3)
860 {
861 return ERROR_COMMAND_SYNTAX_ERROR;
862 }
863
864 duration_start_measure(&duration);
865
866 offset = strtoul(args[2], NULL, 0);
867 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
868 if (!p)
869 {
870 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
871 return ERROR_OK;
872 }
873
874 if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
875 {
876 return ERROR_OK;
877 }
878
879 buffer = malloc(fileio.size);
880 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
881 {
882 free(buffer);
883 fileio_close(&fileio);
884 return ERROR_OK;
885 }
886
887 retval = flash_driver_write(p, buffer, offset, buf_cnt);
888
889 free(buffer);
890 buffer = NULL;
891
892 if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
893 {
894 fileio_close(&fileio);
895 return retvaltemp;
896 }
897 if (retval==ERROR_OK)
898 {
899 command_print(cmd_ctx,
900 "wrote %lld byte from file %s to flash bank %li at offset 0x%8.8" PRIx32 " in %s (%f kb/s)",
901 fileio.size,
902 args[1],
903 strtoul(args[0], NULL, 0),
904 offset,
905 duration_text,
906 (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
907 }
908 free(duration_text);
909
910 fileio_close(&fileio);
911
912 return retval;
913 }
914
915 void flash_set_dirty(void)
916 {
917 flash_bank_t *c;
918 int i;
919
920 /* set all flash to require erasing */
921 for (c = flash_banks; c; c = c->next)
922 {
923 for (i = 0; i < c->num_sectors; i++)
924 {
925 c->sectors[i].is_erased = 0;
926 }
927 }
928 }
929
930 /* lookup flash bank by address */
931 flash_bank_t *get_flash_bank_by_addr(target_t *target, uint32_t addr)
932 {
933 flash_bank_t *c;
934
935 /* cycle through bank list */
936 for (c = flash_banks; c; c = c->next)
937 {
938 int retval;
939 retval = c->driver->auto_probe(c);
940
941 if (retval != ERROR_OK)
942 {
943 LOG_ERROR("auto_probe failed %d\n", retval);
944 return NULL;
945 }
946 /* check whether address belongs to this flash bank */
947 if ((addr >= c->base) && (addr <= c->base + (c->size - 1)) && target == c->target)
948 return c;
949 }
950 LOG_ERROR("No flash at address 0x%08" PRIx32 "\n", addr);
951 return NULL;
952 }
953
954 /* erase given flash region, selects proper bank according to target and address */
955 int flash_erase_address_range(target_t *target, uint32_t addr, uint32_t length)
956 {
957 flash_bank_t *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 flash_driver_erase(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 flash_driver_erase(c, first, last);
1001 }
1002
1003 /* write (optional verify) an image to flash memory of the given target */
1004 int flash_write(target_t *target, image_t *image, uint32_t *written, int erase)
1005 {
1006 int retval=ERROR_OK;
1007
1008 int section;
1009 uint32_t section_offset;
1010 flash_bank_t *c;
1011 int *padding;
1012
1013 section = 0;
1014 section_offset = 0;
1015
1016 if (written)
1017 *written = 0;
1018
1019 if (erase)
1020 {
1021 /* assume all sectors need erasing - stops any problems
1022 * when flash_write is called multiple times */
1023
1024 flash_set_dirty();
1025 }
1026
1027 /* allocate padding array */
1028 padding = malloc(image->num_sections * sizeof(padding));
1029
1030 /* loop until we reach end of the image */
1031 while (section < image->num_sections)
1032 {
1033 uint32_t buffer_size;
1034 uint8_t *buffer;
1035 int section_first;
1036 int section_last;
1037 uint32_t run_address = image->sections[section].base_address + section_offset;
1038 uint32_t run_size = image->sections[section].size - section_offset;
1039 int pad_bytes = 0;
1040
1041 if (image->sections[section].size == 0)
1042 {
1043 LOG_WARNING("empty section %d", section);
1044 section++;
1045 section_offset = 0;
1046 continue;
1047 }
1048
1049 /* find the corresponding flash bank */
1050 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
1051 {
1052 section++; /* and skip it */
1053 section_offset = 0;
1054 continue;
1055 }
1056
1057 /* collect consecutive sections which fall into the same bank */
1058 section_first = section;
1059 section_last = section;
1060 padding[section] = 0;
1061 while ((run_address + run_size - 1 < c->base + c->size - 1)
1062 && (section_last + 1 < image->num_sections))
1063 {
1064 if (image->sections[section_last + 1].base_address < (run_address + run_size))
1065 {
1066 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
1067 break;
1068 }
1069 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1070 * attempt to rebuild a consecutive buffer for the flash loader */
1071 pad_bytes = (image->sections[section_last + 1].base_address) - (run_address + run_size);
1072 if ((run_address + run_size + pad_bytes) > (c->base + c->size))
1073 break;
1074 padding[section_last] = pad_bytes;
1075 run_size += image->sections[++section_last].size;
1076 run_size += pad_bytes;
1077 padding[section_last] = 0;
1078
1079 LOG_INFO("Padding image section %d with %d bytes", section_last-1, pad_bytes );
1080 }
1081
1082 /* fit the run into bank constraints */
1083 if (run_address + run_size - 1 > c->base + c->size - 1)
1084 {
1085 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1086 (int)(c->base + c->size - run_address), (int)(run_size), (int)(c->size));
1087 run_size = c->base + c->size - run_address;
1088 }
1089
1090 /* allocate buffer */
1091 buffer = malloc(run_size);
1092 buffer_size = 0;
1093
1094 /* read sections to the buffer */
1095 while (buffer_size < run_size)
1096 {
1097 uint32_t size_read;
1098
1099 size_read = run_size - buffer_size;
1100 if (size_read > image->sections[section].size - section_offset)
1101 size_read = image->sections[section].size - section_offset;
1102
1103 if ((retval = image_read_section(image, section, section_offset,
1104 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
1105 {
1106 free(buffer);
1107 free(padding);
1108 return retval;
1109 }
1110
1111 /* see if we need to pad the section */
1112 while (padding[section]--)
1113 (buffer+buffer_size)[size_read++] = 0xff;
1114
1115 buffer_size += size_read;
1116 section_offset += size_read;
1117
1118 if (section_offset >= image->sections[section].size)
1119 {
1120 section++;
1121 section_offset = 0;
1122 }
1123 }
1124
1125 retval = ERROR_OK;
1126
1127 if (erase)
1128 {
1129 /* calculate and erase sectors */
1130 retval = flash_erase_address_range( target, run_address, run_size );
1131 }
1132
1133 if (retval == ERROR_OK)
1134 {
1135 /* write flash sectors */
1136 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
1137 }
1138
1139 free(buffer);
1140
1141 if (retval != ERROR_OK)
1142 {
1143 free(padding);
1144 return retval; /* abort operation */
1145 }
1146
1147 if (written != NULL)
1148 *written += run_size; /* add run size to total written counter */
1149 }
1150
1151 free(padding);
1152
1153 return retval;
1154 }
1155
1156 int default_flash_mem_blank_check(struct flash_bank_s *bank)
1157 {
1158 target_t *target = bank->target;
1159 uint8_t buffer[1024];
1160 int buffer_size = sizeof(buffer);
1161 int i;
1162 uint32_t nBytes;
1163
1164 if (bank->target->state != TARGET_HALTED)
1165 {
1166 LOG_ERROR("Target not halted");
1167 return ERROR_TARGET_NOT_HALTED;
1168 }
1169
1170 for (i = 0; i < bank->num_sectors; i++)
1171 {
1172 uint32_t j;
1173 bank->sectors[i].is_erased = 1;
1174
1175 for (j = 0; j < bank->sectors[i].size; j += buffer_size)
1176 {
1177 uint32_t chunk;
1178 int retval;
1179 chunk = buffer_size;
1180 if (chunk > (j - bank->sectors[i].size))
1181 {
1182 chunk = (j - bank->sectors[i].size);
1183 }
1184
1185 retval = target_read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
1186 if (retval != ERROR_OK)
1187 return retval;
1188
1189 for (nBytes = 0; nBytes < chunk; nBytes++)
1190 {
1191 if (buffer[nBytes] != 0xFF)
1192 {
1193 bank->sectors[i].is_erased = 0;
1194 break;
1195 }
1196 }
1197 }
1198 }
1199
1200 return ERROR_OK;
1201 }
1202
1203 int default_flash_blank_check(struct flash_bank_s *bank)
1204 {
1205 target_t *target = bank->target;
1206 int i;
1207 int retval;
1208 int fast_check = 0;
1209 uint32_t blank;
1210
1211 if (bank->target->state != TARGET_HALTED)
1212 {
1213 LOG_ERROR("Target not halted");
1214 return ERROR_TARGET_NOT_HALTED;
1215 }
1216
1217 for (i = 0; i < bank->num_sectors; i++)
1218 {
1219 uint32_t address = bank->base + bank->sectors[i].offset;
1220 uint32_t size = bank->sectors[i].size;
1221
1222 if ((retval = target_blank_check_memory(target, address, size, &blank)) != ERROR_OK)
1223 {
1224 fast_check = 0;
1225 break;
1226 }
1227 if (blank == 0xFF)
1228 bank->sectors[i].is_erased = 1;
1229 else
1230 bank->sectors[i].is_erased = 0;
1231 fast_check = 1;
1232 }
1233
1234 if (!fast_check)
1235 {
1236 LOG_USER("Running slow fallback erase check - add working memory");
1237 return default_flash_mem_blank_check(bank);
1238 }
1239
1240 return ERROR_OK;
1241 }