Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- convert spaces to tabs in at91sam7.[ch]
[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 <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 duration_stop_measure(&duration, &duration_text);
518 command_print(cmd_ctx, "erased address 0x%8.8x length %i in %s", address, length, duration_text);
519 free(duration_text);
520 }
521
522 return retval;
523 }
524
525 int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
526 {
527 flash_bank_t *p;
528 int retval;
529
530 if (argc != 1)
531 {
532 return ERROR_COMMAND_SYNTAX_ERROR;
533 }
534
535 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
536 if (p)
537 {
538 if ((retval = p->driver->protect_check(p)) == ERROR_OK)
539 {
540 command_print(cmd_ctx, "successfully checked protect state");
541 }
542 else if (retval == ERROR_FLASH_OPERATION_FAILED)
543 {
544 command_print(cmd_ctx, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args[0], p->base);
545 }
546 else
547 {
548 command_print(cmd_ctx, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args[0], p->base);
549 }
550 }
551 else
552 {
553 return ERROR_COMMAND_SYNTAX_ERROR;
554 }
555
556 return ERROR_OK;
557 }
558
559 int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
560 {
561 if (argc > 2)
562 {
563 int first = strtoul(args[1], NULL, 0);
564 int last = strtoul(args[2], NULL, 0);
565 int retval;
566 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
567 duration_t duration;
568 char *duration_text;
569
570 duration_start_measure(&duration);
571
572 if (!p)
573 {
574 return ERROR_COMMAND_SYNTAX_ERROR;
575 }
576
577 if ((retval = flash_driver_erase(p, first, last)) == ERROR_OK)
578 {
579 duration_stop_measure(&duration, &duration_text);
580
581 command_print(cmd_ctx, "erased sectors %i through %i on flash bank %i in %s", first, last, strtoul(args[0], 0, 0), duration_text);
582 free(duration_text);
583 }
584 }
585 else
586 {
587 return ERROR_COMMAND_SYNTAX_ERROR;
588 }
589
590 return ERROR_OK;
591 }
592
593 int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
594 {
595 if (argc > 3)
596 {
597 int first = strtoul(args[1], NULL, 0);
598 int last = strtoul(args[2], NULL, 0);
599 int set;
600 int retval;
601 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
602 if (!p)
603 {
604 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
605 return ERROR_OK;
606 }
607
608 if (strcmp(args[3], "on") == 0)
609 set = 1;
610 else if (strcmp(args[3], "off") == 0)
611 set = 0;
612 else
613 {
614 return ERROR_COMMAND_SYNTAX_ERROR;
615 }
616
617 retval = flash_driver_protect(p, set, first, last);
618 if (retval == ERROR_OK)
619 {
620 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));
621 }
622 }
623 else
624 {
625 return ERROR_COMMAND_SYNTAX_ERROR;
626
627 }
628
629 return ERROR_OK;
630 }
631
632 int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
633 {
634 target_t *target = get_current_target(cmd_ctx);
635
636 image_t image;
637 u32 written;
638
639 duration_t duration;
640 char *duration_text;
641
642 int retval;
643
644 if (argc < 1)
645 {
646 return ERROR_COMMAND_SYNTAX_ERROR;
647 }
648
649 /* flash auto-erase is disabled by default*/
650 int auto_erase = 0;
651
652 if (strcmp(args[0], "erase")==0)
653 {
654 auto_erase = 1;
655 args++;
656 argc--;
657 command_print(cmd_ctx, "auto erase enabled");
658 }
659
660
661 if (argc < 1)
662 {
663 return ERROR_COMMAND_SYNTAX_ERROR;
664 }
665
666 if (!target)
667 {
668 LOG_ERROR("no target selected");
669 return ERROR_FAIL;
670 }
671
672 duration_start_measure(&duration);
673
674 if (argc >= 2)
675 {
676 image.base_address_set = 1;
677 image.base_address = strtoul(args[1], NULL, 0);
678 }
679 else
680 {
681 image.base_address_set = 0;
682 image.base_address = 0x0;
683 }
684
685 image.start_address_set = 0;
686
687 retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL);
688 if (retval != ERROR_OK)
689 {
690 return retval;
691 }
692
693 retval = flash_write(target, &image, &written, auto_erase);
694 if (retval != ERROR_OK)
695 {
696 image_close(&image);
697 return retval;
698 }
699
700 duration_stop_measure(&duration, &duration_text);
701 if (retval == ERROR_OK)
702 {
703 command_print(cmd_ctx, "wrote %u byte from file %s in %s (%f kb/s)",
704 written, args[0], duration_text,
705 (float)written / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
706 }
707 free(duration_text);
708
709 image_close(&image);
710
711 return retval;
712 }
713
714 int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
715 {
716 int err = ERROR_OK;
717 u32 address;
718 u32 pattern;
719 u32 count;
720 u8 chunk[1024];
721 u32 wrote = 0;
722 int chunk_count;
723 char *duration_text;
724 duration_t duration;
725 target_t *target = get_current_target(cmd_ctx);
726 u32 i;
727 int wordsize;
728
729 if (argc != 3)
730 {
731 return ERROR_COMMAND_SYNTAX_ERROR;
732 }
733
734 address = strtoul(args[0], NULL, 0);
735 pattern = strtoul(args[1], NULL, 0);
736 count = strtoul(args[2], NULL, 0);
737
738 if(count == 0)
739 return ERROR_OK;
740
741
742 switch(cmd[4])
743 {
744 case 'w':
745 wordsize=4;
746 break;
747 case 'h':
748 wordsize=2;
749 break;
750 case 'b':
751 wordsize=1;
752 break;
753 default:
754 return ERROR_COMMAND_SYNTAX_ERROR;
755 }
756
757 chunk_count = MIN(count, (1024 / wordsize));
758 switch(wordsize)
759 {
760 case 4:
761 for(i = 0; i < chunk_count; i++)
762 {
763 target_buffer_set_u32(target, chunk + i * wordsize, pattern);
764 }
765 break;
766 case 2:
767 for(i = 0; i < chunk_count; i++)
768 {
769 target_buffer_set_u16(target, chunk + i * wordsize, pattern);
770 }
771 break;
772 case 1:
773 memset(chunk, pattern, chunk_count);
774 break;
775 default:
776 LOG_ERROR("BUG: can't happen");
777 exit(-1);
778 }
779
780 duration_start_measure(&duration);
781
782 flash_set_dirty();
783 err = flash_erase_address_range( target, address, count*wordsize );
784 if (err == ERROR_OK)
785 {
786 for (wrote=0; wrote<(count*wordsize); wrote+=sizeof(chunk))
787 {
788 int cur_size = MIN( (count*wordsize - wrote) , 1024 );
789 if (err == ERROR_OK)
790 {
791 flash_bank_t *bank;
792 bank = get_flash_bank_by_addr(target, address);
793 if(bank == NULL)
794 {
795 err = ERROR_FAIL;
796 break;
797 }
798 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
799 wrote += cur_size;
800 }
801 if (err!=ERROR_OK)
802 break;
803 }
804 }
805
806 duration_stop_measure(&duration, &duration_text);
807
808 if(err == ERROR_OK)
809 {
810 float speed;
811 speed=wrote / 1024.0;
812 speed/=((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0));
813 command_print(cmd_ctx, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
814 count*wordsize, address, duration_text,
815 speed);
816 }
817 free(duration_text);
818 return ERROR_OK;
819 }
820
821 int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
822 {
823 u32 offset;
824 u8 *buffer;
825 u32 buf_cnt;
826
827 fileio_t fileio;
828
829 duration_t duration;
830 char *duration_text;
831
832 int retval;
833 flash_bank_t *p;
834
835 if (argc != 3)
836 {
837 return ERROR_COMMAND_SYNTAX_ERROR;
838 }
839
840 duration_start_measure(&duration);
841
842 offset = strtoul(args[2], NULL, 0);
843 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
844 if (!p)
845 {
846 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
847 return ERROR_OK;
848 }
849
850 if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
851 {
852 return ERROR_OK;
853 }
854
855 buffer = malloc(fileio.size);
856 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
857 {
858 free(buffer);
859 fileio_close(&fileio);
860 return ERROR_OK;
861 }
862
863 retval = flash_driver_write(p, buffer, offset, buf_cnt);
864
865 free(buffer);
866 buffer = NULL;
867
868 duration_stop_measure(&duration, &duration_text);
869 if (retval!=ERROR_OK)
870 {
871 command_print(cmd_ctx, "wrote %"PRIi64" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
872 fileio.size, args[1], strtoul(args[0], NULL, 0), offset, duration_text,
873 (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
874 }
875 free(duration_text);
876
877 fileio_close(&fileio);
878
879 return retval;
880 }
881
882 void flash_set_dirty(void)
883 {
884 flash_bank_t *c;
885 int i;
886
887 /* set all flash to require erasing */
888 for (c = flash_banks; c; c = c->next)
889 {
890 for (i = 0; i < c->num_sectors; i++)
891 {
892 c->sectors[i].is_erased = 0;
893 }
894 }
895 }
896
897 /* lookup flash bank by address */
898 flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
899 {
900 flash_bank_t *c;
901
902 /* cycle through bank list */
903 for (c = flash_banks; c; c = c->next)
904 {
905 int retval;
906 retval = c->driver->auto_probe(c);
907
908 if (retval != ERROR_OK)
909 {
910 LOG_ERROR("auto_probe failed %d\n", retval);
911 return NULL;
912 }
913 /* check whether address belongs to this flash bank */
914 if ((addr >= c->base) && (addr <= c->base + (c->size - 1)) && target == c->target)
915 return c;
916 }
917 LOG_ERROR("No flash at address 0x%08x\n", addr);
918 return NULL;
919 }
920
921 /* erase given flash region, selects proper bank according to target and address */
922 int flash_erase_address_range(target_t *target, u32 addr, u32 length)
923 {
924 flash_bank_t *c;
925 int first = -1;
926 int last = -1;
927 int i;
928
929 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
930 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
931
932 if (c->size == 0 || c->num_sectors == 0)
933 {
934 LOG_ERROR("Bank is invalid");
935 return ERROR_FLASH_BANK_INVALID;
936 }
937
938 if (length == 0)
939 {
940 /* special case, erase whole bank when length is zero */
941 if (addr != c->base)
942 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
943
944 return flash_driver_erase(c, 0, c->num_sectors - 1);
945 }
946
947 /* check whether it fits */
948 if (addr + length > c->base + c->size)
949 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
950
951 addr -= c->base;
952
953 for (i = 0; i < c->num_sectors; i++)
954 {
955 /* check whether sector overlaps with the given range and is not yet erased */
956 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
957 /* if first is not set yet then this is the first sector */
958 if (first == -1)
959 first = i;
960 last = i; /* and it is the last one so far in any case */
961 }
962 }
963
964 if( first == -1 || last == -1 )
965 return ERROR_OK;
966
967 return flash_driver_erase(c, first, last);
968 }
969
970 /* write (optional verify) an image to flash memory of the given target */
971 int flash_write(target_t *target, image_t *image, u32 *written, int erase)
972 {
973 int retval=ERROR_OK;
974
975 int section;
976 u32 section_offset;
977 flash_bank_t *c;
978 int *padding;
979
980 section = 0;
981 section_offset = 0;
982
983 if (written)
984 *written = 0;
985
986 if (erase)
987 {
988 /* assume all sectors need erasing - stops any problems
989 * when flash_write is called multiple times */
990
991 flash_set_dirty();
992 }
993
994 /* allocate padding array */
995 padding = malloc(image->num_sections * sizeof(padding));
996
997 /* loop until we reach end of the image */
998 while (section < image->num_sections)
999 {
1000 u32 buffer_size;
1001 u8 *buffer;
1002 int section_first;
1003 int section_last;
1004 u32 run_address = image->sections[section].base_address + section_offset;
1005 u32 run_size = image->sections[section].size - section_offset;
1006 int pad_bytes = 0;
1007
1008 if (image->sections[section].size == 0)
1009 {
1010 LOG_WARNING("empty section %d", section);
1011 section++;
1012 section_offset = 0;
1013 continue;
1014 }
1015
1016 /* find the corresponding flash bank */
1017 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
1018 {
1019 section++; /* and skip it */
1020 section_offset = 0;
1021 continue;
1022 }
1023
1024 /* collect consecutive sections which fall into the same bank */
1025 section_first = section;
1026 section_last = section;
1027 padding[section] = 0;
1028 while ((run_address + run_size < c->base + c->size)
1029 && (section_last + 1 < image->num_sections))
1030 {
1031 if (image->sections[section_last + 1].base_address < (run_address + run_size))
1032 {
1033 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
1034 break;
1035 }
1036 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1037 * attempt to rebuild a consecutive buffer for the flash loader */
1038 pad_bytes = (image->sections[section_last + 1].base_address) - (run_address + run_size);
1039 if ((run_address + run_size + pad_bytes) > (c->base + c->size))
1040 break;
1041 padding[section_last] = pad_bytes;
1042 run_size += image->sections[++section_last].size;
1043 run_size += pad_bytes;
1044 padding[section_last] = 0;
1045
1046 LOG_INFO("Padding image section %d with %d bytes", section_last-1, pad_bytes );
1047 }
1048
1049 /* fit the run into bank constraints */
1050 if (run_address + run_size > c->base + c->size)
1051 run_size = c->base + c->size - run_address;
1052
1053 /* allocate buffer */
1054 buffer = malloc(run_size);
1055 buffer_size = 0;
1056
1057 /* read sections to the buffer */
1058 while (buffer_size < run_size)
1059 {
1060 u32 size_read;
1061
1062 size_read = run_size - buffer_size;
1063 if (size_read > image->sections[section].size - section_offset)
1064 size_read = image->sections[section].size - section_offset;
1065
1066 if ((retval = image_read_section(image, section, section_offset,
1067 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
1068 {
1069 free(buffer);
1070 free(padding);
1071 return retval;
1072 }
1073
1074 /* see if we need to pad the section */
1075 while (padding[section]--)
1076 (buffer+buffer_size)[size_read++] = 0xff;
1077
1078 buffer_size += size_read;
1079 section_offset += size_read;
1080
1081 if (section_offset >= image->sections[section].size)
1082 {
1083 section++;
1084 section_offset = 0;
1085 }
1086 }
1087
1088 retval = ERROR_OK;
1089
1090 if (erase)
1091 {
1092 /* calculate and erase sectors */
1093 retval = flash_erase_address_range( target, run_address, run_size );
1094 }
1095
1096 if (retval == ERROR_OK)
1097 {
1098 /* write flash sectors */
1099 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
1100 }
1101
1102 free(buffer);
1103
1104 if (retval != ERROR_OK)
1105 {
1106 free(padding);
1107 return retval; /* abort operation */
1108 }
1109
1110 if (written != NULL)
1111 *written += run_size; /* add run size to total written counter */
1112 }
1113
1114 free(padding);
1115
1116 return retval;
1117 }
1118
1119 int default_flash_mem_blank_check(struct flash_bank_s *bank)
1120 {
1121 target_t *target = bank->target;
1122 u8 buffer[1024];
1123 int buffer_size = sizeof(buffer);
1124 int i;
1125 int nBytes;
1126
1127 if (bank->target->state != TARGET_HALTED)
1128 {
1129 LOG_ERROR("Target not halted");
1130 return ERROR_TARGET_NOT_HALTED;
1131 }
1132
1133 for (i = 0; i < bank->num_sectors; i++)
1134 {
1135 int j;
1136 bank->sectors[i].is_erased = 1;
1137
1138 for (j = 0; j < bank->sectors[i].size; j += buffer_size)
1139 {
1140 int chunk;
1141 int retval;
1142 chunk = buffer_size;
1143 if (chunk > (j - bank->sectors[i].size))
1144 {
1145 chunk = (j - bank->sectors[i].size);
1146 }
1147
1148 retval = target->type->read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
1149 if (retval != ERROR_OK)
1150 return retval;
1151
1152 for (nBytes = 0; nBytes < chunk; nBytes++)
1153 {
1154 if (buffer[nBytes] != 0xFF)
1155 {
1156 bank->sectors[i].is_erased = 0;
1157 break;
1158 }
1159 }
1160 }
1161 }
1162
1163 return ERROR_OK;
1164 }
1165
1166 int default_flash_blank_check(struct flash_bank_s *bank)
1167 {
1168 target_t *target = bank->target;
1169 int i;
1170 int retval;
1171 int fast_check = 0;
1172 int blank;
1173
1174 if (bank->target->state != TARGET_HALTED)
1175 {
1176 LOG_ERROR("Target not halted");
1177 return ERROR_TARGET_NOT_HALTED;
1178 }
1179
1180 for (i = 0; i < bank->num_sectors; i++)
1181 {
1182 u32 address = bank->base + bank->sectors[i].offset;
1183 u32 size = bank->sectors[i].size;
1184
1185 if ((retval = target_blank_check_memory(target, address, size, &blank)) != ERROR_OK)
1186 {
1187 fast_check = 0;
1188 break;
1189 }
1190 if (blank == 0xFF)
1191 bank->sectors[i].is_erased = 1;
1192 else
1193 bank->sectors[i].is_erased = 0;
1194 fast_check = 1;
1195 }
1196
1197 if (!fast_check)
1198 {
1199 LOG_USER("Running slow fallback erase check - add working memory");
1200 return default_flash_mem_blank_check(bank);
1201 }
1202
1203 return ERROR_OK;
1204 }
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)