SPI-Master, SDCard Updates

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,46 +17,34 @@ 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;
+    static constexpr const char* log_tag = "SDCard";
 
-        auto mount_result = esp_vfs_fat_sdmmc_mount((*mount_point).c_str(), &host, slot_config, &mount_config, &card);
-
-        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;
     }
 
@@ -66,8 +54,13 @@ namespace smooth::core::filesystem
 
         if (is_initialized())
         {
-            res = esp_vfs_fat_sdmmc_unmount();
+            res = esp_vfs_fat_sdcard_unmount(SDCardMount::instance().mount_point().str().data(), card);
             initialized = false;
+
+            if (res != ESP_OK)
+            {
+                Log::error(log_tag, "SDCard unmount failed");
+            }
         }
 
         return res == ESP_OK;

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,22 @@ 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);
+    }
+
+    bool SPISDCard::deinit()
+    {
+        auto res = SDCard::deinit();
+        Master::deinitialize(spi_host);
+
+        return res;
     }
 }

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

@@ -22,64 +22,126 @@ using namespace smooth::core::logging;
 namespace smooth::core::io::spi
 {
     static constexpr const char* log_tag = "SPIMaster";
+    static constexpr const char* vspi_host_str = "VSPI_HOST";
+    static constexpr const char* hspi_host_str = "HSPI_HOST";
 
-    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::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;
+    uint8_t Master::hspi_initialized_count = 0;
+    uint8_t Master::vspi_initialized_count = 0;
+
+    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();
-    }
+        bool initialized = false;
 
-    bool Master::initialize()
-    {
-        std::lock_guard<std::mutex> lock(guard);
-        do_initialization();
+        if (spi_host == VSPI_HOST)
+        {
+            initialized = do_intitialization(VSPI_HOST, vspi_initialized, vspi_initialized_count, vspi_host_str);
+        }
+
+        if (spi_host == HSPI_HOST)
+        {
+            initialized = do_intitialization(HSPI_HOST, hspi_initialized, hspi_initialized_count, hspi_host_str);
+        }
 
         return initialized;
     }
 
-    void Master::do_initialization()
+    bool Master::do_intitialization(spi_host_device_t host,
+                                    bool& initialized,
+                                    uint8_t& initialized_count,
+                                    const char* spi_host_str)
     {
         if (!initialized)
         {
             initialized = spi_bus_initialize(host, &bus_config, dma_channel) == ESP_OK;
 
             if (!initialized)
             {
-                Log::error(log_tag, "Initialization failed");
+                Log::error(log_tag, "{} Initialization has failed", spi_host_str);
             }
             else
             {
-                Log::verbose(log_tag, "SPI initialized, Host {}, DMA {}", host, dma_channel);
+                Log::info(log_tag, "{} has been initialized using DMA channel {}", spi_host_str, dma_channel);
             }
         }
+
+        // if initialized then increment initialized_count so we know how many spi-devices are on this spi-bus
+        if (initialized)
+        {
+            initialized_count++;
+        }
+
+        Log::verbose(log_tag, "{} has an initialized_count = {}", spi_host_str, initialized_count);
+
+        return initialized;
+    }
+
+    void Master::deinitialize(spi_host_device_t spi_host)
+    {
+        std::lock_guard<std::mutex> lock(guard);
+
+        if (spi_host == VSPI_HOST)
+        {
+            do_deinitialize(VSPI_HOST, vspi_initialized, vspi_initialized_count, vspi_host_str);
+        }
+
+        if (spi_host == HSPI_HOST)
+        {
+            do_deinitialize(HSPI_HOST, hspi_initialized, hspi_initialized_count, hspi_host_str);
+        }
     }
 
-    void Master::deinitialize()
+    void Master::do_deinitialize(spi_host_device_t host,
+                                 bool& initialized,
+                                 uint8_t& initialized_count,
+                                 const char* spi_host_str)
     {
         if (initialized)
         {
-            initialized = false;
-            spi_bus_free(host);
+            initialized_count--;
+
+            Log::verbose(log_tag, "{} has an initialized_count = {}", spi_host_str, initialized_count);
+
+            // check to see if this is the last spi device on this spi-bus, if true free this spi-bus
+            if (initialized_count == 0)
+            {
+                initialized = false;
+                auto res = spi_bus_free(host);
+
+                if (res == ESP_OK)
+                {
+                    Log::info(log_tag, "{} has successfully been freed", spi_host_str);
+                }
+                else
+                {
+                    Log::error(log_tag, "spi_bus_free for {} has failed", spi_host_str);
+                }
+            }
         }
     }
 }

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: