Merge branch 'bugfix/ext_flash_load_partitions' into 'master'

spi_flash: ensure partition table loaded when esp_partition_register_external is called

Closes IDFGH-1916

See merge request espressif/esp-idf!6244

components/spi_flash/partition.c

@@ -55,27 +55,38 @@ typedef struct esp_partition_iterator_opaque_ {
 
 static esp_partition_iterator_opaque_t* iterator_create(esp_partition_type_t type, esp_partition_subtype_t subtype, const char* label);
 static esp_err_t load_partitions(void);
+static esp_err_t ensure_partitions_loaded(void);
 
 
+static const char* TAG = "partition";
 static SLIST_HEAD(partition_list_head_, partition_list_item_) s_partition_list =
         SLIST_HEAD_INITIALIZER(s_partition_list);
 static _lock_t s_partition_list_lock;
 
 
-esp_partition_iterator_t esp_partition_find(esp_partition_type_t type,
-        esp_partition_subtype_t subtype, const char* label)
+static esp_err_t ensure_partitions_loaded(void)
 {
+    esp_err_t err = ESP_OK;
     if (SLIST_EMPTY(&s_partition_list)) {
         // only lock if list is empty (and check again after acquiring lock)
         _lock_acquire(&s_partition_list_lock);
-        esp_err_t err = ESP_OK;
         if (SLIST_EMPTY(&s_partition_list)) {
+            ESP_LOGD(TAG, "Loading the partition table");
             err = load_partitions();
+            if (err != ESP_OK) {
+                ESP_LOGE(TAG, "load_partitions returned 0x%x", err);
+            }
         }
         _lock_release(&s_partition_list_lock);
-        if (err != ESP_OK) {
-            return NULL;
     }
+    return err;
+}
+
+esp_partition_iterator_t esp_partition_find(esp_partition_type_t type,
+        esp_partition_subtype_t subtype, const char* label)
+{
+    if (ensure_partitions_loaded() != ESP_OK) {
+        return NULL;
     }
     // create an iterator pointing to the start of the list
     // (next item will be the first one)
@@ -233,6 +244,11 @@ esp_err_t esp_partition_register_external(esp_flash_t* flash_chip, size_t offset
         return ESP_ERR_INVALID_SIZE;
     }
 
+    esp_err_t err = ensure_partitions_loaded();
+    if (err != ESP_OK) {
+        return err;
+    }
+
     partition_list_item_t* item = (partition_list_item_t*) calloc(sizeof(partition_list_item_t), 1);
     if (item == NULL) {
         return ESP_ERR_NO_MEM;

examples/storage/ext_flash_fatfs/example_test.py

@@ -0,0 +1,27 @@
+from __future__ import print_function
+import os
+import sys
+
+try:
+    import IDF
+except ImportError:
+    test_fw_path = os.getenv('TEST_FW_PATH')
+    if test_fw_path and test_fw_path not in sys.path:
+        sys.path.insert(0, test_fw_path)
+    import IDF
+
+
+@IDF.idf_example_test(env_tag='Example_ExtFlash')
+def test_examples_storage_ext_flash_fatfs(env, extra_data):
+    dut = env.get_dut('ext_flash_fatfs', 'examples/storage/ext_flash_fatfs')
+    dut.start_app()
+
+    dut.expect('Initialized external Flash')
+    dut.expect('partition \'nvs\'')
+    dut.expect('partition \'storage\'')
+    dut.expect('File written')
+    dut.expect('Read from file: \'Written using ESP-IDF')
+
+
+if __name__ == '__main__':
+    test_examples_storage_ext_flash_fatfs()

examples/storage/ext_flash_fatfs/main/ext_flash_fatfs_example_main.c

@@ -30,6 +30,7 @@ const char *base_path = "/extflash";
 
 static esp_flash_t* example_init_ext_flash(void);
 static const esp_partition_t* example_add_partition(esp_flash_t* ext_flash, const char* partition_label);
+static void example_list_data_partitions(void);
 static bool example_mount_fatfs(const char* partition_label);
 static void example_get_fatfs_usage(size_t* out_total_bytes, size_t* out_free_bytes);
 
@@ -45,6 +46,9 @@ void app_main(void)
     const char *partition_label = "storage";
     example_add_partition(flash, partition_label);
 
+    // List the available partitions
+    example_list_data_partitions();
+
     // Initialize FAT FS in the partition
     if (!example_mount_fatfs(partition_label)) {
         return;
@@ -139,6 +143,20 @@ static const esp_partition_t* example_add_partition(esp_flash_t* ext_flash, cons
     return fat_partition;
 }
 
+static void example_list_data_partitions(void)
+{
+    ESP_LOGI(TAG, "Listing data partitions:");
+    esp_partition_iterator_t it = esp_partition_find(ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_ANY, NULL);
+
+    for (; it != NULL; it = esp_partition_next(it)) {
+        const esp_partition_t *part = esp_partition_get(it);
+        ESP_LOGI(TAG, "- partition '%s', subtype %d, offset 0x%x, size %d kB",
+        part->label, part->subtype, part->address, part->size / 1024);
+    }
+
+    esp_partition_iterator_release(it);
+}
+
 static bool example_mount_fatfs(const char* partition_label)
 {
     ESP_LOGI(TAG, "Mounting FAT filesystem");

tools/ci/config/target-test.yml

@@ -215,6 +215,12 @@ example_test_009:
   variables:
     SETUP_TOOLS: "1"
 
+example_test_010:
+  extends: .example_test_template
+  tags:
+    - ESP32
+    - Example_ExtFlash
+
 UT_001:
   extends: .unit_test_template
   parallel: 50