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