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