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