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