HAL renaming & relocation (#215)

Implemented more consistent naming:
- Moved all HAL devices into their own namespace (and related folder)
- Post-fixed all HAL device names with "Device"

TactilityHeadless/Include/Tactility/hal/sdcard/SdCardDevice.h

@@ -0,0 +1,67 @@
+#pragma once
+
+#include "../Device.h"
+
+#include <Tactility/TactilityCore.h>
+
+namespace tt::hal::sdcard {
+
+class SdCardDevice : public Device {
+
+public:
+
+    enum class State {
+        Mounted,
+        Unmounted,
+        Error,
+        Unknown
+    };
+
+    enum class MountBehaviour {
+        AtBoot, /** Only mount at boot */
+        Anytime /** Mount/dismount any time */
+    };
+
+private:
+
+    MountBehaviour mountBehaviour;
+
+public:
+
+    explicit SdCardDevice(MountBehaviour mountBehaviour) : mountBehaviour(mountBehaviour) {}
+    virtual ~SdCardDevice() override = default;
+
+    Type getType() const final { return Type::SdCard; };
+
+    virtual bool mount(const std::string& mountPath) = 0;
+    virtual bool unmount() = 0;
+    virtual State getState() const = 0;
+    /** Return empty string when not mounted or the mount path if mounted */
+    virtual std::string getMountPath() const = 0;
+
+    virtual std::shared_ptr<Lockable> getLockable() const = 0;
+
+    virtual MountBehaviour getMountBehaviour() const { return mountBehaviour; }
+    bool isMounted() const { return getState() == State::Mounted; }
+};
+
+/** Return the SdCard device if the path is within the SdCard mounted path (path std::string::starts_with() check)*/
+std::shared_ptr<SdCardDevice> _Nullable find(const std::string& path);
+
+/**
+ * Acquires an SD card lock if the path is an SD card path.
+ * Always calls the function, but doesn't lock if the path is not an SD card path.
+ */
+template<typename ReturnType>
+inline ReturnType withSdCardLock(const std::string& path, std::function<ReturnType()> fn) {
+    auto sdcard = find(path);
+    std::unique_ptr<ScopedLockableUsage> scoped_lockable;
+    if (sdcard != nullptr) {
+        scoped_lockable = sdcard->getLockable()->scoped();
+        scoped_lockable->lock(portMAX_DELAY);
+    }
+
+    return fn();
+}
+
+} // namespace tt::hal

TactilityHeadless/Include/Tactility/hal/sdcard/SpiSdCardDevice.h

@@ -0,0 +1,92 @@
+#ifdef ESP_PLATFORM
+
+#pragma once
+
+#include "SdCardDevice.h"
+
+#include <sd_protocol_types.h>
+#include <utility>
+#include <vector>
+#include <hal/spi_types.h>
+#include <soc/gpio_num.h>
+
+namespace tt::hal::sdcard {
+
+/**
+ * SD card interface at the default SPI interface
+ */
+class SpiSdCardDevice final : public SdCardDevice {
+
+public:
+
+    struct Config {
+        Config(
+            gpio_num_t spiPinCs,
+            gpio_num_t spiPinCd,
+            gpio_num_t spiPinWp,
+            gpio_num_t spiPinInt,
+            MountBehaviour mountBehaviourAtBoot,
+            std::shared_ptr<Lockable> lockable = std::make_shared<Mutex>(),
+            std::vector<gpio_num_t> csPinWorkAround = std::vector<gpio_num_t>(),
+            spi_host_device_t spiHost = SPI2_HOST,
+            int spiFrequencyKhz = SDMMC_FREQ_DEFAULT
+        ) : spiFrequencyKhz(spiFrequencyKhz),
+            spiPinCs(spiPinCs),
+            spiPinCd(spiPinCd),
+            spiPinWp(spiPinWp),
+            spiPinInt(spiPinInt),
+            mountBehaviourAtBoot(mountBehaviourAtBoot),
+            lockable(std::move(lockable)),
+            csPinWorkAround(std::move(csPinWorkAround)),
+            spiHost(spiHost)
+        {
+            assert(this->lockable != nullptr);
+        }
+
+        int spiFrequencyKhz;
+        gpio_num_t spiPinCs; // Clock
+        gpio_num_t spiPinCd; // Card detect
+        gpio_num_t spiPinWp; // Write-protect
+        gpio_num_t spiPinInt; // Interrupt
+        SdCardDevice::MountBehaviour mountBehaviourAtBoot;
+        std::shared_ptr<Lockable> _Nullable lockable;
+        std::vector<gpio_num_t> csPinWorkAround;
+        spi_host_device_t spiHost;
+        bool formatOnMountFailed = false;
+        uint16_t maxOpenFiles = 4;
+        uint16_t allocUnitSize = 16 * 1024;
+        bool statusCheckEnabled = false;
+    };
+
+private:
+
+    std::string mountPath;
+    sdmmc_card_t* card = nullptr;
+    std::shared_ptr<Config> config;
+
+    bool applyGpioWorkAround();
+    bool mountInternal(const std::string& mountPath);
+
+public:
+
+    explicit SpiSdCardDevice(std::unique_ptr<Config> config) : SdCardDevice(config->mountBehaviourAtBoot),
+        config(std::move(config))
+    {}
+
+    std::string getName() const final { return "SD Card"; }
+    std::string getDescription() const final { return "SD card via SPI interface"; }
+
+    bool mount(const std::string& mountPath) final;
+    bool unmount() final;
+    std::string getMountPath() const final { return mountPath; }
+
+    std::shared_ptr<Lockable> getLockable() const final { return config->lockable; }
+
+    State getState() const override;
+
+    sdmmc_card_t* _Nullable getCard() { return card; }
+};
+
+}
+
+#endif