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

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)