feat(spi_nand_flash): update test_app, host_tests and documentation for block device support

Author: RathiSonika

.build-test-rules.yml

@@ -76,20 +76,17 @@ esp_lcd_qemu_rgb/examples/lcd_qemu_rgb_panel:
 
 spi_nand_flash/examples/nand_flash:
   disable:
-    - if: IDF_VERSION_MAJOR < 5
-      reason: The spi_nand_flash component is compatible with IDF version v5.0 and above, due to a change in the f_mkfs API in versions above v5.0, which is not supported in older IDF versions.
+    - if: IDF_VERSION_MAJOR < 6
+      reason: The spi_nand_flash component uses the esp_blockdev interface, which is supported starting from IDF version v6.0. It is not available in older IDF versions.
 
 spi_nand_flash/test_app:
   disable:
-    - if: IDF_VERSION_MAJOR < 5
-      reason: The spi_nand_flash component is compatible with IDF version v5.0 and above, due to a change in the f_mkfs API in versions above v5.0, which is not supported in older IDF versions.
+    - if: IDF_VERSION_MAJOR < 6
+      reason: The spi_nand_flash component uses the esp_blockdev interface, which is supported starting from IDF version v6.0. It is not available in older IDF versions.
 
 spi_nand_flash/host_test:
   enable:
     - if: IDF_TARGET == "linux"
   disable:
-    - if: IDF_VERSION_MAJOR < 5
-      reason: The spi_nand_flash component is compatible with IDF version v5.0 and above, due to a change in the f_mkfs API in versions above v5.0, which is not supported in older IDF versions.
-  disable:
-    - if: IDF_VERSION_MAJOR == 5 and (IDF_VERSION_MINOR < 3)
-      reason: Fails to build on older versions of IDF
+    - if: IDF_VERSION_MAJOR < 6
+      reason: The spi_nand_flash component uses the esp_blockdev interface, which is supported starting from IDF version v6.0. It is not available in older IDF versions.

spi_nand_flash/host_test/README.md

@@ -34,21 +34,44 @@ nand_mmap_emul_config_t cfg = {
 
 ### Usage Example:
 
+#### Option 1: Direct Device API
 ```c
 // Initialize with custom settings
-nand_mmap_emul_config_t cfg = {
+nand_file_mmap_emul_config_t cfg = {
     .flash_file_name = "/tmp/my_nand.bin",
-    .flash_file_size = 1024 * 1024,  // 1MB
+    .flash_file_size = 50 * 1024 * 1024,  // 50MB
     .keep_dump = false
 };
-spi_nand_flash_config_t nand_flash_config = {.emul_conf = &cfg};
+spi_nand_flash_config_t nand_flash_config = {&cfg, 0, SPI_NAND_IO_MODE_SIO, 0};
 
-// Initialize nand_flash with NAND emulation parameter
+// Initialize NAND flash with emulation
 spi_nand_flash_device_t *handle;
-spi_nand_flash_init_device(&nand_flash_config, &handle)
+spi_nand_flash_init_device(&nand_flash_config, &handle);
+
+// Use direct NAND operations
+spi_nand_flash_read_sector(handle, buffer, sector_id);
+spi_nand_flash_write_sector(handle, buffer, sector_id);
+
+// Cleanup
+spi_nand_flash_deinit_device(handle);
+```
+
+#### Option 2: Block Device API
+```c
+// Initialize with block device interface
+nand_file_mmap_emul_config_t cfg = {"", 50 * 1024 * 1024, false};
+spi_nand_flash_config_t nand_flash_config = {&cfg, 0, SPI_NAND_IO_MODE_SIO, 0};
+
+spi_nand_flash_device_t *device_handle;
+esp_blockdev_handle_t nand_bdl;
+
+// Create Flash Block Device Layer
+nand_flash_get_blockdev(&nand_flash_config, &device_handle, &nand_bdl);
 
-// Use NAND operations...
+// Use block device operations
+nand_bdl->ops->read(nand_bdl, buffer, sector_size, offset, size);
+nand_bdl->ops->write(nand_bdl, buffer, offset, size);
 
 // Cleanup
-ESP_ERROR_CHECK(spi_nand_flash_deinit_device(handle));
+nand_bdl->ops->release(nand_bdl);
 ```

spi_nand_flash/host_test/main/test_nand_flash.cpp

@@ -10,11 +10,34 @@
 #include "spi_nand_flash.h"
 #include "nand_linux_mmap_emul.h"
 #include "nand_private/nand_impl_wrap.h"
+#include "esp_blockdev.h"
+#include "esp_nand_blockdev.h"
 
 #include <catch2/catch_test_macros.hpp>
 
 #define PATTERN_SEED    0x12345678
 
+static void fill_buffer(uint32_t seed, uint8_t *dst, size_t count)
+{
+    srand(seed);
+    for (size_t i = 0; i < count; ++i) {
+        uint32_t val = rand();
+        memcpy(dst + i * sizeof(uint32_t), &val, sizeof(val));
+    }
+}
+
+static void check_buffer(uint32_t seed, const uint8_t *src, size_t count)
+{
+    srand(seed);
+    for (size_t i = 0; i < count; ++i) {
+        uint32_t val;
+        memcpy(&val, src + i * sizeof(uint32_t), sizeof(val));
+        if (!(rand() == val)) {
+            printf("Val not equal\n");
+        }
+    }
+}
+
 TEST_CASE("verify mark_bad_block works", "[spi_nand_flash]")
 {
     nand_file_mmap_emul_config_t conf = {"", 50 * 1024 * 1024, true};
@@ -42,15 +65,6 @@ TEST_CASE("verify mark_bad_block works", "[spi_nand_flash]")
     spi_nand_flash_deinit_device(device_handle);
 }
 
-static void fill_buffer(uint32_t seed, uint8_t *dst, size_t count)
-{
-    srand(seed);
-    for (size_t i = 0; i < count; ++i) {
-        uint32_t val = rand();
-        memcpy(dst + i * sizeof(uint32_t), &val, sizeof(val));
-    }
-}
-
 TEST_CASE("verify nand_prog, nand_read, nand_copy, nand_is_free works", "[spi_nand_flash]")
 {
     nand_file_mmap_emul_config_t conf = {"", 50 * 1024 * 1024, false};
@@ -85,10 +99,83 @@ TEST_CASE("verify nand_prog, nand_read, nand_copy, nand_is_free works", "[spi_na
         REQUIRE(is_page_free == false);
 
         REQUIRE(nand_wrap_read(device_handle, test_page, 0, sector_size, temp_buf) == 0);
+        check_buffer(PATTERN_SEED, temp_buf, sector_size / sizeof(uint32_t));
+
         REQUIRE(nand_wrap_copy(device_handle, test_page, dst_page) == 0);
+
         REQUIRE(nand_wrap_read(device_handle, dst_page, 0, sector_size, temp_buf) == 0);
+        check_buffer(PATTERN_SEED, temp_buf, sector_size / sizeof(uint32_t));
     }
     free(pattern_buf);
     free(temp_buf);
     spi_nand_flash_deinit_device(device_handle);
 }
+
+TEST_CASE("verify mark_bad_block works with bdl interface", "[spi_nand_flash]")
+{
+    nand_file_mmap_emul_config_t conf = {"", 50 * 1024 * 1024, true};
+    spi_nand_flash_config_t nand_flash_config = {&conf, 0, SPI_NAND_IO_MODE_SIO, 0};
+    spi_nand_flash_device_t *device_handle;
+    esp_blockdev_handle_t nand_bdl;
+    REQUIRE(nand_flash_get_blockdev(&nand_flash_config, &device_handle, &nand_bdl) == 0);
+
+    uint32_t block_size = nand_bdl->geometry.erase_size;
+    uint32_t block_num = nand_bdl->geometry.disk_size / block_size;
+
+    uint32_t test_block = 15;
+    if (test_block < block_num) {
+        REQUIRE(nand_bdl->ops->erase(nand_bdl, test_block * block_size, block_size) == 0);
+        // Verify if test_block is not bad block
+        esp_blockdev_cmd_arg_is_bad_block_t bad_block_status = {test_block, false};
+        REQUIRE(nand_bdl->ops->ioctl(nand_bdl, ESP_BLOCKDEV_CMD_IS_BAD_BLOCK, &bad_block_status) == 0);
+        REQUIRE(bad_block_status.status == false);
+        // mark test_block as a bad block
+        uint32_t block = test_block;
+        REQUIRE(nand_bdl->ops->ioctl(nand_bdl, ESP_BLOCKDEV_CMD_MARK_BAD_BLOCK, &block) == 0);
+        // Verify if test_block is marked as bad block
+        REQUIRE(nand_bdl->ops->ioctl(nand_bdl, ESP_BLOCKDEV_CMD_IS_BAD_BLOCK, &bad_block_status) == 0);
+        REQUIRE(bad_block_status.status == true);
+    }
+
+    nand_bdl->ops->release(nand_bdl);
+}
+
+TEST_CASE("verify nand_prog, nand_read, nand_copy, nand_is_free works with bdl interface", "[spi_nand_flash]")
+{
+    nand_file_mmap_emul_config_t conf = {"", 50 * 1024 * 1024, false};
+    spi_nand_flash_config_t nand_flash_config = {&conf, 0, SPI_NAND_IO_MODE_SIO, 0};
+    spi_nand_flash_device_t *device_handle;
+    esp_blockdev_handle_t nand_bdl;
+    REQUIRE(nand_flash_get_blockdev(&nand_flash_config, &device_handle, &nand_bdl) == 0);
+
+    uint32_t block_size = nand_bdl->geometry.erase_size;
+    uint32_t sector_size = nand_bdl->geometry.write_size;
+    uint32_t sector_num = nand_bdl->geometry.disk_size / sector_size;
+
+    uint8_t *pattern_buf = (uint8_t *)malloc(sector_size);
+    REQUIRE(pattern_buf != NULL);
+    uint8_t *temp_buf = (uint8_t *)malloc(sector_size);
+    REQUIRE(temp_buf != NULL);
+
+    fill_buffer(PATTERN_SEED, pattern_buf, sector_size / sizeof(uint32_t));
+
+    uint32_t test_block = 20;
+    uint32_t test_page = test_block * (block_size / sector_size); //(block_num * pages_per_block)
+    if (test_page < sector_num) {
+        // Verify if test_page is free
+        esp_blockdev_cmd_arg_is_free_page_t page_free_status = {test_page, true};
+        REQUIRE(nand_bdl->ops->ioctl(nand_bdl, ESP_BLOCKDEV_CMD_IS_FREE_PAGE, &page_free_status) == 0);
+        REQUIRE(page_free_status.status == true);
+        // Write/program test_page
+        REQUIRE(nand_bdl->ops->write(nand_bdl, pattern_buf, test_page * sector_size, sector_size) == 0);
+        // Verify if test_page is used/programmed
+        REQUIRE(nand_bdl->ops->ioctl(nand_bdl, ESP_BLOCKDEV_CMD_IS_FREE_PAGE, &page_free_status) == 0);
+        REQUIRE(page_free_status.status == false);
+
+        REQUIRE(nand_bdl->ops->read(nand_bdl, temp_buf, sector_size, test_page * sector_size, sector_size) == 0);
+        check_buffer(PATTERN_SEED, temp_buf, sector_size / sizeof(uint32_t));
+    }
+    free(pattern_buf);
+    free(temp_buf);
+    nand_bdl->ops->release(nand_bdl);
+}

spi_nand_flash/host_test/sdkconfig.defaults

@@ -1,3 +1,4 @@
+CONFIG_IDF_TARGET="linux"
 CONFIG_COMPILER_CXX_EXCEPTIONS=y
 CONFIG_MMU_PAGE_SIZE=0X10000
 CONFIG_NAND_ENABLE_STATS=y