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