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