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