Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
The following patches was applied:
[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 at91sam7_old_flash;
69 extern flash_driver_t str7x_flash;
70 extern flash_driver_t str9x_flash;
71 extern flash_driver_t aduc702x_flash;
72 extern flash_driver_t stellaris_flash;
73 extern flash_driver_t str9xpec_flash;
74 extern flash_driver_t stm32x_flash;
75 extern flash_driver_t tms470_flash;
76 extern flash_driver_t ecosflash_flash;
77 extern flash_driver_t lpc288x_flash;
78 extern flash_driver_t ocl_flash;
79 extern flash_driver_t pic32mx_flash;
80
81 flash_driver_t *flash_drivers[] = {
82 &lpc2000_flash,
83 &cfi_flash,
84 &at91sam7_flash,
85 &at91sam7_old_flash,
86 &str7x_flash,
87 &str9x_flash,
88 &aduc702x_flash,
89 &stellaris_flash,
90 &str9xpec_flash,
91 &stm32x_flash,
92 &tms470_flash,
93 &ecosflash_flash,
94 &lpc288x_flash,
95 &ocl_flash,
96 &pic32mx_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 int 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 u32 wrote = 0;
728 u32 cur_size = 0;
729 int chunk_count;
730 char *duration_text;
731 duration_t duration;
732 target_t *target = get_current_target(cmd_ctx);
733 u32 i;
734 int wordsize;
735
736 if (argc != 3)
737 {
738 return ERROR_COMMAND_SYNTAX_ERROR;
739 }
740
741 address = strtoul(args[0], NULL, 0);
742 pattern = strtoul(args[1], NULL, 0);
743 count = strtoul(args[2], NULL, 0);
744
745 if(count == 0)
746 return ERROR_OK;
747
748 switch(cmd[4])
749 {
750 case 'w':
751 wordsize=4;
752 break;
753 case 'h':
754 wordsize=2;
755 break;
756 case 'b':
757 wordsize=1;
758 break;
759 default:
760 return ERROR_COMMAND_SYNTAX_ERROR;
761 }
762
763 chunk_count = MIN(count, (1024 / wordsize));
764 switch(wordsize)
765 {
766 case 4:
767 for(i = 0; i < chunk_count; i++)
768 {
769 target_buffer_set_u32(target, chunk + i * wordsize, pattern);
770 }
771 break;
772 case 2:
773 for(i = 0; i < chunk_count; i++)
774 {
775 target_buffer_set_u16(target, chunk + i * wordsize, pattern);
776 }
777 break;
778 case 1:
779 memset(chunk, pattern, chunk_count);
780 break;
781 default:
782 LOG_ERROR("BUG: can't happen");
783 exit(-1);
784 }
785
786 duration_start_measure(&duration);
787
788 for (wrote=0; wrote<(count*wordsize); wrote += cur_size)
789 {
790 cur_size = MIN( (count*wordsize - wrote), sizeof(chunk) );
791 flash_bank_t *bank;
792 bank = get_flash_bank_by_addr(target, address);
793 if(bank == NULL)
794 {
795 return ERROR_FAIL;
796 }
797 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
798 if (err!=ERROR_OK)
799 return err;
800 }
801
802 if ((retval = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
803 {
804 return retval;
805 }
806
807 if(err == ERROR_OK)
808 {
809 float speed;
810 speed=wrote / 1024.0;
811 speed/=((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0));
812 command_print(cmd_ctx, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
813 count*wordsize, address, duration_text,
814 speed);
815 }
816 free(duration_text);
817 return ERROR_OK;
818 }
819
820 static int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
821 {
822 u32 offset;
823 u8 *buffer;
824 u32 buf_cnt;
825
826 fileio_t fileio;
827
828 duration_t duration;
829 char *duration_text;
830
831 int retval, retvaltemp;
832 flash_bank_t *p;
833
834 if (argc != 3)
835 {
836 return ERROR_COMMAND_SYNTAX_ERROR;
837 }
838
839 duration_start_measure(&duration);
840
841 offset = strtoul(args[2], NULL, 0);
842 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
843 if (!p)
844 {
845 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
846 return ERROR_OK;
847 }
848
849 if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
850 {
851 return ERROR_OK;
852 }
853
854 buffer = malloc(fileio.size);
855 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
856 {
857 free(buffer);
858 fileio_close(&fileio);
859 return ERROR_OK;
860 }
861
862 retval = flash_driver_write(p, buffer, offset, buf_cnt);
863
864 free(buffer);
865 buffer = NULL;
866
867 if ((retvaltemp = duration_stop_measure(&duration, &duration_text)) != ERROR_OK)
868 {
869 fileio_close(&fileio);
870 return retvaltemp;
871 }
872 if (retval==ERROR_OK)
873 {
874 command_print(cmd_ctx, "wrote %"PRIi64" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
875 fileio.size, args[1], strtoul(args[0], NULL, 0), offset, duration_text,
876 (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
877 }
878 free(duration_text);
879
880 fileio_close(&fileio);
881
882 return retval;
883 }
884
885 void flash_set_dirty(void)
886 {
887 flash_bank_t *c;
888 int i;
889
890 /* set all flash to require erasing */
891 for (c = flash_banks; c; c = c->next)
892 {
893 for (i = 0; i < c->num_sectors; i++)
894 {
895 c->sectors[i].is_erased = 0;
896 }
897 }
898 }
899
900 /* lookup flash bank by address */
901 flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
902 {
903 flash_bank_t *c;
904
905 /* cycle through bank list */
906 for (c = flash_banks; c; c = c->next)
907 {
908 int retval;
909 retval = c->driver->auto_probe(c);
910
911 if (retval != ERROR_OK)
912 {
913 LOG_ERROR("auto_probe failed %d\n", retval);
914 return NULL;
915 }
916 /* check whether address belongs to this flash bank */
917 if ((addr >= c->base) && (addr <= c->base + (c->size - 1)) && target == c->target)
918 return c;
919 }
920 LOG_ERROR("No flash at address 0x%08x\n", addr);
921 return NULL;
922 }
923
924 /* erase given flash region, selects proper bank according to target and address */
925 int flash_erase_address_range(target_t *target, u32 addr, u32 length)
926 {
927 flash_bank_t *c;
928 int first = -1;
929 int last = -1;
930 int i;
931
932 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
933 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
934
935 if (c->size == 0 || c->num_sectors == 0)
936 {
937 LOG_ERROR("Bank is invalid");
938 return ERROR_FLASH_BANK_INVALID;
939 }
940
941 if (length == 0)
942 {
943 /* special case, erase whole bank when length is zero */
944 if (addr != c->base)
945 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
946
947 return flash_driver_erase(c, 0, c->num_sectors - 1);
948 }
949
950 /* check whether it fits */
951 if (addr + length - 1 > c->base + c->size - 1)
952 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
953
954 addr -= c->base;
955
956 for (i = 0; i < c->num_sectors; i++)
957 {
958 /* check whether sector overlaps with the given range and is not yet erased */
959 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
960 /* if first is not set yet then this is the first sector */
961 if (first == -1)
962 first = i;
963 last = i; /* and it is the last one so far in any case */
964 }
965 }
966
967 if( first == -1 || last == -1 )
968 return ERROR_OK;
969
970 return flash_driver_erase(c, first, last);
971 }
972
973 /* write (optional verify) an image to flash memory of the given target */
974 int flash_write(target_t *target, image_t *image, u32 *written, int erase)
975 {
976 int retval=ERROR_OK;
977
978 int section;
979 u32 section_offset;
980 flash_bank_t *c;
981 int *padding;
982
983 section = 0;
984 section_offset = 0;
985
986 if (written)
987 *written = 0;
988
989 if (erase)
990 {
991 /* assume all sectors need erasing - stops any problems
992 * when flash_write is called multiple times */
993
994 flash_set_dirty();
995 }
996
997 /* allocate padding array */
998 padding = malloc(image->num_sections * sizeof(padding));
999
1000 /* loop until we reach end of the image */
1001 while (section < image->num_sections)
1002 {
1003 u32 buffer_size;
1004 u8 *buffer;
1005 int section_first;
1006 int section_last;
1007 u32 run_address = image->sections[section].base_address + section_offset;
1008 u32 run_size = image->sections[section].size - section_offset;
1009 int pad_bytes = 0;
1010
1011 if (image->sections[section].size == 0)
1012 {
1013 LOG_WARNING("empty section %d", section);
1014 section++;
1015 section_offset = 0;
1016 continue;
1017 }
1018
1019 /* find the corresponding flash bank */
1020 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
1021 {
1022 section++; /* and skip it */
1023 section_offset = 0;
1024 continue;
1025 }
1026
1027 /* collect consecutive sections which fall into the same bank */
1028 section_first = section;
1029 section_last = section;
1030 padding[section] = 0;
1031 while ((run_address + run_size - 1 < c->base + c->size - 1)
1032 && (section_last + 1 < image->num_sections))
1033 {
1034 if (image->sections[section_last + 1].base_address < (run_address + run_size))
1035 {
1036 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
1037 break;
1038 }
1039 /* if we have multiple sections within our image, flash programming could fail due to alignment issues
1040 * attempt to rebuild a consecutive buffer for the flash loader */
1041 pad_bytes = (image->sections[section_last + 1].base_address) - (run_address + run_size);
1042 if ((run_address + run_size + pad_bytes) > (c->base + c->size))
1043 break;
1044 padding[section_last] = pad_bytes;
1045 run_size += image->sections[++section_last].size;
1046 run_size += pad_bytes;
1047 padding[section_last] = 0;
1048
1049 LOG_INFO("Padding image section %d with %d bytes", section_last-1, pad_bytes );
1050 }
1051
1052 /* fit the run into bank constraints */
1053 if (run_address + run_size - 1 > c->base + c->size - 1)
1054 {
1055 LOG_WARNING("writing %d bytes only - as image section is %d bytes and bank is only %d bytes", \
1056 c->base + c->size - run_address, run_size, c->size);
1057 run_size = c->base + c->size - run_address;
1058 }
1059
1060 /* allocate buffer */
1061 buffer = malloc(run_size);
1062 buffer_size = 0;
1063
1064 /* read sections to the buffer */
1065 while (buffer_size < run_size)
1066 {
1067 u32 size_read;
1068
1069 size_read = run_size - buffer_size;
1070 if (size_read > image->sections[section].size - section_offset)
1071 size_read = image->sections[section].size - section_offset;
1072
1073 if ((retval = image_read_section(image, section, section_offset,
1074 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
1075 {
1076 free(buffer);
1077 free(padding);
1078 return retval;
1079 }
1080
1081 /* see if we need to pad the section */
1082 while (padding[section]--)
1083 (buffer+buffer_size)[size_read++] = 0xff;
1084
1085 buffer_size += size_read;
1086 section_offset += size_read;
1087
1088 if (section_offset >= image->sections[section].size)
1089 {
1090 section++;
1091 section_offset = 0;
1092 }
1093 }
1094
1095 retval = ERROR_OK;
1096
1097 if (erase)
1098 {
1099 /* calculate and erase sectors */
1100 retval = flash_erase_address_range( target, run_address, run_size );
1101 }
1102
1103 if (retval == ERROR_OK)
1104 {
1105 /* write flash sectors */
1106 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
1107 }
1108
1109 free(buffer);
1110
1111 if (retval != ERROR_OK)
1112 {
1113 free(padding);
1114 return retval; /* abort operation */
1115 }
1116
1117 if (written != NULL)
1118 *written += run_size; /* add run size to total written counter */
1119 }
1120
1121 free(padding);
1122
1123 return retval;
1124 }
1125
1126 int default_flash_mem_blank_check(struct flash_bank_s *bank)
1127 {
1128 target_t *target = bank->target;
1129 u8 buffer[1024];
1130 int buffer_size = sizeof(buffer);
1131 int i;
1132 int nBytes;
1133
1134 if (bank->target->state != TARGET_HALTED)
1135 {
1136 LOG_ERROR("Target not halted");
1137 return ERROR_TARGET_NOT_HALTED;
1138 }
1139
1140 for (i = 0; i < bank->num_sectors; i++)
1141 {
1142 int j;
1143 bank->sectors[i].is_erased = 1;
1144
1145 for (j = 0; j < bank->sectors[i].size; j += buffer_size)
1146 {
1147 int chunk;
1148 int retval;
1149 chunk = buffer_size;
1150 if (chunk > (j - bank->sectors[i].size))
1151 {
1152 chunk = (j - bank->sectors[i].size);
1153 }
1154
1155 retval = target->type->read_memory(target, bank->base + bank->sectors[i].offset + j, 4, chunk/4, buffer);
1156 if (retval != ERROR_OK)
1157 return retval;
1158
1159 for (nBytes = 0; nBytes < chunk; nBytes++)
1160 {
1161 if (buffer[nBytes] != 0xFF)
1162 {
1163 bank->sectors[i].is_erased = 0;
1164 break;
1165 }
1166 }
1167 }
1168 }
1169
1170 return ERROR_OK;
1171 }
1172
1173 int default_flash_blank_check(struct flash_bank_s *bank)
1174 {
1175 target_t *target = bank->target;
1176 int i;
1177 int retval;
1178 int fast_check = 0;
1179 u32 blank;
1180
1181 if (bank->target->state != TARGET_HALTED)
1182 {
1183 LOG_ERROR("Target not halted");
1184 return ERROR_TARGET_NOT_HALTED;
1185 }
1186
1187 for (i = 0; i < bank->num_sectors; i++)
1188 {
1189 u32 address = bank->base + bank->sectors[i].offset;
1190 u32 size = bank->sectors[i].size;
1191
1192 if ((retval = target_blank_check_memory(target, address, size, &blank)) != ERROR_OK)
1193 {
1194 fast_check = 0;
1195 break;
1196 }
1197 if (blank == 0xFF)
1198 bank->sectors[i].is_erased = 1;
1199 else
1200 bank->sectors[i].is_erased = 0;
1201 fast_check = 1;
1202 }
1203
1204 if (!fast_check)
1205 {
1206 LOG_USER("Running slow fallback erase check - add working memory");
1207 return default_flash_mem_blank_check(bank);
1208 }
1209
1210 return ERROR_OK;
1211 }
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)