Code Review / openocd.git / blob
? search:


a0c8984124445fc5e766df5f617d61e107ceedb8
[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 p->driver->auto_probe(p);
338
339 command_print(cmd_ctx, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
340 i, p->driver->name, p->base, p->size, p->bus_width, p->chip_width);
341 for (j = 0; j < p->num_sectors; j++)
342 {
343 char *erase_state, *protect_state;
344
345 if (p->sectors[j].is_erased == 0)
346 erase_state = "not erased";
347 else if (p->sectors[j].is_erased == 1)
348 erase_state = "erased";
349 else
350 erase_state = "erase state unknown";
351
352 if (p->sectors[j].is_protected == 0)
353 protect_state = "not protected";
354 else if (p->sectors[j].is_protected == 1)
355 protect_state = "protected";
356 else
357 protect_state = "protection state unknown";
358
359 command_print(cmd_ctx, "\t#%i: 0x%8.8x (0x%x %ikB) %s, %s",
360 j, p->sectors[j].offset, p->sectors[j].size, p->sectors[j].size>>10,
361 erase_state, protect_state);
362 }
363
364 *buf = '\0'; /* initialize buffer, otherwise it migh contain garbage if driver function fails */
365 retval = p->driver->info(p, buf, sizeof(buf));
366 command_print(cmd_ctx, "%s", buf);
367 if (retval != ERROR_OK)
368 LOG_ERROR("error retrieving flash info (%d)", retval);
369 }
370 }
371
372 return ERROR_OK;
373 }
374
375 int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
376 {
377 flash_bank_t *p;
378 int retval;
379
380 if (argc != 1)
381 {
382 return ERROR_COMMAND_SYNTAX_ERROR;
383 }
384
385 p = get_flash_bank_by_num_noprobe(strtoul(args[0], NULL, 0));
386 if (p)
387 {
388 if ((retval = p->driver->probe(p)) == ERROR_OK)
389 {
390 command_print(cmd_ctx, "flash '%s' found at 0x%8.8x", p->driver->name, p->base);
391 }
392 else if (retval == ERROR_FLASH_BANK_INVALID)
393 {
394 command_print(cmd_ctx, "probing failed for flash bank '#%s' at 0x%8.8x",
395 args[0], p->base);
396 }
397 else
398 {
399 command_print(cmd_ctx, "unknown error when probing flash bank '#%s' at 0x%8.8x",
400 args[0], p->base);
401 }
402 }
403 else
404 {
405 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
406 }
407
408 return ERROR_OK;
409 }
410
411 int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
412 {
413 flash_bank_t *p;
414 int retval;
415
416 if (argc != 1)
417 {
418 return ERROR_COMMAND_SYNTAX_ERROR;
419 }
420
421 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
422 if (p)
423 {
424 if ((retval = p->driver->erase_check(p)) == ERROR_OK)
425 {
426 command_print(cmd_ctx, "successfully checked erase state", p->driver->name, p->base);
427 }
428 else
429 {
430 command_print(cmd_ctx, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
431 args[0], p->base);
432 }
433 }
434
435 return ERROR_OK;
436 }
437
438 int handle_flash_erase_address_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
439 {
440 flash_bank_t *p;
441 int retval;
442 int address;
443 int length;
444 duration_t duration;
445 char *duration_text;
446
447 target_t *target = get_current_target(cmd_ctx);
448
449 if (argc != 2)
450 {
451 return ERROR_COMMAND_SYNTAX_ERROR;
452 }
453
454 address = strtoul(args[0], NULL, 0);
455 length = strtoul(args[1], NULL, 0);
456 if (length <= 0)
457 {
458 command_print(cmd_ctx, "Length must be >0");
459 return ERROR_COMMAND_SYNTAX_ERROR;
460 }
461
462 p = get_flash_bank_by_addr(target, address);
463 if (p == NULL)
464 {
465 return ERROR_COMMAND_SYNTAX_ERROR;
466 }
467
468 /* We can't know if we did a resume + halt, in which case we no longer know the erased state */
469 flash_set_dirty();
470
471 duration_start_measure(&duration);
472
473 if ((retval = flash_erase_address_range(target, address, length)) == ERROR_OK)
474 {
475 duration_stop_measure(&duration, &duration_text);
476 command_print(cmd_ctx, "erased address 0x%8.8x length %i in %s", address, length, duration_text);
477 free(duration_text);
478 }
479
480 return retval;
481 }
482
483 int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
484 {
485 flash_bank_t *p;
486 int retval;
487
488 if (argc != 1)
489 {
490 return ERROR_COMMAND_SYNTAX_ERROR;
491 }
492
493 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
494 if (p)
495 {
496 if ((retval = p->driver->protect_check(p)) == ERROR_OK)
497 {
498 command_print(cmd_ctx, "successfully checked protect state");
499 }
500 else if (retval == ERROR_FLASH_OPERATION_FAILED)
501 {
502 command_print(cmd_ctx, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args[0], p->base);
503 }
504 else
505 {
506 command_print(cmd_ctx, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args[0], p->base);
507 }
508 }
509 else
510 {
511 return ERROR_COMMAND_SYNTAX_ERROR;
512 }
513
514 return ERROR_OK;
515 }
516
517 int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
518 {
519 if (argc > 2)
520 {
521 int first = strtoul(args[1], NULL, 0);
522 int last = strtoul(args[2], NULL, 0);
523 int retval;
524 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
525 duration_t duration;
526 char *duration_text;
527
528 duration_start_measure(&duration);
529
530 if (!p)
531 {
532 return ERROR_COMMAND_SYNTAX_ERROR;
533 }
534
535 if ((retval = flash_driver_erase(p, first, last)) == ERROR_OK)
536 {
537 duration_stop_measure(&duration, &duration_text);
538
539 command_print(cmd_ctx, "erased sectors %i through %i on flash bank %i in %s", first, last, strtoul(args[0], 0, 0), duration_text);
540 free(duration_text);
541 }
542 }
543 else
544 {
545 return ERROR_COMMAND_SYNTAX_ERROR;
546 }
547
548 return ERROR_OK;
549 }
550
551 int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
552 {
553 if (argc > 3)
554 {
555 int first = strtoul(args[1], NULL, 0);
556 int last = strtoul(args[2], NULL, 0);
557 int set;
558 int retval;
559 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
560 if (!p)
561 {
562 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
563 return ERROR_OK;
564 }
565
566 if (strcmp(args[3], "on") == 0)
567 set = 1;
568 else if (strcmp(args[3], "off") == 0)
569 set = 0;
570 else
571 {
572 return ERROR_COMMAND_SYNTAX_ERROR;
573 }
574
575 retval = flash_driver_protect(p, set, first, last);
576 if (retval == ERROR_OK)
577 {
578 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));
579 }
580 }
581 else
582 {
583 return ERROR_COMMAND_SYNTAX_ERROR;
584
585 }
586
587 return ERROR_OK;
588 }
589
590 int handle_flash_write_image_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
591 {
592 target_t *target = get_current_target(cmd_ctx);
593
594 image_t image;
595 u32 written;
596
597 duration_t duration;
598 char *duration_text;
599
600 int retval;
601
602 if (argc < 1)
603 {
604 return ERROR_COMMAND_SYNTAX_ERROR;
605
606 }
607
608 if (!target)
609 {
610 LOG_ERROR("no target selected");
611 return ERROR_OK;
612 }
613
614 duration_start_measure(&duration);
615
616 if (argc >= 2)
617 {
618 image.base_address_set = 1;
619 image.base_address = strtoul(args[1], NULL, 0);
620 }
621 else
622 {
623 image.base_address_set = 0;
624 image.base_address = 0x0;
625 }
626
627 image.start_address_set = 0;
628
629 retval = image_open(&image, args[0], (argc == 3) ? args[2] : NULL);
630 if (retval != ERROR_OK)
631 {
632 return retval;
633 }
634
635 retval = flash_write(target, &image, &written, auto_erase);
636
637 if (retval != ERROR_OK)
638 {
639 image_close(&image);
640 return retval;
641 }
642
643 duration_stop_measure(&duration, &duration_text);
644 if (retval == ERROR_OK)
645 {
646 command_print(cmd_ctx, "wrote %u byte from file %s in %s (%f kb/s)",
647 written, args[0], duration_text,
648 (float)written / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
649 }
650 free(duration_text);
651
652 image_close(&image);
653
654 return retval;
655 }
656
657 int handle_flash_fill_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
658 {
659 int err = ERROR_OK;
660 u32 address;
661 u32 pattern;
662 u32 count;
663 u8 chunk[1024];
664 u32 wrote = 0;
665 int chunk_count;
666 char *duration_text;
667 duration_t duration;
668 target_t *target = get_current_target(cmd_ctx);
669 u32 i;
670 int wordsize;
671
672 if (argc != 3)
673 {
674 return ERROR_COMMAND_SYNTAX_ERROR;
675 }
676
677 address = strtoul(args[0], NULL, 0);
678 pattern = strtoul(args[1], NULL, 0);
679 count = strtoul(args[2], NULL, 0);
680
681 if(count == 0)
682 return ERROR_OK;
683
684
685 switch(cmd[4])
686 {
687 case 'w':
688 wordsize=4;
689 break;
690 case 'h':
691 wordsize=2;
692 break;
693 case 'b':
694 wordsize=1;
695 break;
696 default:
697 return ERROR_COMMAND_SYNTAX_ERROR;
698 }
699
700 chunk_count = MIN(count, (1024 / wordsize));
701 switch(wordsize)
702 {
703 case 4:
704 for(i = 0; i < chunk_count; i++)
705 {
706 target_buffer_set_u32(target, chunk + i * wordsize, pattern);
707 }
708 break;
709 case 2:
710 for(i = 0; i < chunk_count; i++)
711 {
712 target_buffer_set_u16(target, chunk + i * wordsize, pattern);
713 }
714 break;
715 case 1:
716 memset(chunk, pattern, chunk_count);
717 break;
718 default:
719 LOG_ERROR("BUG: can't happen");
720 exit(-1);
721 }
722
723 duration_start_measure(&duration);
724
725 flash_set_dirty();
726 err = flash_erase_address_range( target, address, count*wordsize );
727 if (err == ERROR_OK)
728 {
729 for (wrote=0; wrote<(count*wordsize); wrote+=sizeof(chunk))
730 {
731 int cur_size = MIN( (count*wordsize - wrote) , 1024 );
732 if (err == ERROR_OK)
733 {
734 flash_bank_t *bank;
735 bank = get_flash_bank_by_addr(target, address);
736 if(bank == NULL)
737 {
738 err = ERROR_FAIL;
739 break;
740 }
741 err = flash_driver_write(bank, chunk, address - bank->base + wrote, cur_size);
742 wrote += cur_size;
743 }
744 if (err!=ERROR_OK)
745 break;
746 }
747 }
748
749 duration_stop_measure(&duration, &duration_text);
750
751 if(err == ERROR_OK)
752 {
753 float speed;
754 speed=wrote / 1024.0;
755 speed/=((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0));
756 command_print(cmd_ctx, "wrote %d bytes to 0x%8.8x in %s (%f kb/s)",
757 count*wordsize, address, duration_text,
758 speed);
759 }
760 free(duration_text);
761 return ERROR_OK;
762 }
763
764 int handle_flash_write_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
765 {
766 u32 offset;
767 u8 *buffer;
768 u32 buf_cnt;
769
770 fileio_t fileio;
771
772 duration_t duration;
773 char *duration_text;
774
775 int retval;
776 flash_bank_t *p;
777
778 if (argc != 3)
779 {
780 return ERROR_COMMAND_SYNTAX_ERROR;
781 }
782
783 duration_start_measure(&duration);
784
785 offset = strtoul(args[2], NULL, 0);
786 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
787 if (!p)
788 {
789 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
790 return ERROR_OK;
791 }
792
793 if (fileio_open(&fileio, args[1], FILEIO_READ, FILEIO_BINARY) != ERROR_OK)
794 {
795 return ERROR_OK;
796 }
797
798 buffer = malloc(fileio.size);
799 if (fileio_read(&fileio, fileio.size, buffer, &buf_cnt) != ERROR_OK)
800 {
801 return ERROR_OK;
802 }
803
804 retval = flash_driver_write(p, buffer, offset, buf_cnt);
805
806 free(buffer);
807
808 duration_stop_measure(&duration, &duration_text);
809 if (retval!=ERROR_OK)
810 {
811 command_print(cmd_ctx, "wrote %"PRIi64" byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
812 fileio.size, args[1], strtoul(args[0], NULL, 0), offset, duration_text,
813 (float)fileio.size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
814 }
815 free(duration_text);
816
817 fileio_close(&fileio);
818
819 return retval;
820 }
821
822 void flash_set_dirty(void)
823 {
824 flash_bank_t *c;
825 int i;
826
827 /* set all flash to require erasing */
828 for (c = flash_banks; c; c = c->next)
829 {
830 for (i = 0; i < c->num_sectors; i++)
831 {
832 c->sectors[i].is_erased = 0;
833 }
834 }
835 }
836
837 /* lookup flash bank by address */
838 flash_bank_t *get_flash_bank_by_addr(target_t *target, u32 addr)
839 {
840 flash_bank_t *c;
841
842 /* cycle through bank list */
843 for (c = flash_banks; c; c = c->next)
844 {
845 int retval;
846 retval = c->driver->auto_probe(c);
847
848 if (retval != ERROR_OK)
849 {
850 LOG_ERROR("auto_probe failed %d\n", retval);
851 return NULL;
852 }
853 /* check whether address belongs to this flash bank */
854 if ((addr >= c->base) && (addr < c->base + c->size) && target == c->target)
855 return c;
856 }
857 LOG_ERROR("No flash at address 0x%08x\n", addr);
858 return NULL;
859 }
860
861 /* erase given flash region, selects proper bank according to target and address */
862 int flash_erase_address_range(target_t *target, u32 addr, u32 length)
863 {
864 flash_bank_t *c;
865 int first = -1;
866 int last = -1;
867 int i;
868
869 if ((c = get_flash_bank_by_addr(target, addr)) == NULL)
870 return ERROR_FLASH_DST_OUT_OF_BANK; /* no corresponding bank found */
871
872 if (c->size == 0 || c->num_sectors == 0)
873 return ERROR_FLASH_BANK_INVALID;
874
875 if (length == 0)
876 {
877 /* special case, erase whole bank when length is zero */
878 if (addr != c->base)
879 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
880
881 return flash_driver_erase(c, 0, c->num_sectors - 1);
882 }
883
884 /* check whether it fits */
885 if (addr + length > c->base + c->size)
886 return ERROR_FLASH_DST_BREAKS_ALIGNMENT;
887
888 addr -= c->base;
889
890 for (i = 0; i < c->num_sectors; i++)
891 {
892 /* check whether sector overlaps with the given range and is not yet erased */
893 if (addr < c->sectors[i].offset + c->sectors[i].size && addr + length > c->sectors[i].offset && c->sectors[i].is_erased != 1) {
894 /* if first is not set yet then this is the first sector */
895 if (first == -1)
896 first = i;
897 last = i; /* and it is the last one so far in any case */
898 }
899 }
900
901 if( first == -1 || last == -1 )
902 return ERROR_OK;
903
904 return flash_driver_erase(c, first, last);
905 }
906
907 /* write (optional verify) an image to flash memory of the given target */
908 int flash_write(target_t *target, image_t *image, u32 *written, int erase)
909 {
910 int retval;
911
912 int section;
913 u32 section_offset;
914 flash_bank_t *c;
915
916 section = 0;
917 section_offset = 0;
918
919 if (written)
920 *written = 0;
921
922 if (erase)
923 {
924 /* assume all sectors need erasing - stops any problems
925 * when flash_write is called multiple times */
926
927 flash_set_dirty();
928 }
929
930 /* loop until we reach end of the image */
931 while (section < image->num_sections)
932 {
933 u32 buffer_size;
934 u8 *buffer;
935 int section_first;
936 int section_last;
937 u32 run_address = image->sections[section].base_address + section_offset;
938 u32 run_size = image->sections[section].size - section_offset;
939
940 if (image->sections[section].size == 0)
941 {
942 LOG_WARNING("empty section %d", section);
943 section++;
944 section_offset = 0;
945 continue;
946 }
947
948 /* find the corresponding flash bank */
949 if ((c = get_flash_bank_by_addr(target, run_address)) == NULL)
950 {
951 section++; /* and skip it */
952 section_offset = 0;
953 continue;
954 }
955
956 /* collect consecutive sections which fall into the same bank */
957 section_first = section;
958 section_last = section;
959 while ((run_address + run_size < c->base + c->size)
960 && (section_last + 1 < image->num_sections))
961 {
962 if (image->sections[section_last + 1].base_address < (run_address + run_size))
963 {
964 LOG_DEBUG("section %d out of order(very slightly surprising, but supported)", section_last + 1);
965 break;
966 }
967 if (image->sections[section_last + 1].base_address != (run_address + run_size))
968 break;
969 run_size += image->sections[++section_last].size;
970 }
971
972 /* fit the run into bank constraints */
973 if (run_address + run_size > c->base + c->size)
974 run_size = c->base + c->size - run_address;
975
976 /* allocate buffer */
977 buffer = malloc(run_size);
978 buffer_size = 0;
979
980 /* read sections to the buffer */
981 while (buffer_size < run_size)
982 {
983 u32 size_read;
984
985 if (buffer_size - run_size <= image->sections[section].size - section_offset)
986 size_read = buffer_size - run_size;
987 else
988 size_read = image->sections[section].size - section_offset;
989
990 if ((retval = image_read_section(image, section, section_offset,
991 size_read, buffer + buffer_size, &size_read)) != ERROR_OK || size_read == 0)
992 {
993 free(buffer);
994
995 return retval;
996 }
997
998 buffer_size += size_read;
999 section_offset += size_read;
1000
1001 if (section_offset >= image->sections[section].size)
1002 {
1003 section++;
1004 section_offset = 0;
1005 }
1006 }
1007
1008 retval = ERROR_OK;
1009
1010 if (erase)
1011 {
1012 /* calculate and erase sectors */
1013 retval = flash_erase_address_range( target, run_address, run_size );
1014 }
1015
1016 if (retval == ERROR_OK)
1017 {
1018 /* write flash sectors */
1019 retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
1020 }
1021
1022 free(buffer);
1023
1024 if (retval != ERROR_OK)
1025 {
1026 return retval; /* abort operation */
1027 }
1028
1029 if (written != NULL)
1030 *written += run_size; /* add run size to total written counter */
1031 }
1032
1033 return ERROR_OK;
1034 }
1035
1036 int handle_flash_auto_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
1037 {
1038 if (argc != 1)
1039 {
1040 return ERROR_COMMAND_SYNTAX_ERROR;
1041 }
1042
1043 if (strcmp(args[0], "on") == 0)
1044 auto_erase = 1;
1045 else if (strcmp(args[0], "off") == 0)
1046 auto_erase = 0;
1047 else
1048 return ERROR_COMMAND_SYNTAX_ERROR;
1049
1050 return ERROR_OK;
1051 }
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)