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