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