SPI-Master, SDCard Updates

CMakeLists.txt

@@ -22,7 +22,7 @@ set(CMAKE_CXX_STANDARD 17)
 
 
 # Select the test project to build
-set(selected_test_project starter_example)
+set(selected_test_project access_point)
 
 # For Linux builds, you may enable address sanitizer
 set(SMOOTH_ENABLE_ASAN 0)

lib/smooth/core/filesystem/MMCSDCard.cpp

@@ -16,6 +16,7 @@ limitations under the License.
 */
 
 #include "smooth/core/filesystem/MMCSDCard.h"
+#include "smooth/core/filesystem/FSLock.h"
 
 namespace smooth::core::filesystem
 {
@@ -40,10 +41,14 @@ namespace smooth::core::filesystem
 
     bool MMCSDCard::init(const SDCardMount& mount_point, bool format_on_mount_failure, int max_file_count)
     {
-        host = (sdmmc_host_t)SDMMC_HOST_DEFAULT();
+        sdmmc_host = (sdmmc_host_t)SDMMC_HOST_DEFAULT();
 
         // host.max_freq_khz = SDMMC_FREQ_HIGHSPEED()
 
+        esp_vfs_fat_sdmmc_mount_config_t mount_config{};
+        mount_config.format_if_mount_failed = format_on_mount_failure;
+        mount_config.max_files = max_file_count;
+
         sdmmc_slot_config_t slot_config = SDMMC_SLOT_CONFIG_DEFAULT();
 
         if (card_detect != -1)
@@ -67,6 +72,14 @@ namespace smooth::core::filesystem
         gpio_set_pull_mode(data2, GPIO_PULLUP_ONLY);   // D2, needed in 4-line mode only
         gpio_set_pull_mode(data3, GPIO_PULLUP_ONLY);   // D3, needed in 4- and 1-line modes
 
-        return do_common_initialization(mount_point, max_file_count, format_on_mount_failure, &slot_config);
+        auto mount_result = esp_vfs_fat_sdmmc_mount((*mount_point).c_str(),
+        &sdmmc_host,
+        &slot_config,
+        &mount_config,
+        &card);
+
+        FSLock::set_limit(max_file_count);
+
+        return do_common_error_checking(mount_result);
     }
 }

lib/smooth/core/filesystem/SDCard.cpp

@@ -17,56 +17,47 @@ limitations under the License.
 
 #include "smooth/core/logging/log.h"
 #include "smooth/core/filesystem/SDCard.h"
-#include "smooth/core/filesystem/FSLock.h"
 
 using namespace smooth::core::logging;
 
 namespace smooth::core::filesystem
 {
-    bool SDCard::do_common_initialization(const MountPoint& mount_point,
-                                          int max_file_count,
-                                          bool format_on_mount_failure,
-                                          void* slot_config)
-    {
-        esp_vfs_fat_sdmmc_mount_config_t mount_config{};
-        mount_config.format_if_mount_failed = format_on_mount_failure;
-        mount_config.max_files = max_file_count;
-
-        //mount_config.allocation_unit_size = 16 * 1024;
-
-        auto mount_result = esp_vfs_fat_sdmmc_mount((*mount_point).c_str(), &host, slot_config, &mount_config, &card);
+    static constexpr const char* log_tag = "SDCard";
 
-        initialized = mount_result == ESP_OK;
+    bool SDCard::do_common_error_checking(esp_err_t result)
+    {
+        initialized = result == ESP_OK;
 
         if (initialized)
         {
-            Log::info("SPISDCard", "SD Card initialized");
+            Log::info(log_tag, "Storage Card initialized");
             sdmmc_card_print_info(stdout, card);
         }
         else
         {
-            if (mount_result == ESP_FAIL)
+            if (result == ESP_FAIL)
             {
-                Log::error("SPISDCard", "Failed to mount the file system.");
+                Log::error(log_tag, "Failed to mount the file system.");
             }
             else
             {
-                Log::error("SPISDCard", "Failed to initialize SD Card.");
+                Log::error(log_tag, "Failed to initialize storage card.");
             }
         }
 
-        FSLock::set_limit(max_file_count);
-
         return initialized;
     }
 
+    // Note: If the SDCard is the only spi-device using spi-host-bus-master then the class calling this
+    // function should also call Master::deinitialize(spi_host_device_t spi_host) to deinitialize the
+    // spi-bus
     bool SDCard::deinit()
     {
         auto res = ESP_OK;
 
         if (is_initialized())
         {
-            res = esp_vfs_fat_sdmmc_unmount();
+            res = esp_vfs_fat_sdcard_unmount(SDCardMount::instance().mount_point().str().data(), card);
             initialized = false;
         }
 

lib/smooth/core/filesystem/SPISDCard.cpp

@@ -15,37 +15,52 @@ See the License for the specific language governing permissions and
 limitations under the License.
 */
 
-#include "smooth/core/filesystem/SDCard.h"
 #include "smooth/core/filesystem/SPISDCard.h"
+#include "smooth/core/filesystem/FSLock.h"
 
-#include <driver/sdspi_host.h>
+using namespace smooth::core::io::spi;
 
 namespace smooth::core::filesystem
 {
-    SPISDCard::SPISDCard(gpio_num_t miso,
+    SPISDCard::SPISDCard(spi_host_device_t spi_host,
+                         SPI_DMA_Channel dma_channel,
+                         gpio_num_t miso,
                          gpio_num_t mosi,
                          gpio_num_t serial_clock,
                          gpio_num_t chip_select,
                          gpio_num_t card_detect,
-                         gpio_num_t write_protect)
-            : miso(miso),
+                         gpio_num_t write_protect,
+                         int transfer_size)
+            : spi_host(spi_host),
+              dma_chl(dma_channel),
+              miso(miso),
               mosi(mosi),
               serial_clock(serial_clock),
               chip_select(chip_select),
               card_detect(card_detect),
-              write_protect(write_protect)
+              write_protect(write_protect),
+              transfer_size(transfer_size)
     {
     }
 
     bool SPISDCard::init(const SDCardMount& mount_point, bool format_on_mount_failure, int max_file_count)
     {
-        host = (sdmmc_host_t)SDSPI_HOST_DEFAULT();
-        sdspi_slot_config_t slot_config = SDSPI_SLOT_CONFIG_DEFAULT();
+        Master::initialize(spi_host,
+                           dma_chl,
+                           mosi,
+                           miso,
+                           serial_clock);
 
-        slot_config.gpio_miso = miso;
-        slot_config.gpio_mosi = mosi;
-        slot_config.gpio_sck = serial_clock;
+        esp_vfs_fat_sdmmc_mount_config_t mount_config{};
+        mount_config.format_if_mount_failed = format_on_mount_failure;
+        mount_config.max_files = max_file_count;
+
+        sdmmc_host = (sdmmc_host_t)SDSPI_HOST_DEFAULT();
+        sdmmc_host.slot = spi_host;
+
+        sdspi_device_config_t slot_config = SDSPI_DEVICE_CONFIG_DEFAULT();
         slot_config.gpio_cs = chip_select;
+        slot_config.host_id = static_cast<spi_host_device_t>(sdmmc_host.slot);
 
         if (card_detect != -1)
         {
@@ -57,6 +72,14 @@ namespace smooth::core::filesystem
             slot_config.gpio_wp = write_protect;
         }
 
-        return do_common_initialization(mount_point, max_file_count, format_on_mount_failure, &slot_config);
+        auto mount_result = esp_vfs_fat_sdspi_mount((*mount_point).c_str(),
+                                                     &sdmmc_host,
+                                                     &slot_config,
+                                                     &mount_config,
+                                                     &card);
+
+        FSLock::set_limit(max_file_count);
+
+        return do_common_error_checking(mount_result);
     }
 }

lib/smooth/core/io/spi/Master.cpp

@@ -23,63 +23,101 @@ namespace smooth::core::io::spi
 {
     static constexpr const char* log_tag = "SPIMaster";
 
-    Master::Master(
-        spi_host_device_t host,
-        SPI_DMA_Channel dma_channel,
-        gpio_num_t mosi,
-        gpio_num_t miso,
-        gpio_num_t clock,
-        int transfer_size,
-        gpio_num_t quadwp_io_num,
-        gpio_num_t quadhd_io_num
-        )
-            : host(host),
-              dma_channel(dma_channel)
+    // Declare static variables
+    bool Master::spi_bus_initialized = false;
+    bool Master::hspi_initialized = false;
+    bool Master::vspi_initialized = false;
+    std::mutex Master::guard{};
+    spi_bus_config_t Master::bus_config{};
+    spi_host_device_t Master::spi_host;
+    SPI_DMA_Channel Master::dma_channel;
+
+    bool Master::initialize(spi_host_device_t host,
+                            SPI_DMA_Channel dma_chl,
+                            gpio_num_t mosi,
+                            gpio_num_t miso,
+                            gpio_num_t clock,
+                            int transfer_size,
+                            gpio_num_t quadwp_io_num,
+                            gpio_num_t quadhd_io_num)
     {
+        std::lock_guard<std::mutex> lock(guard);
+
+        spi_host = host;
+        dma_channel = dma_chl;
+
         bus_config.mosi_io_num = mosi;
         bus_config.miso_io_num = miso;
         bus_config.sclk_io_num = clock;
         bus_config.quadwp_io_num = quadwp_io_num;
         bus_config.quadhd_io_num = quadhd_io_num;
         bus_config.max_transfer_sz = transfer_size;
-    }
 
-    Master::~Master()
-    {
-        deinitialize();
+        spi_bus_initialized = false;
+
+        if (spi_host == VSPI_HOST)
+        {
+            spi_bus_initialized = do_vspi_initialization();
+        }
+
+        if (spi_host == HSPI_HOST)
+        {
+            spi_bus_initialized = do_hspi_initialization();
+        }
+
+        return spi_bus_initialized;
     }
 
-    bool Master::initialize()
+    bool Master::do_vspi_initialization()
     {
-        std::lock_guard<std::mutex> lock(guard);
-        do_initialization();
+        if (!vspi_initialized)
+        {
+            vspi_initialized = spi_bus_initialize(spi_host, &bus_config, dma_channel) == ESP_OK;
 
-        return initialized;
+            if (!vspi_initialized)
+            {
+                Log::error(log_tag, "VSPI_HOST Initialization failed");
+            }
+            else
+            {
+                Log::info(log_tag, "VSPI initialized, Host {}, DMA {}", spi_host, dma_channel);
+            }
+        }
+
+        return vspi_initialized;
     }
 
-    void Master::do_initialization()
+    bool Master::do_hspi_initialization()
     {
-        if (!initialized)
+        if (!hspi_initialized)
         {
-            initialized = spi_bus_initialize(host, &bus_config, dma_channel) == ESP_OK;
+            hspi_initialized = spi_bus_initialize(spi_host, &bus_config, dma_channel) == ESP_OK;
 
-            if (!initialized)
+            if (!hspi_initialized)
             {
-                Log::error(log_tag, "Initialization failed");
+                Log::error(log_tag, "HSPI_HOST Initialization failed");
             }
             else
             {
-                Log::verbose(log_tag, "SPI initialized, Host {}, DMA {}", host, dma_channel);
+                Log::info(log_tag, "HSPI initialized, Host {}, DMA {}", spi_host, dma_channel);
             }
         }
+
+        return hspi_initialized;
     }
 
-    void Master::deinitialize()
+    void Master::deinitialize(spi_host_device_t spi_host)
     {
-        if (initialized)
+        if ((spi_host == VSPI_HOST) & (vspi_initialized))
+        {
+            vspi_initialized = false;
+            spi_bus_free(VSPI_HOST);
+        }
+
+        if ((spi_host == HSPI_HOST) & (hspi_initialized))
         {
-            initialized = false;
-            spi_bus_free(host);
+            hspi_initialized = false;
+            spi_bus_free(HSPI_HOST);
         }
     }
 }

lib/smooth/include/smooth/core/filesystem/SDCard.h

@@ -25,7 +25,7 @@ limitations under the License.
 #pragma GCC diagnostic ignored "-Wold-style-cast"
 #include <sdmmc_cmd.h>
 #include <esp_vfs_fat.h>
-#include <esp_vfs.h>
+#include <driver/sdspi_host.h>
 #pragma GCC diagnostic pop
 
 namespace smooth::core::filesystem
@@ -48,12 +48,9 @@ namespace smooth::core::filesystem
             virtual bool deinit();
 
         protected:
-            bool do_common_initialization(const MountPoint& mount_point,
-                                          int max_file_count,
-                                          bool format_on_mount_failure,
-                                          void* slot_config);
+            bool do_common_error_checking(esp_err_t result);
 
-            sdmmc_host_t host{};
+            sdmmc_host_t sdmmc_host{};
             sdmmc_card_t* card{};
             bool initialized{};
         private:

lib/smooth/include/smooth/core/filesystem/SPISDCard.h

@@ -17,32 +17,38 @@ limitations under the License.
 
 #pragma once
 
-#include "SDCard.h"
 #include <driver/gpio.h>
+#include "SDCard.h"
 #include "MountPoint.h"
+#include "smooth/core/io/spi/Master.h"
 
 namespace smooth::core::filesystem
 {
     class SPISDCard
         : public SDCard
     {
         public:
-            SPISDCard(gpio_num_t miso,
+            SPISDCard(spi_host_device_t spi_host,
+                      smooth::core::io::spi::SPI_DMA_Channel dma_channel,
+                      gpio_num_t miso,
                       gpio_num_t mosi,
                       gpio_num_t serial_clock,
                       gpio_num_t chip_select,
                       gpio_num_t card_detect = GPIO_NUM_NC,
-                      gpio_num_t write_protect = GPIO_NUM_NC);
+                      gpio_num_t write_protect = GPIO_NUM_NC,
+                      int transfer_size = 0);
 
             bool init(const SDCardMount& mount_point, bool format_on_mount_failure, int max_file_count) override;
 
         private:
+            spi_host_device_t spi_host;
+            smooth::core::io::spi::SPI_DMA_Channel dma_chl;
             gpio_num_t miso;
             gpio_num_t mosi;
             gpio_num_t serial_clock;
             gpio_num_t chip_select;
             gpio_num_t card_detect;
             gpio_num_t write_protect;
-            sdmmc_card_t* card;
+            int transfer_size;
     };
 }