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