Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
added a couple of LOG_ERROR() messages to improve logfile.
[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 {
888 LOG_ERROR("Bank is invalid");
889 return ERROR_FLASH_BANK_INVALID;
890 }
891
892 if (length == 0)
893 {
894 /* special case, erase whole bank when length is zero */
895 if (addr != c->base)
896 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
897
898 return flash_driver_erase(c, 0, c->num_sectors - 1);
899 }
900
901 /* check whether it fits */
902 if (addr + length > c->base + c->size)
903 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
904
905 addr -= c->base;
906
907 for (i = 0; i < c->num_sectors; i++)
908 {
909 /* check whether sector overlaps with the given range and is not yet erased */
910 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
911 /* if first is not set yet then this is the first sector */
912 if (first == -1)
913 first = i;
914 last = i; /* and it is the last one so far in any case */
915 }
916 }
917
918 if( first == -1 || last == -1 )
919 return ERROR_OK;
920
921 return flash_driver_erase(c, first, last);
922 }
923
924 /* write (optional verify) an image to flash memory of the given target */
925 int flash_write(target_t *target, image_t *image, u32 *written, int erase)
926 {
927 int retval=ERROR_OK;
928
929 int section;
930 u32 section_offset;
931 flash_bank_t *c;
932
933 section = 0;
934 section_offset = 0;
935
936 if (written)
937 *written = 0;
938
939 if (erase)
940 {
941 /* assume all sectors need erasing - stops any problems
942 * when flash_write is called multiple times */
943
944 flash_set_dirty();
945 }
946
947 /* loop until we reach end of the image */
948 while (section < image->num_sections)
949 {
950 u32 buffer_size;
951 u8 *buffer;
952 int section_first;
953 int section_last;
954 u32 run_address = image->sections[section].base_address + section_offset;
955 u32 run_size = image->sections[section].size - section_offset;
956
957 if (image->sections[section].size == 0)
958 {
959 LOG_WARNING("empty section %d", section);
960 section++;
961 section_offset = 0;
962 continue;
963 }
964
965 /* find the corresponding flash bank */
966 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
967 {
968 section++; /* and skip it */
969 section_offset = 0;
970 continue;
971 }
972
973 /* collect consecutive sections which fall into the same bank */
974 section_first = section;
975 section_last = section;
976 while ((run_address + run_size < c->base + c->size)
977 && (section_last + 1 < image->num_sections))
978 {
979 if (image->sections[section_last + 1].base_address < (run_address + run_size))
980 {
981 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
982 break;
983 }
984 if (image->sections[section_last + 1].base_address != (run_address + run_size))
985 break;
986 run_size += image->sections[++section_last].size;
987 }
988
989 /* fit the run into bank constraints */
990 if (run_address + run_size > c->base + c->size)
991 run_size = c->base + c->size - run_address;
992
993 /* allocate buffer */
994 buffer = malloc(run_size);
995 buffer_size = 0;
996
997 /* read sections to the buffer */
998 while (buffer_size < run_size)
999 {
1000 u32 size_read;
1001
1002 if (buffer_size - run_size <= image->sections[section].size - section_offset)
1003 size_read = buffer_size - run_size;
1004 else
1005 size_read = image->sections[section].size - section_offset;
1006
1007 if ((retval = image_read_section(image, section, section_offset,
1008 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
1009 {
1010 free(buffer);
1011
1012 return retval;
1013 }
1014
1015 buffer_size += size_read;
1016 section_offset += size_read;
1017
1018 if (section_offset >= image->sections[section].size)
1019 {
1020 section++;
1021 section_offset = 0;
1022 }
1023 }
1024
1025 retval = ERROR_OK;
1026
1027 if (erase)
1028 {
1029 /* calculate and erase sectors */
1030 retval = flash_erase_address_range( target, run_address, run_size );
1031 }
1032
1033 if (retval == ERROR_OK)
1034 {
1035 /* write flash sectors */
1036 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
1037 }
1038
1039 free(buffer);
1040
1041 if (retval != ERROR_OK)
1042 {
1043 return retval; /* abort operation */
1044 }
1045
1046 if (written != NULL)
1047 *written += run_size; /* add run size to total written counter */
1048 }
1049
1050 return retval;
1051 }
1052
1053 int handle_flash_auto_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1054 {
1055 if (argc != 1)
1056 {
1057 return ERROR_COMMAND_SYNTAX_ERROR;
1058 }
1059
1060 if (strcmp(args[0], "on") == 0)
1061 auto_erase = 1;
1062 else if (strcmp(args[0], "off") == 0)
1063 auto_erase = 0;
1064 else
1065 return ERROR_COMMAND_SYNTAX_ERROR;
1066
1067 return ERROR_OK;
1068 }
1069
1070
1071 int default_flash_blank_check(struct flash_bank_s *bank)
1072 {
1073 target_t *target = bank->target;
1074 u8 buffer[1024];
1075 int buffer_size=sizeof(buffer);
1076 int i;
1077 int nBytes;
1078
1079 if (bank->target->state != TARGET_HALTED)
1080 {
1081 return ERROR_TARGET_NOT_HALTED;
1082 }
1083
1084 int retval;
1085 int fast_check=0;
1086 working_area_t *erase_check_algorithm;
1087 #if 0
1088 /* FIX! doesn't work yet... */
1089 /*
1090 char test(char *a, int len, char t)
1091 {
1092 int i=0;
1093
1094 for (i=0; i<len; i++)
1095 {
1096 t&=a[i];
1097
1098 }
1099 }
1100
1101 $ arm-elf-gcc -c -mthumb -O3 test.c
1102
1103 $ arm-elf-objdump --disassemble test.o
1104
1105 test.o: file format elf32-littlearm
1106
1107 Disassembly of section .text:
1108
1109 00000000 <test>:
1110 0: b510 push {r4, lr}
1111 2: 0612 lsl r2, r2, #24
1112 4: 1c04 mov r4, r0 (add r4, r0, #0)
1113 6: 0e10 lsr r0, r2, #24
1114 8: 2200 mov r2, #0
1115 a: 2900 cmp r1, #0
1116 c: dd04 ble 18 <test+0x18>
1117 e: 5ca3 ldrb r3, [r4, r2]
1118 10: 3201 add r2, #1
1119 12: 4018 and r0, r3
1120 14: 428a cmp r2, r1
1121 16: dbfa blt e <test+0xe>
1122 18: bd10 pop {r4, pc}
1123 1a: 46c0 nop (mov r8, r8)
1124
1125
1126 */
1127 u16 erase_check_code[] =
1128 {
1129 0x0612,// lsl r2, r2, #24
1130 0x1c04,// mov r4, r0 (add r4, r0, #0)
1131 0x0e10,// lsr r0, r2, #24
1132 0x2200,// mov r2, #0
1133 0x2900,// cmp r1, #0
1134 0xdd04,// ble 18 <test+0x18>
1135 0x5ca3,// ldrb r3, [r4, r2]
1136 0x3201,// add r2, #1
1137 0x4018,// and r0, r3
1138 0x428a,// cmp r2, r1
1139 0xdbfa,// blt e <test+0xe>
1140 0x46c0,// nop (mov r8, r8)
1141
1142 };
1143
1144
1145
1146 /* make sure we have a working area */
1147 if (target_alloc_working_area(target, ((sizeof(erase_check_code)+3)/4)*4, &erase_check_algorithm) != ERROR_OK)
1148 {
1149 erase_check_algorithm = NULL;
1150 }
1151
1152 if (erase_check_algorithm)
1153 {
1154 u8 erase_check_code_buf[((sizeof(erase_check_code)+3)/4)*4];
1155 LOG_DEBUG("Running fast flash erase check");
1156
1157 for (i = 0; i < sizeof(erase_check_code)/sizeof(*erase_check_code); i++)
1158 target_buffer_set_u16(target, erase_check_code_buf + (i*2), erase_check_code[i]);
1159
1160 /* write algorithm code to working area */
1161 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)
1162 {
1163 for (i = 0; i < bank->num_sectors; i++)
1164 {
1165 u32 address = bank->base + bank->sectors[i].offset;
1166 u32 size = bank->sectors[i].size;
1167
1168 reg_param_t reg_params[3];
1169 armv7m_algorithm_t arm_info;
1170
1171 arm_info.common_magic = ARMV7M_COMMON_MAGIC;
1172 arm_info.core_mode = ARMV7M_MODE_ANY;
1173 arm_info.core_state = ARMV7M_STATE_THUMB;
1174
1175 init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
1176 buf_set_u32(reg_params[0].value, 0, 32, address);
1177
1178 init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
1179 buf_set_u32(reg_params[1].value, 0, 32, size);
1180
1181 init_reg_param(&reg_params[2], "r2", 32, PARAM_IN_OUT);
1182 buf_set_u32(reg_params[2].value, 0, 32, 0xff);
1183
1184 if ((retval = target->type->run_algorithm(target, 0, NULL, 3, reg_params, erase_check_algorithm->address,
1185 erase_check_algorithm->address + sizeof(erase_check_code) - 2, 10000, &arm_info)) != ERROR_OK)
1186 break;
1187
1188 if (buf_get_u32(reg_params[2].value, 0, 32) == 0xff)
1189 bank->sectors[i].is_erased = 1;
1190 else
1191 bank->sectors[i].is_erased = 0;
1192
1193 destroy_reg_param(&reg_params[0]);
1194 destroy_reg_param(&reg_params[1]);
1195 destroy_reg_param(&reg_params[2]);
1196 }
1197 if (i == bank->num_sectors)
1198 {
1199 fast_check = 1;
1200 }
1201 }
1202 target_free_working_area(target, erase_check_algorithm);
1203 }
1204 #endif
1205 if (!fast_check)
1206 {
1207 /* try ARM7 instead */
1208
1209 u32 erase_check_code[] =
1210 {
1211 0xe4d03001, /* ldrb r3, [r0], #1 */
1212 0xe0022003, /* and r2, r2, r3 */
1213 0xe2511001, /* subs r1, r1, #1 */
1214 0x1afffffb, /* b -4 */
1215 0xeafffffe /* b 0 */
1216 };
1217
1218 /* make sure we have a working area */
1219 if (target_alloc_working_area(target, 20, &erase_check_algorithm) == ERROR_OK)
1220 {
1221 u8 erase_check_code_buf[5 * 4];
1222
1223 for (i = 0; i < 5; i++)
1224 target_buffer_set_u32(target, erase_check_code_buf + (i*4), erase_check_code[i]);
1225
1226 /* write algorithm code to working area */
1227 if ((retval=target->type->write_memory(target, erase_check_algorithm->address, 4, 5, erase_check_code_buf))==ERROR_OK)
1228 {
1229 for (i = 0; i < bank->num_sectors; i++)
1230 {
1231 u32 address = bank->base + bank->sectors[i].offset;
1232 u32 size = bank->sectors[i].size;
1233
1234 reg_param_t reg_params[3];
1235 armv4_5_algorithm_t armv4_5_info;
1236
1237 armv4_5_info.common_magic = ARMV4_5_COMMON_MAGIC;
1238 armv4_5_info.core_mode = ARMV4_5_MODE_SVC;
1239 armv4_5_info.core_state = ARMV4_5_STATE_ARM;
1240
1241 init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
1242 buf_set_u32(reg_params[0].value, 0, 32, address);
1243
1244 init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
1245 buf_set_u32(reg_params[1].value, 0, 32, size);
1246
1247 init_reg_param(&reg_params[2], "r2", 32, PARAM_IN_OUT);
1248 buf_set_u32(reg_params[2].value, 0, 32, 0xff);
1249
1250 if ((retval = target->type->run_algorithm(target, 0, NULL, 3, reg_params,
1251 erase_check_algorithm->address, erase_check_algorithm->address + 0x10, 10000, &armv4_5_info)) != ERROR_OK)
1252 break;
1253
1254 if (buf_get_u32(reg_params[2].value, 0, 32) == 0xff)
1255 bank->sectors[i].is_erased = 1;
1256 else
1257 bank->sectors[i].is_erased = 0;
1258
1259 destroy_reg_param(&reg_params[0]);
1260 destroy_reg_param(&reg_params[1]);
1261 destroy_reg_param(&reg_params[2]);
1262 }
1263 if (i == bank->num_sectors)
1264 {
1265 fast_check = 1;
1266 }
1267 }
1268 target_free_working_area(target, erase_check_algorithm);
1269 }
1270 }
1271
1272
1273 if (!fast_check)
1274 {
1275 LOG_USER("Running slow fallback erase check - add working memory");
1276 for (i = 0; i < bank->num_sectors; i++)
1277 {
1278 int j;
1279 bank->sectors[i].is_erased = 1;
1280
1281 for (j=0; j<bank->sectors[i].size; j+=buffer_size)
1282 {
1283 int chunk;
1284 int retval;
1285 chunk=buffer_size;
1286 if (chunk>(j-bank->sectors[i].size))
1287 {
1288 chunk=(j-bank->sectors[i].size);
1289 }
1290
1291 retval=target->type->read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
1292 if (retval!=ERROR_OK)
1293 return retval;
1294
1295 for (nBytes = 0; nBytes < chunk; nBytes++)
1296 {
1297 if (buffer[nBytes] != 0xFF)
1298 {
1299 bank->sectors[i].is_erased = 0;
1300 break;
1301 }
1302 }
1303 }
1304 }
1305 }
1306
1307 return ERROR_OK;
1308 }
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)