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