[spiflash][bio][stm32f7] Fixed (sub)sector erase on spiflash device.

lib/bio/debug.c

 /*
  * Copyright (c) 2009-2014 Travis Geiselbrecht
  *
  * Permission is hereby granted, free of charge, to any person obtaining
  * a copy of this software and associated documentation files
  * (the "Software"), to deal in the Software without restriction,
  * including without limitation the rights to use, copy, modify, merge,
  * publish, distribute, sublicense, and/or sell copies of the Software,
  * and to permit persons to whom the Software is furnished to do so,
  * subject to the following conditions:
@@ skipping 18 matching lines @@
 #include <lib/console.h>
 #include <lib/bio.h>
 #include <lib/partition.h>
 #include <platform.h>
 
 #if WITH_LIB_CKSUM
 #include <lib/cksum.h>
 #endif
 
 #define DMA_ALIGNMENT (CACHE_LINE)
+#define THREE_BYTE_ADDR_BOUNDARY (16777216)
+#define SUB_ERASE_TEST_SAMPLES (32)
 
 #if defined(WITH_LIB_CONSOLE)
 
 #if LK_DEBUGLEVEL > 0
 static int cmd_bio(int argc, const cmd_args *argv);
 static int bio_test_device(bdev_t* device);
 
 STATIC_COMMAND_START
 STATIC_COMMAND("bio", "block io debug commands", &cmd_bio)
 STATIC_COMMAND_END(bio);
@@ skipping 277 matching lines @@
     printf("validating erase...\n");
     size_t num_invalid_blocks = 0;
     for (bnum_t bnum = 0; bnum < device->block_count; bnum++) {
         if (!is_valid_block(device, bnum, &device->erase_byte, sizeof(device->erase_byte))) {
             num_invalid_blocks++;
         }
     }
     return num_invalid_blocks;
 }
 
+static bool test_erase_block(bdev_t* device, uint32_t block_addr)
+{
+    bool success = false;
+    uint8_t valid_byte[1];
+
+    uint8_t *block_contents = memalign(DMA_ALIGNMENT, device->block_size);
+    memset(block_contents, ~(device->erase_byte), device->block_size);
+
+    ssize_t err = bio_write_block(device, block_contents, block_addr, 1);
+    if (err != (ssize_t)device->block_size) {
+        goto finish;
+    }
+
+    valid_byte[0] = ~(device->erase_byte);
+    if (!is_valid_block(device, block_addr, valid_byte, 1)) {
+        goto finish;
+    }
+
+    err = bio_erase(device, block_addr * device->block_size, 1);
+    if (err <= 0) {
+        goto finish;
+    }
+
+    valid_byte[0] = device->erase_byte;
+    if (is_valid_block(device, block_addr, valid_byte, 1)) {
+        success = true;
+    }
+
+finish:
+    free(block_contents);
+    return success;
+}
+
+// Ensure that (sub)sector erase work.
+static bool sub_erase_test(bdev_t* device, uint32_t n_samples)
+{
+    printf("Sampling the device %d times.\n", n_samples);
+    for (uint32_t i = 0; i < n_samples; i++) {
+        bnum_t block_addr = rand() % device->block_count;
+        if (!test_erase_block(device, block_addr)) {
+            return false;
+        }
+    }
+    return true;
+}
+
 static uint8_t get_signature(uint32_t word)
 {
     uint8_t* sigptr = (uint8_t*)(&word);
     return sigptr[0] ^ sigptr[1] ^ sigptr[2] ^ sigptr[3];
 }
 
 // returns the number of blocks where the write was not successful.
 static ssize_t write_test(bdev_t *device)
 {
     uint8_t *test_buffer = memalign(DMA_ALIGNMENT, device->block_size);
@@ skipping 34 matching lines @@
         printf("not continuing to test writes.\n");
         return -1;
     }
 
     num_errors = write_test(device);
     printf("Discovered %ld error(s) while testing write.\n", num_errors);
     if (num_errors) {
         return -1;
     }
 
+    printf ("Testing sub-erase...\n");
+    bool success = sub_erase_test(device, SUB_ERASE_TEST_SAMPLES);
+    if (!success) {
+        printf("Discovered errors while testing sub-erase.\n");
+        return -1;
+    } else {
+        printf("No errors while testing sub-erase.\n");
+    }
+
     return 0;
 }