Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
Improve flash.c command argument parsing.
[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 COMMAND_PARSE_NUMBER(u32, args[1], c->base);
311 COMMAND_PARSE_NUMBER(u32, args[2], c->size);
312 COMMAND_PARSE_NUMBER(int, args[3], c->chip_width);
313 COMMAND_PARSE_NUMBER(int, args[4], c->bus_width);
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 return ERROR_COMMAND_SYNTAX_ERROR;
364
365 unsigned bank_nr;
366 COMMAND_PARSE_NUMBER(uint, args[0], bank_nr);
367
368 for (p = flash_banks; p; p = p->next, i++)
369 {
370 if (i == bank_nr)
371 {
372 char buf[1024];
373
374 /* attempt auto probe */
375 if ((retval = p->driver->auto_probe(p)) != ERROR_OK)
376 return retval;
377
378 command_print(cmd_ctx,
379 "#%" PRIi32 " : %s at 0x%8.8" PRIx32 ", size 0x%8.8" PRIx32 ", buswidth %i, chipwidth %i",
380 i,
381 p->driver->name,
382 p->base,
383 p->size,
384 p->bus_width,
385 p->chip_width);
386 for (j = 0; j < p->num_sectors; j++)
387 {
388 char *protect_state;
389
390 if (p->sectors[j].is_protected == 0)
391 protect_state = "not protected";
392 else if (p->sectors[j].is_protected == 1)
393 protect_state = "protected";
394 else
395 protect_state = "protection state unknown";
396
397 command_print(cmd_ctx,
398 "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
399 j,
400 p->sectors[j].offset,
401 p->sectors[j].size,
402 p->sectors[j].size >> 10,
403 protect_state);
404 }
405
406 *buf = '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
407 retval = p->driver->info(p, buf, sizeof(buf));
408 command_print(cmd_ctx, "%s", buf);
409 if (retval != ERROR_OK)
410 LOG_ERROR("error retrieving flash info (%d)", retval);
411 }
412 }
413
414 return ERROR_OK;
415 }
416
417 static int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
418 {
419 int retval;
420
421 if (argc != 1)
422 {
423 return ERROR_COMMAND_SYNTAX_ERROR;
424 }
425
426 unsigned bank_nr;
427 COMMAND_PARSE_NUMBER(uint, args[0], bank_nr);
428 flash_bank_t *p = get_flash_bank_by_num_noprobe(bank_nr);
429 if (p)
430 {
431 if ((retval = p->driver->probe(p)) == ERROR_OK)
432 {
433 command_print(cmd_ctx, "flash '%s' found at 0x%8.8" PRIx32, p->driver->name, p->base);
434 }
435 else if (retval == ERROR_FLASH_BANK_INVALID)
436 {
437 command_print(cmd_ctx, "probing failed for flash bank '#%s' at 0x%8.8" PRIx32,
438 args[0], p->base);
439 }
440 else
441 {
442 command_print(cmd_ctx, "unknown error when probing flash bank '#%s' at 0x%8.8" PRIx32,
443 args[0], p->base);
444 }
445 }
446 else
447 {
448 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
449 }
450
451 return ERROR_OK;
452 }
453
454 static int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
455 {
456 if (argc != 1)
457 {
458 return ERROR_COMMAND_SYNTAX_ERROR;
459 }
460
461 flash_bank_t *p;
462 int retval = flash_command_get_bank_by_num(cmd_ctx, args[0], &p);
463 if (ERROR_OK != retval)
464 return retval;
465
466 if (p)
467 {
468 int j;
469 if ((retval = p->driver->erase_check(p)) == ERROR_OK)
470 {
471 command_print(cmd_ctx, "successfully checked erase state");
472 }
473 else
474 {
475 command_print(cmd_ctx, "unknown error when checking erase state of flash bank #%s at 0x%8.8" PRIx32,
476 args[0], p->base);
477 }
478
479 for (j = 0; j < p->num_sectors; j++)
480 {
481 char *erase_state;
482
483 if (p->sectors[j].is_erased == 0)
484 erase_state = "not erased";
485 else if (p->sectors[j].is_erased == 1)
486 erase_state = "erased";
487 else
488 erase_state = "erase state unknown";
489
490 command_print(cmd_ctx,
491 "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIi32 "kB) %s",
492 j,
493 p->sectors[j].offset,
494 p->sectors[j].size,
495 p->sectors[j].size >> 10,
496 erase_state);
497 }
498 }
499
500 return ERROR_OK;
501 }
502
503 static int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
504 {
505 flash_bank_t *p;
506 int retval;
507 int address;
508 int length;
509 duration_t duration;
510 char *duration_text;
511
512 target_t *target = get_current_target(cmd_ctx);
513
514 if (argc != 2)
515 return ERROR_COMMAND_SYNTAX_ERROR;
516
517 COMMAND_PARSE_NUMBER(int, args[0], address);
518 COMMAND_PARSE_NUMBER(int, args[1], length);
519 if (length <= 0)
520 {
521 command_print(cmd_ctx, "Length must be >0");
522 return ERROR_COMMAND_SYNTAX_ERROR;
523 }
524
525 p = get_flash_bank_by_addr(target, address);
526 if (p == NULL)
527 {
528 return ERROR_FAIL;
529 }
530
531 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
532 flash_set_dirty();
533
534 duration_start_measure(&duration);
535
536 if ((retval = flash_erase_address_range(target, address, length)) == ERROR_OK)
537 {
538 if ((retval = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
539 {
540 return retval;
541 }
542 command_print(cmd_ctx, "erased address 0x%8.8x length %i in %s", address, length, duration_text);
543 free(duration_text);
544 }
545
546 return retval;
547 }
548
549 static int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
550 {
551 if (argc != 1)
552 return ERROR_COMMAND_SYNTAX_ERROR;
553
554 flash_bank_t *p;
555 int retval = flash_command_get_bank_by_num(cmd_ctx, args[0], &p);
556 if (ERROR_OK != retval)
557 return retval;
558
559 if (p)
560 {
561 int retval;
562 if ((retval = p->driver->protect_check(p)) == ERROR_OK)
563 {
564 command_print(cmd_ctx, "successfully checked protect state");
565 }
566 else if (retval == ERROR_FLASH_OPERATION_FAILED)
567 {
568 command_print(cmd_ctx, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8" PRIx32, args[0], p->base);
569 }
570 else
571 {
572 command_print(cmd_ctx, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8" PRIx32, args[0], p->base);
573 }
574 }
575
576 return ERROR_OK;
577 }
578
579 static int flash_check_sector_parameters(struct command_context_s *cmd_ctx,
580 uint32_t first, uint32_t last, uint32_t num_sectors)
581 {
582 if (!(first <= last)) {
583 command_print(cmd_ctx, "ERROR: "
584 "first sector must be <= last sector");
585 return ERROR_FAIL;
586 }
587
588 if (!(last <= (num_sectors - 1))) {
589 command_print(cmd_ctx, "ERROR: last sector must be <= %d",
590 (int) num_sectors - 1);
591 return ERROR_FAIL;
592 }
593
594 return ERROR_OK;
595 }
596
597 static int handle_flash_erase_command(struct command_context_s *cmd_ctx,
598 char *cmd, char **args, int argc)
599 {
600 if (argc > 2)
601 {
602 uint32_t bank_nr;
603 uint32_t first;
604 uint32_t last;
605
606 COMMAND_PARSE_NUMBER(u32, args[0], bank_nr);
607 flash_bank_t *p = get_flash_bank_by_num(bank_nr);
608 if (!p)
609 return ERROR_OK;
610
611 COMMAND_PARSE_NUMBER(u32, args[1], first);
612 if (strcmp(args[2], "last") == 0)
613 last = p->num_sectors - 1;
614 else
615 COMMAND_PARSE_NUMBER(u32, args[2], last);
616
617 int retval;
618 if ((retval = flash_check_sector_parameters(cmd_ctx,
619 first, last, p->num_sectors)) != ERROR_OK)
620 return retval;
621
622 duration_t duration;
623 char *duration_text;
624 duration_start_measure(&duration);
625
626 if ((retval = flash_driver_erase(p, first, last)) == ERROR_OK) {
627 if ((retval = duration_stop_measure(&duration,
628 &duration_text)) != ERROR_OK)
629 return retval;
630 command_print(cmd_ctx, "erased sectors %i through %i "
631 "on flash bank %i in %s",
632 (int) first, (int) last, (int) bank_nr,
633 duration_text);
634 free(duration_text);
635 }
636 }
637 else
638 return ERROR_COMMAND_SYNTAX_ERROR;
639
640 return ERROR_OK;
641 }
642
643 static int handle_flash_protect_command(struct command_context_s *cmd_ctx,
644 char *cmd, char **args, int argc)
645 {
646 if (argc > 3)
647 {
648 uint32_t bank_nr;
649 uint32_t first;
650 uint32_t last;
651 int set;
652
653 COMMAND_PARSE_NUMBER(u32, args[0], bank_nr);
654 flash_bank_t *p = get_flash_bank_by_num(bank_nr);
655 if (!p)
656 return ERROR_OK;
657
658 COMMAND_PARSE_NUMBER(u32, args[1], first);
659 if (strcmp(args[2], "last") == 0)
660 last = p->num_sectors - 1;
661 else
662 COMMAND_PARSE_NUMBER(u32, args[2], last);
663
664 if (strcmp(args[3], "on") == 0)
665 set = 1;
666 else if (strcmp(args[3], "off") == 0)
667 set = 0;
668 else
669 return ERROR_COMMAND_SYNTAX_ERROR;
670
671 int retval;
672 if ((retval = flash_check_sector_parameters(cmd_ctx,
673 first, last, p->num_sectors)) != ERROR_OK)
674 return retval;
675
676 retval = flash_driver_protect(p, set, first, last);
677 if (retval == ERROR_OK) {
678 command_print(cmd_ctx, "%s protection for sectors %i "
679 "through %i on flash bank %i",
680 (set) ? "set" : "cleared", (int) first,
681 (int) last, (int) bank_nr);
682 }
683 }
684 else
685 return ERROR_COMMAND_SYNTAX_ERROR;
686
687 return ERROR_OK;
688 }
689
690 static int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
691 {
692 target_t *target = get_current_target(cmd_ctx);
693
694 image_t image;
695 uint32_t written;
696
697 duration_t duration;
698 char *duration_text;
699
700 int retval, retvaltemp;
701
702 if (argc < 1)
703 {
704 return ERROR_COMMAND_SYNTAX_ERROR;
705 }
706
707 /* flash auto-erase is disabled by default*/
708 int auto_erase = 0;
709 bool auto_unlock = false;
710
711 for (;;)
712 {
713 if (strcmp(args[0], "erase") == 0)
714 {
715 auto_erase = 1;
716 args++;
717 argc--;
718 command_print(cmd_ctx, "auto erase enabled");
719 } else if (strcmp(args[0], "unlock") == 0)
720 {
721 auto_unlock = true;
722 args++;
723 argc--;
724 command_print(cmd_ctx, "auto unlock enabled");
725 } else
726 {
727 break;
728 }
729 }
730
731 if (argc < 1)
732 {
733 return ERROR_COMMAND_SYNTAX_ERROR;
734 }
735
736 if (!target)
737 {
738 LOG_ERROR("no target selected");
739 return ERROR_FAIL;
740 }
741
742 duration_start_measure(&duration);
743
744 if (argc >= 2)
745 {
746 image.base_address_set = 1;
747 COMMAND_PARSE_NUMBER(int, args[1], image.base_address);
748 }
749 else
750 {
751 image.base_address_set = 0;
752 image.base_address = 0x0;
753 }
754
755 image.start_address_set = 0;
756
757 retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL);
758 if (retval != ERROR_OK)
759 {
760 return retval;
761 }
762
763 retval = flash_write_unlock(target, &image, &written, auto_erase, auto_unlock);
764 if (retval != ERROR_OK)
765 {
766 image_close(&image);
767 return retval;
768 }
769
770 if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
771 {
772 image_close(&image);
773 return retvaltemp;
774 }
775
776 float speed;
777
778 speed = written / 1024.0;
779 speed /= ((float)duration.duration.tv_sec
780 + ((float)duration.duration.tv_usec / 1000000.0));
781 command_print(cmd_ctx,
782 "wrote %" PRIu32 " byte from file %s in %s (%f kb/s)",
783 written, args[0], duration_text, speed);
784
785 free(duration_text);
786
787 image_close(&image);
788
789 return retval;
790 }
791
792 static int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
793 {
794 int err = ERROR_OK, retval;
795 uint32_t address;
796 uint32_t pattern;
797 uint32_t count;
798 uint8_t chunk[1024];
799 uint8_t readback[1024];
800 uint32_t wrote = 0;
801 uint32_t cur_size = 0;
802 uint32_t chunk_count;
803 char *duration_text;
804 duration_t duration;
805 target_t *target = get_current_target(cmd_ctx);
806 uint32_t i;
807 uint32_t wordsize;
808
809 if (argc != 3)
810 return ERROR_COMMAND_SYNTAX_ERROR;
811
812 COMMAND_PARSE_NUMBER(u32, args[0], address);
813 COMMAND_PARSE_NUMBER(u32, args[1], pattern);
814 COMMAND_PARSE_NUMBER(u32, args[2], count);
815
816 if (count == 0)
817 return ERROR_OK;
818
819 switch (cmd[4])
820 {
821 case 'w':
822 wordsize = 4;
823 break;
824 case 'h':
825 wordsize = 2;
826 break;
827 case 'b':
828 wordsize = 1;
829 break;
830 default:
831 return ERROR_COMMAND_SYNTAX_ERROR;
832 }
833
834 chunk_count = MIN(count, (1024 / wordsize));
835 switch (wordsize)
836 {
837 case 4:
838 for (i = 0; i < chunk_count; i++)
839 {
840 target_buffer_set_u32(target, chunk + i * wordsize, pattern);
841 }
842 break;
843 case 2:
844 for (i = 0; i < chunk_count; i++)
845 {
846 target_buffer_set_u16(target, chunk + i * wordsize, pattern);
847 }
848 break;
849 case 1:
850 memset(chunk, pattern, chunk_count);
851 break;
852 default:
853 LOG_ERROR("BUG: can't happen");
854 exit(-1);
855 }
856
857 duration_start_measure(&duration);
858
859 for (wrote = 0; wrote < (count*wordsize); wrote += cur_size)
860 {
861 cur_size = MIN((count*wordsize - wrote), sizeof(chunk));
862 flash_bank_t *bank;
863 bank = get_flash_bank_by_addr(target, address);
864 if (bank == NULL)
865 {
866 return ERROR_FAIL;
867 }
868 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
869 if (err != ERROR_OK)
870 return err;
871
872 err = target_read_buffer(target, address + wrote, cur_size, readback);
873 if (err != ERROR_OK)
874 return err;
875
876 unsigned i;
877 for (i = 0; i < cur_size; i++)
878 {
879 if (readback[i]!=chunk[i])
880 {
881 LOG_ERROR("Verfication error address 0x%08" PRIx32 ", read back 0x%02x, expected 0x%02x",
882 address + wrote + i, readback[i], chunk[i]);
883 return ERROR_FAIL;
884 }
885 }
886
887 }
888
889 if ((retval = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
890 {
891 return retval;
892 }
893
894 float speed;
895
896 speed = wrote / 1024.0;
897 speed /= ((float)duration.duration.tv_sec
898 + ((float)duration.duration.tv_usec / 1000000.0));
899 command_print(cmd_ctx,
900 "wrote %" PRIu32 " bytes to 0x%8.8" PRIx32 " in %s (%f kb/s)",
901 wrote, address, duration_text, speed);
902
903 free(duration_text);
904 return ERROR_OK;
905 }
906
907 static int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
908 {
909 uint32_t offset;
910 uint8_t *buffer;
911 uint32_t buf_cnt;
912
913 fileio_t fileio;
914
915 duration_t duration;
916 char *duration_text;
917
918
919 if (argc != 3)
920 return ERROR_COMMAND_SYNTAX_ERROR;
921
922 duration_start_measure(&duration);
923
924 flash_bank_t *p;
925 int retval = flash_command_get_bank_by_num(cmd_ctx, args[0], &p);
926 if (ERROR_OK != retval)
927 return retval;
928
929 COMMAND_PARSE_NUMBER(u32, args[2], offset);
930
931 if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
932 {
933 return ERROR_OK;
934 }
935
936 buffer = malloc(fileio.size);
937 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
938 {
939 free(buffer);
940 fileio_close(&fileio);
941 return ERROR_OK;
942 }
943
944 retval = flash_driver_write(p, buffer, offset, buf_cnt);
945
946 free(buffer);
947 buffer = NULL;
948
949 int retvaltemp;
950 if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
951 {
952 fileio_close(&fileio);
953 return retvaltemp;
954 }
955 if (retval == ERROR_OK)
956 {
957 float elapsed = (float)duration.duration.tv_sec;
958 elapsed += (float)duration.duration.tv_usec / 1000000.0;
959 float speed = (float)fileio.size / elapsed;
960 command_print(cmd_ctx,
961 "wrote %lld byte from file %s to flash bank %u "
962 "at offset 0x%8.8" PRIx32 " in %s (%f kb/s)",
963 fileio.size, args[1], p->bank_number, offset,
964 duration_text, speed / 1024);
965 }
966 free(duration_text);
967
968 fileio_close(&fileio);
969
970 return retval;
971 }
972
973 void flash_set_dirty(void)
974 {
975 flash_bank_t *c;
976 int i;
977
978 /* set all flash to require erasing */
979 for (c = flash_banks; c; c = c->next)
980 {
981 for (i = 0; i < c->num_sectors; i++)
982 {
983 c->sectors[i].is_erased = 0;
984 }
985 }
986 }
987
988 /* lookup flash bank by address */
989 flash_bank_t *get_flash_bank_by_addr(target_t *target, uint32_t addr)
990 {
991 flash_bank_t *c;
992
993 /* cycle through bank list */
994 for (c = flash_banks; c; c = c->next)
995 {
996 int retval;
997 retval = c->driver->auto_probe(c);
998
999 if (retval != ERROR_OK)
1000 {
1001 LOG_ERROR("auto_probe failed %d\n", retval);
1002 return NULL;
1003 }
1004 /* check whether address belongs to this flash bank */
1005 if ((addr >= c->base) && (addr <= c->base + (c->size - 1)) && target == c->target)
1006 return c;
1007 }
1008 LOG_ERROR("No flash at address 0x%08" PRIx32 "\n", addr);
1009 return NULL;
1010 }
1011
1012 /* erase given flash region, selects proper bank according to target and address */
1013 static int flash_iterate_address_range(target_t *target, uint32_t addr, uint32_t length,
1014 int (*callback)(struct flash_bank_s *bank, int first, int last))
1015 {
1016 flash_bank_t *c;
1017 int first = -1;
1018 int last = -1;
1019 int i;
1020
1021 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
1022 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
1023
1024 if (c->size == 0 || c->num_sectors == 0)
1025 {
1026 LOG_ERROR("Bank is invalid");
1027 return ERROR_FLASH_BANK_INVALID;
1028 }
1029
1030 if (length == 0)
1031 {
1032 /* special case, erase whole bank when length is zero */
1033 if (addr != c->base)
1034 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
1035
1036 return callback(c, 0, c->num_sectors - 1);
1037 }
1038
1039 /* check whether it fits */
1040 if (addr + length - 1 > c->base + c->size - 1)
1041 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
1042
1043 addr -= c->base;
1044
1045 for (i = 0; i < c->num_sectors; i++)
1046 {
1047 /* check whether sector overlaps with the given range and is not yet erased */
1048 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
1049 /* if first is not set yet then this is the first sector */
1050 if (first == -1)
1051 first = i;
1052 last = i; /* and it is the last one so far in any case */
1053 }
1054 }
1055
1056 if (first == -1 || last == -1)
1057 return ERROR_OK;
1058
1059 return callback(c, first, last);
1060 }
1061
1062
1063
1064 int flash_erase_address_range(target_t *target, uint32_t addr, uint32_t length)
1065 {
1066 return flash_iterate_address_range(target, addr, length, &flash_driver_erase);
1067 }
1068
1069 static int flash_driver_unprotect(struct flash_bank_s *bank, int first, int last)
1070 {
1071 return flash_driver_protect(bank, 0, first, last);
1072 }
1073
1074 static int flash_unlock_address_range(target_t *target, uint32_t addr, uint32_t length)
1075 {
1076 return flash_iterate_address_range(target, addr, length, &flash_driver_unprotect);
1077 }
1078
1079
1080 /* write (optional verify) an image to flash memory of the given target */
1081 static int flash_write_unlock(target_t *target, image_t *image, uint32_t *written, int erase, bool unlock)
1082 {
1083 int retval = ERROR_OK;
1084
1085 int section;
1086 uint32_t section_offset;
1087 flash_bank_t *c;
1088 int *padding;
1089
1090 section = 0;
1091 section_offset = 0;
1092
1093 if (written)
1094 *written = 0;
1095
1096 if (erase)
1097 {
1098 /* assume all sectors need erasing - stops any problems
1099 * when flash_write is called multiple times */
1100
1101 flash_set_dirty();
1102 }
1103
1104 /* allocate padding array */
1105 padding = malloc(image->num_sections * sizeof(padding));
1106
1107 /* loop until we reach end of the image */
1108 while (section < image->num_sections)
1109 {
1110 uint32_t buffer_size;
1111 uint8_t *buffer;
1112 int section_first;
1113 int section_last;
1114 uint32_t run_address = image->sections[section].base_address + section_offset;
1115 uint32_t run_size = image->sections[section].size - section_offset;
1116 int pad_bytes = 0;
1117
1118 if (image->sections[section].size == 0)
1119 {
1120 LOG_WARNING("empty section %d", section);
1121 section++;
1122 section_offset = 0;
1123 continue;
1124 }
1125
1126 /* find the corresponding flash bank */
1127 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
1128 {
1129 section++; /* and skip it */
1130 section_offset = 0;
1131 continue;
1132 }
1133
1134 /* collect consecutive sections which fall into the same bank */
1135 section_first = section;
1136 section_last = section;
1137 padding[section] = 0;
1138 while ((run_address + run_size - 1 < c->base + c->size - 1)
1139 && (section_last + 1 < image->num_sections))
1140 {
1141 if (image->sections[section_last + 1].base_address < (run_address + run_size))
1142 {
1143 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
1144 break;
1145 }
1146 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1147 * attempt to rebuild a consecutive buffer for the flash loader */
1148 pad_bytes = (image->sections[section_last + 1].base_address) - (run_address + run_size);
1149 if ((run_address + run_size + pad_bytes) > (c->base + c->size))
1150 break;
1151 padding[section_last] = pad_bytes;
1152 run_size += image->sections[++section_last].size;
1153 run_size += pad_bytes;
1154 padding[section_last] = 0;
1155
1156 LOG_INFO("Padding image section %d with %d bytes", section_last-1, pad_bytes);
1157 }
1158
1159 /* fit the run into bank constraints */
1160 if (run_address + run_size - 1 > c->base + c->size - 1)
1161 {
1162 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1163 (int)(c->base + c->size - run_address), (int)(run_size), (int)(c->size));
1164 run_size = c->base + c->size - run_address;
1165 }
1166
1167 /* allocate buffer */
1168 buffer = malloc(run_size);
1169 buffer_size = 0;
1170
1171 /* read sections to the buffer */
1172 while (buffer_size < run_size)
1173 {
1174 uint32_t size_read;
1175
1176 size_read = run_size - buffer_size;
1177 if (size_read > image->sections[section].size - section_offset)
1178 size_read = image->sections[section].size - section_offset;
1179
1180 if ((retval = image_read_section(image, section, section_offset,
1181 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
1182 {
1183 free(buffer);
1184 free(padding);
1185 return retval;
1186 }
1187
1188 /* see if we need to pad the section */
1189 while (padding[section]--)
1190 (buffer + buffer_size)[size_read++] = 0xff;
1191
1192 buffer_size += size_read;
1193 section_offset += size_read;
1194
1195 if (section_offset >= image->sections[section].size)
1196 {
1197 section++;
1198 section_offset = 0;
1199 }
1200 }
1201
1202 retval = ERROR_OK;
1203
1204 if (unlock)
1205 {
1206 retval = flash_unlock_address_range(target, run_address, run_size);
1207 }
1208 if (retval == ERROR_OK)
1209 {
1210 if (erase)
1211 {
1212 /* calculate and erase sectors */
1213 retval = flash_erase_address_range(target, run_address, run_size);
1214 }
1215 }
1216
1217 if (retval == ERROR_OK)
1218 {
1219 /* write flash sectors */
1220 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
1221 }
1222
1223 free(buffer);
1224
1225 if (retval != ERROR_OK)
1226 {
1227 free(padding);
1228 return retval; /* abort operation */
1229 }
1230
1231 if (written != NULL)
1232 *written += run_size; /* add run size to total written counter */
1233 }
1234
1235 free(padding);
1236
1237 return retval;
1238 }
1239
1240 int flash_write(target_t *target, image_t *image, uint32_t *written, int erase)
1241 {
1242 return flash_write_unlock(target, image, written, erase, false);
1243 }
1244
1245 int default_flash_mem_blank_check(struct flash_bank_s *bank)
1246 {
1247 target_t *target = bank->target;
1248 uint8_t buffer[1024];
1249 int buffer_size = sizeof(buffer);
1250 int i;
1251 uint32_t nBytes;
1252
1253 if (bank->target->state != TARGET_HALTED)
1254 {
1255 LOG_ERROR("Target not halted");
1256 return ERROR_TARGET_NOT_HALTED;
1257 }
1258
1259 for (i = 0; i < bank->num_sectors; i++)
1260 {
1261 uint32_t j;
1262 bank->sectors[i].is_erased = 1;
1263
1264 for (j = 0; j < bank->sectors[i].size; j += buffer_size)
1265 {
1266 uint32_t chunk;
1267 int retval;
1268 chunk = buffer_size;
1269 if (chunk > (j - bank->sectors[i].size))
1270 {
1271 chunk = (j - bank->sectors[i].size);
1272 }
1273
1274 retval = target_read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
1275 if (retval != ERROR_OK)
1276 return retval;
1277
1278 for (nBytes = 0; nBytes < chunk; nBytes++)
1279 {
1280 if (buffer[nBytes] != 0xFF)
1281 {
1282 bank->sectors[i].is_erased = 0;
1283 break;
1284 }
1285 }
1286 }
1287 }
1288
1289 return ERROR_OK;
1290 }
1291
1292 int default_flash_blank_check(struct flash_bank_s *bank)
1293 {
1294 target_t *target = bank->target;
1295 int i;
1296 int retval;
1297 int fast_check = 0;
1298 uint32_t blank;
1299
1300 if (bank->target->state != TARGET_HALTED)
1301 {
1302 LOG_ERROR("Target not halted");
1303 return ERROR_TARGET_NOT_HALTED;
1304 }
1305
1306 for (i = 0; i < bank->num_sectors; i++)
1307 {
1308 uint32_t address = bank->base + bank->sectors[i].offset;
1309 uint32_t size = bank->sectors[i].size;
1310
1311 if ((retval = target_blank_check_memory(target, address, size, &blank)) != ERROR_OK)
1312 {
1313 fast_check = 0;
1314 break;
1315 }
1316 if (blank == 0xFF)
1317 bank->sectors[i].is_erased = 1;
1318 else
1319 bank->sectors[i].is_erased = 0;
1320 fast_check = 1;
1321 }
1322
1323 if (!fast_check)
1324 {
1325 LOG_USER("Running slow fallback erase check - add working memory");
1326 return default_flash_mem_blank_check(bank);
1327 }
1328
1329 return ERROR_OK;
1330 }
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)