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