Code Review / openocd.git / blob
? search:


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