OpenOCD
flash/nor/tcl.c
Go to the documentation of this file.
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 
3 /***************************************************************************
4  * Copyright (C) 2005 by Dominic Rath <Dominic.Rath@gmx.de> *
5  * Copyright (C) 2007,2008 Øyvind Harboe <oyvind.harboe@zylin.com> *
6  * Copyright (C) 2008 by Spencer Oliver <spen@spen-soft.co.uk> *
7  * Copyright (C) 2009 Zachary T Welch <zw@superlucidity.net> *
8  * Copyright (C) 2017-2018 Tomas Vanek <vanekt@fbl.cz> *
9  ***************************************************************************/
10 #ifdef HAVE_CONFIG_H
11 #include "config.h"
12 #endif
13 #include "imp.h"
14 #include <helper/time_support.h>
15 #include <target/image.h>
16 
22 static COMMAND_HELPER(flash_command_get_bank_maybe_probe, unsigned name_index,
23  struct flash_bank **bank, bool do_probe)
24 {
25  const char *name = CMD_ARGV[name_index];
26  int retval;
27  if (do_probe) {
28  retval = get_flash_bank_by_name(name, bank);
29  } else {
31  retval = ERROR_OK;
32  }
33 
34  if (retval != ERROR_OK)
35  return retval;
36  if (*bank)
37  return ERROR_OK;
38 
39  unsigned bank_num;
40  COMMAND_PARSE_NUMBER(uint, name, bank_num);
41 
42  if (do_probe) {
43  return get_flash_bank_by_num(bank_num, bank);
44  } else {
46  retval = (bank) ? ERROR_OK : ERROR_FAIL;
47  return retval;
48  }
49 }
50 
51 COMMAND_HELPER(flash_command_get_bank, unsigned name_index,
52  struct flash_bank **bank)
53 {
54  return CALL_COMMAND_HANDLER(flash_command_get_bank_maybe_probe,
55  name_index, bank, true);
56 }
57 
58 COMMAND_HANDLER(handle_flash_info_command)
59 {
60  struct flash_bank *p;
61  int j = 0;
62  int retval;
63  bool show_sectors = false;
64  bool prot_block_available;
65 
66  if (CMD_ARGC < 1 || CMD_ARGC > 2)
68 
69  if (CMD_ARGC == 2) {
70  if (strcmp("sectors", CMD_ARGV[1]) == 0)
71  show_sectors = true;
72  else
74  }
75 
76  retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
77  if (retval != ERROR_OK)
78  return retval;
79 
80  if (p) {
81  int num_blocks;
82  struct flash_sector *block_array;
83 
84  /* attempt auto probe */
85  retval = p->driver->auto_probe(p);
86  if (retval != ERROR_OK)
87  return retval;
88 
89  /* If the driver does not implement protection, we show the default
90  * state of is_protected array - usually protection state unknown */
91  if (!p->driver->protect_check) {
93  } else {
94  /* We must query the hardware to avoid printing stale information! */
95  retval = p->driver->protect_check(p);
96  if (retval != ERROR_OK && retval != ERROR_FLASH_OPER_UNSUPPORTED)
97  return retval;
98  }
99  if (retval == ERROR_FLASH_OPER_UNSUPPORTED)
100  LOG_INFO("Flash protection check is not implemented.");
101 
103  "#%u : %s at " TARGET_ADDR_FMT ", size 0x%8.8" PRIx32
104  ", buswidth %u, chipwidth %u",
105  p->bank_number,
106  p->driver->name,
107  p->base,
108  p->size,
109  p->bus_width,
110  p->chip_width);
111 
112  prot_block_available = p->num_prot_blocks && p->prot_blocks;
113  if (!show_sectors && prot_block_available) {
114  block_array = p->prot_blocks;
115  num_blocks = p->num_prot_blocks;
116  } else {
117  block_array = p->sectors;
118  num_blocks = p->num_sectors;
119  }
120 
121  for (j = 0; j < num_blocks; j++) {
122  char *protect_state = "";
123 
124  if (block_array[j].is_protected == 0)
125  protect_state = "not protected";
126  else if (block_array[j].is_protected == 1)
127  protect_state = "protected";
128  else if (!show_sectors || !prot_block_available)
129  protect_state = "protection state unknown";
130 
132  "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIu32 "kB) %s",
133  j,
134  block_array[j].offset,
135  block_array[j].size,
136  block_array[j].size >> 10,
137  protect_state);
138  }
139 
140  if (p->driver->info) {
141  /* Let the flash driver print extra custom info */
142  retval = p->driver->info(p, CMD);
144  if (retval != ERROR_OK)
145  LOG_ERROR("error retrieving flash info");
146  }
147  }
148 
149  return retval;
150 }
151 
152 COMMAND_HANDLER(handle_flash_probe_command)
153 {
154  struct flash_bank *p;
155  int retval;
156 
157  if (CMD_ARGC != 1)
159 
160  retval = CALL_COMMAND_HANDLER(flash_command_get_bank_maybe_probe, 0, &p, false);
161  if (retval != ERROR_OK)
162  return retval;
163 
164  if (p) {
165  retval = p->driver->probe(p);
166  if (retval == ERROR_OK)
168  "flash '%s' found at " TARGET_ADDR_FMT,
169  p->driver->name,
170  p->base);
171  } else {
172  command_print(CMD, "flash bank '#%s' is out of bounds", CMD_ARGV[0]);
173  retval = ERROR_FAIL;
174  }
175 
176  return retval;
177 }
178 
179 COMMAND_HANDLER(handle_flash_erase_check_command)
180 {
181  bool blank = true;
182  if (CMD_ARGC != 1)
184 
185  struct flash_bank *p;
186  int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
187  if (retval != ERROR_OK)
188  return retval;
189 
190  retval = p->driver->erase_check(p);
191  if (retval == ERROR_OK)
192  command_print(CMD, "successfully checked erase state");
193  else {
195  "unknown error when checking erase state of flash bank #%s at "
197  CMD_ARGV[0],
198  p->base);
199  }
200 
201  for (unsigned int j = 0; j < p->num_sectors; j++) {
202  char *erase_state;
203 
204  if (p->sectors[j].is_erased == 0)
205  erase_state = "not erased";
206  else if (p->sectors[j].is_erased == 1)
207  continue;
208  else
209  erase_state = "erase state unknown";
210 
211  blank = false;
213  "\t#%3i: 0x%8.8" PRIx32 " (0x%" PRIx32 " %" PRIu32 "kB) %s",
214  j,
215  p->sectors[j].offset,
216  p->sectors[j].size,
217  p->sectors[j].size >> 10,
218  erase_state);
219  }
220 
221  if (blank)
222  command_print(CMD, "\tBank is erased");
223  return retval;
224 }
225 
226 COMMAND_HANDLER(handle_flash_erase_address_command)
227 {
228  struct flash_bank *p;
229  int retval = ERROR_OK;
230  target_addr_t address;
231  uint32_t length;
232  bool do_pad = false;
233  bool do_unlock = false;
235 
236  while (CMD_ARGC >= 3) {
237  /* Optionally pad out the address range to block/sector
238  * boundaries. We can't know if there's data in that part
239  * of the flash; only do padding if we're told to.
240  */
241  if (strcmp("pad", CMD_ARGV[0]) == 0)
242  do_pad = true;
243  else if (strcmp("unlock", CMD_ARGV[0]) == 0)
244  do_unlock = true;
245  else
247  CMD_ARGC--;
248  CMD_ARGV++;
249  }
250  if (CMD_ARGC != 2)
252 
253  COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);
255 
256  if (length <= 0) {
257  command_print(CMD, "Length must be >0");
259  }
260 
261  retval = get_flash_bank_by_addr(target, address, true, &p);
262  if (retval != ERROR_OK)
263  return retval;
264 
265  /* We can't know if we did a resume + halt, in which case we no longer know the erased state
266  **/
267  flash_set_dirty();
268 
269  struct duration bench;
270  duration_start(&bench);
271 
272  if (do_unlock)
273  retval = flash_unlock_address_range(target, address, length);
274 
275  if (retval == ERROR_OK)
276  retval = flash_erase_address_range(target, do_pad, address, length);
277 
278  if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
279  command_print(CMD, "erased address " TARGET_ADDR_FMT " (length %" PRIu32 ")"
280  " in %fs (%0.3f KiB/s)", address, length,
281  duration_elapsed(&bench), duration_kbps(&bench, length));
282  }
283 
284  return retval;
285 }
286 
287 COMMAND_HANDLER(handle_flash_erase_command)
288 {
289  if (CMD_ARGC != 3)
291 
292  uint32_t first;
293  uint32_t last;
294 
295  struct flash_bank *p;
296  int retval;
297 
298  retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
299  if (retval != ERROR_OK)
300  return retval;
301 
302  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first);
303  if (strcmp(CMD_ARGV[2], "last") == 0)
304  last = p->num_sectors - 1;
305  else
306  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
307 
308  if (!(first <= last)) {
309  command_print(CMD, "ERROR: "
310  "first sector must be <= last");
311  return ERROR_FAIL;
312  }
313 
314  if (!(last <= (p->num_sectors - 1))) {
315  command_print(CMD, "ERROR: "
316  "last sector must be <= %u",
317  p->num_sectors - 1);
318  return ERROR_FAIL;
319  }
320 
321  struct duration bench;
322  duration_start(&bench);
323 
324  retval = flash_driver_erase(p, first, last);
325 
326  if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
327  command_print(CMD, "erased sectors %" PRIu32 " "
328  "through %" PRIu32 " on flash bank %u "
329  "in %fs", first, last, p->bank_number, duration_elapsed(&bench));
330  }
331 
332  return retval;
333 }
334 
335 COMMAND_HANDLER(handle_flash_protect_command)
336 {
337  if (CMD_ARGC != 4)
339 
340  uint32_t first;
341  uint32_t last;
342 
343  struct flash_bank *p;
344  int retval;
345  int num_blocks;
346 
347  retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
348  if (retval != ERROR_OK)
349  return retval;
350 
351  if (p->num_prot_blocks)
352  num_blocks = p->num_prot_blocks;
353  else
354  num_blocks = p->num_sectors;
355 
356  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[1], first);
357  if (strcmp(CMD_ARGV[2], "last") == 0)
358  last = num_blocks - 1;
359  else
360  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], last);
361 
362  bool set;
364 
365  if (!(first <= last)) {
366  command_print(CMD, "ERROR: "
367  "first %s must be <= last",
368  (p->num_prot_blocks) ? "block" : "sector");
369  return ERROR_FAIL;
370  }
371 
372  if (!(last <= (uint32_t)(num_blocks - 1))) {
373  command_print(CMD, "ERROR: "
374  "last %s must be <= %d",
375  (p->num_prot_blocks) ? "block" : "sector",
376  num_blocks - 1);
377  return ERROR_FAIL;
378  }
379 
380  retval = flash_driver_protect(p, set, first, last);
381  if (retval == ERROR_OK) {
382  command_print(CMD, "%s protection for %s %" PRIu32
383  " through %" PRIu32 " on flash bank %d",
384  (set) ? "set" : "cleared",
385  (p->num_prot_blocks) ? "blocks" : "sectors",
386  first, last, p->bank_number);
387  }
388 
389  return retval;
390 }
391 
392 COMMAND_HANDLER(handle_flash_write_image_command)
393 {
395 
396  struct image image;
397  uint32_t written;
398 
399  int retval;
400 
401  /* flash auto-erase is disabled by default*/
402  int auto_erase = 0;
403  bool auto_unlock = false;
404 
405  while (CMD_ARGC) {
406  if (strcmp(CMD_ARGV[0], "erase") == 0) {
407  auto_erase = 1;
408  CMD_ARGV++;
409  CMD_ARGC--;
410  command_print(CMD, "auto erase enabled");
411  } else if (strcmp(CMD_ARGV[0], "unlock") == 0) {
412  auto_unlock = true;
413  CMD_ARGV++;
414  CMD_ARGC--;
415  command_print(CMD, "auto unlock enabled");
416  } else
417  break;
418  }
419 
420  if (CMD_ARGC < 1)
422 
423  if (!target) {
424  LOG_ERROR("no target selected");
425  return ERROR_FAIL;
426  }
427 
428  struct duration bench;
429  duration_start(&bench);
430 
431  if (CMD_ARGC >= 2) {
432  image.base_address_set = true;
434  } else {
435  image.base_address_set = false;
436  image.base_address = 0x0;
437  }
438 
439  image.start_address_set = false;
440 
441  retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL);
442  if (retval != ERROR_OK)
443  return retval;
444 
445  retval = flash_write_unlock_verify(target, &image, &written, auto_erase,
446  auto_unlock, true, false);
447  if (retval != ERROR_OK) {
448  image_close(&image);
449  return retval;
450  }
451 
452  if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
453  command_print(CMD, "wrote %" PRIu32 " bytes from file %s "
454  "in %fs (%0.3f KiB/s)", written, CMD_ARGV[0],
455  duration_elapsed(&bench), duration_kbps(&bench, written));
456  }
457 
458  image_close(&image);
459 
460  return retval;
461 }
462 
463 COMMAND_HANDLER(handle_flash_verify_image_command)
464 {
466 
467  struct image image;
468  uint32_t verified;
469 
470  int retval;
471 
472  if (CMD_ARGC < 1)
474 
475  if (!target) {
476  LOG_ERROR("no target selected");
477  return ERROR_FAIL;
478  }
479 
480  struct duration bench;
481  duration_start(&bench);
482 
483  if (CMD_ARGC >= 2) {
486  } else {
488  image.base_address = 0x0;
489  }
490 
492 
493  retval = image_open(&image, CMD_ARGV[0], (CMD_ARGC == 3) ? CMD_ARGV[2] : NULL);
494  if (retval != ERROR_OK)
495  return retval;
496 
497  retval = flash_write_unlock_verify(target, &image, &verified, false,
498  false, false, true);
499  if (retval != ERROR_OK) {
500  image_close(&image);
501  return retval;
502  }
503 
504  if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
505  command_print(CMD, "verified %" PRIu32 " bytes from file %s "
506  "in %fs (%0.3f KiB/s)", verified, CMD_ARGV[0],
507  duration_elapsed(&bench), duration_kbps(&bench, verified));
508  }
509 
510  image_close(&image);
511 
512  return retval;
513 }
514 
515 COMMAND_HANDLER(handle_flash_fill_command)
516 {
517  target_addr_t address;
518  uint64_t pattern;
519  uint32_t count;
521  unsigned i;
522  uint32_t wordsize;
523  int retval;
524 
525  if (CMD_ARGC != 3)
527 
528  COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);
529  COMMAND_PARSE_NUMBER(u64, CMD_ARGV[1], pattern);
531 
532  struct flash_bank *bank;
533  retval = get_flash_bank_by_addr(target, address, true, &bank);
534  if (retval != ERROR_OK)
535  return retval;
536 
537  switch (CMD_NAME[4]) {
538  case 'd':
539  wordsize = 8;
540  break;
541  case 'w':
542  wordsize = 4;
543  break;
544  case 'h':
545  wordsize = 2;
546  break;
547  case 'b':
548  wordsize = 1;
549  break;
550  default:
552  }
553 
554  if ((wordsize < sizeof(pattern)) && (pattern >> (8 * wordsize) != 0)) {
555  command_print(CMD, "Fill pattern 0x%" PRIx64 " does not fit within %" PRIu32 "-byte word", pattern, wordsize);
556  return ERROR_FAIL;
557  }
558 
559  if (count == 0)
560  return ERROR_OK;
561 
562  if (address + count * wordsize > bank->base + bank->size) {
563  LOG_ERROR("Cannot cross flash bank borders");
564  return ERROR_FAIL;
565  }
566 
567  uint32_t size_bytes = count * wordsize;
568  target_addr_t aligned_start = flash_write_align_start(bank, address);
569  target_addr_t end_addr = address + size_bytes - 1;
570  target_addr_t aligned_end = flash_write_align_end(bank, end_addr);
571  uint32_t aligned_size = aligned_end + 1 - aligned_start;
572  uint32_t padding_at_start = address - aligned_start;
573  uint32_t padding_at_end = aligned_end - end_addr;
574 
575  uint8_t *buffer = malloc(aligned_size);
576  if (!buffer)
577  return ERROR_FAIL;
578 
579  if (padding_at_start) {
580  memset(buffer, bank->default_padded_value, padding_at_start);
581  LOG_WARNING("Start address " TARGET_ADDR_FMT
582  " breaks the required alignment of flash bank %s",
583  address, bank->name);
584  LOG_WARNING("Padding %" PRIu32 " bytes from " TARGET_ADDR_FMT,
585  padding_at_start, aligned_start);
586  }
587 
588  uint8_t *ptr = buffer + padding_at_start;
589 
590  switch (wordsize) {
591  case 8:
592  for (i = 0; i < count; i++, ptr += wordsize)
593  target_buffer_set_u64(target, ptr, pattern);
594  break;
595  case 4:
596  for (i = 0; i < count; i++, ptr += wordsize)
597  target_buffer_set_u32(target, ptr, pattern);
598  break;
599  case 2:
600  for (i = 0; i < count; i++, ptr += wordsize)
601  target_buffer_set_u16(target, ptr, pattern);
602  break;
603  case 1:
604  memset(ptr, pattern, count);
605  ptr += count;
606  break;
607  default:
608  LOG_ERROR("BUG: can't happen");
609  exit(-1);
610  }
611 
612  if (padding_at_end) {
613  memset(ptr, bank->default_padded_value, padding_at_end);
614  LOG_INFO("Padding at " TARGET_ADDR_FMT " with %" PRIu32
615  " bytes (bank write end alignment)",
616  end_addr + 1, padding_at_end);
617  }
618 
619  struct duration bench;
620  duration_start(&bench);
621 
622  retval = flash_driver_write(bank, buffer, aligned_start - bank->base, aligned_size);
623  if (retval != ERROR_OK)
624  goto done;
625 
626  retval = flash_driver_read(bank, buffer, address - bank->base, size_bytes);
627  if (retval != ERROR_OK)
628  goto done;
629 
630  for (i = 0, ptr = buffer; i < count; i++) {
631  uint64_t readback = 0;
632 
633  switch (wordsize) {
634  case 8:
635  readback = target_buffer_get_u64(target, ptr);
636  break;
637  case 4:
638  readback = target_buffer_get_u32(target, ptr);
639  break;
640  case 2:
641  readback = target_buffer_get_u16(target, ptr);
642  break;
643  case 1:
644  readback = *ptr;
645  break;
646  }
647  if (readback != pattern) {
648  LOG_ERROR(
649  "Verification error address " TARGET_ADDR_FMT
650  ", read back 0x%02" PRIx64 ", expected 0x%02" PRIx64,
651  address + i * wordsize, readback, pattern);
652  retval = ERROR_FAIL;
653  goto done;
654  }
655  ptr += wordsize;
656  }
657 
658  if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
659  command_print(CMD, "wrote %" PRIu32 " bytes to " TARGET_ADDR_FMT
660  " in %fs (%0.3f KiB/s)", size_bytes, address,
661  duration_elapsed(&bench), duration_kbps(&bench, size_bytes));
662  }
663 
664 done:
665  free(buffer);
666 
667  return retval;
668 }
669 
670 COMMAND_HANDLER(handle_flash_md_command)
671 {
672  int retval;
673 
674  if (CMD_ARGC < 1 || CMD_ARGC > 2)
676 
677  target_addr_t address;
678  COMMAND_PARSE_ADDRESS(CMD_ARGV[0], address);
679 
680  uint32_t count = 1;
681  if (CMD_ARGC == 2)
683 
684  unsigned int wordsize;
685  switch (CMD_NAME[2]) {
686  case 'w':
687  wordsize = 4;
688  break;
689  case 'h':
690  wordsize = 2;
691  break;
692  case 'b':
693  wordsize = 1;
694  break;
695  default:
697  }
698 
699  if (count == 0)
700  return ERROR_OK;
701 
703  struct flash_bank *bank;
704  retval = get_flash_bank_by_addr(target, address, true, &bank);
705  if (retval != ERROR_OK)
706  return retval;
707 
708  uint32_t offset = address - bank->base;
709  uint32_t sizebytes = count * wordsize;
710  if (offset + sizebytes > bank->size) {
711  command_print(CMD, "Cannot cross flash bank borders");
712  return ERROR_FAIL;
713  }
714 
715  uint8_t *buffer = calloc(count, wordsize);
716  if (!buffer) {
717  command_print(CMD, "No memory for flash read buffer");
718  return ERROR_FAIL;
719  }
720 
721  retval = flash_driver_read(bank, buffer, offset, sizebytes);
722  if (retval == ERROR_OK)
723  target_handle_md_output(CMD, target, address, wordsize, count, buffer);
724 
725  free(buffer);
726 
727  return retval;
728 }
729 
730 
731 COMMAND_HANDLER(handle_flash_write_bank_command)
732 {
733  uint32_t offset;
734  uint8_t *buffer;
735  size_t length;
736  struct fileio *fileio;
737 
738  if (CMD_ARGC < 2 || CMD_ARGC > 3)
740 
741  struct duration bench;
742  duration_start(&bench);
743 
744  struct flash_bank *bank;
745  int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &bank);
746  if (retval != ERROR_OK)
747  return retval;
748 
749  offset = 0;
750 
751  if (CMD_ARGC > 2)
753 
754  if (offset > bank->size) {
755  LOG_ERROR("Offset 0x%8.8" PRIx32 " is out of range of the flash bank",
756  offset);
758  }
759 
761  return ERROR_FAIL;
762 
763  size_t filesize;
764  retval = fileio_size(fileio, &filesize);
765  if (retval != ERROR_OK) {
767  return retval;
768  }
769 
770  length = MIN(filesize, bank->size - offset);
771 
772  if (!length) {
773  LOG_INFO("Nothing to write to flash bank");
775  return ERROR_OK;
776  }
777 
778  if (length != filesize)
779  LOG_INFO("File content exceeds flash bank size. Only writing the "
780  "first %zu bytes of the file", length);
781 
782  target_addr_t start_addr = bank->base + offset;
783  target_addr_t aligned_start = flash_write_align_start(bank, start_addr);
784  target_addr_t end_addr = start_addr + length - 1;
785  target_addr_t aligned_end = flash_write_align_end(bank, end_addr);
786  uint32_t aligned_size = aligned_end + 1 - aligned_start;
787  uint32_t padding_at_start = start_addr - aligned_start;
788  uint32_t padding_at_end = aligned_end - end_addr;
789 
790  buffer = malloc(aligned_size);
791  if (!buffer) {
793  LOG_ERROR("Out of memory");
794  return ERROR_FAIL;
795  }
796 
797  if (padding_at_start) {
798  memset(buffer, bank->default_padded_value, padding_at_start);
799  LOG_WARNING("Start offset 0x%08" PRIx32
800  " breaks the required alignment of flash bank %s",
801  offset, bank->name);
802  LOG_WARNING("Padding %" PRIu32 " bytes from " TARGET_ADDR_FMT,
803  padding_at_start, aligned_start);
804  }
805 
806  uint8_t *ptr = buffer + padding_at_start;
807  size_t buf_cnt;
808  if (fileio_read(fileio, length, ptr, &buf_cnt) != ERROR_OK) {
809  free(buffer);
811  return ERROR_FAIL;
812  }
813 
814  if (buf_cnt != length) {
815  LOG_ERROR("Short read");
816  free(buffer);
817  return ERROR_FAIL;
818  }
819 
820  ptr += length;
821 
822  if (padding_at_end) {
823  memset(ptr, bank->default_padded_value, padding_at_end);
824  LOG_INFO("Padding at " TARGET_ADDR_FMT " with %" PRIu32
825  " bytes (bank write end alignment)",
826  end_addr + 1, padding_at_end);
827  }
828 
829  retval = flash_driver_write(bank, buffer, aligned_start - bank->base, aligned_size);
830 
831  free(buffer);
832 
833  if ((retval == ERROR_OK) && (duration_measure(&bench) == ERROR_OK)) {
834  command_print(CMD, "wrote %zu bytes from file %s to flash bank %u"
835  " at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
836  length, CMD_ARGV[1], bank->bank_number, offset,
837  duration_elapsed(&bench), duration_kbps(&bench, length));
838  }
839 
841 
842  return retval;
843 }
844 
845 COMMAND_HANDLER(handle_flash_read_bank_command)
846 {
847  uint32_t offset;
848  uint8_t *buffer;
849  struct fileio *fileio;
850  uint32_t length;
851  size_t written;
852 
853  if (CMD_ARGC < 2 || CMD_ARGC > 4)
855 
856  struct duration bench;
857  duration_start(&bench);
858 
859  struct flash_bank *p;
860  int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
861 
862  if (retval != ERROR_OK)
863  return retval;
864 
865  offset = 0;
866 
867  if (CMD_ARGC > 2)
869 
870  if (offset > p->size) {
871  LOG_ERROR("Offset 0x%8.8" PRIx32 " is out of range of the flash bank",
872  offset);
874  }
875 
876  length = p->size - offset;
877 
878  if (CMD_ARGC > 3)
880 
881  if (offset + length > p->size) {
882  LOG_ERROR("Length of %" PRIu32 " bytes with offset 0x%8.8" PRIx32
883  " is out of range of the flash bank", length, offset);
885  }
886 
887  buffer = malloc(length);
888  if (!buffer) {
889  LOG_ERROR("Out of memory");
890  return ERROR_FAIL;
891  }
892 
893  retval = flash_driver_read(p, buffer, offset, length);
894  if (retval != ERROR_OK) {
895  LOG_ERROR("Read error");
896  free(buffer);
897  return retval;
898  }
899 
901  if (retval != ERROR_OK) {
902  LOG_ERROR("Could not open file");
903  free(buffer);
904  return retval;
905  }
906 
907  retval = fileio_write(fileio, length, buffer, &written);
909  free(buffer);
910  if (retval != ERROR_OK) {
911  LOG_ERROR("Could not write file");
912  return ERROR_FAIL;
913  }
914 
915  if (duration_measure(&bench) == ERROR_OK)
916  command_print(CMD, "wrote %zd bytes to file %s from flash bank %u"
917  " at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
918  written, CMD_ARGV[1], p->bank_number, offset,
919  duration_elapsed(&bench), duration_kbps(&bench, written));
920 
921  return retval;
922 }
923 
924 
925 COMMAND_HANDLER(handle_flash_verify_bank_command)
926 {
927  uint32_t offset;
928  uint8_t *buffer_file, *buffer_flash;
929  struct fileio *fileio;
930  size_t read_cnt;
931  size_t filesize;
932  size_t length;
933  int differ;
934 
935  if (CMD_ARGC < 2 || CMD_ARGC > 3)
937 
938  struct duration bench;
939  duration_start(&bench);
940 
941  struct flash_bank *p;
942  int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
943  if (retval != ERROR_OK)
944  return retval;
945 
946  offset = 0;
947 
948  if (CMD_ARGC > 2)
950 
951  if (offset > p->size) {
952  LOG_ERROR("Offset 0x%8.8" PRIx32 " is out of range of the flash bank",
953  offset);
955  }
956 
958  if (retval != ERROR_OK) {
959  LOG_ERROR("Could not open file");
960  return retval;
961  }
962 
963  retval = fileio_size(fileio, &filesize);
964  if (retval != ERROR_OK) {
966  return retval;
967  }
968 
969  length = MIN(filesize, p->size - offset);
970 
971  if (!length) {
972  LOG_INFO("Nothing to compare with flash bank");
974  return ERROR_OK;
975  }
976 
977  if (length != filesize)
978  LOG_INFO("File content exceeds flash bank size. Only comparing the "
979  "first %zu bytes of the file", length);
980 
981  buffer_file = malloc(length);
982  if (!buffer_file) {
983  LOG_ERROR("Out of memory");
985  return ERROR_FAIL;
986  }
987 
988  retval = fileio_read(fileio, length, buffer_file, &read_cnt);
990  if (retval != ERROR_OK) {
991  LOG_ERROR("File read failure");
992  free(buffer_file);
993  return retval;
994  }
995 
996  if (read_cnt != length) {
997  LOG_ERROR("Short read");
998  free(buffer_file);
999  return ERROR_FAIL;
1000  }
1001 
1002  buffer_flash = malloc(length);
1003  if (!buffer_flash) {
1004  LOG_ERROR("Out of memory");
1005  free(buffer_file);
1006  return ERROR_FAIL;
1007  }
1008 
1009  retval = flash_driver_read(p, buffer_flash, offset, length);
1010  if (retval != ERROR_OK) {
1011  LOG_ERROR("Flash read error");
1012  free(buffer_flash);
1013  free(buffer_file);
1014  return retval;
1015  }
1016 
1017  if (duration_measure(&bench) == ERROR_OK)
1018  command_print(CMD, "read %zd bytes from file %s and flash bank %u"
1019  " at offset 0x%8.8" PRIx32 " in %fs (%0.3f KiB/s)",
1020  length, CMD_ARGV[1], p->bank_number, offset,
1021  duration_elapsed(&bench), duration_kbps(&bench, length));
1022 
1023  differ = memcmp(buffer_file, buffer_flash, length);
1024  command_print(CMD, "contents %s", differ ? "differ" : "match");
1025  if (differ) {
1026  uint32_t t;
1027  int diffs = 0;
1028  for (t = 0; t < length; t++) {
1029  if (buffer_flash[t] == buffer_file[t])
1030  continue;
1031  command_print(CMD, "diff %d address 0x%08" PRIx32 ". Was 0x%02x instead of 0x%02x",
1032  diffs, t + offset, buffer_flash[t], buffer_file[t]);
1033  if (diffs++ >= 127) {
1034  command_print(CMD, "More than 128 errors, the rest are not printed.");
1035  break;
1036  }
1037  keep_alive();
1038  }
1039  }
1040  free(buffer_flash);
1041  free(buffer_file);
1042 
1043  return differ ? ERROR_FAIL : ERROR_OK;
1044 }
1045 
1047 {
1048  struct flash_bank *c;
1049 
1050  /* set all flash to require erasing */
1051  for (c = flash_bank_list(); c; c = c->next) {
1052  for (unsigned int i = 0; i < c->num_sectors; i++)
1053  c->sectors[i].is_erased = 0;
1054  }
1055 }
1056 
1057 COMMAND_HANDLER(handle_flash_padded_value_command)
1058 {
1059  if (CMD_ARGC != 2)
1061 
1062  struct flash_bank *p;
1063  int retval = CALL_COMMAND_HANDLER(flash_command_get_bank, 0, &p);
1064  if (retval != ERROR_OK)
1065  return retval;
1066 
1068 
1069  command_print(CMD, "Default padded value set to 0x%" PRIx8 " for flash bank %u",
1071 
1072  return retval;
1073 }
1074 
1075 static const struct command_registration flash_exec_command_handlers[] = {
1076  {
1077  .name = "probe",
1078  .handler = handle_flash_probe_command,
1079  .mode = COMMAND_EXEC,
1080  .usage = "bank_id",
1081  .help = "Identify a flash bank.",
1082  },
1083  {
1084  .name = "info",
1085  .handler = handle_flash_info_command,
1086  .mode = COMMAND_EXEC,
1087  .usage = "bank_id ['sectors']",
1088  .help = "Print information about a flash bank.",
1089  },
1090  {
1091  .name = "erase_check",
1092  .handler = handle_flash_erase_check_command,
1093  .mode = COMMAND_EXEC,
1094  .usage = "bank_id",
1095  .help = "Check erase state of all blocks in a "
1096  "flash bank.",
1097  },
1098  {
1099  .name = "erase_sector",
1100  .handler = handle_flash_erase_command,
1101  .mode = COMMAND_EXEC,
1102  .usage = "bank_id first_sector_num (last_sector_num|'last')",
1103  .help = "Erase a range of sectors in a flash bank.",
1104  },
1105  {
1106  .name = "erase_address",
1107  .handler = handle_flash_erase_address_command,
1108  .mode = COMMAND_EXEC,
1109  .usage = "['pad'] ['unlock'] address length",
1110  .help = "Erase flash sectors starting at address and "
1111  "continuing for length bytes. If 'pad' is specified, "
1112  "data outside that range may also be erased: the start "
1113  "address may be decreased, and length increased, so "
1114  "that all of the first and last sectors are erased. "
1115  "If 'unlock' is specified, then the flash is unprotected "
1116  "before erasing.",
1117 
1118  },
1119  {
1120  .name = "filld",
1121  .handler = handle_flash_fill_command,
1122  .mode = COMMAND_EXEC,
1123  .usage = "address value n",
1124  .help = "Fill n double-words with 64-bit value, starting at "
1125  "word address. (No autoerase.)",
1126  },
1127  {
1128  .name = "fillw",
1129  .handler = handle_flash_fill_command,
1130  .mode = COMMAND_EXEC,
1131  .usage = "address value n",
1132  .help = "Fill n words with 32-bit value, starting at "
1133  "word address. (No autoerase.)",
1134  },
1135  {
1136  .name = "fillh",
1137  .handler = handle_flash_fill_command,
1138  .mode = COMMAND_EXEC,
1139  .usage = "address value n",
1140  .help = "Fill n halfwords with 16-bit value, starting at "
1141  "word address. (No autoerase.)",
1142  },
1143  {
1144  .name = "fillb",
1145  .handler = handle_flash_fill_command,
1146  .mode = COMMAND_EXEC,
1147  .usage = "address value n",
1148  .help = "Fill n bytes with 8-bit value, starting at "
1149  "word address. (No autoerase.)",
1150  },
1151  {
1152  .name = "mdb",
1153  .handler = handle_flash_md_command,
1154  .mode = COMMAND_EXEC,
1155  .usage = "address [count]",
1156  .help = "Display bytes from flash.",
1157  },
1158  {
1159  .name = "mdh",
1160  .handler = handle_flash_md_command,
1161  .mode = COMMAND_EXEC,
1162  .usage = "address [count]",
1163  .help = "Display half-words from flash.",
1164  },
1165  {
1166  .name = "mdw",
1167  .handler = handle_flash_md_command,
1168  .mode = COMMAND_EXEC,
1169  .usage = "address [count]",
1170  .help = "Display words from flash.",
1171  },
1172  {
1173  .name = "write_bank",
1174  .handler = handle_flash_write_bank_command,
1175  .mode = COMMAND_EXEC,
1176  .usage = "bank_id filename [offset]",
1177  .help = "Write binary data from file to flash bank. Allow optional "
1178  "offset from beginning of the bank (defaults to zero).",
1179  },
1180  {
1181  .name = "write_image",
1182  .handler = handle_flash_write_image_command,
1183  .mode = COMMAND_EXEC,
1184  .usage = "[erase] [unlock] filename [offset [file_type]]",
1185  .help = "Write an image to flash. Optionally first unprotect "
1186  "and/or erase the region to be used. Allow optional "
1187  "offset from beginning of bank (defaults to zero)",
1188  },
1189  {
1190  .name = "verify_image",
1191  .handler = handle_flash_verify_image_command,
1192  .mode = COMMAND_EXEC,
1193  .usage = "filename [offset [file_type]]",
1194  .help = "Verify an image against flash. Allow optional "
1195  "offset from beginning of bank (defaults to zero)",
1196  },
1197  {
1198  .name = "read_bank",
1199  .handler = handle_flash_read_bank_command,
1200  .mode = COMMAND_EXEC,
1201  .usage = "bank_id filename [offset [length]]",
1202  .help = "Read binary data from flash bank to file. Allow optional "
1203  "offset from beginning of the bank (defaults to zero).",
1204  },
1205  {
1206  .name = "verify_bank",
1207  .handler = handle_flash_verify_bank_command,
1208  .mode = COMMAND_EXEC,
1209  .usage = "bank_id filename [offset]",
1210  .help = "Compare the contents of a file with the contents of the "
1211  "flash bank. Allow optional offset from beginning of the bank "
1212  "(defaults to zero).",
1213  },
1214  {
1215  .name = "protect",
1216  .handler = handle_flash_protect_command,
1217  .mode = COMMAND_EXEC,
1218  .usage = "bank_id first_block [last_block|'last'] "
1219  "('on'|'off')",
1220  .help = "Turn protection on or off for a range of protection "
1221  "blocks or sectors in a given flash bank. "
1222  "See 'flash info' output for a list of blocks.",
1223  },
1224  {
1225  .name = "padded_value",
1226  .handler = handle_flash_padded_value_command,
1227  .mode = COMMAND_EXEC,
1228  .usage = "bank_id value",
1229  .help = "Set default flash padded value",
1230  },
1232 };
1233 
1234 static int flash_init_drivers(struct command_context *cmd_ctx)
1235 {
1236  if (!flash_bank_list())
1237  return ERROR_OK;
1238 
1239  return register_commands(cmd_ctx, "flash", flash_exec_command_handlers);
1240 }
1241 
1242 COMMAND_HANDLER(handle_flash_bank_command)
1243 {
1244  if (CMD_ARGC < 7) {
1245  LOG_ERROR("usage: flash bank <name> <driver> "
1246  "<base> <size> <chip_width> <bus_width> <target>");
1248  }
1249  /* save bank name and advance arguments for compatibility */
1250  const char *bank_name = *CMD_ARGV++;
1251  CMD_ARGC--;
1252 
1253  struct target *target = get_target(CMD_ARGV[5]);
1254  if (!target) {
1255  LOG_ERROR("target '%s' not defined", CMD_ARGV[5]);
1256  return ERROR_FAIL;
1257  }
1258 
1259  const char *driver_name = CMD_ARGV[0];
1260  const struct flash_driver *driver = flash_driver_find_by_name(driver_name);
1261  if (!driver) {
1262  /* no matching flash driver found */
1263  LOG_ERROR("flash driver '%s' not found", driver_name);
1264  return ERROR_FAIL;
1265  }
1266 
1267  /* check the flash bank name is unique */
1268  if (get_flash_bank_by_name_noprobe(bank_name)) {
1269  /* flash bank name already exists */
1270  LOG_ERROR("flash bank name '%s' already exists", bank_name);
1271  return ERROR_FAIL;
1272  }
1273 
1274  /* register flash specific commands */
1275  if (driver->commands) {
1276  int retval = register_commands(CMD_CTX, NULL, driver->commands);
1277  if (retval != ERROR_OK) {
1278  LOG_ERROR("couldn't register '%s' commands",
1279  driver_name);
1280  return ERROR_FAIL;
1281  }
1282  }
1283 
1284  struct flash_bank *c = calloc(1, sizeof(*c));
1285  c->name = strdup(bank_name);
1286  c->target = target;
1287  c->driver = driver;
1288  COMMAND_PARSE_NUMBER(target_addr, CMD_ARGV[1], c->base);
1289  COMMAND_PARSE_NUMBER(u32, CMD_ARGV[2], c->size);
1291  COMMAND_PARSE_NUMBER(uint, CMD_ARGV[4], c->bus_width);
1292  c->default_padded_value = c->erased_value = 0xff;
1294 
1295  int retval;
1296  retval = CALL_COMMAND_HANDLER(driver->flash_bank_command, c);
1297  if (retval != ERROR_OK) {
1298  LOG_ERROR("'%s' driver rejected flash bank at " TARGET_ADDR_FMT
1299  "; usage: %s", driver_name, c->base, driver->usage);
1300  free(c);
1301  return retval;
1302  }
1303 
1304  if (!driver->usage)
1305  LOG_DEBUG("'%s' driver usage field missing", driver_name);
1306 
1307  flash_bank_add(c);
1308 
1309  return ERROR_OK;
1310 }
1311 
1312 COMMAND_HANDLER(handle_flash_banks_command)
1313 {
1314  if (CMD_ARGC != 0)
1316 
1317  unsigned n = 0;
1318  for (struct flash_bank *p = flash_bank_list(); p; p = p->next, n++) {
1319  command_print(CMD, "#%d : %s (%s) at " TARGET_ADDR_FMT ", size 0x%8.8" PRIx32 ", "
1320  "buswidth %u, chipwidth %u", p->bank_number,
1321  p->name, p->driver->name, p->base, p->size,
1322  p->bus_width, p->chip_width);
1323  }
1324  return ERROR_OK;
1325 }
1326 
1327 static int jim_flash_list(Jim_Interp *interp, int argc, Jim_Obj * const *argv)
1328 {
1329  if (argc != 1) {
1330  Jim_WrongNumArgs(interp, 1, argv,
1331  "no arguments to 'flash list' command");
1332  return JIM_ERR;
1333  }
1334 
1335  Jim_Obj *list = Jim_NewListObj(interp, NULL, 0);
1336 
1337  for (struct flash_bank *p = flash_bank_list(); p; p = p->next) {
1338  Jim_Obj *elem = Jim_NewListObj(interp, NULL, 0);
1339 
1340  Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "name", -1));
1341  Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, p->name, -1));
1342  Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "driver", -1));
1343  Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, p->driver->name, -1));
1344  Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "base", -1));
1345  Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->base));
1346  Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "size", -1));
1347  Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->size));
1348  Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "bus_width", -1));
1349  Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->bus_width));
1350  Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "chip_width", -1));
1351  Jim_ListAppendElement(interp, elem, Jim_NewIntObj(interp, p->chip_width));
1352  Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, "target", -1));
1353  Jim_ListAppendElement(interp, elem, Jim_NewStringObj(interp, target_name(p->target), -1));
1354 
1355  Jim_ListAppendElement(interp, list, elem);
1356  }
1357 
1358  Jim_SetResult(interp, list);
1359 
1360  return JIM_OK;
1361 }
1362 
1363 COMMAND_HANDLER(handle_flash_init_command)
1364 {
1365  if (CMD_ARGC != 0)
1367 
1368  static bool flash_initialized;
1369  if (flash_initialized) {
1370  LOG_INFO("'flash init' has already been called");
1371  return ERROR_OK;
1372  }
1373  flash_initialized = true;
1374 
1375  LOG_DEBUG("Initializing flash devices...");
1376  return flash_init_drivers(CMD_CTX);
1377 }
1378 
1379 static const struct command_registration flash_config_command_handlers[] = {
1380  {
1381  .name = "bank",
1382  .handler = handle_flash_bank_command,
1383  .mode = COMMAND_CONFIG,
1384  .usage = "bank_id driver_name base_address size_bytes "
1385  "chip_width_bytes bus_width_bytes target "
1386  "[driver_options ...]",
1387  .help = "Define a new bank with the given name, "
1388  "using the specified NOR flash driver.",
1389  },
1390  {
1391  .name = "init",
1392  .mode = COMMAND_CONFIG,
1393  .handler = handle_flash_init_command,
1394  .help = "Initialize flash devices.",
1395  .usage = "",
1396  },
1397  {
1398  .name = "banks",
1399  .mode = COMMAND_ANY,
1400  .handler = handle_flash_banks_command,
1401  .help = "Display table with information about flash banks.",
1402  .usage = "",
1403  },
1404  {
1405  .name = "list",
1406  .mode = COMMAND_ANY,
1407  .jim_handler = jim_flash_list,
1408  .help = "Returns a list of details about the flash banks.",
1409  },
1411 };
1412 static const struct command_registration flash_command_handlers[] = {
1413  {
1414  .name = "flash",
1415  .mode = COMMAND_ANY,
1416  .help = "NOR flash command group",
1418  .usage = "",
1419  },
1421 };
1422 
1424 {
1425  return register_commands(cmd_ctx, NULL, flash_command_handlers);
1426 }
const char * name
Definition: armv4_5.c:76
void command_print_sameline(struct command_invocation *cmd, const char *format,...)
Definition: command.c:450
void command_print(struct command_invocation *cmd, const char *format,...)
Definition: command.c:473
#define CMD
Use this macro to access the command being handled, rather than accessing the variable directly.
Definition: command.h:140
#define CALL_COMMAND_HANDLER(name, extra ...)
Use this to macro to call a command helper (or a nested handler).
Definition: command.h:117
#define CMD_NAME
Use this macro to access the name of the command being handled, rather than accessing the variable di...
Definition: command.h:160
#define CMD_ARGV
Use this macro to access the arguments for the command being handled, rather than accessing the varia...
Definition: command.h:155
#define COMMAND_PARSE_ADDRESS(in, out)
Definition: command.h:435
#define COMMAND_PARSE_ON_OFF(in, out)
parses an on/off command argument
Definition: command.h:504
#define ERROR_COMMAND_SYNTAX_ERROR
Definition: command.h:385
#define CMD_ARGC
Use this macro to access the number of arguments for the command being handled, rather than accessing...
Definition: command.h:150
#define COMMAND_PARSE_NUMBER(type, in, out)
parses the string in into out as a type, or prints a command error and passes the error code to the c...
Definition: command.h:425
#define CMD_CTX
Use this macro to access the context of the command being handled, rather than accessing the variable...
Definition: command.h:145
#define COMMAND_REGISTRATION_DONE
Use this as the last entry in an array of command_registration records.
Definition: command.h:247
#define ERROR_COMMAND_ARGUMENT_INVALID
Definition: command.h:387
static int register_commands(struct command_context *cmd_ctx, const char *cmd_prefix, const struct command_registration *cmds)
Register one or more commands in the specified context, as children of parent (or top-level commends,...
Definition: command.h:268
@ COMMAND_CONFIG
Definition: command.h:41
@ COMMAND_ANY
Definition: command.h:42
@ COMMAND_EXEC
Definition: command.h:40
uint8_t bank
Definition: esirisc.c:135
uint8_t length
Definition: esp_usb_jtag.c:1
#define ERROR_FLASH_OPER_UNSUPPORTED
Definition: flash/common.h:36
target_addr_t flash_write_align_start(struct flash_bank *bank, target_addr_t addr)
Get aligned start address of a flash write region.
int flash_driver_read(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
struct flash_bank * get_flash_bank_by_name_noprobe(const char *name)
Returns the flash bank specified by name, which matches the driver name and a suffix (option) specify...
target_addr_t flash_write_align_end(struct flash_bank *bank, target_addr_t addr)
Get aligned end address of a flash write region.
int flash_driver_protect(struct flash_bank *bank, int set, unsigned int first, unsigned int last)
int flash_driver_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
void flash_bank_add(struct flash_bank *bank)
Adds a new NOR bank to the global list of banks.
int flash_unlock_address_range(struct target *target, target_addr_t addr, uint32_t length)
struct flash_bank * get_flash_bank_by_num_noprobe(unsigned int num)
Returns the flash bank like get_flash_bank_by_num(), without probing.
int get_flash_bank_by_addr(struct target *target, target_addr_t addr, bool check, struct flash_bank **result_bank)
Returns the flash bank located at a specified address.
int flash_erase_address_range(struct target *target, bool pad, target_addr_t addr, uint32_t length)
Erases length bytes in the target flash, starting at addr.
int flash_driver_erase(struct flash_bank *bank, unsigned int first, unsigned int last)
int get_flash_bank_by_name(const char *name, struct flash_bank **bank_result)
Returns the flash bank specified by name, which matches the driver name and a suffix (option) specify...
struct flash_bank * flash_bank_list(void)
int get_flash_bank_by_num(unsigned int num, struct flash_bank **bank)
Returns the flash bank like get_flash_bank_by_name(), without probing.
int flash_write_unlock_verify(struct target *target, struct image *image, uint32_t *written, bool erase, bool unlock, bool write, bool verify)
static const struct command_registration flash_config_command_handlers[]
static const struct command_registration flash_command_handlers[]
void flash_set_dirty(void)
Forces targets to re-examine their erase/protection state.
static const struct command_registration flash_exec_command_handlers[]
static int flash_init_drivers(struct command_context *cmd_ctx)
COMMAND_HANDLER(handle_flash_info_command)
Definition: flash/nor/tcl.c:58
static COMMAND_HELPER(flash_command_get_bank_maybe_probe, unsigned name_index, struct flash_bank **bank, bool do_probe)
Definition: flash/nor/tcl.c:22
int flash_register_commands(struct command_context *cmd_ctx)
Registers the 'flash' subsystem commands.
static int jim_flash_list(Jim_Interp *interp, int argc, Jim_Obj *const *argv)
int fileio_write(struct fileio *fileio, size_t size, const void *buffer, size_t *size_written)
int fileio_read(struct fileio *fileio, size_t size, void *buffer, size_t *size_read)
int fileio_close(struct fileio *fileio)
int fileio_size(struct fileio *fileio, size_t *size)
FIX!!!!
int fileio_open(struct fileio **fileio, const char *url, enum fileio_access access_type, enum fileio_type type)
@ FILEIO_WRITE
Definition: helper/fileio.h:29
@ FILEIO_READ
Definition: helper/fileio.h:28
@ FILEIO_BINARY
Definition: helper/fileio.h:23
void image_close(struct image *image)
Definition: image.c:1197
int image_open(struct image *image, const char *url, const char *type_string)
Definition: image.c:949
void keep_alive(void)
Definition: log.c:419
#define LOG_WARNING(expr ...)
Definition: log.h:120
#define ERROR_FAIL
Definition: log.h:161
#define LOG_ERROR(expr ...)
Definition: log.h:123
#define LOG_INFO(expr ...)
Definition: log.h:117
#define LOG_DEBUG(expr ...)
Definition: log.h:109
#define ERROR_OK
Definition: log.h:155
#define FLASH_WRITE_GAP_SECTOR
Definition: nor/core.h:63
const struct flash_driver * flash_driver_find_by_name(const char *name)
Find a NOR flash driver by its name.
Definition: drivers.c:161
#define MIN(a, b)
Definition: replacements.h:22
struct target * target
Definition: rtt/rtt.c:26
size_t size
Size of the control block search area.
Definition: rtt/rtt.c:30
const char * name
Definition: command.h:229
const char * usage
a string listing the options and arguments, required or optional
Definition: command.h:235
Provides details of a flash bank, available either on-chip or through a major interface.
Definition: nor/core.h:75
unsigned int num_prot_blocks
The number of protection blocks in this bank.
Definition: nor/core.h:124
struct flash_sector * sectors
Array of sectors, allocated and initialized by the flash driver.
Definition: nor/core.h:116
uint8_t default_padded_value
Default padded value used, normally this matches the flash erased value.
Definition: nor/core.h:95
const struct flash_driver * driver
Driver for this bank.
Definition: nor/core.h:80
unsigned int chip_width
Width of the chip in bytes (1,2,4 bytes)
Definition: nor/core.h:87
target_addr_t base
The base address of this bank.
Definition: nor/core.h:84
uint32_t size
The size of this chip bank, in bytes.
Definition: nor/core.h:85
unsigned int num_sectors
The number of sectors on this chip.
Definition: nor/core.h:114
struct flash_sector * prot_blocks
Array of protection blocks, allocated and initialized by the flash driver.
Definition: nor/core.h:126
unsigned int bus_width
Maximum bus width, in bytes (1,2,4 bytes)
Definition: nor/core.h:88
struct flash_bank * next
The next flash bank on this chip.
Definition: nor/core.h:128
struct target * target
Target to which this bank belongs.
Definition: nor/core.h:78
uint32_t minimal_write_gap
Minimal gap between sections to discontinue flash write Default FLASH_WRITE_GAP_SECTOR splits the wri...
Definition: nor/core.h:107
char * name
Definition: nor/core.h:76
uint8_t erased_value
Erased value.
Definition: nor/core.h:91
unsigned int bank_number
The 'bank' (or chip number) of this instance.
Definition: nor/core.h:83
Provides the implementation-independent structure that defines all of the callbacks required by OpenO...
Definition: nor/driver.h:39
const struct command_registration * commands
An array of driver-specific commands to register.
Definition: nor/driver.h:56
int(* auto_probe)(struct flash_bank *bank)
A more gentle flavor of flash_driver_s::probe, performing setup with less noise.
Definition: nor/driver.h:219
const char * usage
Gives a human-readable description of arguments.
Definition: nor/driver.h:49
int(* erase_check)(struct flash_bank *bank)
Check the erasure status of a flash bank.
Definition: nor/driver.h:179
int(* info)(struct flash_bank *bank, struct command_invocation *cmd)
Display human-readable information about the flash bank.
Definition: nor/driver.h:204
int(* probe)(struct flash_bank *bank)
Probe to determine what kind of flash is present.
Definition: nor/driver.h:168
int(* protect_check)(struct flash_bank *bank)
Determine if the specific bank is "protected" or not.
Definition: nor/driver.h:193
const char * name
Gives a human-readable name of this flash driver, This field is used to select and initialize the dri...
Definition: nor/driver.h:44
Describes the geometry and status of a single flash sector within a flash bank.
Definition: nor/core.h:28
int is_erased
Indication of erasure status: 0 = not erased, 1 = erased, other = unknown.
Definition: nor/core.h:42
uint32_t offset
Bus offset from start of the flash chip (in bytes).
Definition: nor/core.h:30
int is_protected
Indication of protection status: 0 = unprotected/unlocked, 1 = protected/locked, other = unknown.
Definition: nor/core.h:55
uint32_t size
Number of bytes in this flash sector.
Definition: nor/core.h:32
Definition: image.h:48
bool start_address_set
Definition: image.h:55
long long base_address
Definition: image.h:54
bool base_address_set
Definition: image.h:53
Definition: target.h:120
uint64_t target_buffer_get_u64(struct target *target, const uint8_t *buffer)
Definition: target.c:366
struct target * get_target(const char *id)
Definition: target.c:492
void target_buffer_set_u16(struct target *target, uint8_t *buffer, uint16_t value)
Definition: target.c:429
void target_buffer_set_u32(struct target *target, uint8_t *buffer, uint32_t value)
Definition: target.c:411
void target_handle_md_output(struct command_invocation *cmd, struct target *target, target_addr_t address, unsigned size, unsigned count, const uint8_t *buffer)
Definition: target.c:3399
void target_buffer_set_u64(struct target *target, uint8_t *buffer, uint64_t value)
Definition: target.c:402
uint16_t target_buffer_get_u16(struct target *target, const uint8_t *buffer)
Definition: target.c:393
struct target * get_current_target(struct command_context *cmd_ctx)
Definition: target.c:536
uint32_t target_buffer_get_u32(struct target *target, const uint8_t *buffer)
Definition: target.c:375
static const char * target_name(struct target *target)
Returns the instance-specific name of the specified target.
Definition: target.h:234
float duration_elapsed(const struct duration *duration)
Definition: time_support.c:83
int duration_measure(struct duration *duration)
Update the duration->elapsed field to finish the duration measurement.
Definition: time_support.c:74
int duration_start(struct duration *duration)
Update the duration->start field to start the duration measurement.
Definition: time_support.c:69
float duration_kbps(const struct duration *duration, size_t count)
Definition: time_support.c:90
#define TARGET_ADDR_FMT
Definition: types.h:342
uint64_t target_addr_t
Definition: types.h:335
#define NULL
Definition: usb.h:16
uint8_t offset[4]
Definition: vdebug.c:9
uint8_t count[4]
Definition: vdebug.c:22