Code Review / openocd.git / blob
? search:


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