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