Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
- ST STM32x cortex support added
[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
29 #include <string.h>
30 #include <unistd.h>
31 #include <stdlib.h>
32 #include <sys/types.h>
33 #include <sys/stat.h>
34 #include <errno.h>
35
36 #include <fileio.h>
37 #include <image.h>
38 #include "log.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_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
47 int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
48 int handle_flash_write_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
49 int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc);
50
51 /* flash drivers
52 */
53 extern flash_driver_t lpc2000_flash;
54 extern flash_driver_t cfi_flash;
55 extern flash_driver_t at91sam7_flash;
56 extern flash_driver_t str7x_flash;
57 extern flash_driver_t str9x_flash;
58 extern flash_driver_t stellaris_flash;
59 extern flash_driver_t str9xpec_flash;
60 extern flash_driver_t stm32x_flash;
61
62 flash_driver_t *flash_drivers[] =
63 {
64 &lpc2000_flash,
65 &cfi_flash,
66 &at91sam7_flash,
67 &str7x_flash,
68 &str9x_flash,
69 &stellaris_flash,
70 &str9xpec_flash,
71 &stm32x_flash,
72 NULL,
73 };
74
75 flash_bank_t *flash_banks;
76 static command_t *flash_cmd;
77
78 int flash_register_commands(struct command_context_s *cmd_ctx)
79 {
80 flash_cmd = register_command(cmd_ctx, NULL, "flash", NULL, COMMAND_ANY, NULL);
81
82 register_command(cmd_ctx, flash_cmd, "bank", handle_flash_bank_command, COMMAND_CONFIG, NULL);
83
84 return ERROR_OK;
85 }
86
87 int flash_init(struct command_context_s *cmd_ctx)
88 {
89 if (flash_banks)
90 {
91 register_command(cmd_ctx, flash_cmd, "banks", handle_flash_banks_command, COMMAND_EXEC,
92 "list configured flash banks ");
93 register_command(cmd_ctx, flash_cmd, "info", handle_flash_info_command, COMMAND_EXEC,
94 "print info about flash bank <num>");
95 register_command(cmd_ctx, flash_cmd, "probe", handle_flash_probe_command, COMMAND_EXEC,
96 "identify flash bank <num>");
97 register_command(cmd_ctx, flash_cmd, "erase_check", handle_flash_erase_check_command, COMMAND_EXEC,
98 "check erase state of sectors in flash bank <num>");
99 register_command(cmd_ctx, flash_cmd, "protect_check", handle_flash_protect_check_command, COMMAND_EXEC,
100 "check protection state of sectors in flash bank <num>");
101 register_command(cmd_ctx, flash_cmd, "erase", handle_flash_erase_command, COMMAND_EXEC,
102 "erase sectors at <bank> <first> <last>");
103 register_command(cmd_ctx, flash_cmd, "write", handle_flash_write_command, COMMAND_EXEC,
104 "write binary <bank> <file> <offset>");
105 register_command(cmd_ctx, flash_cmd, "protect", handle_flash_protect_command, COMMAND_EXEC,
106 "set protection of sectors at <bank> <first> <last> <on|off>");
107 }
108
109 return ERROR_OK;
110 }
111
112 flash_bank_t *get_flash_bank_by_num(int num)
113 {
114 flash_bank_t *p;
115 int i = 0;
116
117 for (p = flash_banks; p; p = p->next)
118 {
119 if (i++ == num)
120 {
121 return p;
122 }
123 }
124
125 return NULL;
126 }
127
128 /* flash_bank <driver> <base> <size> <chip_width> <bus_width> [driver_options ...]
129 */
130 int handle_flash_bank_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
131 {
132 int i;
133 int found = 0;
134
135 if (argc < 5)
136 {
137 WARNING("incomplete flash_bank configuration");
138 return ERROR_OK;
139 }
140
141 for (i = 0; flash_drivers[i]; i++)
142 {
143 if (strcmp(args[0], flash_drivers[i]->name) == 0)
144 {
145 flash_bank_t *p, *c;
146
147 /* register flash specific commands */
148 if (flash_drivers[i]->register_commands(cmd_ctx) != ERROR_OK)
149 {
150 ERROR("couldn't register '%s' commands", args[0]);
151 exit(-1);
152 }
153
154 c = malloc(sizeof(flash_bank_t));
155 c->driver = flash_drivers[i];
156 c->driver_priv = NULL;
157 c->base = strtoul(args[1], NULL, 0);
158 c->size = strtoul(args[2], NULL, 0);
159 c->chip_width = strtoul(args[3], NULL, 0);
160 c->bus_width = strtoul(args[4], NULL, 0);
161 c->next = NULL;
162
163 if (flash_drivers[i]->flash_bank_command(cmd_ctx, cmd, args, argc, c) != ERROR_OK)
164 {
165 ERROR("'%s' driver rejected flash bank at 0x%8.8x", args[0], c->base);
166 free(c);
167 return ERROR_OK;
168 }
169
170 /* put flash bank in linked list */
171 if (flash_banks)
172 {
173 /* find last flash bank */
174 for (p = flash_banks; p && p->next; p = p->next);
175 if (p)
176 p->next = c;
177 }
178 else
179 {
180 flash_banks = c;
181 }
182
183 found = 1;
184 }
185 }
186
187 /* no matching flash driver found */
188 if (!found)
189 {
190 ERROR("flash driver '%s' not found", args[0]);
191 exit(-1);
192 }
193
194 return ERROR_OK;
195 }
196
197 int handle_flash_banks_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
198 {
199 flash_bank_t *p;
200 int i = 0;
201
202 if (!flash_banks)
203 {
204 command_print(cmd_ctx, "no flash banks configured");
205 return ERROR_OK;
206 }
207
208 for (p = flash_banks; p; p = p->next)
209 {
210 command_print(cmd_ctx, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
211 i++, p->driver->name, p->base, p->size, p->bus_width, p->chip_width);
212 }
213
214 return ERROR_OK;
215 }
216
217 int handle_flash_info_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
218 {
219 flash_bank_t *p;
220 int i = 0;
221 int j = 0;
222
223 if (argc != 1)
224 {
225 command_print(cmd_ctx, "usage: flash info <num>");
226 return ERROR_OK;
227 }
228
229 for (p = flash_banks; p; p = p->next)
230 {
231 if (i++ == strtoul(args[0], NULL, 0))
232 {
233 char buf[1024];
234
235 command_print(cmd_ctx, "#%i: %s at 0x%8.8x, size 0x%8.8x, buswidth %i, chipwidth %i",
236 i, p->driver->name, p->base, p->size, p->bus_width, p->chip_width);
237 for (j = 0; j < p->num_sectors; j++)
238 {
239 char *erase_state, *protect_state;
240
241 if (p->sectors[j].is_erased == 0)
242 erase_state = "not erased";
243 else if (p->sectors[j].is_erased == 1)
244 erase_state = "erased";
245 else
246 erase_state = "erase state unknown";
247
248 if (p->sectors[j].is_protected == 0)
249 protect_state = "not protected";
250 else if (p->sectors[j].is_protected == 1)
251 protect_state = "protected";
252 else
253 protect_state = "protection state unknown";
254
255 command_print(cmd_ctx, "\t#%i: 0x%8.8x (0x%xkB) %s, %s",
256 j, p->sectors[j].offset, p->sectors[j].size,
257 erase_state, protect_state);
258 }
259
260 p->driver->info(p, buf, 1024);
261 command_print(cmd_ctx, "%s", buf);
262 }
263 }
264
265 return ERROR_OK;
266 }
267
268 int handle_flash_probe_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
269 {
270 flash_bank_t *p;
271 int retval;
272
273 if (argc != 1)
274 {
275 command_print(cmd_ctx, "usage: flash probe <num>");
276 return ERROR_OK;
277 }
278
279 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
280 if (p)
281 {
282 if ((retval = p->driver->probe(p)) == ERROR_OK)
283 {
284 command_print(cmd_ctx, "flash '%s' found at 0x%8.8x", p->driver->name, p->base);
285 }
286 else if (retval == ERROR_FLASH_BANK_INVALID)
287 {
288 command_print(cmd_ctx, "probing failed for flash bank '#%s' at 0x%8.8x",
289 args[0], p->base);
290 }
291 else
292 {
293 command_print(cmd_ctx, "unknown error when probing flash bank '#%s' at 0x%8.8x",
294 args[0], p->base);
295 }
296 }
297 else
298 {
299 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
300 }
301
302 return ERROR_OK;
303 }
304
305 int handle_flash_erase_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
306 {
307 flash_bank_t *p;
308 int retval;
309
310 if (argc != 1)
311 {
312 command_print(cmd_ctx, "usage: flash erase_check <num>");
313 return ERROR_OK;
314 }
315
316 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
317 if (p)
318 {
319 if ((retval = p->driver->erase_check(p)) == ERROR_OK)
320 {
321 command_print(cmd_ctx, "successfully checked erase state", p->driver->name, p->base);
322 }
323 else
324 {
325 command_print(cmd_ctx, "unknown error when checking erase state of flash bank #%s at 0x%8.8x",
326 args[0], p->base);
327 }
328 }
329 else
330 {
331 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
332 }
333
334 return ERROR_OK;
335 }
336
337 int handle_flash_protect_check_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
338 {
339 flash_bank_t *p;
340 int retval;
341
342 if (argc != 1)
343 {
344 command_print(cmd_ctx, "usage: flash protect_check <num>");
345 return ERROR_OK;
346 }
347
348 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
349 if (p)
350 {
351 if ((retval = p->driver->protect_check(p)) == ERROR_OK)
352 {
353 command_print(cmd_ctx, "successfully checked protect state");
354 }
355 else if (retval == ERROR_FLASH_OPERATION_FAILED)
356 {
357 command_print(cmd_ctx, "checking protection state failed (possibly unsupported) by flash #%s at 0x%8.8x", args[0], p->base);
358 }
359 else
360 {
361 command_print(cmd_ctx, "unknown error when checking protection state of flash bank '#%s' at 0x%8.8x", args[0], p->base);
362 }
363 }
364 else
365 {
366 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
367 }
368
369 return ERROR_OK;
370 }
371
372 int handle_flash_erase_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
373 {
374 if (argc > 2)
375 {
376 int first = strtoul(args[1], NULL, 0);
377 int last = strtoul(args[2], NULL, 0);
378 int retval;
379 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
380 duration_t duration;
381 char *duration_text;
382
383 duration_start_measure(&duration);
384
385 if (!p)
386 {
387 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
388 return ERROR_OK;
389 }
390
391 if ((retval = p->driver->erase(p, first, last)) != ERROR_OK)
392 {
393 switch (retval)
394 {
395 case ERROR_TARGET_NOT_HALTED:
396 command_print(cmd_ctx, "can't work with this flash while target is running");
397 break;
398 case ERROR_INVALID_ARGUMENTS:
399 command_print(cmd_ctx, "usage: flash_erase <bank> <first> <last>");
400 break;
401 case ERROR_FLASH_BANK_INVALID:
402 command_print(cmd_ctx, "no '%s' flash found at 0x%8.8x", p->driver->name, p->base);
403 break;
404 case ERROR_FLASH_OPERATION_FAILED:
405 command_print(cmd_ctx, "flash erase error");
406 break;
407 case ERROR_FLASH_SECTOR_INVALID:
408 command_print(cmd_ctx, "sector number(s) invalid");
409 break;
410 case ERROR_OK:
411 command_print(cmd_ctx, "erased flash sectors %i to %i", first, last);
412 break;
413 default:
414 command_print(cmd_ctx, "unknown error");
415 }
416 }
417 else
418 {
419 duration_stop_measure(&duration, &duration_text);
420
421 command_print(cmd_ctx, "erased sectors %i through %i on flash bank %i in %s", first, last, strtoul(args[0], 0, 0), duration_text);
422 free(duration_text);
423 }
424 }
425 else
426 {
427 command_print(cmd_ctx, "usage: flash erase <bank> <first> <last>");
428 }
429
430 return ERROR_OK;
431 }
432
433 int handle_flash_protect_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
434 {
435 if (argc > 3)
436 {
437 int first = strtoul(args[1], NULL, 0);
438 int last = strtoul(args[2], NULL, 0);
439 int set;
440 int retval;
441 flash_bank_t *p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
442 if (!p)
443 {
444 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
445 return ERROR_OK;
446 }
447
448 if (strcmp(args[3], "on") == 0)
449 set = 1;
450 else if (strcmp(args[3], "off") == 0)
451 set = 0;
452 else
453 {
454 command_print(cmd_ctx, "usage: flash protect <bank> <first> <last> <on|off>");
455 return ERROR_OK;
456 }
457
458 if ((retval = p->driver->protect(p, set, first, last)) != ERROR_OK)
459 {
460 switch (retval)
461 {
462 case ERROR_TARGET_NOT_HALTED:
463 command_print(cmd_ctx, "can't work with this flash while target is running");
464 break;
465 case ERROR_INVALID_ARGUMENTS:
466 command_print(cmd_ctx, "usage: flash protect <bank> <first> <last> <on|off>");
467 break;
468 case ERROR_FLASH_BANK_INVALID:
469 command_print(cmd_ctx, "no '%s' flash found at 0x%8.8x", p->driver->name, p->base);
470 break;
471 case ERROR_FLASH_OPERATION_FAILED:
472 command_print(cmd_ctx, "flash program error");
473 break;
474 case ERROR_FLASH_SECTOR_INVALID:
475 command_print(cmd_ctx, "sector number(s) invalid");
476 break;
477 case ERROR_OK:
478 command_print(cmd_ctx, "protection of flash sectors %i to %i turned %s", first, last, args[3]);
479 break;
480 default:
481 command_print(cmd_ctx, "unknown error");
482 }
483 }
484 else
485 {
486 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));
487 }
488 }
489 else
490 {
491 command_print(cmd_ctx, "usage: flash protect <bank> <first> <last> <on|off>");
492 }
493
494 return ERROR_OK;
495 }
496
497 int handle_flash_write_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
498 {
499 u32 offset;
500 u8 *buffer;
501 u32 buf_cnt;
502 u32 image_size;
503 int i;
504
505 image_t image;
506
507 duration_t duration;
508 char *duration_text;
509
510 int retval;
511 flash_bank_t *p;
512
513 if (argc < 3)
514 {
515 command_print(cmd_ctx, "usage: flash write <bank> <file> <offset> [type]");
516 return ERROR_OK;
517 }
518
519 duration_start_measure(&duration);
520
521 image.base_address_set = 1;
522 image.base_address = strtoul(args[1], NULL, 0);
523
524 image.start_address_set = 0;
525
526 offset = strtoul(args[2], NULL, 0);
527 p = get_flash_bank_by_num(strtoul(args[0], NULL, 0));
528 if (!p)
529 {
530 command_print(cmd_ctx, "flash bank '#%s' is out of bounds", args[0]);
531 return ERROR_OK;
532 }
533
534 if (image_open(&image, args[1], (argc == 4) ? args[3] : NULL) != ERROR_OK)
535 {
536 command_print(cmd_ctx, "flash write error: %s", image.error_str);
537 return ERROR_OK;
538 }
539
540 image_size = 0x0;
541 for (i = 0; i < image.num_sections; i++)
542 {
543 buffer = malloc(image.sections[i].size);
544 if ((retval = image_read_section(&image, i, 0x0, image.sections[i].size, buffer, &buf_cnt)) != ERROR_OK)
545 {
546 ERROR("image_read_section failed with error code: %i", retval);
547 command_print(cmd_ctx, "image reading failed, flash write aborted");
548 free(buffer);
549 image_close(&image);
550 return ERROR_OK;
551 }
552
553 if ((retval = p->driver->write(p, buffer, offset, buf_cnt)) != ERROR_OK)
554 {
555 command_print(cmd_ctx, "failed writing file %s to flash bank %i at offset 0x%8.8x",
556 args[1], strtoul(args[0], NULL, 0), strtoul(args[2], NULL, 0));
557 switch (retval)
558 {
559 case ERROR_TARGET_NOT_HALTED:
560 command_print(cmd_ctx, "can't work with this flash while target is running");
561 break;
562 case ERROR_INVALID_ARGUMENTS:
563 command_print(cmd_ctx, "usage: flash write <bank> <file> <offset>");
564 break;
565 case ERROR_FLASH_BANK_INVALID:
566 command_print(cmd_ctx, "no '%s' flash found at 0x%8.8x", p->driver->name, p->base);
567 break;
568 case ERROR_FLASH_OPERATION_FAILED:
569 command_print(cmd_ctx, "flash program error");
570 break;
571 case ERROR_FLASH_DST_BREAKS_ALIGNMENT:
572 command_print(cmd_ctx, "offset breaks required alignment");
573 break;
574 case ERROR_FLASH_DST_OUT_OF_BANK:
575 command_print(cmd_ctx, "destination is out of flash bank (offset and/or file too large)");
576 break;
577 case ERROR_FLASH_SECTOR_NOT_ERASED:
578 command_print(cmd_ctx, "destination sector(s) not erased");
579 break;
580 default:
581 command_print(cmd_ctx, "unknown error");
582 }
583 }
584 image_size += buf_cnt;
585
586 free(buffer);
587 }
588
589
590 duration_stop_measure(&duration, &duration_text);
591 command_print(cmd_ctx, "wrote %u byte from file %s to flash bank %i at offset 0x%8.8x in %s (%f kb/s)",
592 image_size, args[1], strtoul(args[0], NULL, 0), offset, duration_text,
593 (float)image_size / 1024.0 / ((float)duration.duration.tv_sec + ((float)duration.duration.tv_usec / 1000000.0)));
594 free(duration_text);
595
596 image_close(&image);
597
598 return ERROR_OK;
599 }
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)