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