master.hpp

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2026 Chris Leishman
 
#pragma once
 
#include <idfxx/cpu>
#include <idfxx/error>
#include <idfxx/flags>
#include <idfxx/gpio>
#include <idfxx/intr_alloc>
 
#include <driver/spi_master.h>
#include <optional>
#include <string>
 
namespace idfxx::spi {
 
enum class host_device : int {
    spi1 = SPI1_HOST, 
    spi2 = SPI2_HOST, 
#if SOC_SPI_PERIPH_NUM > 2
    spi3 = SPI3_HOST, 
#endif
};
 
enum class dma_chan : int {
    disabled = SPI_DMA_DISABLED, 
#if CONFIG_IDF_TARGET_ESP32
    ch_1 = SPI_DMA_CH1, 
    ch_2 = SPI_DMA_CH2, 
#endif
    ch_auto = SPI_DMA_CH_AUTO, 
};
 
enum class bus_flags : uint32_t {
    slave = SPICOMMON_BUSFLAG_SLAVE,           
    master = SPICOMMON_BUSFLAG_MASTER,         
    iomux_pins = SPICOMMON_BUSFLAG_IOMUX_PINS, 
    sclk = SPICOMMON_BUSFLAG_SCLK,             
    miso = SPICOMMON_BUSFLAG_MISO,             
    mosi = SPICOMMON_BUSFLAG_MOSI,             
    dual =
        SPICOMMON_BUSFLAG_DUAL, 
    wphd = SPICOMMON_BUSFLAG_WPHD, 
    quad = SPICOMMON_BUSFLAG_QUAD, 
    io4_io7 = SPICOMMON_BUSFLAG_IO4_IO7, 
    octal = SPICOMMON_BUSFLAG_OCTAL, 
    native_pins = SPICOMMON_BUSFLAG_NATIVE_PINS,   
    slp_allow_pd = SPICOMMON_BUSFLAG_SLP_ALLOW_PD, 
};
 
} // namespace idfxx::spi
 
template<>
inline constexpr bool idfxx::enable_flags_operators<idfxx::spi::bus_flags> = true;
 
namespace idfxx::spi {
 
struct bus_config {
    union {
        idfxx::gpio mosi_io_num = gpio::nc(); 
        idfxx::gpio data0_io_num;             
    };
    union {
        idfxx::gpio miso_io_num = gpio::nc(); 
        idfxx::gpio data1_io_num;             
    };
    idfxx::gpio sclk_io_num = gpio::nc(); 
    union {
        idfxx::gpio quadwp_io_num = gpio::nc(); 
        idfxx::gpio data2_io_num; 
    };
    union {
        idfxx::gpio quadhd_io_num = gpio::nc(); 
        idfxx::gpio data3_io_num; 
    };
    idfxx::gpio data4_io_num = gpio::nc(); 
    idfxx::gpio data5_io_num = gpio::nc(); 
    idfxx::gpio data6_io_num = gpio::nc(); 
    idfxx::gpio data7_io_num = gpio::nc(); 
 
    bool data_io_default_level = false; 
    int max_transfer_sz = 0; 
 
    idfxx::flags<bus_flags> flags = {}; 
 
    std::optional<idfxx::core_id> isr_cpu_id = std::nullopt; 
 
    idfxx::intr_levels intr_levels = {};            
    idfxx::flags<idfxx::intr_flag> intr_flags = {}; 
};
 
class master_bus {
public:
#ifdef CONFIG_COMPILER_CXX_EXCEPTIONS
    [[nodiscard]] explicit master_bus(enum host_device host, enum dma_chan dma_chan, struct bus_config config);
#endif
 
    [[nodiscard]] static result<master_bus>
    make(enum host_device host, enum dma_chan dma_chan, struct bus_config config);
 
    ~master_bus();
 
    master_bus(const master_bus&) = delete;
    master_bus& operator=(const master_bus&) = delete;
 
    master_bus(master_bus&& other) noexcept;
 
    master_bus& operator=(master_bus&& other) noexcept;
 
    [[nodiscard]] enum host_device host() const { return _host; }
 
private:
    explicit master_bus(enum host_device host);
 
    enum host_device _host;
    bool _initialized = true;
};
 
 
} // namespace idfxx::spi
 
namespace idfxx {
 
[[nodiscard]] inline std::string to_string(spi::host_device h) {
    switch (h) {
    case spi::host_device::spi1:
        return "SPI1";
    case spi::host_device::spi2:
        return "SPI2";
#if SOC_SPI_PERIPH_NUM > 2
    case spi::host_device::spi3:
        return "SPI3";
#endif
    default:
        return "unknown(" + std::to_string(static_cast<int>(h)) + ")";
    }
}
 
} // namespace idfxx
 
#include "sdkconfig.h"
#ifdef CONFIG_IDFXX_STD_FORMAT
#include <algorithm>
#include <format>
namespace std {
template<>
struct formatter<idfxx::spi::host_device> {
    constexpr auto parse(format_parse_context& ctx) { return ctx.begin(); }
 
    template<typename FormatContext>
    auto format(idfxx::spi::host_device h, FormatContext& ctx) const {
        auto s = idfxx::to_string(h);
        return std::copy(s.begin(), s.end(), ctx.out());
    }
};
} // namespace std
#endif // CONFIG_IDFXX_STD_FORMAT