target_flash: Implement blank check

* Reuse flash write buffer for block reads
* Compare against erased value and skip to next sector on mismatch
* Indicate progress via tc_printf() to gdb_if.c or BMDA stdout

src/include/target.h

@@ -70,6 +70,7 @@ bool target_mem_access_needs_halt(target_s *target);
 bool target_flash_erase(target_s *target, target_addr_t addr, size_t len);
 bool target_flash_write(target_s *target, target_addr_t dest, const void *src, size_t len);
 bool target_flash_complete(target_s *target);
+bool target_flash_blank_check(target_s *target);
 
 /* Register access functions */
 size_t target_regs_size(target_s *target);

src/target/target.c

@@ -45,11 +45,13 @@ target_s *target_list = NULL;
 
 static bool target_cmd_mass_erase(target_s *target, int argc, const char **argv);
 static bool target_cmd_range_erase(target_s *target, int argc, const char **argv);
+static bool target_cmd_blank_check(target_s *target, int argc, const char **argv);
 static bool target_cmd_redirect_output(target_s *target, int argc, const char **argv);
 
 const command_s target_cmd_list[] = {
  {"erase_mass", target_cmd_mass_erase, "Erase whole device Flash"},
  {"erase_range", target_cmd_range_erase, "Erase a range of memory on a device"},
+ {"blank_check", target_cmd_blank_check, "Blank-check device Flash"},
  {"redirect_stdout", target_cmd_redirect_output, "Redirect semihosting output to aux USB serial"},
  {NULL, NULL, NULL},
 };
@@ -510,6 +512,16 @@ static bool target_cmd_range_erase(target_s *const target, const int argc, const
  return target_flash_erase(target, addr, length);
 }
 
+static bool target_cmd_blank_check(target_s *const target, const int argc, const char **const argv)
+{
+ (void)argc;
+ (void)argv;
+ gdb_out("Blank-checking device Flash: ");
+ const bool result = target_flash_blank_check(target);
+ gdb_out("done\n");
+ return result;
+}
+
 static bool target_cmd_redirect_output(target_s *target, int argc, const char **argv)
 {
  if (argc == 1) {

src/target/target_flash.c

@@ -312,3 +312,65 @@ bool target_flash_complete(target_s *target)
  target_exit_flash_mode(target);
  return result;
 }
+
+static bool flash_blank_check(target_flash_s *flash, target_addr_t src, size_t len, target_addr_t *mismatch)
+{
+ bool result = true; /* Catch false returns with &= */
+ target_s *target = flash->t;
+ platform_timeout_s timeout;
+ platform_timeout_set(&timeout, 500);
+
+ while (len) {
+ const size_t offset = src % flash->writebufsize;
+ const size_t local_len = MIN(flash->writebufsize - offset, len);
+ /* Fetch chunk into sector buffer */
+ target_mem32_read(target, flash->buf, src, local_len);
+
+ /* Compare bytewise with erased value */
+ const uint8_t erased = flash->erased;
+ for (size_t i = 0; i < local_len; i++) {
+ if (flash->buf[i] != erased) {
+ *mismatch = src + i;
+ return false;
+ }
+ }
+ src += local_len;
+ len -= local_len;
+ target_print_progress(&timeout);
+ }
+ return result;
+}
+
+bool target_flash_blank_check(target_s *target)
+{
+ if (!target->flash)
+ return false;
+
+ bool result = true;
+ target_addr_t mismatch = 0;
+
+ for (target_flash_s *flash = target->flash; flash; flash = flash->next) {
+ if (!flash->buf)
+ if (!flash_buffer_alloc(flash))
+ return false;
+
+ target_addr_t local_start = flash->start;
+ const target_addr_t local_end = flash->start + flash->length;
+ while (local_start < local_end) {
+ result = flash_blank_check(flash, local_start, flash->blocksize, &mismatch);
+ if (!result) {
+ tc_printf(target, "Has data at 0x%08" PRIx32 "\n", mismatch);
+ } else {
+ tc_printf(target, "Blank 0x%08" PRIx32 "+%" PRIu32 "\n", local_start, (uint32_t)flash->blocksize);
+ }
+ local_start += flash->blocksize;
+ }
+ /* Free the operation buffer */
+ if (flash->buf) {
+ free(flash->buf);
+ flash->buf = NULL;
+ }
+ }
+
+ return result;
+}