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