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