Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Edgar Grimberg fixes some memory handling issues and
[openocd.git] / src / flash / flash.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
9 * *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
14 * *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
20 #ifdef HAVE_CONFIG_H
21 #include "config.h"
22 #endif
23
24 #include "flash.h"
25 #include "command.h"
26 #include "target.h"
27 #include "time_support.h"
28 #include "fileio.h"
29 #include "image.h"
30 #include "log.h"
31 #include "armv4_5.h"
32 #include "algorithm.h"
33 #include "binarybuffer.h"
34 #include "armv7m.h"
35
36 #include <string.h>
37 #include <unistd.h>
38 #include <stdlib.h>
39 #include <sys/types.h>
40 #include <sys/stat.h>
41 #include <errno.h>
42 #include <inttypes.h>
43
44 /* command handlers */
45 int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
46 int handle_flash_banks_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
47 int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
48 int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
49 int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
50 int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
51 int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
52 int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
53 int handle_flash_write_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
54 int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
55 int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
56 int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
57 int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
58 flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr);
59
60 /* flash drivers
61 */
62 extern flash_driver_t lpc2000_flash;
63 extern flash_driver_t cfi_flash;
64 extern flash_driver_t at91sam7_flash;
65 extern flash_driver_t str7x_flash;
66 extern flash_driver_t str9x_flash;
67 extern flash_driver_t stellaris_flash;
68 extern flash_driver_t str9xpec_flash;
69 extern flash_driver_t stm32x_flash;
70 extern flash_driver_t tms470_flash;
71 extern flash_driver_t ecosflash_flash;
72 extern flash_driver_t lpc288x_flash;
73 extern flash_driver_t ocl_flash;
74
75 flash_driver_t *flash_drivers[] =
76 {
77 &lpc2000_flash,
78 &cfi_flash,
79 &at91sam7_flash,
80 &str7x_flash,
81 &str9x_flash,
82 &stellaris_flash,
83 &str9xpec_flash,
84 &stm32x_flash,
85 &tms470_flash,
86 &ecosflash_flash,
87 &lpc288x_flash,
88 &ocl_flash,
89 NULL,
90 };
91
92 flash_bank_t *flash_banks;
93 static command_t *flash_cmd;
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 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 [erase] <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_FAIL;
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 /* flash auto-erase is disabled by default*/
624 int auto_erase = 0;
625
626 if (strcmp(args[0], "erase")==0)
627 {
628 auto_erase = 1;
629 args++;
630 argc--;
631 command_print(cmd_ctx, "auto erase enabled");
632 }
633
634
635 if (argc < 1)
636 {
637 return ERROR_COMMAND_SYNTAX_ERROR;
638 }
639
640 if (!target)
641 {
642 LOG_ERROR("no target selected");
643 return ERROR_FAIL;
644 }
645
646 duration_start_measure(&duration);
647
648 if (argc >= 2)
649 {
650 image.base_address_set = 1;
651 image.base_address = strtoul(args[1], NULL, 0);
652 }
653 else
654 {
655 image.base_address_set = 0;
656 image.base_address = 0x0;
657 }
658
659 image.start_address_set = 0;
660
661 retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL);
662 if (retval != ERROR_OK)
663 {
664 return retval;
665 }
666
667 retval = flash_write(target, &image, &written, auto_erase);
668 if (retval != ERROR_OK)
669 {
670 image_close(&image);
671 return retval;
672 }
673
674 duration_stop_measure(&duration, &duration_text);
675 if (retval == ERROR_OK)
676 {
677 command_print(cmd_ctx, "wrote %u byte from file %s in %s (%f kb/s)",
678 written, args[0], duration_text,
679 (float)written / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
680 }
681 free(duration_text);
682
683 image_close(&image);
684
685 return retval;
686 }
687
688 int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
689 {
690 int err = ERROR_OK;
691 u32 address;
692 u32 pattern;
693 u32 count;
694 u8 chunk[1024];
695 u32 wrote = 0;
696 int chunk_count;
697 char *duration_text;
698 duration_t duration;
699 target_t *target = get_current_target(cmd_ctx);
700 u32 i;
701 int wordsize;
702
703 if (argc != 3)
704 {
705 return ERROR_COMMAND_SYNTAX_ERROR;
706 }
707
708 address = strtoul(args[0], NULL, 0);
709 pattern = strtoul(args[1], NULL, 0);
710 count = strtoul(args[2], NULL, 0);
711
712 if(count == 0)
713 return ERROR_OK;
714
715
716 switch(cmd[4])
717 {
718 case 'w':
719 wordsize=4;
720 break;
721 case 'h':
722 wordsize=2;
723 break;
724 case 'b':
725 wordsize=1;
726 break;
727 default:
728 return ERROR_COMMAND_SYNTAX_ERROR;
729 }
730
731 chunk_count = MIN(count, (1024 / wordsize));
732 switch(wordsize)
733 {
734 case 4:
735 for(i = 0; i < chunk_count; i++)
736 {
737 target_buffer_set_u32(target, chunk + i * wordsize, pattern);
738 }
739 break;
740 case 2:
741 for(i = 0; i < chunk_count; i++)
742 {
743 target_buffer_set_u16(target, chunk + i * wordsize, pattern);
744 }
745 break;
746 case 1:
747 memset(chunk, pattern, chunk_count);
748 break;
749 default:
750 LOG_ERROR("BUG: can't happen");
751 exit(-1);
752 }
753
754 duration_start_measure(&duration);
755
756 flash_set_dirty();
757 err = flash_erase_address_range( target, address, count*wordsize );
758 if (err == ERROR_OK)
759 {
760 for (wrote=0; wrote<(count*wordsize); wrote+=sizeof(chunk))
761 {
762 int cur_size = MIN( (count*wordsize - wrote) , 1024 );
763 if (err == ERROR_OK)
764 {
765 flash_bank_t *bank;
766 bank = get_flash_bank_by_addr(target, address);
767 if(bank == NULL)
768 {
769 err = ERROR_FAIL;
770 break;
771 }
772 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
773 wrote += cur_size;
774 }
775 if (err!=ERROR_OK)
776 break;
777 }
778 }
779
780 duration_stop_measure(&duration, &duration_text);
781
782 if(err == ERROR_OK)
783 {
784 float speed;
785 speed=wrote / 1024.0;
786 speed/=((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0));
787 command_print(cmd_ctx, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
788 count*wordsize, address, duration_text,
789 speed);
790 }
791 free(duration_text);
792 return ERROR_OK;
793 }
794
795 int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
796 {
797 u32 offset;
798 u8 *buffer;
799 u32 buf_cnt;
800
801 fileio_t fileio;
802
803 duration_t duration;
804 char *duration_text;
805
806 int retval;
807 flash_bank_t *p;
808
809 if (argc != 3)
810 {
811 return ERROR_COMMAND_SYNTAX_ERROR;
812 }
813
814 duration_start_measure(&duration);
815
816 offset = strtoul(args[2], NULL, 0);
817 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
818 if (!p)
819 {
820 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
821 return ERROR_OK;
822 }
823
824 if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
825 {
826 return ERROR_OK;
827 }
828
829 buffer = malloc(fileio.size);
830 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
831 {
832 free(buffer);
833 fileio_close(&fileio);
834 return ERROR_OK;
835 }
836
837 retval = flash_driver_write(p, buffer, offset, buf_cnt);
838
839 free(buffer);
840 buffer = NULL;
841
842 duration_stop_measure(&duration, &duration_text);
843 if (retval!=ERROR_OK)
844 {
845 command_print(cmd_ctx, "wrote %"PRIi64" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
846 fileio.size, args[1], strtoul(args[0], NULL, 0), offset, duration_text,
847 (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
848 }
849 free(duration_text);
850
851 fileio_close(&fileio);
852
853 return retval;
854 }
855
856 void flash_set_dirty(void)
857 {
858 flash_bank_t *c;
859 int i;
860
861 /* set all flash to require erasing */
862 for (c = flash_banks; c; c = c->next)
863 {
864 for (i = 0; i < c->num_sectors; i++)
865 {
866 c->sectors[i].is_erased = 0;
867 }
868 }
869 }
870
871 /* lookup flash bank by address */
872 flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
873 {
874 flash_bank_t *c;
875
876 /* cycle through bank list */
877 for (c = flash_banks; c; c = c->next)
878 {
879 int retval;
880 retval = c->driver->auto_probe(c);
881
882 if (retval != ERROR_OK)
883 {
884 LOG_ERROR("auto_probe failed %d\n", retval);
885 return NULL;
886 }
887 /* check whether address belongs to this flash bank */
888 if ((addr >= c->base) && (addr < c->base + c->size) && target == c->target)
889 return c;
890 }
891 LOG_ERROR("No flash at address 0x%08x\n", addr);
892 return NULL;
893 }
894
895 /* erase given flash region, selects proper bank according to target and address */
896 int flash_erase_address_range(target_t *target, u32 addr, u32 length)
897 {
898 flash_bank_t *c;
899 int first = -1;
900 int last = -1;
901 int i;
902
903 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
904 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
905
906 if (c->size == 0 || c->num_sectors == 0)
907 {
908 LOG_ERROR("Bank is invalid");
909 return ERROR_FLASH_BANK_INVALID;
910 }
911
912 if (length == 0)
913 {
914 /* special case, erase whole bank when length is zero */
915 if (addr != c->base)
916 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
917
918 return flash_driver_erase(c, 0, c->num_sectors - 1);
919 }
920
921 /* check whether it fits */
922 if (addr + length > c->base + c->size)
923 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
924
925 addr -= c->base;
926
927 for (i = 0; i < c->num_sectors; i++)
928 {
929 /* check whether sector overlaps with the given range and is not yet erased */
930 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
931 /* if first is not set yet then this is the first sector */
932 if (first == -1)
933 first = i;
934 last = i; /* and it is the last one so far in any case */
935 }
936 }
937
938 if( first == -1 || last == -1 )
939 return ERROR_OK;
940
941 return flash_driver_erase(c, first, last);
942 }
943
944 /* write (optional verify) an image to flash memory of the given target */
945 int flash_write(target_t *target, image_t *image, u32 *written, int erase)
946 {
947 int retval=ERROR_OK;
948
949 int section;
950 u32 section_offset;
951 flash_bank_t *c;
952
953 section = 0;
954 section_offset = 0;
955
956 if (written)
957 *written = 0;
958
959 if (erase)
960 {
961 /* assume all sectors need erasing - stops any problems
962 * when flash_write is called multiple times */
963
964 flash_set_dirty();
965 }
966
967 /* loop until we reach end of the image */
968 while (section < image->num_sections)
969 {
970 u32 buffer_size;
971 u8 *buffer;
972 int section_first;
973 int section_last;
974 u32 run_address = image->sections[section].base_address + section_offset;
975 u32 run_size = image->sections[section].size - section_offset;
976
977 if (image->sections[section].size == 0)
978 {
979 LOG_WARNING("empty section %d", section);
980 section++;
981 section_offset = 0;
982 continue;
983 }
984
985 /* find the corresponding flash bank */
986 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
987 {
988 section++; /* and skip it */
989 section_offset = 0;
990 continue;
991 }
992
993 /* collect consecutive sections which fall into the same bank */
994 section_first = section;
995 section_last = section;
996 while ((run_address + run_size < c->base + c->size)
997 && (section_last + 1 < image->num_sections))
998 {
999 if (image->sections[section_last + 1].base_address < (run_address + run_size))
1000 {
1001 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
1002 break;
1003 }
1004 if (image->sections[section_last + 1].base_address != (run_address + run_size))
1005 break;
1006 run_size += image->sections[++section_last].size;
1007 }
1008
1009 /* fit the run into bank constraints */
1010 if (run_address + run_size > c->base + c->size)
1011 run_size = c->base + c->size - run_address;
1012
1013 /* allocate buffer */
1014 buffer = malloc(run_size);
1015 buffer_size = 0;
1016
1017 /* read sections to the buffer */
1018 while (buffer_size < run_size)
1019 {
1020 u32 size_read;
1021
1022 if (buffer_size - run_size <= image->sections[section].size - section_offset)
1023 size_read = buffer_size - run_size;
1024 else
1025 size_read = image->sections[section].size - section_offset;
1026
1027 if ((retval = image_read_section(image, section, section_offset,
1028 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
1029 {
1030 free(buffer);
1031
1032 return retval;
1033 }
1034
1035 buffer_size += size_read;
1036 section_offset += size_read;
1037
1038 if (section_offset >= image->sections[section].size)
1039 {
1040 section++;
1041 section_offset = 0;
1042 }
1043 }
1044
1045 retval = ERROR_OK;
1046
1047 if (erase)
1048 {
1049 /* calculate and erase sectors */
1050 retval = flash_erase_address_range( target, run_address, run_size );
1051 }
1052
1053 if (retval == ERROR_OK)
1054 {
1055 /* write flash sectors */
1056 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
1057 }
1058
1059 free(buffer);
1060
1061 if (retval != ERROR_OK)
1062 {
1063 return retval; /* abort operation */
1064 }
1065
1066 if (written != NULL)
1067 *written += run_size; /* add run size to total written counter */
1068 }
1069
1070 return retval;
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)