hal_flash; add function to hal_flash interface to query whether

a region is empty (erased or not).

Author: Marko Kiiskila

hw/hal/include/hal/hal_flash.h

@@ -40,6 +40,7 @@ int hal_flash_write(uint8_t flash_id, uint32_t address, const void *src,
   uint32_t num_bytes);
 int hal_flash_erase_sector(uint8_t flash_id, uint32_t sector_address);
 int hal_flash_erase(uint8_t flash_id, uint32_t address, uint32_t num_bytes);
+int hal_flash_isempty(uint8_t flash_id, uint32_t address, uint32_t num_bytes);
 uint8_t hal_flash_align(uint8_t flash_id);
 int hal_flash_init(void);
 

hw/hal/include/hal/hal_flash_int.h

@@ -40,6 +40,8 @@ struct hal_flash_funcs {
             uint32_t sector_address);
     int (*hff_sector_info)(const struct hal_flash *dev, int idx,
             uint32_t *address, uint32_t *size);
+    int (*hff_is_empty)(const struct hal_flash *dev, uint32_t address,
+            uint32_t num_bytes);
     int (*hff_init)(const struct hal_flash *dev);
 };
 
@@ -56,6 +58,11 @@ struct hal_flash {
  */
 uint32_t hal_flash_sector_size(const struct hal_flash *hf, int sec_idx);
 
+/*
+ * Use as hal_flash_funcs.hff_is_empty if flash is erased to zeroes.
+ */
+int hal_flash_is_zeroes(const struct hal_flash *, uint32_t, uint32_t);
+int hal_flash_is_ones(const struct hal_flash *, uint32_t, uint32_t);
 
 #ifdef __cplusplus
 }

hw/hal/src/hal_flash.c

@@ -6,7 +6,7 @@
  * to you under the Apache License, Version 2.0 (the
  * "License"); you may not use this file except in compliance
  * with the License.  You may obtain a copy of the License at
- * 
+ *
  *  http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing,
@@ -298,6 +298,66 @@ hal_flash_erase(uint8_t id, uint32_t address, uint32_t num_bytes)
     return 0;
 }
 
+static int
+hal_flash_is_setto(const struct hal_flash *hf, uint32_t address,
+                   uint32_t num_bytes, uint8_t val)
+{
+    uint8_t buf[32];
+    uint32_t blksz;
+    int i;
+
+    while (num_bytes) {
+        blksz = sizeof(buf);
+        if (blksz > num_bytes) {
+            blksz = num_bytes;
+        }
+        if (hf->hf_itf->hff_read(hf, address, buf, blksz)) {
+            return -1;
+        }
+        for (i = 0; i < blksz; i++) {
+            if (buf[i] != val) {
+                return 0;
+            }
+        }
+        num_bytes -= blksz;
+    }
+    return 1;
+}
+
+int
+hal_flash_is_ones(const struct hal_flash *hf, uint32_t address,
+                   uint32_t num_bytes)
+{
+    return hal_flash_is_setto(hf, address, num_bytes, 0xff);
+}
+
+int
+hal_flash_is_zeroes(const struct hal_flash *hf, uint32_t address,
+                   uint32_t num_bytes)
+{
+    return hal_flash_is_setto(hf, address, num_bytes, 0);
+}
+
+int
+hal_flash_isempty(uint8_t id, uint32_t address, uint32_t num_bytes)
+{
+    const struct hal_flash *hf;
+
+    hf = hal_bsp_flash_dev(id);
+    if (!hf) {
+        return -1;
+    }
+    if (hal_flash_check_addr(hf, address) ||
+      hal_flash_check_addr(hf, address + num_bytes)) {
+        return -1;
+    }
+    if (hf->hf_itf->hff_is_empty) {
+        return hf->hf_itf->hff_is_empty(hf, address, num_bytes);
+    } else {
+        return hal_flash_is_ones(hf, address, num_bytes);
+    }
+}
+
 int
 hal_flash_ioctl(uint8_t id, uint32_t cmd, void *args)
 {

sys/flash_map/include/flash_map/flash_map.h

@@ -76,8 +76,18 @@ int flash_area_read(const struct flash_area *, uint32_t off, void *dst,
 int flash_area_write(const struct flash_area *, uint32_t off, const void *src,
   uint32_t len);
 int flash_area_erase(const struct flash_area *, uint32_t off, uint32_t len);
+
+/*
+ * Whether the whole area is empty.
+ */
 int flash_area_is_empty(const struct flash_area *, bool *);
 
+/*
+ * Whether a region of flash_area is empty
+ */
+int flash_area_isempty_at(const struct flash_area *, uint32_t off,
+  uint32_t len);
+
 /*
  * Alignment restriction for flash writes.
  */

sys/flash_map/src/flash_map.c

@@ -182,32 +182,25 @@ flash_area_align(const struct flash_area *fa)
 int
 flash_area_is_empty(const struct flash_area *fa, bool *empty)
 {
-    uint32_t data[64 >> 2];
-    uint32_t data_off = 0;
-    int8_t bytes_to_read;
-    uint8_t i;
     int rc;
 
-    while (data_off < fa->fa_size) {
-        bytes_to_read = min(64, fa->fa_size - data_off);
-        rc = flash_area_read(fa, data_off, data, bytes_to_read);
-        if (rc) {
-            return rc;
-        }
-        for (i = 0; i < bytes_to_read >> 2; i++) {
-          if (data[i] != (uint32_t) -1) {
-            goto not_empty;
-          }
-        }
-        data_off += bytes_to_read;
+    rc = hal_flash_isempty(fa->fa_device_id, fa->fa_off, fa->fa_size);
+    if (rc < 0) {
+        return rc;
+    } else if (rc == 1) {
+        *empty = true;
+    } else {
+        *empty = false;
     }
-    *empty = true;
-    return 0;
-not_empty:
-    *empty = false;
     return 0;
 }
 
+int
+flash_area_isempty_at(const struct flash_area *fa, uint32_t off, uint32_t len)
+{
+    return hal_flash_isempty(fa->fa_device_id, fa->fa_off + off, len);
+}
+
 /**
  * Converts the specified image slot index to a flash area ID.  If the
  * specified value is not a valid image slot index (0 or 1), a crash is