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