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