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