Pavel Chromy's on chip flash loader
[openocd.git] / src / flash / flash.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include "flash.h"
25 #include "command.h"
26 #include "target.h"
27 #include "time_support.h"
28 #include "fileio.h"
29 #include "image.h"
30 #include "log.h"
31 #include "armv4_5.h"
32 #include "algorithm.h"
33 #include "binarybuffer.h"
34 #include "armv7m.h"
35
36 #include <string.h>
37 #include <unistd.h>
38 #include <stdlib.h>
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <errno.h>
42 #include <inttypes.h>
43
44 /* command handlers */
45 int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
46 int handle_flash_banks_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
47 int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
48 int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
49 int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
50 int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
51 int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
52 int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
53 int handle_flash_write_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
54 int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
55 int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
56 int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
57 int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
58 flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr);
59
60 /* flash drivers
61 */
62 extern flash_driver_t lpc2000_flash;
63 extern flash_driver_t cfi_flash;
64 extern flash_driver_t at91sam7_flash;
65 extern flash_driver_t str7x_flash;
66 extern flash_driver_t str9x_flash;
67 extern flash_driver_t stellaris_flash;
68 extern flash_driver_t str9xpec_flash;
69 extern flash_driver_t stm32x_flash;
70 extern flash_driver_t tms470_flash;
71 extern flash_driver_t ecosflash_flash;
72 extern flash_driver_t lpc288x_flash;
73 extern flash_driver_t ocl_flash;
74
75 flash_driver_t *flash_drivers[] =
76 {
77 &lpc2000_flash,
78 &cfi_flash,
79 &at91sam7_flash,
80 &str7x_flash,
81 &str9x_flash,
82 &stellaris_flash,
83 &str9xpec_flash,
84 &stm32x_flash,
85 &tms470_flash,
86 &ecosflash_flash,
87 &lpc288x_flash,
88 &ocl_flash,
89 NULL,
90 };
91
92 flash_bank_t *flash_banks;
93 static command_t *flash_cmd;
94
95 /* wafer thin wrapper for invoking the flash driver */
96 static int flash_driver_write(struct flash_bank_s *bank, u8 *buffer, u32 offset, u32 count)
97 {
98 int retval;
99
100 retval=bank->driver->write(bank, buffer, offset, count);
101 if (retval!=ERROR_OK)
102 {
103 LOG_ERROR("error writing to flash at address 0x%08x at offset 0x%8.8x (%d)", bank->base, offset, retval);
104 }
105
106 return retval;
107 }
108
109 static int flash_driver_erase(struct flash_bank_s *bank, int first, int last)
110 {
111 int retval;
112
113 retval=bank->driver->erase(bank, first, last);
114 if (retval!=ERROR_OK)
115 {
116 LOG_ERROR("failed erasing sectors %d to %d (%d)", first, last, retval);
117 }
118
119 return retval;
120 }
121
122 int flash_driver_protect(struct flash_bank_s *bank, int set, int first, int last)
123 {
124 int retval;
125
126 retval=bank->driver->protect(bank, set, first, last);
127 if (retval!=ERROR_OK)
128 {
129 LOG_ERROR("failed setting protection for areas %d to %d (%d)", first, last, retval);
130 }
131
132 return retval;
133 }
134
135
136 int flash_register_commands(struct command_context_s *cmd_ctx)
137 {
138 flash_cmd = register_command(cmd_ctx, NULL, "flash", NULL, COMMAND_ANY, NULL);
139
140 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 ...]");
141 return ERROR_OK;
142 }
143
144 int flash_init_drivers(struct command_context_s *cmd_ctx)
145 {
146 if (flash_banks)
147 {
148 register_command(cmd_ctx, flash_cmd, "banks", handle_flash_banks_command, COMMAND_EXEC,
149 "list configured flash banks ");
150 register_command(cmd_ctx, flash_cmd, "info", handle_flash_info_command, COMMAND_EXEC,
151 "print info about flash bank <num>");
152 register_command(cmd_ctx, flash_cmd, "probe", handle_flash_probe_command, COMMAND_EXEC,
153 "identify flash bank <num>");
154 register_command(cmd_ctx, flash_cmd, "erase_check", handle_flash_erase_check_command, COMMAND_EXEC,
155 "check erase state of sectors in flash bank <num>");
156 register_command(cmd_ctx, flash_cmd, "protect_check", handle_flash_protect_check_command, COMMAND_EXEC,
157 "check protection state of sectors in flash bank <num>");
158 register_command(cmd_ctx, flash_cmd, "erase_sector", handle_flash_erase_command, COMMAND_EXEC,
159 "erase sectors at <bank> <first> <last>");
160 register_command(cmd_ctx, flash_cmd, "erase_address", handle_flash_erase_address_command, COMMAND_EXEC,
161 "erase address range <address> <length>");
162
163 register_command(cmd_ctx, flash_cmd, "fillw", handle_flash_fill_command, COMMAND_EXEC,
164 "fill with pattern <address> <word_pattern> <count>");
165 register_command(cmd_ctx, flash_cmd, "fillh", handle_flash_fill_command, COMMAND_EXEC,
166 "fill with pattern <address> <halfword_pattern> <count>");
167 register_command(cmd_ctx, flash_cmd, "fillb", handle_flash_fill_command, COMMAND_EXEC,
168 "fill with pattern <address> <byte_pattern> <count>");
169
170 register_command(cmd_ctx, flash_cmd, "write_bank", handle_flash_write_bank_command, COMMAND_EXEC,
171 "write binary data to <bank> <file> <offset>");
172 register_command(cmd_ctx, flash_cmd, "write_image", handle_flash_write_image_command, COMMAND_EXEC,
173 "write_image [erase] <file> [offset] [type]");
174 register_command(cmd_ctx, flash_cmd, "protect", handle_flash_protect_command, COMMAND_EXEC,
175 "set protection of sectors at <bank> <first> <last> <on|off>");
176 }
177
178 return ERROR_OK;
179 }
180
181 flash_bank_t *get_flash_bank_by_num_noprobe(int num)
182 {
183 flash_bank_t *p;
184 int i = 0;
185
186 for (p = flash_banks; p; p = p->next)
187 {
188 if (i++ == num)
189 {
190 return p;
191 }
192 }
193 LOG_ERROR("flash bank %d does not exist", num);
194 return NULL;
195 }
196
197 int flash_get_bank_count()
198 {
199 flash_bank_t *p;
200 int i = 0;
201 for (p = flash_banks; p; p = p->next)
202 {
203 i++;
204 }
205 return i;
206 }
207
208 flash_bank_t *get_flash_bank_by_num(int num)
209 {
210 flash_bank_t *p = get_flash_bank_by_num_noprobe(num);
211 int retval;
212
213 if (p == NULL)
214 return NULL;
215
216 retval = p->driver->auto_probe(p);
217
218 if (retval != ERROR_OK)
219 {
220 LOG_ERROR("auto_probe failed %d\n", retval);
221 return NULL;
222 }
223 return p;
224 }
225
226 int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
227 {
228 int i;
229 int found = 0;
230 target_t *target;
231
232 if (argc < 6)
233 {
234 return ERROR_COMMAND_SYNTAX_ERROR;
235 }
236
237 if ((target = get_target_by_num(strtoul(args[5], NULL, 0))) == NULL)
238 {
239 LOG_ERROR("target %lu not defined", strtoul(args[5], NULL, 0));
240 return ERROR_OK;
241 }
242
243 for (i = 0; flash_drivers[i]; i++)
244 {
245 if (strcmp(args[0], flash_drivers[i]->name) == 0)
246 {
247 flash_bank_t *p, *c;
248
249 /* register flash specific commands */
250 if (flash_drivers[i]->register_commands(cmd_ctx) != ERROR_OK)
251 {
252 LOG_ERROR("couldn't register '%s' commands", args[0]);
253 exit(-1);
254 }
255
256 c = malloc(sizeof(flash_bank_t));
257 c->target = target;
258 c->driver = flash_drivers[i];
259 c->driver_priv = NULL;
260 c->base = strtoul(args[1], NULL, 0);
261 c->size = strtoul(args[2], NULL, 0);
262 c->chip_width = strtoul(args[3], NULL, 0);
263 c->bus_width = strtoul(args[4], NULL, 0);
264 c->num_sectors = 0;
265 c->sectors = NULL;
266 c->next = NULL;
267
268 if (flash_drivers[i]->flash_bank_command(cmd_ctx, cmd, args, argc, c) != ERROR_OK)
269 {
270 LOG_ERROR("'%s' driver rejected flash bank at 0x%8.8x", args[0], c->base);
271 free(c);
272 return ERROR_OK;
273 }
274
275 /* put flash bank in linked list */
276 if (flash_banks)
277 {
278 /* find last flash bank */
279 for (p = flash_banks; p && p->next; p = p->next);
280 if (p)
281 p->next = c;
282 }
283 else
284 {
285 flash_banks = c;
286 }
287
288 found = 1;
289 }
290 }
291
292 /* no matching flash driver found */
293 if (!found)
294 {
295 LOG_ERROR("flash driver '%s' not found", args[0]);
296 exit(-1);
297 }
298
299 return ERROR_OK;
300 }
301
302 int handle_flash_banks_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
303 {
304 flash_bank_t *p;
305 int i = 0;
306
307 if (!flash_banks)
308 {
309 command_print(cmd_ctx, "no flash banks configured");
310 return ERROR_OK;
311 }
312
313 for (p = flash_banks; p; p = p->next)
314 {
315 command_print(cmd_ctx, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
316 i++, p->driver->name, p->base, p->size, p->bus_width, p->chip_width);
317 }
318
319 return ERROR_OK;
320 }
321
322 int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
323 {
324 flash_bank_t *p;
325 int i = 0;
326 int j = 0;
327 int retval;
328
329 if (argc != 1)
330 {
331 return ERROR_COMMAND_SYNTAX_ERROR;
332 }
333
334 for (p = flash_banks; p; p = p->next, i++)
335 {
336 if (i == strtoul(args[0], NULL, 0))
337 {
338 char buf[1024];
339
340 /* attempt auto probe */
341 if ((retval = p->driver->auto_probe(p)) != ERROR_OK)
342 return retval;
343
344 command_print(cmd_ctx, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
345 i, p->driver->name, p->base, p->size, p->bus_width, p->chip_width);
346 for (j = 0; j < p->num_sectors; j++)
347 {
348 char *protect_state;
349
350 if (p->sectors[j].is_protected == 0)
351 protect_state = "not protected";
352 else if (p->sectors[j].is_protected == 1)
353 protect_state = "protected";
354 else
355 protect_state = "protection state unknown";
356
357 command_print(cmd_ctx, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
358 j, p->sectors[j].offset, p->sectors[j].size, p->sectors[j].size>>10,
359 protect_state);
360 }
361
362 *buf = '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
363 retval = p->driver->info(p, buf, sizeof(buf));
364 command_print(cmd_ctx, "%s", buf);
365 if (retval != ERROR_OK)
366 LOG_ERROR("error retrieving flash info (%d)", retval);
367 }
368 }
369
370 return ERROR_OK;
371 }
372
373 int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
374 {
375 flash_bank_t *p;
376 int retval;
377
378 if (argc != 1)
379 {
380 return ERROR_COMMAND_SYNTAX_ERROR;
381 }
382
383 p = get_flash_bank_by_num_noprobe(strtoul(args[0], NULL, 0));
384 if (p)
385 {
386 if ((retval = p->driver->probe(p)) == ERROR_OK)
387 {
388 command_print(cmd_ctx, "flash '%s' found at 0x%8.8x", p->driver->name, p->base);
389 }
390 else if (retval == ERROR_FLASH_BANK_INVALID)
391 {
392 command_print(cmd_ctx, "probing failed for flash bank '#%s' at 0x%8.8x",
393 args[0], p->base);
394 }
395 else
396 {
397 command_print(cmd_ctx, "unknown error when probing flash bank '#%s' at 0x%8.8x",
398 args[0], p->base);
399 }
400 }
401 else
402 {
403 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
404 }
405
406 return ERROR_OK;
407 }
408
409 int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
410 {
411 flash_bank_t *p;
412 int retval;
413
414 if (argc != 1)
415 {
416 return ERROR_COMMAND_SYNTAX_ERROR;
417 }
418
419 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
420 if (p)
421 {
422 int j;
423 if ((retval = p->driver->erase_check(p)) == ERROR_OK)
424 {
425 command_print(cmd_ctx, "successfully checked erase state", p->driver->name, p->base);
426 }
427 else
428 {
429 command_print(cmd_ctx, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
430 args[0], p->base);
431 }
432
433 for (j = 0; j < p->num_sectors; j++)
434 {
435 char *erase_state;
436
437 if (p->sectors[j].is_erased == 0)
438 erase_state = "not erased";
439 else if (p->sectors[j].is_erased == 1)
440 erase_state = "erased";
441 else
442 erase_state = "erase state unknown";
443
444 command_print(cmd_ctx, "\t#%i: 0x%8.8x (0x%x %ikB) %s",
445 j, p->sectors[j].offset, p->sectors[j].size, p->sectors[j].size>>10,
446 erase_state);
447 }
448
449 }
450
451 return ERROR_OK;
452 }
453
454 int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
455 {
456 flash_bank_t *p;
457 int retval;
458 int address;
459 int length;
460 duration_t duration;
461 char *duration_text;
462
463 target_t *target = get_current_target(cmd_ctx);
464
465 if (argc != 2)
466 {
467 return ERROR_COMMAND_SYNTAX_ERROR;
468 }
469
470 address = strtoul(args[0], NULL, 0);
471 length = strtoul(args[1], NULL, 0);
472 if (length <= 0)
473 {
474 command_print(cmd_ctx, "Length must be >0");
475 return ERROR_COMMAND_SYNTAX_ERROR;
476 }
477
478 p = get_flash_bank_by_addr(target, address);
479 if (p == NULL)
480 {
481 return ERROR_COMMAND_SYNTAX_ERROR;
482 }
483
484 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
485 flash_set_dirty();
486
487 duration_start_measure(&duration);
488
489 if ((retval = flash_erase_address_range(target, address, length)) == ERROR_OK)
490 {
491 duration_stop_measure(&duration, &duration_text);
492 command_print(cmd_ctx, "erased address 0x%8.8x length %i in %s", address, length, duration_text);
493 free(duration_text);
494 }
495
496 return retval;
497 }
498
499 int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
500 {
501 flash_bank_t *p;
502 int retval;
503
504 if (argc != 1)
505 {
506 return ERROR_COMMAND_SYNTAX_ERROR;
507 }
508
509 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
510 if (p)
511 {
512 if ((retval = p->driver->protect_check(p)) == ERROR_OK)
513 {
514 command_print(cmd_ctx, "successfully checked protect state");
515 }
516 else if (retval == ERROR_FLASH_OPERATION_FAILED)
517 {
518 command_print(cmd_ctx, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args[0], p->base);
519 }
520 else
521 {
522 command_print(cmd_ctx, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args[0], p->base);
523 }
524 }
525 else
526 {
527 return ERROR_COMMAND_SYNTAX_ERROR;
528 }
529
530 return ERROR_OK;
531 }
532
533 int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
534 {
535 if (argc > 2)
536 {
537 int first = strtoul(args[1], NULL, 0);
538 int last = strtoul(args[2], NULL, 0);
539 int retval;
540 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
541 duration_t duration;
542 char *duration_text;
543
544 duration_start_measure(&duration);
545
546 if (!p)
547 {
548 return ERROR_COMMAND_SYNTAX_ERROR;
549 }
550
551 if ((retval = flash_driver_erase(p, first, last)) == ERROR_OK)
552 {
553 duration_stop_measure(&duration, &duration_text);
554
555 command_print(cmd_ctx, "erased sectors %i through %i on flash bank %i in %s", first, last, strtoul(args[0], 0, 0), duration_text);
556 free(duration_text);
557 }
558 }
559 else
560 {
561 return ERROR_COMMAND_SYNTAX_ERROR;
562 }
563
564 return ERROR_OK;
565 }
566
567 int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
568 {
569 if (argc > 3)
570 {
571 int first = strtoul(args[1], NULL, 0);
572 int last = strtoul(args[2], NULL, 0);
573 int set;
574 int retval;
575 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
576 if (!p)
577 {
578 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
579 return ERROR_OK;
580 }
581
582 if (strcmp(args[3], "on") == 0)
583 set = 1;
584 else if (strcmp(args[3], "off") == 0)
585 set = 0;
586 else
587 {
588 return ERROR_COMMAND_SYNTAX_ERROR;
589 }
590
591 retval = flash_driver_protect(p, set, first, last);
592 if (retval == ERROR_OK)
593 {
594 command_print(cmd_ctx, "%s protection for sectors %i through %i on flash bank %i", (set) ? "set" : "cleared", first, last, strtoul(args[0], 0, 0));
595 }
596 }
597 else
598 {
599 return ERROR_COMMAND_SYNTAX_ERROR;
600
601 }
602
603 return ERROR_OK;
604 }
605
606 int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
607 {
608 target_t *target = get_current_target(cmd_ctx);
609
610 image_t image;
611 u32 written;
612
613 duration_t duration;
614 char *duration_text;
615
616 int retval;
617
618 if (argc < 1)
619 {
620 return ERROR_COMMAND_SYNTAX_ERROR;
621 }
622
623 /* flash auto-erase is disabled by default*/
624 int auto_erase = 0;
625
626 if (strcmp(args[0], "erase")==0)
627 {
628 auto_erase = 1;
629 args++;
630 argc--;
631 command_print(cmd_ctx, "auto erase enabled");
632 }
633
634
635 if (argc < 1)
636 {
637 return ERROR_COMMAND_SYNTAX_ERROR;
638 }
639
640 if (!target)
641 {
642 LOG_ERROR("no target selected");
643 return ERROR_FAIL;
644 }
645
646 duration_start_measure(&duration);
647
648 if (argc >= 2)
649 {
650 image.base_address_set = 1;
651 image.base_address = strtoul(args[1], NULL, 0);
652 }
653 else
654 {
655 image.base_address_set = 0;
656 image.base_address = 0x0;
657 }
658
659 image.start_address_set = 0;
660
661 retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL);
662 if (retval != ERROR_OK)
663 {
664 return retval;
665 }
666
667 retval = flash_write(target, &image, &written, auto_erase);
668 if (retval != ERROR_OK)
669 {
670 image_close(&image);
671 return retval;
672 }
673
674 duration_stop_measure(&duration, &duration_text);
675 if (retval == ERROR_OK)
676 {
677 command_print(cmd_ctx, "wrote %u byte from file %s in %s (%f kb/s)",
678 written, args[0], duration_text,
679 (float)written / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
680 }
681 free(duration_text);
682
683 image_close(&image);
684
685 return retval;
686 }
687
688 int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
689 {
690 int err = ERROR_OK;
691 u32 address;
692 u32 pattern;
693 u32 count;
694 u8 chunk[1024];
695 u32 wrote = 0;
696 int chunk_count;
697 char *duration_text;
698 duration_t duration;
699 target_t *target = get_current_target(cmd_ctx);
700 u32 i;
701 int wordsize;
702
703 if (argc != 3)
704 {
705 return ERROR_COMMAND_SYNTAX_ERROR;
706 }
707
708 address = strtoul(args[0], NULL, 0);
709 pattern = strtoul(args[1], NULL, 0);
710 count = strtoul(args[2], NULL, 0);
711
712 if(count == 0)
713 return ERROR_OK;
714
715
716 switch(cmd[4])
717 {
718 case 'w':
719 wordsize=4;
720 break;
721 case 'h':
722 wordsize=2;
723 break;
724 case 'b':
725 wordsize=1;
726 break;
727 default:
728 return ERROR_COMMAND_SYNTAX_ERROR;
729 }
730
731 chunk_count = MIN(count, (1024 / wordsize));
732 switch(wordsize)
733 {
734 case 4:
735 for(i = 0; i < chunk_count; i++)
736 {
737 target_buffer_set_u32(target, chunk + i * wordsize, pattern);
738 }
739 break;
740 case 2:
741 for(i = 0; i < chunk_count; i++)
742 {
743 target_buffer_set_u16(target, chunk + i * wordsize, pattern);
744 }
745 break;
746 case 1:
747 memset(chunk, pattern, chunk_count);
748 break;
749 default:
750 LOG_ERROR("BUG: can't happen");
751 exit(-1);
752 }
753
754 duration_start_measure(&duration);
755
756 flash_set_dirty();
757 err = flash_erase_address_range( target, address, count*wordsize );
758 if (err == ERROR_OK)
759 {
760 for (wrote=0; wrote<(count*wordsize); wrote+=sizeof(chunk))
761 {
762 int cur_size = MIN( (count*wordsize - wrote) , 1024 );
763 if (err == ERROR_OK)
764 {
765 flash_bank_t *bank;
766 bank = get_flash_bank_by_addr(target, address);
767 if(bank == NULL)
768 {
769 err = ERROR_FAIL;
770 break;
771 }
772 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
773 wrote += cur_size;
774 }
775 if (err!=ERROR_OK)
776 break;
777 }
778 }
779
780 duration_stop_measure(&duration, &duration_text);
781
782 if(err == ERROR_OK)
783 {
784 float speed;
785 speed=wrote / 1024.0;
786 speed/=((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0));
787 command_print(cmd_ctx, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
788 count*wordsize, address, duration_text,
789 speed);
790 }
791 free(duration_text);
792 return ERROR_OK;
793 }
794
795 int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
796 {
797 u32 offset;
798 u8 *buffer;
799 u32 buf_cnt;
800
801 fileio_t fileio;
802
803 duration_t duration;
804 char *duration_text;
805
806 int retval;
807 flash_bank_t *p;
808
809 if (argc != 3)
810 {
811 return ERROR_COMMAND_SYNTAX_ERROR;
812 }
813
814 duration_start_measure(&duration);
815
816 offset = strtoul(args[2], NULL, 0);
817 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
818 if (!p)
819 {
820 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
821 return ERROR_OK;
822 }
823
824 if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
825 {
826 return ERROR_OK;
827 }
828
829 buffer = malloc(fileio.size);
830 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
831 {
832 return ERROR_OK;
833 }
834
835 retval = flash_driver_write(p, buffer, offset, buf_cnt);
836
837 free(buffer);
838
839 duration_stop_measure(&duration, &duration_text);
840 if (retval!=ERROR_OK)
841 {
842 command_print(cmd_ctx, "wrote %"PRIi64" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
843 fileio.size, args[1], strtoul(args[0], NULL, 0), offset, duration_text,
844 (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
845 }
846 free(duration_text);
847
848 fileio_close(&fileio);
849
850 return retval;
851 }
852
853 void flash_set_dirty(void)
854 {
855 flash_bank_t *c;
856 int i;
857
858 /* set all flash to require erasing */
859 for (c = flash_banks; c; c = c->next)
860 {
861 for (i = 0; i < c->num_sectors; i++)
862 {
863 c->sectors[i].is_erased = 0;
864 }
865 }
866 }
867
868 /* lookup flash bank by address */
869 flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
870 {
871 flash_bank_t *c;
872
873 /* cycle through bank list */
874 for (c = flash_banks; c; c = c->next)
875 {
876 int retval;
877 retval = c->driver->auto_probe(c);
878
879 if (retval != ERROR_OK)
880 {
881 LOG_ERROR("auto_probe failed %d\n", retval);
882 return NULL;
883 }
884 /* check whether address belongs to this flash bank */
885 if ((addr >= c->base) && (addr < c->base + c->size) && target == c->target)
886 return c;
887 }
888 LOG_ERROR("No flash at address 0x%08x\n", addr);
889 return NULL;
890 }
891
892 /* erase given flash region, selects proper bank according to target and address */
893 int flash_erase_address_range(target_t *target, u32 addr, u32 length)
894 {
895 flash_bank_t *c;
896 int first = -1;
897 int last = -1;
898 int i;
899
900 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
901 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
902
903 if (c->size == 0 || c->num_sectors == 0)
904 {
905 LOG_ERROR("Bank is invalid");
906 return ERROR_FLASH_BANK_INVALID;
907 }
908
909 if (length == 0)
910 {
911 /* special case, erase whole bank when length is zero */
912 if (addr != c->base)
913 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
914
915 return flash_driver_erase(c, 0, c->num_sectors - 1);
916 }
917
918 /* check whether it fits */
919 if (addr + length > c->base + c->size)
920 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
921
922 addr -= c->base;
923
924 for (i = 0; i < c->num_sectors; i++)
925 {
926 /* check whether sector overlaps with the given range and is not yet erased */
927 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
928 /* if first is not set yet then this is the first sector */
929 if (first == -1)
930 first = i;
931 last = i; /* and it is the last one so far in any case */
932 }
933 }
934
935 if( first == -1 || last == -1 )
936 return ERROR_OK;
937
938 return flash_driver_erase(c, first, last);
939 }
940
941 /* write (optional verify) an image to flash memory of the given target */
942 int flash_write(target_t *target, image_t *image, u32 *written, int erase)
943 {
944 int retval=ERROR_OK;
945
946 int section;
947 u32 section_offset;
948 flash_bank_t *c;
949
950 section = 0;
951 section_offset = 0;
952
953 if (written)
954 *written = 0;
955
956 if (erase)
957 {
958 /* assume all sectors need erasing - stops any problems
959 * when flash_write is called multiple times */
960
961 flash_set_dirty();
962 }
963
964 /* loop until we reach end of the image */
965 while (section < image->num_sections)
966 {
967 u32 buffer_size;
968 u8 *buffer;
969 int section_first;
970 int section_last;
971 u32 run_address = image->sections[section].base_address + section_offset;
972 u32 run_size = image->sections[section].size - section_offset;
973
974 if (image->sections[section].size == 0)
975 {
976 LOG_WARNING("empty section %d", section);
977 section++;
978 section_offset = 0;
979 continue;
980 }
981
982 /* find the corresponding flash bank */
983 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
984 {
985 section++; /* and skip it */
986 section_offset = 0;
987 continue;
988 }
989
990 /* collect consecutive sections which fall into the same bank */
991 section_first = section;
992 section_last = section;
993 while ((run_address + run_size < c->base + c->size)
994 && (section_last + 1 < image->num_sections))
995 {
996 if (image->sections[section_last + 1].base_address < (run_address + run_size))
997 {
998 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
999 break;
1000 }
1001 if (image->sections[section_last + 1].base_address != (run_address + run_size))
1002 break;
1003 run_size += image->sections[++section_last].size;
1004 }
1005
1006 /* fit the run into bank constraints */
1007 if (run_address + run_size > c->base + c->size)
1008 run_size = c->base + c->size - run_address;
1009
1010 /* allocate buffer */
1011 buffer = malloc(run_size);
1012 buffer_size = 0;
1013
1014 /* read sections to the buffer */
1015 while (buffer_size < run_size)
1016 {
1017 u32 size_read;
1018
1019 if (buffer_size - run_size <= image->sections[section].size - section_offset)
1020 size_read = buffer_size - run_size;
1021 else
1022 size_read = image->sections[section].size - section_offset;
1023
1024 if ((retval = image_read_section(image, section, section_offset,
1025 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
1026 {
1027 free(buffer);
1028
1029 return retval;
1030 }
1031
1032 buffer_size += size_read;
1033 section_offset += size_read;
1034
1035 if (section_offset >= image->sections[section].size)
1036 {
1037 section++;
1038 section_offset = 0;
1039 }
1040 }
1041
1042 retval = ERROR_OK;
1043
1044 if (erase)
1045 {
1046 /* calculate and erase sectors */
1047 retval = flash_erase_address_range( target, run_address, run_size );
1048 }
1049
1050 if (retval == ERROR_OK)
1051 {
1052 /* write flash sectors */
1053 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
1054 }
1055
1056 free(buffer);
1057
1058 if (retval != ERROR_OK)
1059 {
1060 return retval; /* abort operation */
1061 }
1062
1063 if (written != NULL)
1064 *written += run_size; /* add run size to total written counter */
1065 }
1066
1067 return retval;
1068 }
1069
1070 int default_flash_blank_check(struct flash_bank_s *bank)
1071 {
1072 target_t *target = bank->target;
1073 u8 buffer[1024];
1074 int buffer_size=sizeof(buffer);
1075 int i;
1076 int nBytes;
1077
1078 if (bank->target->state != TARGET_HALTED)
1079 {
1080 return ERROR_TARGET_NOT_HALTED;
1081 }
1082
1083 int retval;
1084 int fast_check=0;
1085 working_area_t *erase_check_algorithm;
1086 #if 0
1087 /* FIX! doesn't work yet... */
1088 /*
1089 char test(char *a, int len, char t)
1090 {
1091 int i=0;
1092
1093 for (i=0; i<len; i++)
1094 {
1095 t&=a[i];
1096
1097 }
1098 }
1099
1100 $ arm-elf-gcc -c -mthumb -O3 test.c
1101
1102 $ arm-elf-objdump --disassemble test.o
1103
1104 test.o: file format elf32-littlearm
1105
1106 Disassembly of section .text:
1107
1108 00000000 <test>:
1109 0: b510 push {r4, lr}
1110 2: 0612 lsl r2, r2, #24
1111 4: 1c04 mov r4, r0 (add r4, r0, #0)
1112 6: 0e10 lsr r0, r2, #24
1113 8: 2200 mov r2, #0
1114 a: 2900 cmp r1, #0
1115 c: dd04 ble 18 <test+0x18>
1116 e: 5ca3 ldrb r3, [r4, r2]
1117 10: 3201 add r2, #1
1118 12: 4018 and r0, r3
1119 14: 428a cmp r2, r1
1120 16: dbfa blt e <test+0xe>
1121 18: bd10 pop {r4, pc}
1122 1a: 46c0 nop (mov r8, r8)
1123
1124
1125 */
1126 u16 erase_check_code[] =
1127 {
1128 0x0612,// lsl r2, r2, #24
1129 0x1c04,// mov r4, r0 (add r4, r0, #0)
1130 0x0e10,// lsr r0, r2, #24
1131 0x2200,// mov r2, #0
1132 0x2900,// cmp r1, #0
1133 0xdd04,// ble 18 <test+0x18>
1134 0x5ca3,// ldrb r3, [r4, r2]
1135 0x3201,// add r2, #1
1136 0x4018,// and r0, r3
1137 0x428a,// cmp r2, r1
1138 0xdbfa,// blt e <test+0xe>
1139 0x46c0,// nop (mov r8, r8)
1140
1141 };
1142
1143
1144
1145 /* make sure we have a working area */
1146 if (target_alloc_working_area(target, ((sizeof(erase_check_code)+3)/4)*4, &erase_check_algorithm) != ERROR_OK)
1147 {
1148 erase_check_algorithm = NULL;
1149 }
1150
1151 if (erase_check_algorithm)
1152 {
1153 u8 erase_check_code_buf[((sizeof(erase_check_code)+3)/4)*4];
1154 LOG_DEBUG("Running fast flash erase check");
1155
1156 for (i = 0; i < sizeof(erase_check_code)/sizeof(*erase_check_code); i++)
1157 target_buffer_set_u16(target, erase_check_code_buf + (i*2), erase_check_code[i]);
1158
1159 /* write algorithm code to working area */
1160 if ((retval=target->type->write_memory(target, erase_check_algorithm->address, 2, sizeof(erase_check_code)/sizeof(*erase_check_code), erase_check_code_buf))==ERROR_OK)
1161 {
1162 for (i = 0; i < bank->num_sectors; i++)
1163 {
1164 u32 address = bank->base + bank->sectors[i].offset;
1165 u32 size = bank->sectors[i].size;
1166
1167 reg_param_t reg_params[3];
1168 armv7m_algorithm_t arm_info;
1169
1170 arm_info.common_magic = ARMV7M_COMMON_MAGIC;
1171 arm_info.core_mode = ARMV7M_MODE_ANY;
1172 arm_info.core_state = ARMV7M_STATE_THUMB;
1173
1174 init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
1175 buf_set_u32(reg_params[0].value, 0, 32, address);
1176
1177 init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
1178 buf_set_u32(reg_params[1].value, 0, 32, size);
1179
1180 init_reg_param(&reg_params[2], "r2", 32, PARAM_IN_OUT);
1181 buf_set_u32(reg_params[2].value, 0, 32, 0xff);
1182
1183 if ((retval = target->type->run_algorithm(target, 0, NULL, 3, reg_params, erase_check_algorithm->address,
1184 erase_check_algorithm->address + sizeof(erase_check_code) - 2, 10000, &arm_info)) != ERROR_OK)
1185 break;
1186
1187 if (buf_get_u32(reg_params[2].value, 0, 32) == 0xff)
1188 bank->sectors[i].is_erased = 1;
1189 else
1190 bank->sectors[i].is_erased = 0;
1191
1192 destroy_reg_param(&reg_params[0]);
1193 destroy_reg_param(&reg_params[1]);
1194 destroy_reg_param(&reg_params[2]);
1195 }
1196 if (i == bank->num_sectors)
1197 {
1198 fast_check = 1;
1199 }
1200 }
1201 target_free_working_area(target, erase_check_algorithm);
1202 }
1203 #endif
1204 if (!fast_check)
1205 {
1206 /* try ARM7 instead */
1207
1208 u32 erase_check_code[] =
1209 {
1210 0xe4d03001, /* ldrb r3, [r0], #1 */
1211 0xe0022003, /* and r2, r2, r3 */
1212 0xe2511001, /* subs r1, r1, #1 */
1213 0x1afffffb, /* b -4 */
1214 0xeafffffe /* b 0 */
1215 };
1216
1217 /* make sure we have a working area */
1218 if (target_alloc_working_area(target, 20, &erase_check_algorithm) == ERROR_OK)
1219 {
1220 u8 erase_check_code_buf[5 * 4];
1221
1222 for (i = 0; i < 5; i++)
1223 target_buffer_set_u32(target, erase_check_code_buf + (i*4), erase_check_code[i]);
1224
1225 /* write algorithm code to working area */
1226 if ((retval=target->type->write_memory(target, erase_check_algorithm->address, 4, 5, erase_check_code_buf))==ERROR_OK)
1227 {
1228 for (i = 0; i < bank->num_sectors; i++)
1229 {
1230 u32 address = bank->base + bank->sectors[i].offset;
1231 u32 size = bank->sectors[i].size;
1232
1233 reg_param_t reg_params[3];
1234 armv4_5_algorithm_t armv4_5_info;
1235
1236 armv4_5_info.common_magic = ARMV4_5_COMMON_MAGIC;
1237 armv4_5_info.core_mode = ARMV4_5_MODE_SVC;
1238 armv4_5_info.core_state = ARMV4_5_STATE_ARM;
1239
1240 init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
1241 buf_set_u32(reg_params[0].value, 0, 32, address);
1242
1243 init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
1244 buf_set_u32(reg_params[1].value, 0, 32, size);
1245
1246 init_reg_param(&reg_params[2], "r2", 32, PARAM_IN_OUT);
1247 buf_set_u32(reg_params[2].value, 0, 32, 0xff);
1248
1249 if ((retval = target->type->run_algorithm(target, 0, NULL, 3, reg_params,
1250 erase_check_algorithm->address, erase_check_algorithm->address + 0x10, 10000, &armv4_5_info)) != ERROR_OK)
1251 break;
1252
1253 if (buf_get_u32(reg_params[2].value, 0, 32) == 0xff)
1254 bank->sectors[i].is_erased = 1;
1255 else
1256 bank->sectors[i].is_erased = 0;
1257
1258 destroy_reg_param(&reg_params[0]);
1259 destroy_reg_param(&reg_params[1]);
1260 destroy_reg_param(&reg_params[2]);
1261 }
1262 if (i == bank->num_sectors)
1263 {
1264 fast_check = 1;
1265 }
1266 }
1267 target_free_working_area(target, erase_check_algorithm);
1268 }
1269 }
1270
1271
1272 if (!fast_check)
1273 {
1274 LOG_USER("Running slow fallback erase check - add working memory");
1275 for (i = 0; i < bank->num_sectors; i++)
1276 {
1277 int j;
1278 bank->sectors[i].is_erased = 1;
1279
1280 for (j=0; j<bank->sectors[i].size; j+=buffer_size)
1281 {
1282 int chunk;
1283 int retval;
1284 chunk=buffer_size;
1285 if (chunk>(j-bank->sectors[i].size))
1286 {
1287 chunk=(j-bank->sectors[i].size);
1288 }
1289
1290 retval=target->type->read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
1291 if (retval!=ERROR_OK)
1292 return retval;
1293
1294 for (nBytes = 0; nBytes < chunk; nBytes++)
1295 {
1296 if (buffer[nBytes] != 0xFF)
1297 {
1298 bank->sectors[i].is_erased = 0;
1299 break;
1300 }
1301 }
1302 }
1303 }
1304 }
1305
1306 return ERROR_OK;
1307 }