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