StmSpi.h

Go to the documentation of this file.

 
#pragma once
 
#include "BaseSpi.h"
#include "StmTypes.h"
#include "PlatformMutex.h"
#include "SoftChipSelectGuard.h"
#include <vector>
#include <memory>
 
class StmSpiBus;
 
class StmSpiBusLock final {
public:
    StmSpiBusLock(StmSpiBus& bus, hf_u32_t timeout_ms) noexcept;
    ~StmSpiBusLock() noexcept;
 
    StmSpiBusLock(const StmSpiBusLock&) = delete;
    StmSpiBusLock& operator=(const StmSpiBusLock&) = delete;
    StmSpiBusLock(StmSpiBusLock&& other) noexcept;
    StmSpiBusLock& operator=(StmSpiBusLock&& other) noexcept;
 
    [[nodiscard]] bool OwnsLock() const noexcept { return locked_; }
 
private:
    StmSpiBus* bus_{nullptr};
    bool locked_{false};
};
 
class StmSpiDevice : public BaseSpi {
public:
    StmSpiDevice(StmSpiBus* parent, const hf_spi_device_config_t& config) noexcept;
    ~StmSpiDevice() noexcept override;
 
    bool Initialize() noexcept override;
    bool Deinitialize() noexcept override;
 
    hf_spi_err_t Transfer(const hf_u8_t* tx_data, hf_u8_t* rx_data,
                          hf_u16_t length, hf_u32_t timeout_ms = 0) noexcept override;
 
    hf_spi_err_t TransferChain(const hf_u8_t* const* tx_frames, hf_u8_t* const* rx_frames,
                               hf_u16_t frame_length, hf_u16_t frame_count,
                               hf_u32_t inter_frame_gap_us,
                               hf_u32_t timeout_ms = 0) noexcept override;
 
    const void* GetDeviceConfig() const noexcept override;
 
    void IdleChipSelect() noexcept override;
 
    void HoldChipSelectMs(hf_u32_t ms) noexcept override;
 
    bool SetTransferMode(hf_u8_t mode_0_to_3) noexcept override;
 
    bool SetIoSwap(bool enable) noexcept override;
 
    const hf_spi_device_config_t& GetConfig() const noexcept { return config_; }
 
private:
    friend class StmSpiBus;
 
    void AssertCS() noexcept;
 
    void DeassertCS() noexcept;
 
    hf_spi_err_t TransferLocked(const hf_u8_t* tx_data, hf_u8_t* rx_data,
                                hf_u16_t length, hf_u32_t effective_timeout,
                                bool park_mode3_after = true,
                                bool bus_already_armed = false) noexcept;
 
    hf_u32_t GetEffectiveTimeout(hf_u32_t requested_ms) const noexcept;
 
    static hf_spi_err_t ConvertHalStatus(hf_u32_t hal_status) noexcept;
 
    StmSpiBus*            parent_bus_;  
    hf_spi_device_config_t config_;     
    bool                  io_swap_{false}; 
};
 
class StmSpiBus {
public:
    explicit StmSpiBus(const hf_spi_bus_config_t& config) noexcept;
 
    explicit StmSpiBus(SPI_HandleTypeDef* hal_handle, hf_u32_t timeout_ms = 1000) noexcept;
 
    ~StmSpiBus() noexcept;
 
    bool Initialize() noexcept;
    bool IsInitialized() const noexcept;
    bool Deinitialize() noexcept;
 
    int CreateDevice(const hf_spi_device_config_t& device_config) noexcept;
    BaseSpi* GetDevice(int device_index) noexcept;
    const BaseSpi* GetDevice(int device_index) const noexcept;
    std::size_t GetDeviceCount() const noexcept;
    bool RemoveDevice(int device_index) noexcept;
    const hf_spi_bus_config_t& GetConfig() const noexcept;
 
    SPI_HandleTypeDef* GetHalHandle() const noexcept;
 
    bool ApplyDeviceMode(hf_stm32_spi_mode_t mode, bool io_swap = false,
                         hf_u8_t midi_cycles = 15,
                         hf_u32_t clock_speed_hz = 0,
                         bool* reconfigured = nullptr) noexcept;
 
    [[nodiscard]] hf_u32_t GetKernelClockHz() const noexcept;
 
    [[nodiscard]] hf_u32_t GetEffectiveClockHz() const noexcept;
 
    [[nodiscard]] static hf_u8_t ResolveBaudMbr(hf_u32_t kernel_hz,
                                                hf_u32_t requested_hz) noexcept;
 
    void IdleAllChipSelects() noexcept;
 
    hf_u8_t ProbeMisoLine(void* miso_port, hf_u8_t miso_pin_pos,
                          const BaseSpi* device) noexcept;
 
    static constexpr hf_u16_t kScratchBytes = 32;
    uint8_t* ScratchTx() noexcept { return scratch_tx_; }
    uint8_t* ScratchRx() noexcept { return scratch_rx_; }
 
    bool LockBus(hf_u32_t timeout_ms) noexcept;
    void UnlockBus() noexcept;
 
private:
    friend class StmSpiDevice;
    friend class StmSpiBusLock;
 
    hf_spi_bus_config_t config_;
    bool initialized_{false};
    bool mode_applied_{false};
    hf_stm32_spi_mode_t last_mode_{hf_stm32_spi_mode_t::MODE_0};
    bool last_io_swap_{false};
    hf_u8_t last_midi_cycles_{15};
    hf_u8_t last_baud_mbr_{0xFFU};
    mutable PlatformMutex bus_mutex_{};
    std::vector<std::unique_ptr<StmSpiDevice>> devices_;
    alignas(4) uint8_t scratch_tx_[kScratchBytes]{};
    alignas(4) uint8_t scratch_rx_[kScratchBytes]{};
};