Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- Work on fixing erase check. Many implementations are plain broken.
[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
624 if (!target)
625 {
626 LOG_ERROR("no target selected");
627 return ERROR_OK;
628 }
629
630 duration_start_measure(&duration);
631
632 if (argc >= 2)
633 {
634 image.base_address_set = 1;
635 image.base_address = strtoul(args[1], NULL, 0);
636 }
637 else
638 {
639 image.base_address_set = 0;
640 image.base_address = 0x0;
641 }
642
643 image.start_address_set = 0;
644
645 retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL);
646 if (retval != ERROR_OK)
647 {
648 return retval;
649 }
650
651 retval = flash_write(target, &image, &written, auto_erase);
652
653 if (retval != ERROR_OK)
654 {
655 image_close(&image);
656 return retval;
657 }
658
659 duration_stop_measure(&duration, &duration_text);
660 if (retval == ERROR_OK)
661 {
662 command_print(cmd_ctx, "wrote %u byte from file %s in %s (%f kb/s)",
663 written, args[0], duration_text,
664 (float)written / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
665 }
666 free(duration_text);
667
668 image_close(&image);
669
670 return retval;
671 }
672
673 int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
674 {
675 int err = ERROR_OK;
676 u32 address;
677 u32 pattern;
678 u32 count;
679 u8 chunk[1024];
680 u32 wrote = 0;
681 int chunk_count;
682 char *duration_text;
683 duration_t duration;
684 target_t *target = get_current_target(cmd_ctx);
685 u32 i;
686 int wordsize;
687
688 if (argc != 3)
689 {
690 return ERROR_COMMAND_SYNTAX_ERROR;
691 }
692
693 address = strtoul(args[0], NULL, 0);
694 pattern = strtoul(args[1], NULL, 0);
695 count = strtoul(args[2], NULL, 0);
696
697 if(count == 0)
698 return ERROR_OK;
699
700
701 switch(cmd[4])
702 {
703 case 'w':
704 wordsize=4;
705 break;
706 case 'h':
707 wordsize=2;
708 break;
709 case 'b':
710 wordsize=1;
711 break;
712 default:
713 return ERROR_COMMAND_SYNTAX_ERROR;
714 }
715
716 chunk_count = MIN(count, (1024 / wordsize));
717 switch(wordsize)
718 {
719 case 4:
720 for(i = 0; i < chunk_count; i++)
721 {
722 target_buffer_set_u32(target, chunk + i * wordsize, pattern);
723 }
724 break;
725 case 2:
726 for(i = 0; i < chunk_count; i++)
727 {
728 target_buffer_set_u16(target, chunk + i * wordsize, pattern);
729 }
730 break;
731 case 1:
732 memset(chunk, pattern, chunk_count);
733 break;
734 default:
735 LOG_ERROR("BUG: can't happen");
736 exit(-1);
737 }
738
739 duration_start_measure(&duration);
740
741 flash_set_dirty();
742 err = flash_erase_address_range( target, address, count*wordsize );
743 if (err == ERROR_OK)
744 {
745 for (wrote=0; wrote<(count*wordsize); wrote+=sizeof(chunk))
746 {
747 int cur_size = MIN( (count*wordsize - wrote) , 1024 );
748 if (err == ERROR_OK)
749 {
750 flash_bank_t *bank;
751 bank = get_flash_bank_by_addr(target, address);
752 if(bank == NULL)
753 {
754 err = ERROR_FAIL;
755 break;
756 }
757 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
758 wrote += cur_size;
759 }
760 if (err!=ERROR_OK)
761 break;
762 }
763 }
764
765 duration_stop_measure(&duration, &duration_text);
766
767 if(err == ERROR_OK)
768 {
769 float speed;
770 speed=wrote / 1024.0;
771 speed/=((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0));
772 command_print(cmd_ctx, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
773 count*wordsize, address, duration_text,
774 speed);
775 }
776 free(duration_text);
777 return ERROR_OK;
778 }
779
780 int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
781 {
782 u32 offset;
783 u8 *buffer;
784 u32 buf_cnt;
785
786 fileio_t fileio;
787
788 duration_t duration;
789 char *duration_text;
790
791 int retval;
792 flash_bank_t *p;
793
794 if (argc != 3)
795 {
796 return ERROR_COMMAND_SYNTAX_ERROR;
797 }
798
799 duration_start_measure(&duration);
800
801 offset = strtoul(args[2], NULL, 0);
802 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
803 if (!p)
804 {
805 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
806 return ERROR_OK;
807 }
808
809 if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
810 {
811 return ERROR_OK;
812 }
813
814 buffer = malloc(fileio.size);
815 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
816 {
817 return ERROR_OK;
818 }
819
820 retval = flash_driver_write(p, buffer, offset, buf_cnt);
821
822 free(buffer);
823
824 duration_stop_measure(&duration, &duration_text);
825 if (retval!=ERROR_OK)
826 {
827 command_print(cmd_ctx, "wrote %"PRIi64" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
828 fileio.size, args[1], strtoul(args[0], NULL, 0), offset, duration_text,
829 (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
830 }
831 free(duration_text);
832
833 fileio_close(&fileio);
834
835 return retval;
836 }
837
838 void flash_set_dirty(void)
839 {
840 flash_bank_t *c;
841 int i;
842
843 /* set all flash to require erasing */
844 for (c = flash_banks; c; c = c->next)
845 {
846 for (i = 0; i < c->num_sectors; i++)
847 {
848 c->sectors[i].is_erased = 0;
849 }
850 }
851 }
852
853 /* lookup flash bank by address */
854 flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
855 {
856 flash_bank_t *c;
857
858 /* cycle through bank list */
859 for (c = flash_banks; c; c = c->next)
860 {
861 int retval;
862 retval = c->driver->auto_probe(c);
863
864 if (retval != ERROR_OK)
865 {
866 LOG_ERROR("auto_probe failed %d\n", retval);
867 return NULL;
868 }
869 /* check whether address belongs to this flash bank */
870 if ((addr >= c->base) && (addr < c->base + c->size) && target == c->target)
871 return c;
872 }
873 LOG_ERROR("No flash at address 0x%08x\n", addr);
874 return NULL;
875 }
876
877 /* erase given flash region, selects proper bank according to target and address */
878 int flash_erase_address_range(target_t *target, u32 addr, u32 length)
879 {
880 flash_bank_t *c;
881 int first = -1;
882 int last = -1;
883 int i;
884
885 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
886 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
887
888 if (c->size == 0 || c->num_sectors == 0)
889 return ERROR_FLASH_BANK_INVALID;
890
891 if (length == 0)
892 {
893 /* special case, erase whole bank when length is zero */
894 if (addr != c->base)
895 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
896
897 return flash_driver_erase(c, 0, c->num_sectors - 1);
898 }
899
900 /* check whether it fits */
901 if (addr + length > c->base + c->size)
902 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
903
904 addr -= c->base;
905
906 for (i = 0; i < c->num_sectors; i++)
907 {
908 /* check whether sector overlaps with the given range and is not yet erased */
909 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
910 /* if first is not set yet then this is the first sector */
911 if (first == -1)
912 first = i;
913 last = i; /* and it is the last one so far in any case */
914 }
915 }
916
917 if( first == -1 || last == -1 )
918 return ERROR_OK;
919
920 return flash_driver_erase(c, first, last);
921 }
922
923 /* write (optional verify) an image to flash memory of the given target */
924 int flash_write(target_t *target, image_t *image, u32 *written, int erase)
925 {
926 int retval;
927
928 int section;
929 u32 section_offset;
930 flash_bank_t *c;
931
932 section = 0;
933 section_offset = 0;
934
935 if (written)
936 *written = 0;
937
938 if (erase)
939 {
940 /* assume all sectors need erasing - stops any problems
941 * when flash_write is called multiple times */
942
943 flash_set_dirty();
944 }
945
946 /* loop until we reach end of the image */
947 while (section < image->num_sections)
948 {
949 u32 buffer_size;
950 u8 *buffer;
951 int section_first;
952 int section_last;
953 u32 run_address = image->sections[section].base_address + section_offset;
954 u32 run_size = image->sections[section].size - section_offset;
955
956 if (image->sections[section].size == 0)
957 {
958 LOG_WARNING("empty section %d", section);
959 section++;
960 section_offset = 0;
961 continue;
962 }
963
964 /* find the corresponding flash bank */
965 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
966 {
967 section++; /* and skip it */
968 section_offset = 0;
969 continue;
970 }
971
972 /* collect consecutive sections which fall into the same bank */
973 section_first = section;
974 section_last = section;
975 while ((run_address + run_size < c->base + c->size)
976 && (section_last + 1 < image->num_sections))
977 {
978 if (image->sections[section_last + 1].base_address < (run_address + run_size))
979 {
980 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
981 break;
982 }
983 if (image->sections[section_last + 1].base_address != (run_address + run_size))
984 break;
985 run_size += image->sections[++section_last].size;
986 }
987
988 /* fit the run into bank constraints */
989 if (run_address + run_size > c->base + c->size)
990 run_size = c->base + c->size - run_address;
991
992 /* allocate buffer */
993 buffer = malloc(run_size);
994 buffer_size = 0;
995
996 /* read sections to the buffer */
997 while (buffer_size < run_size)
998 {
999 u32 size_read;
1000
1001 if (buffer_size - run_size <= image->sections[section].size - section_offset)
1002 size_read = buffer_size - run_size;
1003 else
1004 size_read = image->sections[section].size - section_offset;
1005
1006 if ((retval = image_read_section(image, section, section_offset,
1007 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
1008 {
1009 free(buffer);
1010
1011 return retval;
1012 }
1013
1014 buffer_size += size_read;
1015 section_offset += size_read;
1016
1017 if (section_offset >= image->sections[section].size)
1018 {
1019 section++;
1020 section_offset = 0;
1021 }
1022 }
1023
1024 retval = ERROR_OK;
1025
1026 if (erase)
1027 {
1028 /* calculate and erase sectors */
1029 retval = flash_erase_address_range( target, run_address, run_size );
1030 }
1031
1032 if (retval == ERROR_OK)
1033 {
1034 /* write flash sectors */
1035 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
1036 }
1037
1038 free(buffer);
1039
1040 if (retval != ERROR_OK)
1041 {
1042 return retval; /* abort operation */
1043 }
1044
1045 if (written != NULL)
1046 *written += run_size; /* add run size to total written counter */
1047 }
1048
1049 return ERROR_OK;
1050 }
1051
1052 int handle_flash_auto_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1053 {
1054 if (argc != 1)
1055 {
1056 return ERROR_COMMAND_SYNTAX_ERROR;
1057 }
1058
1059 if (strcmp(args[0], "on") == 0)
1060 auto_erase = 1;
1061 else if (strcmp(args[0], "off") == 0)
1062 auto_erase = 0;
1063 else
1064 return ERROR_COMMAND_SYNTAX_ERROR;
1065
1066 return ERROR_OK;
1067 }
1068
1069
1070 int default_flash_blank_check(struct flash_bank_s *bank)
1071 {
1072 target_t *target = bank->target;
1073 u8 buffer[1024];
1074 int buffer_size=sizeof(buffer);
1075 int i;
1076 int nBytes;
1077
1078 if (bank->target->state != TARGET_HALTED)
1079 {
1080 return ERROR_TARGET_NOT_HALTED;
1081 }
1082
1083 int retval;
1084 int fast_check=0;
1085 working_area_t *erase_check_algorithm;
1086 #if 0
1087 /* FIX! doesn't work yet... */
1088 /*
1089 char test(char *a, int len, char t)
1090 {
1091 int i=0;
1092
1093 for (i=0; i<len; i++)
1094 {
1095 t&=a[i];
1096
1097 }
1098 }
1099
1100 $ arm-elf-gcc -c -mthumb -O3 test.c
1101
1102 $ arm-elf-objdump --disassemble test.o
1103
1104 test.o: file format elf32-littlearm
1105
1106 Disassembly of section .text:
1107
1108 00000000 <test>:
1109 0: b510 push {r4, lr}
1110 2: 0612 lsl r2, r2, #24
1111 4: 1c04 mov r4, r0 (add r4, r0, #0)
1112 6: 0e10 lsr r0, r2, #24
1113 8: 2200 mov r2, #0
1114 a: 2900 cmp r1, #0
1115 c: dd04 ble 18 <test+0x18>
1116 e: 5ca3 ldrb r3, [r4, r2]
1117 10: 3201 add r2, #1
1118 12: 4018 and r0, r3
1119 14: 428a cmp r2, r1
1120 16: dbfa blt e <test+0xe>
1121 18: bd10 pop {r4, pc}
1122 1a: 46c0 nop (mov r8, r8)
1123
1124
1125 */
1126 u16 erase_check_code[] =
1127 {
1128 0x0612,// lsl r2, r2, #24
1129 0x1c04,// mov r4, r0 (add r4, r0, #0)
1130 0x0e10,// lsr r0, r2, #24
1131 0x2200,// mov r2, #0
1132 0x2900,// cmp r1, #0
1133 0xdd04,// ble 18 <test+0x18>
1134 0x5ca3,// ldrb r3, [r4, r2]
1135 0x3201,// add r2, #1
1136 0x4018,// and r0, r3
1137 0x428a,// cmp r2, r1
1138 0xdbfa,// blt e <test+0xe>
1139 0x46c0,// nop (mov r8, r8)
1140
1141 };
1142
1143
1144
1145 /* make sure we have a working area */
1146 if (target_alloc_working_area(target, ((sizeof(erase_check_code)+3)/4)*4, &erase_check_algorithm) != ERROR_OK)
1147 {
1148 erase_check_algorithm = NULL;
1149 }
1150
1151 if (erase_check_algorithm)
1152 {
1153 u8 erase_check_code_buf[((sizeof(erase_check_code)+3)/4)*4];
1154 LOG_DEBUG("Running fast flash erase check");
1155
1156 for (i = 0; i < sizeof(erase_check_code)/sizeof(*erase_check_code); i++)
1157 target_buffer_set_u16(target, erase_check_code_buf + (i*2), erase_check_code[i]);
1158
1159 /* write algorithm code to working area */
1160 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)
1161 {
1162 for (i = 0; i < bank->num_sectors; i++)
1163 {
1164 u32 address = bank->base + bank->sectors[i].offset;
1165 u32 size = bank->sectors[i].size;
1166
1167 reg_param_t reg_params[3];
1168 armv7m_algorithm_t arm_info;
1169
1170 arm_info.common_magic = ARMV7M_COMMON_MAGIC;
1171 arm_info.core_mode = ARMV7M_MODE_ANY;
1172 arm_info.core_state = ARMV7M_STATE_THUMB;
1173
1174 init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
1175 buf_set_u32(reg_params[0].value, 0, 32, address);
1176
1177 init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
1178 buf_set_u32(reg_params[1].value, 0, 32, size);
1179
1180 init_reg_param(&reg_params[2], "r2", 32, PARAM_IN_OUT);
1181 buf_set_u32(reg_params[2].value, 0, 32, 0xff);
1182
1183 if ((retval = target->type->run_algorithm(target, 0, NULL, 3, reg_params, erase_check_algorithm->address,
1184 erase_check_algorithm->address + sizeof(erase_check_code) - 2, 10000, &arm_info)) != ERROR_OK)
1185 break;
1186
1187 if (buf_get_u32(reg_params[2].value, 0, 32) == 0xff)
1188 bank->sectors[i].is_erased = 1;
1189 else
1190 bank->sectors[i].is_erased = 0;
1191
1192 destroy_reg_param(&reg_params[0]);
1193 destroy_reg_param(&reg_params[1]);
1194 destroy_reg_param(&reg_params[2]);
1195 }
1196 if (i == bank->num_sectors)
1197 {
1198 fast_check = 1;
1199 }
1200 }
1201 target_free_working_area(target, erase_check_algorithm);
1202 }
1203 #endif
1204 if (!fast_check)
1205 {
1206 /* try ARM7 instead */
1207
1208 u32 erase_check_code[] =
1209 {
1210 0xe4d03001, /* ldrb r3, [r0], #1 */
1211 0xe0022003, /* and r2, r2, r3 */
1212 0xe2511001, /* subs r1, r1, #1 */
1213 0x1afffffb, /* b -4 */
1214 0xeafffffe /* b 0 */
1215 };
1216
1217 /* make sure we have a working area */
1218 if (target_alloc_working_area(target, 20, &erase_check_algorithm) == ERROR_OK)
1219 {
1220 u8 erase_check_code_buf[5 * 4];
1221
1222 for (i = 0; i < 5; i++)
1223 target_buffer_set_u32(target, erase_check_code_buf + (i*4), erase_check_code[i]);
1224
1225 /* write algorithm code to working area */
1226 if ((retval=target->type->write_memory(target, erase_check_algorithm->address, 4, 5, erase_check_code_buf))==ERROR_OK)
1227 {
1228 for (i = 0; i < bank->num_sectors; i++)
1229 {
1230 u32 address = bank->base + bank->sectors[i].offset;
1231 u32 size = bank->sectors[i].size;
1232
1233 reg_param_t reg_params[3];
1234 armv4_5_algorithm_t armv4_5_info;
1235
1236 armv4_5_info.common_magic = ARMV4_5_COMMON_MAGIC;
1237 armv4_5_info.core_mode = ARMV4_5_MODE_SVC;
1238 armv4_5_info.core_state = ARMV4_5_STATE_ARM;
1239
1240 init_reg_param(&reg_params[0], "r0", 32, PARAM_OUT);
1241 buf_set_u32(reg_params[0].value, 0, 32, address);
1242
1243 init_reg_param(&reg_params[1], "r1", 32, PARAM_OUT);
1244 buf_set_u32(reg_params[1].value, 0, 32, size);
1245
1246 init_reg_param(&reg_params[2], "r2", 32, PARAM_IN_OUT);
1247 buf_set_u32(reg_params[2].value, 0, 32, 0xff);
1248
1249 if ((retval = target->type->run_algorithm(target, 0, NULL, 3, reg_params,
1250 erase_check_algorithm->address, erase_check_algorithm->address + 0x10, 10000, &armv4_5_info)) != ERROR_OK)
1251 break;
1252
1253 if (buf_get_u32(reg_params[2].value, 0, 32) == 0xff)
1254 bank->sectors[i].is_erased = 1;
1255 else
1256 bank->sectors[i].is_erased = 0;
1257
1258 destroy_reg_param(&reg_params[0]);
1259 destroy_reg_param(&reg_params[1]);
1260 destroy_reg_param(&reg_params[2]);
1261 }
1262 if (i == bank->num_sectors)
1263 {
1264 fast_check = 1;
1265 }
1266 }
1267 target_free_working_area(target, erase_check_algorithm);
1268 }
1269 }
1270
1271
1272 if (!fast_check)
1273 {
1274 LOG_USER("Running slow fallback erase check - add working memory");
1275 for (i = 0; i < bank->num_sectors; i++)
1276 {
1277 int j;
1278 bank->sectors[i].is_erased = 1;
1279
1280 for (j=0; j<bank->sectors[i].size; j+=buffer_size)
1281 {
1282 int chunk;
1283 int retval;
1284 chunk=buffer_size;
1285 if (chunk>(j-bank->sectors[i].size))
1286 {
1287 chunk=(j-bank->sectors[i].size);
1288 }
1289
1290 retval=target->type->read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
1291 if (retval!=ERROR_OK)
1292 return retval;
1293
1294 for (nBytes = 0; nBytes < chunk; nBytes++)
1295 {
1296 if (buffer[nBytes] != 0xFF)
1297 {
1298 bank->sectors[i].is_erased = 0;
1299 break;
1300 }
1301 }
1302 }
1303 }
1304 }
1305
1306 return ERROR_OK;
1307 }
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)