OpenOCD
flash/nor/core.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-2010 Ø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) 2010 by Antonio Borneo <borneo.antonio@gmail.com> *
9  * Copyright (C) 2017-2018 Tomas Vanek <vanekt@fbl.cz> *
10  ***************************************************************************/
11 
12 #ifdef HAVE_CONFIG_H
13 #include <config.h>
14 #endif
15 #include <flash/common.h>
16 #include <flash/nor/core.h>
17 #include <flash/nor/imp.h>
18 #include <target/image.h>
19 
27 static struct flash_bank *flash_banks;
28 
29 int flash_driver_erase(struct flash_bank *bank, unsigned int first,
30  unsigned int last)
31 {
32  int retval;
33 
34  retval = bank->driver->erase(bank, first, last);
35  if (retval != ERROR_OK)
36  LOG_ERROR("failed erasing sectors %u to %u", first, last);
37 
38  return retval;
39 }
40 
41 int flash_driver_protect(struct flash_bank *bank, int set, unsigned int first,
42  unsigned int last)
43 {
44  int retval;
45  unsigned int num_blocks;
46 
47  if (bank->num_prot_blocks)
48  num_blocks = bank->num_prot_blocks;
49  else
50  num_blocks = bank->num_sectors;
51 
52 
53  /* callers may not supply illegal parameters ... */
54  if (first > last || last >= num_blocks) {
55  LOG_ERROR("illegal protection block range");
56  return ERROR_FAIL;
57  }
58 
59  /* force "set" to 0/1 */
60  set = !!set;
61 
62  if (!bank->driver->protect) {
63  LOG_ERROR("Flash protection is not supported.");
65  }
66 
67  /* DANGER!
68  *
69  * We must not use any cached information about protection state!!!!
70  *
71  * There are a million things that could change the protect state:
72  *
73  * the target could have reset, power cycled, been hot plugged,
74  * the application could have run, etc.
75  *
76  * Drivers only receive valid protection block range.
77  */
78  retval = bank->driver->protect(bank, set, first, last);
79  if (retval != ERROR_OK)
80  LOG_ERROR("failed setting protection for blocks %u to %u", first, last);
81 
82  return retval;
83 }
84 
86  const uint8_t *buffer, uint32_t offset, uint32_t count)
87 {
88  int retval;
89 
90  retval = bank->driver->write(bank, buffer, offset, count);
91  if (retval != ERROR_OK) {
92  LOG_ERROR(
93  "error writing to flash at address " TARGET_ADDR_FMT
94  " at offset 0x%8.8" PRIx32,
95  bank->base,
96  offset);
97  }
98 
99  return retval;
100 }
101 
103  uint8_t *buffer, uint32_t offset, uint32_t count)
104 {
105  int retval;
106 
107  LOG_DEBUG("call flash_driver_read()");
108 
109  retval = bank->driver->read(bank, buffer, offset, count);
110  if (retval != ERROR_OK) {
111  LOG_ERROR(
112  "error reading to flash at address " TARGET_ADDR_FMT
113  " at offset 0x%8.8" PRIx32,
114  bank->base,
115  offset);
116  }
117 
118  return retval;
119 }
120 
122  uint8_t *buffer, uint32_t offset, uint32_t count)
123 {
124  return target_read_buffer(bank->target, offset + bank->base, count, buffer);
125 }
126 
128  const uint8_t *buffer, uint32_t offset, uint32_t count)
129 {
130  int retval;
131 
132  retval = bank->driver->verify ? bank->driver->verify(bank, buffer, offset, count) :
134  if (retval != ERROR_OK) {
135  LOG_ERROR("verify failed in bank at " TARGET_ADDR_FMT " starting at 0x%8.8" PRIx32,
136  bank->base, offset);
137  }
138 
139  return retval;
140 }
141 
143  const uint8_t *buffer, uint32_t offset, uint32_t count)
144 {
145  uint32_t target_crc, image_crc;
146  int retval;
147 
148  retval = image_calculate_checksum(buffer, count, &image_crc);
149  if (retval != ERROR_OK)
150  return retval;
151 
152  retval = target_checksum_memory(bank->target, offset + bank->base, count, &target_crc);
153  if (retval != ERROR_OK)
154  return retval;
155 
156  LOG_DEBUG("addr " TARGET_ADDR_FMT ", len 0x%08" PRIx32 ", crc 0x%08" PRIx32 " 0x%08" PRIx32,
157  offset + bank->base, count, ~image_crc, ~target_crc);
158  if (target_crc == image_crc)
159  return ERROR_OK;
160  else
161  return ERROR_FAIL;
162 }
163 
165 {
166  /* put flash bank in linked list */
167  unsigned bank_num = 0;
168  if (flash_banks) {
169  /* find last flash bank */
170  struct flash_bank *p = flash_banks;
171  while (p->next) {
172  bank_num += 1;
173  p = p->next;
174  }
175  p->next = bank;
176  bank_num += 1;
177  } else
178  flash_banks = bank;
179 
180  bank->bank_number = bank_num;
181 }
182 
184 {
185  return flash_banks;
186 }
187 
188 struct flash_bank *get_flash_bank_by_num_noprobe(unsigned int num)
189 {
190  struct flash_bank *p;
191  unsigned int i = 0;
192 
193  for (p = flash_banks; p; p = p->next) {
194  if (i++ == num)
195  return p;
196  }
197  LOG_ERROR("flash bank %d does not exist", num);
198  return NULL;
199 }
200 
201 unsigned int flash_get_bank_count(void)
202 {
203  struct flash_bank *p;
204  unsigned int i = 0;
205  for (p = flash_banks; p; p = p->next)
206  i++;
207  return i;
208 }
209 
211 {
212  free(bank->driver_priv);
213  bank->driver_priv = NULL;
214 }
215 
217 {
218  struct flash_bank *bank = flash_banks;
219  while (bank) {
220  struct flash_bank *next = bank->next;
221  if (bank->driver->free_driver_priv)
222  bank->driver->free_driver_priv(bank);
223  else
224  LOG_WARNING("Flash driver of %s does not support free_driver_priv()", bank->name);
225 
226  /* For 'virtual' flash driver bank->sectors and bank->prot_blocks pointers are copied from
227  * master flash_bank structure. They point to memory locations allocated by master flash driver
228  * so master driver is responsible for releasing them.
229  * Avoid UB caused by double-free memory corruption if flash bank is 'virtual'. */
230 
231  if (strcmp(bank->driver->name, "virtual") != 0) {
232  free(bank->sectors);
233  free(bank->prot_blocks);
234  }
235 
236  free(bank->name);
237  free(bank);
238  bank = next;
239  }
240  flash_banks = NULL;
241 }
242 
244 {
245  unsigned requested = get_flash_name_index(name);
246  unsigned found = 0;
247 
248  struct flash_bank *bank;
249  for (bank = flash_banks; bank; bank = bank->next) {
250  if (strcmp(bank->name, name) == 0)
251  return bank;
252  if (!flash_driver_name_matches(bank->driver->name, name))
253  continue;
254  if (++found < requested)
255  continue;
256  return bank;
257  }
258  return NULL;
259 }
260 
261 int get_flash_bank_by_name(const char *name, struct flash_bank **bank_result)
262 {
263  struct flash_bank *bank;
264  int retval;
265 
267  if (bank) {
268  retval = bank->driver->auto_probe(bank);
269 
270  if (retval != ERROR_OK) {
271  LOG_ERROR("auto_probe failed");
272  return retval;
273  }
274  }
275 
276  *bank_result = bank;
277  return ERROR_OK;
278 }
279 
280 int get_flash_bank_by_num(unsigned int num, struct flash_bank **bank)
281 {
282  struct flash_bank *p = get_flash_bank_by_num_noprobe(num);
283  int retval;
284 
285  if (!p)
286  return ERROR_FAIL;
287 
288  retval = p->driver->auto_probe(p);
289 
290  if (retval != ERROR_OK) {
291  LOG_ERROR("auto_probe failed");
292  return retval;
293  }
294  *bank = p;
295  return ERROR_OK;
296 }
297 
298 /* lookup flash bank by address, bank not found is success, but
299  * result_bank is set to NULL. */
302  bool check,
303  struct flash_bank **result_bank)
304 {
305  struct flash_bank *c;
306 
307  /* cycle through bank list */
308  for (c = flash_banks; c; c = c->next) {
309  if (c->target != target)
310  continue;
311 
312  int retval;
313  retval = c->driver->auto_probe(c);
314 
315  if (retval != ERROR_OK) {
316  LOG_ERROR("auto_probe failed");
317  return retval;
318  }
319  /* check whether address belongs to this flash bank */
320  if ((addr >= c->base) && (addr <= c->base + (c->size - 1))) {
321  *result_bank = c;
322  return ERROR_OK;
323  }
324  }
325  *result_bank = NULL;
326  if (check) {
327  LOG_ERROR("No flash at address " TARGET_ADDR_FMT, addr);
328  return ERROR_FAIL;
329  }
330  return ERROR_OK;
331 }
332 
334 {
335  struct target *target = bank->target;
336  const int buffer_size = 1024;
337  uint32_t n_bytes;
338  int retval = ERROR_OK;
339 
340  if (bank->target->state != TARGET_HALTED) {
341  LOG_ERROR("Target not halted");
343  }
344 
345  uint8_t *buffer = malloc(buffer_size);
346 
347  for (unsigned int i = 0; i < bank->num_sectors; i++) {
348  uint32_t j;
349  bank->sectors[i].is_erased = 1;
350 
351  for (j = 0; j < bank->sectors[i].size; j += buffer_size) {
352  uint32_t chunk;
353  chunk = buffer_size;
354  if (chunk > (bank->sectors[i].size - j))
355  chunk = (bank->sectors[i].size - j);
356 
357  retval = target_read_memory(target,
358  bank->base + bank->sectors[i].offset + j,
359  4,
360  chunk/4,
361  buffer);
362  if (retval != ERROR_OK)
363  goto done;
364 
365  for (n_bytes = 0; n_bytes < chunk; n_bytes++) {
366  if (buffer[n_bytes] != bank->erased_value) {
367  bank->sectors[i].is_erased = 0;
368  break;
369  }
370  }
371  }
372  }
373 
374 done:
375  free(buffer);
376 
377  return retval;
378 }
379 
381 {
382  struct target *target = bank->target;
383  int retval;
384 
385  if (bank->target->state != TARGET_HALTED) {
386  LOG_ERROR("Target not halted");
388  }
389 
390  struct target_memory_check_block *block_array;
391  block_array = malloc(bank->num_sectors * sizeof(struct target_memory_check_block));
392  if (!block_array)
394 
395  for (unsigned int i = 0; i < bank->num_sectors; i++) {
396  block_array[i].address = bank->base + bank->sectors[i].offset;
397  block_array[i].size = bank->sectors[i].size;
398  block_array[i].result = UINT32_MAX; /* erase state unknown */
399  }
400 
401  bool fast_check = true;
402  for (unsigned int i = 0; i < bank->num_sectors; ) {
404  block_array + i, bank->num_sectors - i,
405  bank->erased_value);
406  if (retval < 1) {
407  /* Run slow fallback if the first run gives no result
408  * otherwise use possibly incomplete results */
409  if (i == 0)
410  fast_check = false;
411  break;
412  }
413  i += retval; /* add number of blocks done this round */
414  }
415 
416  if (fast_check) {
417  for (unsigned int i = 0; i < bank->num_sectors; i++)
418  bank->sectors[i].is_erased = block_array[i].result;
419  retval = ERROR_OK;
420  } else {
421  if (retval == ERROR_NOT_IMPLEMENTED)
422  LOG_USER("Running slow fallback erase check");
423  else
424  LOG_USER("Running slow fallback erase check - add working memory");
425 
427  }
428  free(block_array);
429 
430  return retval;
431 }
432 
433 /* Manipulate given flash region, selecting the bank according to target
434  * and address. Maps an address range to a set of sectors, and issues
435  * the callback() on that set ... e.g. to erase or unprotect its members.
436  *
437  * Parameter iterate_protect_blocks switches iteration of protect block
438  * instead of erase sectors. If there is no protect blocks array, sectors
439  * are used in iteration, so compatibility for old flash drivers is retained.
440  *
441  * The "pad_reason" parameter is a kind of boolean: when it's NULL, the
442  * range must fit those sectors exactly. This is clearly safe; it can't
443  * erase data which the caller said to leave alone, for example. If it's
444  * non-NULL, rather than failing, extra data in the first and/or last
445  * sectors will be added to the range, and that reason string is used when
446  * warning about those additions.
447  */
449  char *pad_reason, target_addr_t addr, uint32_t length,
450  bool iterate_protect_blocks,
451  int (*callback)(struct flash_bank *bank, unsigned int first,
452  unsigned int last))
453 {
454  struct flash_bank *c;
455  struct flash_sector *block_array;
456  target_addr_t last_addr = addr + length - 1; /* the last address of range */
457  int first = -1;
458  int last = -1;
459  int i;
460  int num_blocks;
461 
462  int retval = get_flash_bank_by_addr(target, addr, true, &c);
463  if (retval != ERROR_OK)
464  return retval;
465 
466  if (c->size == 0 || c->num_sectors == 0) {
467  LOG_ERROR("Bank is invalid");
469  }
470 
471  if (length == 0) {
472  /* special case, erase whole bank when length is zero */
473  if (addr != c->base) {
474  LOG_ERROR("Whole bank access must start at beginning of bank.");
476  }
477 
478  return callback(c, 0, c->num_sectors - 1);
479  }
480 
481  /* check whether it all fits in this bank */
482  if (last_addr > c->base + c->size - 1) {
483  LOG_ERROR("Flash access does not fit into bank.");
485  }
486 
487  if (!c->prot_blocks || c->num_prot_blocks == 0) {
488  /* flash driver does not define protect blocks, use sectors instead */
489  iterate_protect_blocks = false;
490  }
491 
492  if (iterate_protect_blocks) {
493  block_array = c->prot_blocks;
494  num_blocks = c->num_prot_blocks;
495  } else {
496  block_array = c->sectors;
497  num_blocks = c->num_sectors;
498  }
499 
500  for (i = 0; i < num_blocks; i++) {
501  struct flash_sector *f = &block_array[i];
502  target_addr_t sector_addr = c->base + f->offset;
503  target_addr_t sector_last_addr = sector_addr + f->size - 1;
504 
505  /* start only on a sector boundary */
506  if (first < 0) {
507  /* scanned past the first sector? */
508  if (addr < sector_addr)
509  break;
510 
511  /* is this the first sector? */
512  if (addr == sector_addr)
513  first = i;
514 
515  /* Does this need head-padding? If so, pad and warn;
516  * or else force an error.
517  *
518  * Such padding can make trouble, since *WE* can't
519  * ever know if that data was in use. The warning
520  * should help users sort out messes later.
521  */
522  else if (addr <= sector_last_addr && pad_reason) {
523  /* FIXME say how many bytes (e.g. 80 KB) */
524  LOG_WARNING("Adding extra %s range, "
526  pad_reason,
527  sector_addr,
528  addr - 1);
529  first = i;
530  } else
531  continue;
532  }
533 
534  /* is this (also?) the last sector? */
535  if (last_addr == sector_last_addr) {
536  last = i;
537  break;
538  }
539 
540  /* Does this need tail-padding? If so, pad and warn;
541  * or else force an error.
542  */
543  if (last_addr < sector_last_addr && pad_reason) {
544  /* FIXME say how many bytes (e.g. 80 KB) */
545  LOG_WARNING("Adding extra %s range, "
547  pad_reason,
548  last_addr + 1,
549  sector_last_addr);
550  last = i;
551  break;
552  }
553 
554  /* MUST finish on a sector boundary */
555  if (last_addr < sector_addr)
556  break;
557  }
558 
559  /* invalid start or end address? */
560  if (first == -1 || last == -1) {
561  LOG_ERROR("address range " TARGET_ADDR_FMT " .. " TARGET_ADDR_FMT
562  " is not sector-aligned",
563  addr,
564  last_addr);
566  }
567 
568  /* The NOR driver may trim this range down, based on what
569  * sectors are already erased/unprotected. GDB currently
570  * blocks such optimizations.
571  */
572  return callback(c, first, last);
573 }
574 
575 /* The inner fn only handles a single bank, we could be spanning
576  * multiple chips.
577  */
579  char *pad_reason, target_addr_t addr, uint32_t length,
580  bool iterate_protect_blocks,
581  int (*callback)(struct flash_bank *bank, unsigned int first,
582  unsigned int last))
583 {
584  struct flash_bank *c;
585  int retval = ERROR_OK;
586 
587  /* Danger! zero-length iterations means entire bank! */
588  do {
589  retval = get_flash_bank_by_addr(target, addr, true, &c);
590  if (retval != ERROR_OK)
591  return retval;
592 
593  uint32_t cur_length = length;
594  /* check whether it all fits in this bank */
595  if (addr + length - 1 > c->base + c->size - 1) {
596  LOG_DEBUG("iterating over more than one flash bank.");
597  cur_length = c->base + c->size - addr;
598  }
600  pad_reason, addr, cur_length,
601  iterate_protect_blocks,
602  callback);
603  if (retval != ERROR_OK)
604  break;
605 
606  length -= cur_length;
607  addr += cur_length;
608  } while (length > 0);
609 
610  return retval;
611 }
612 
614  bool pad, target_addr_t addr, uint32_t length)
615 {
616  return flash_iterate_address_range(target, pad ? "erase" : NULL,
617  addr, length, false, &flash_driver_erase);
618 }
619 
620 static int flash_driver_unprotect(struct flash_bank *bank, unsigned int first,
621  unsigned int last)
622 {
623  return flash_driver_protect(bank, 0, first, last);
624 }
625 
627  uint32_t length)
628 {
629  /* By default, pad to sector boundaries ... the real issue here
630  * is that our (only) caller *permanently* removes protection,
631  * and doesn't restore it.
632  */
633  return flash_iterate_address_range(target, "unprotect",
635 }
636 
637 static int compare_section(const void *a, const void *b)
638 {
639  struct imagesection *b1, *b2;
640  b1 = *((struct imagesection **)a);
641  b2 = *((struct imagesection **)b);
642 
643  if (b1->base_address == b2->base_address)
644  return 0;
645  else if (b1->base_address > b2->base_address)
646  return 1;
647  else
648  return -1;
649 }
650 
655 {
656  if (addr < bank->base || addr >= bank->base + bank->size
657  || bank->write_start_alignment <= 1)
658  return addr;
659 
660  if (bank->write_start_alignment == FLASH_WRITE_ALIGN_SECTOR) {
661  uint32_t offset = addr - bank->base;
662  uint32_t aligned = 0;
663  for (unsigned int sect = 0; sect < bank->num_sectors; sect++) {
664  if (bank->sectors[sect].offset > offset)
665  break;
666 
667  aligned = bank->sectors[sect].offset;
668  }
669  return bank->base + aligned;
670  }
671 
672  return addr & ~(bank->write_start_alignment - 1);
673 }
674 
679 {
680  if (addr < bank->base || addr >= bank->base + bank->size
681  || bank->write_end_alignment <= 1)
682  return addr;
683 
684  if (bank->write_end_alignment == FLASH_WRITE_ALIGN_SECTOR) {
685  uint32_t offset = addr - bank->base;
686  uint32_t aligned = 0;
687  for (unsigned int sect = 0; sect < bank->num_sectors; sect++) {
688  aligned = bank->sectors[sect].offset + bank->sectors[sect].size - 1;
689  if (aligned >= offset)
690  break;
691  }
692  return bank->base + aligned;
693  }
694 
695  return addr | (bank->write_end_alignment - 1);
696 }
697 
702  target_addr_t addr1, target_addr_t addr2)
703 {
704  if (bank->minimal_write_gap == FLASH_WRITE_CONTINUOUS
705  || addr1 < bank->base || addr1 >= bank->base + bank->size
706  || addr2 < bank->base || addr2 >= bank->base + bank->size)
707  return false;
708 
709  if (bank->minimal_write_gap == FLASH_WRITE_GAP_SECTOR) {
710  unsigned int sect;
711  uint32_t offset1 = addr1 - bank->base;
712  /* find the sector following the one containing addr1 */
713  for (sect = 0; sect < bank->num_sectors; sect++) {
714  if (bank->sectors[sect].offset > offset1)
715  break;
716  }
717  if (sect >= bank->num_sectors)
718  return false;
719 
720  uint32_t offset2 = addr2 - bank->base;
721  return bank->sectors[sect].offset + bank->sectors[sect].size <= offset2;
722  }
723 
724  target_addr_t aligned1 = flash_write_align_end(bank, addr1);
725  target_addr_t aligned2 = flash_write_align_start(bank, addr2);
726  return aligned1 + bank->minimal_write_gap < aligned2;
727 }
728 
729 
731  uint32_t *written, bool erase, bool unlock, bool write, bool verify)
732 {
733  int retval = ERROR_OK;
734 
735  unsigned int section;
736  uint32_t section_offset;
737  struct flash_bank *c;
738  int *padding;
739 
740  section = 0;
741  section_offset = 0;
742 
743  if (written)
744  *written = 0;
745 
746  if (erase) {
747  /* assume all sectors need erasing - stops any problems
748  * when flash_write is called multiple times */
749 
750  flash_set_dirty();
751  }
752 
753  /* allocate padding array */
754  padding = calloc(image->num_sections, sizeof(*padding));
755 
756  /* This fn requires all sections to be in ascending order of addresses,
757  * whereas an image can have sections out of order. */
758  struct imagesection **sections = malloc(sizeof(struct imagesection *) *
760 
761  for (unsigned int i = 0; i < image->num_sections; i++)
762  sections[i] = &image->sections[i];
763 
764  qsort(sections, image->num_sections, sizeof(struct imagesection *),
766 
767  /* loop until we reach end of the image */
768  while (section < image->num_sections) {
769  uint32_t buffer_idx;
770  uint8_t *buffer;
771  unsigned int section_last;
772  target_addr_t run_address = sections[section]->base_address + section_offset;
773  uint32_t run_size = sections[section]->size - section_offset;
774  int pad_bytes = 0;
775 
776  if (sections[section]->size == 0) {
777  LOG_WARNING("empty section %d", section);
778  section++;
779  section_offset = 0;
780  continue;
781  }
782 
783  /* find the corresponding flash bank */
784  retval = get_flash_bank_by_addr(target, run_address, false, &c);
785  if (retval != ERROR_OK)
786  goto done;
787  if (!c) {
788  LOG_WARNING("no flash bank found for address " TARGET_ADDR_FMT, run_address);
789  section++; /* and skip it */
790  section_offset = 0;
791  continue;
792  }
793 
794  /* collect consecutive sections which fall into the same bank */
795  section_last = section;
796  padding[section] = 0;
797  while ((run_address + run_size - 1 < c->base + c->size - 1) &&
798  (section_last + 1 < image->num_sections)) {
799  /* sections are sorted */
800  assert(sections[section_last + 1]->base_address >= c->base);
801  if (sections[section_last + 1]->base_address >= (c->base + c->size)) {
802  /* Done with this bank */
803  break;
804  }
805 
806  /* if we have multiple sections within our image,
807  * flash programming could fail due to alignment issues
808  * attempt to rebuild a consecutive buffer for the flash loader */
809  target_addr_t run_next_addr = run_address + run_size;
810  target_addr_t next_section_base = sections[section_last + 1]->base_address;
811  if (next_section_base < run_next_addr) {
812  LOG_ERROR("Section at " TARGET_ADDR_FMT
813  " overlaps section ending at " TARGET_ADDR_FMT,
814  next_section_base, run_next_addr);
815  LOG_ERROR("Flash write aborted.");
816  retval = ERROR_FAIL;
817  goto done;
818  }
819 
820  pad_bytes = next_section_base - run_next_addr;
821  if (pad_bytes) {
822  if (flash_write_check_gap(c, run_next_addr - 1, next_section_base)) {
823  LOG_INFO("Flash write discontinued at " TARGET_ADDR_FMT
824  ", next section at " TARGET_ADDR_FMT,
825  run_next_addr, next_section_base);
826  break;
827  }
828  }
829  if (pad_bytes > 0)
830  LOG_INFO("Padding image section %d at " TARGET_ADDR_FMT
831  " with %d bytes",
832  section_last, run_next_addr, pad_bytes);
833 
834  padding[section_last] = pad_bytes;
835  run_size += pad_bytes;
836  run_size += sections[++section_last]->size;
837  }
838 
839  if (run_address + run_size - 1 > c->base + c->size - 1) {
840  /* If we have more than one flash chip back to back, then we limit
841  * the current write operation to the current chip.
842  */
843  LOG_DEBUG("Truncate flash run size to the current flash chip.");
844 
845  run_size = c->base + c->size - run_address;
846  assert(run_size > 0);
847  }
848 
849  uint32_t padding_at_start = 0;
851  /* align write region according to bank requirements */
852  target_addr_t aligned_start = flash_write_align_start(c, run_address);
853  padding_at_start = run_address - aligned_start;
854  if (padding_at_start > 0) {
855  LOG_WARNING("Section start address " TARGET_ADDR_FMT
856  " breaks the required alignment of flash bank %s",
857  run_address, c->name);
858  LOG_WARNING("Padding %" PRIu32 " bytes from " TARGET_ADDR_FMT,
859  padding_at_start, aligned_start);
860 
861  run_address -= padding_at_start;
862  run_size += padding_at_start;
863  }
864 
865  target_addr_t run_end = run_address + run_size - 1;
866  target_addr_t aligned_end = flash_write_align_end(c, run_end);
867  pad_bytes = aligned_end - run_end;
868  if (pad_bytes > 0) {
869  LOG_INFO("Padding image section %d at " TARGET_ADDR_FMT
870  " with %d bytes (bank write end alignment)",
871  section_last, run_end + 1, pad_bytes);
872 
873  padding[section_last] += pad_bytes;
874  run_size += pad_bytes;
875  }
876 
877  } else if (unlock || erase) {
878  /* If we're applying any sector automagic, then pad this
879  * (maybe-combined) segment to the end of its last sector.
880  */
881  uint32_t offset_start = run_address - c->base;
882  uint32_t offset_end = offset_start + run_size;
883  uint32_t end = offset_end, delta;
884 
885  for (unsigned int sector = 0; sector < c->num_sectors; sector++) {
886  end = c->sectors[sector].offset
887  + c->sectors[sector].size;
888  if (offset_end <= end)
889  break;
890  }
891 
892  delta = end - offset_end;
893  padding[section_last] += delta;
894  run_size += delta;
895  }
896 
897  /* allocate buffer */
898  buffer = malloc(run_size);
899  if (!buffer) {
900  LOG_ERROR("Out of memory for flash bank buffer");
901  retval = ERROR_FAIL;
902  goto done;
903  }
904 
905  if (padding_at_start)
906  memset(buffer, c->default_padded_value, padding_at_start);
907 
908  buffer_idx = padding_at_start;
909 
910  /* read sections to the buffer */
911  while (buffer_idx < run_size) {
912  size_t size_read;
913 
914  size_read = run_size - buffer_idx;
915  if (size_read > sections[section]->size - section_offset)
916  size_read = sections[section]->size - section_offset;
917 
918  /* KLUDGE!
919  *
920  * #¤%#"%¤% we have to figure out the section # from the sorted
921  * list of pointers to sections to invoke image_read_section()...
922  */
923  intptr_t diff = (intptr_t)sections[section] - (intptr_t)image->sections;
924  int t_section_num = diff / sizeof(struct imagesection);
925 
926  LOG_DEBUG("image_read_section: section = %d, t_section_num = %d, "
927  "section_offset = %"PRIu32", buffer_idx = %"PRIu32", size_read = %zu",
928  section, t_section_num, section_offset,
929  buffer_idx, size_read);
930  retval = image_read_section(image, t_section_num, section_offset,
931  size_read, buffer + buffer_idx, &size_read);
932  if (retval != ERROR_OK || size_read == 0) {
933  free(buffer);
934  goto done;
935  }
936 
937  buffer_idx += size_read;
938  section_offset += size_read;
939 
940  /* see if we need to pad the section */
941  if (padding[section]) {
942  memset(buffer + buffer_idx, c->default_padded_value, padding[section]);
943  buffer_idx += padding[section];
944  }
945 
946  if (section_offset >= sections[section]->size) {
947  section++;
948  section_offset = 0;
949  }
950  }
951 
952  retval = ERROR_OK;
953 
954  if (unlock)
955  retval = flash_unlock_address_range(target, run_address, run_size);
956  if (retval == ERROR_OK) {
957  if (erase) {
958  /* calculate and erase sectors */
960  true, run_address, run_size);
961  }
962  }
963 
964  if (retval == ERROR_OK) {
965  if (write) {
966  /* write flash sectors */
967  retval = flash_driver_write(c, buffer, run_address - c->base, run_size);
968  }
969  }
970 
971  if (retval == ERROR_OK) {
972  if (verify) {
973  /* verify flash sectors */
974  retval = flash_driver_verify(c, buffer, run_address - c->base, run_size);
975  }
976  }
977 
978  free(buffer);
979 
980  if (retval != ERROR_OK) {
981  /* abort operation */
982  goto done;
983  }
984 
985  if (written)
986  *written += run_size; /* add run size to total written counter */
987  }
988 
989 done:
990  free(sections);
991  free(padding);
992 
993  return retval;
994 }
995 
996 int flash_write(struct target *target, struct image *image,
997  uint32_t *written, bool erase)
998 {
999  return flash_write_unlock_verify(target, image, written, erase, false, true, false);
1000 }
1001 
1002 struct flash_sector *alloc_block_array(uint32_t offset, uint32_t size,
1003  unsigned int num_blocks)
1004 {
1005  struct flash_sector *array = calloc(num_blocks, sizeof(struct flash_sector));
1006  if (!array)
1007  return NULL;
1008 
1009  for (unsigned int i = 0; i < num_blocks; i++) {
1010  array[i].offset = offset;
1011  array[i].size = size;
1012  array[i].is_erased = -1;
1013  array[i].is_protected = -1;
1014  offset += size;
1015  }
1016 
1017  return array;
1018 }
const char * name
Definition: armv4_5.c:76
unsigned get_flash_name_index(const char *name)
Parses the optional '.index' portion of a flash bank identifier.
Definition: common.c:14
bool flash_driver_name_matches(const char *name, const char *expected)
Attempt to match the expected name with the name of a driver.
Definition: common.c:27
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
#define ERROR_FLASH_BANK_INVALID
Definition: flash/common.h:28
#define ERROR_FLASH_DST_BREAKS_ALIGNMENT
Definition: flash/common.h:32
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 default_flash_verify(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
Provides default verify implementation for flash memory.
int flash_driver_read(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
int flash_driver_verify(struct flash_bank *bank, const 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...
static int flash_driver_unprotect(struct flash_bank *bank, unsigned int first, unsigned int last)
static int flash_iterate_address_range(struct target *target, char *pad_reason, target_addr_t addr, uint32_t length, bool iterate_protect_blocks, int(*callback)(struct flash_bank *bank, unsigned int first, unsigned int last))
struct flash_sector * alloc_block_array(uint32_t offset, uint32_t size, unsigned int num_blocks)
Allocate and fill an array of sectors or protection blocks.
target_addr_t flash_write_align_end(struct flash_bank *bank, target_addr_t addr)
Get aligned end address of a flash write region.
static bool flash_write_check_gap(struct flash_bank *bank, target_addr_t addr1, target_addr_t addr2)
Check if gap between sections is bigger than minimum required to discontinue flash write.
int flash_driver_protect(struct flash_bank *bank, int set, unsigned int first, unsigned int last)
static int compare_section(const void *a, const void *b)
int flash_driver_write(struct flash_bank *bank, const uint8_t *buffer, uint32_t offset, uint32_t count)
int default_flash_blank_check(struct flash_bank *bank)
Provides default erased-bank check handling.
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.
static int flash_iterate_address_range_inner(struct target *target, char *pad_reason, target_addr_t addr, uint32_t length, bool iterate_protect_blocks, int(*callback)(struct flash_bank *bank, unsigned int first, unsigned int last))
static int default_flash_mem_blank_check(struct flash_bank *bank)
static struct flash_bank * flash_banks
void flash_free_all_banks(void)
Deallocates all flash banks.
int default_flash_read(struct flash_bank *bank, uint8_t *buffer, uint32_t offset, uint32_t count)
Provides default read implementation for flash memory.
unsigned int flash_get_bank_count(void)
void default_flash_free_driver_priv(struct flash_bank *bank)
Deallocates bank->driver_priv.
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_write(struct target *target, struct image *image, uint32_t *written, bool erase)
Writes image into the target flash.
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)
int image_read_section(struct image *image, int section, target_addr_t offset, uint32_t size, uint8_t *buffer, size_t *size_read)
Definition: image.c:1065
int image_calculate_checksum(const uint8_t *buffer, uint32_t nbytes, uint32_t *checksum)
Definition: image.c:1254
#define LOG_USER(expr ...)
Definition: log.h:126
#define ERROR_NOT_IMPLEMENTED
Definition: log.h:165
#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
Upper level NOR flash interfaces.
#define FLASH_WRITE_GAP_SECTOR
Definition: nor/core.h:63
#define FLASH_WRITE_ALIGN_SECTOR
Special value for write_start_alignment and write_end_alignment field.
Definition: nor/core.h:59
void flash_set_dirty(void)
Forces targets to re-examine their erase/protection state.
#define FLASH_WRITE_CONTINUOUS
Special values for minimal_write_gap field.
Definition: nor/core.h:62
uint32_t addr
Definition: nuttx.c:65
size_t size
Size of the control block search area.
Definition: rtt/rtt.c:30
Provides details of a flash bank, available either on-chip or through a major interface.
Definition: nor/core.h:75
uint32_t write_end_alignment
Required alignment of flash write end address.
Definition: nor/core.h:102
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
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
uint32_t write_start_alignment
Required alignment of flash write start address.
Definition: nor/core.h:99
struct flash_sector * prot_blocks
Array of protection blocks, allocated and initialized by the flash driver.
Definition: nor/core.h:126
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
char * name
Definition: nor/core.h:76
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
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
unsigned int num_sections
Definition: image.h:51
struct imagesection * sections
Definition: image.h:52
target_addr_t base_address
Definition: image.h:42
uint32_t size
Definition: image.h:43
target_addr_t address
Definition: target.h:342
Definition: target.h:120
int target_checksum_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t *crc)
Definition: target.c:2533
int target_read_buffer(struct target *target, target_addr_t address, uint32_t size, uint8_t *buffer)
Definition: target.c:2473
int target_blank_check_memory(struct target *target, struct target_memory_check_block *blocks, int num_blocks, uint8_t erased_value)
Definition: target.c:2577
int target_read_memory(struct target *target, target_addr_t address, uint32_t size, uint32_t count, uint8_t *buffer)
Read count items of size bytes from the memory of target at the address given.
Definition: target.c:1306
#define ERROR_TARGET_NOT_HALTED
Definition: target.h:792
@ TARGET_HALTED
Definition: target.h:55
#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