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