patrick/OpenDTU-old
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Apply license headers and automatic code formatting to SpiManager

Browse Source
This commit is contained in:
Thomas Basler 2024-09-26 18:47:27 +02:00
parent 326525c961
commit 7746d01fc0
8 changed files with 115 additions and 90 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

19
lib/SpiManager/src/SpiBus.cpp
View File

@ -1,12 +1,12 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#include "SpiBus.h"
#include "SpiBusConfig.h"
#include "SpiCallback.h"
SpiBus::SpiBus(const std::string &_id, spi_host_device_t _host_device) :
id(_id),
host_device(_host_device),
cur_config(nullptr)
SpiBus::SpiBus(const std::string& _id, spi_host_device_t _host_device)
: id(_id)
, host_device(_host_device)
, cur_config(nullptr)
{
spi_bus_config_t bus_config {
.mosi_io_num = -1,
@ -25,11 +25,13 @@ SpiBus::SpiBus(const std::string &_id, spi_host_device_t _host_device) :
ESP_ERROR_CHECK(spi_bus_initialize(host_device, &bus_config, SPI_DMA_CH_AUTO));
}
SpiBus::~SpiBus() {
SpiBus::~SpiBus()
{
ESP_ERROR_CHECK(spi_bus_free(host_device));
}
spi_device_handle_t SpiBus::add_device(const std::shared_ptr<SpiBusConfig> &bus_config, spi_device_interface_config_t &device_config) {
spi_device_handle_t SpiBus::add_device(const std::shared_ptr<SpiBusConfig>& bus_config, spi_device_interface_config_t& device_config)
{
if (!SpiCallback::patch(shared_from_this(), bus_config, device_config))
return nullptr;
@ -40,7 +42,8 @@ spi_device_handle_t SpiBus::add_device(const std::shared_ptr<SpiBusConfig> &bus_
// TODO: add remove_device (with spi_device_acquire_bus)
void SpiBus::apply_config(SpiBusConfig *config) {
void SpiBus::apply_config(SpiBusConfig* config)
{
if (cur_config)
cur_config->unpatch(host_device);
cur_config = config;

24
lib/SpiManager/src/SpiBus.h
View File

@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <driver/spi_master.h>
#include <memory>
#include <string>
@ -9,37 +9,41 @@ class SpiBusConfig;
class SpiBus : public std::enable_shared_from_this<SpiBus> {
public:
explicit SpiBus(const std::string &id, spi_host_device_t host_device);
explicit SpiBus(const std::string& id, spi_host_device_t host_device);
SpiBus(const SpiBus&) = delete;
SpiBus &operator=(const SpiBus&) = delete;
SpiBus& operator=(const SpiBus&) = delete;
~SpiBus();
inline __attribute__((always_inline)) void require_config(SpiBusConfig *config) {
inline __attribute__((always_inline)) void require_config(SpiBusConfig* config)
{
if (config == cur_config)
return;
apply_config(config);
}
inline __attribute__((always_inline)) void free_config(SpiBusConfig *config) {
inline __attribute__((always_inline)) void free_config(SpiBusConfig* config)
{
if (config != cur_config)
return;
apply_config(nullptr);
}
inline const std::string &get_id() const {
inline const std::string& get_id() const
{
return id;
}
inline spi_host_device_t get_host_device() const {
inline spi_host_device_t get_host_device() const
{
return host_device;
}
spi_device_handle_t add_device(const std::shared_ptr<SpiBusConfig> &bus_config, spi_device_interface_config_t &device_config);
spi_device_handle_t add_device(const std::shared_ptr<SpiBusConfig>& bus_config, spi_device_interface_config_t& device_config);
private:
void apply_config(SpiBusConfig *config);
void apply_config(SpiBusConfig* config);
std::string id;
spi_host_device_t host_device;
SpiBusConfig *cur_config;
SpiBusConfig* cur_config;
};

18
lib/SpiManager/src/SpiBusConfig.cpp
View File

@ -1,13 +1,14 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#include "SpiBusConfig.h"
#include <driver/gpio.h>
#include <esp_rom_gpio.h>
#include <soc/spi_periph.h>
SpiBusConfig::SpiBusConfig(gpio_num_t _pin_mosi, gpio_num_t _pin_miso, gpio_num_t _pin_sclk) :
pin_mosi(_pin_mosi),
pin_miso(_pin_miso),
pin_sclk(_pin_sclk)
SpiBusConfig::SpiBusConfig(gpio_num_t _pin_mosi, gpio_num_t _pin_miso, gpio_num_t _pin_sclk)
: pin_mosi(_pin_mosi)
, pin_miso(_pin_miso)
, pin_sclk(_pin_sclk)
{
if (pin_mosi != GPIO_NUM_NC) {
ESP_ERROR_CHECK(gpio_reset_pin(pin_mosi));
@ -25,7 +26,8 @@ SpiBusConfig::SpiBusConfig(gpio_num_t _pin_mosi, gpio_num_t _pin_miso, gpio_num_
}
}
SpiBusConfig::~SpiBusConfig() {
SpiBusConfig::~SpiBusConfig()
{
if (pin_mosi != GPIO_NUM_NC)
ESP_ERROR_CHECK(gpio_reset_pin(pin_mosi));
@ -36,7 +38,8 @@ SpiBusConfig::~SpiBusConfig() {
ESP_ERROR_CHECK(gpio_reset_pin(pin_sclk));
}
void SpiBusConfig::patch(spi_host_device_t host_device) {
void SpiBusConfig::patch(spi_host_device_t host_device)
{
if (pin_mosi != GPIO_NUM_NC) {
esp_rom_gpio_connect_out_signal(pin_mosi, spi_periph_signal[host_device].spid_out, false, false);
esp_rom_gpio_connect_in_signal(pin_mosi, spi_periph_signal[host_device].spid_in, false);
@ -51,7 +54,8 @@ void SpiBusConfig::patch(spi_host_device_t host_device) {
}
}
void SpiBusConfig::unpatch(spi_host_device_t host_device) {
void SpiBusConfig::unpatch(spi_host_device_t host_device)
{
if (pin_mosi != GPIO_NUM_NC) {
esp_rom_gpio_connect_out_signal(pin_mosi, SIG_GPIO_OUT_IDX, false, false);
esp_rom_gpio_connect_in_signal(GPIO_MATRIX_CONST_ONE_INPUT, spi_periph_signal[host_device].spid_in, false);

3
lib/SpiManager/src/SpiBusConfig.h
View File

@ -1,3 +1,4 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <hal/gpio_types.h>
@ -7,7 +8,7 @@ class SpiBusConfig {
public:
explicit SpiBusConfig(gpio_num_t pin_mosi, gpio_num_t pin_miso, gpio_num_t pin_sclk);
SpiBusConfig(const SpiBusConfig&) = delete;
SpiBusConfig &operator=(const SpiBusConfig&) = delete;
SpiBusConfig& operator=(const SpiBusConfig&) = delete;
~SpiBusConfig();
void patch(spi_host_device_t host_device);

106
lib/SpiManager/src/SpiCallback.cpp
View File

@ -1,65 +1,69 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#include "SpiCallback.h"
#include "SpiBus.h"
#include <array>
#include <optional>
namespace SpiCallback {
namespace {
struct CallbackData {
std::shared_ptr<SpiBus> bus;
std::shared_ptr<SpiBusConfig> config;
transaction_cb_t inner_pre_cb;
transaction_cb_t inner_post_cb;
};
namespace {
struct CallbackData {
std::shared_ptr<SpiBus> bus;
std::shared_ptr<SpiBusConfig> config;
transaction_cb_t inner_pre_cb;
transaction_cb_t inner_post_cb;
};
std::array<std::optional<CallbackData>, SPI_MANAGER_CALLBACK_COUNT> instances;
std::array<std::optional<CallbackData>, SPI_MANAGER_CALLBACK_COUNT> instances;
template<int N>
void IRAM_ATTR fn_pre_cb(spi_transaction_t *trans) {
instances[N]->bus->require_config(instances[N]->config.get());
if (instances[N]->inner_pre_cb)
instances[N]->inner_pre_cb(trans);
}
template<int N>
void IRAM_ATTR fn_post_cb(spi_transaction_t *trans) {
if (instances[N]->inner_post_cb)
instances[N]->inner_post_cb(trans);
}
template<int N>
inline __attribute__((always_inline)) bool alloc(CallbackData *&instance, transaction_cb_t &pre_cb, transaction_cb_t &post_cb) {
if constexpr (N > 0) {
if (alloc<N - 1>(instance, pre_cb, post_cb))
return true;
if (!instances[N - 1]) {
instances[N - 1].emplace();
instance = &*instances[N - 1];
pre_cb = fn_pre_cb<N - 1>;
post_cb = fn_post_cb<N - 1>;
return true;
}
}
return false;
}
template <int N>
void IRAM_ATTR fn_pre_cb(spi_transaction_t* trans)
{
instances[N]->bus->require_config(instances[N]->config.get());
if (instances[N]->inner_pre_cb)
instances[N]->inner_pre_cb(trans);
}
bool patch(const std::shared_ptr<SpiBus> &bus, const std::shared_ptr<SpiBusConfig> &bus_config, spi_device_interface_config_t &device_config) {
CallbackData *instance;
transaction_cb_t pre_cb;
transaction_cb_t post_cb;
if (!alloc<SPI_MANAGER_CALLBACK_COUNT>(instance, pre_cb, post_cb))
return false;
template <int N>
void IRAM_ATTR fn_post_cb(spi_transaction_t* trans)
{
if (instances[N]->inner_post_cb)
instances[N]->inner_post_cb(trans);
}
instance->bus = bus;
instance->config = bus_config;
instance->inner_pre_cb = device_config.pre_cb;
instance->inner_post_cb = device_config.post_cb;
device_config.pre_cb = pre_cb;
device_config.post_cb = post_cb;
return true;
template <int N>
inline __attribute__((always_inline)) bool alloc(CallbackData*& instance, transaction_cb_t& pre_cb, transaction_cb_t& post_cb)
{
if constexpr (N > 0) {
if (alloc<N - 1>(instance, pre_cb, post_cb))
return true;
if (!instances[N - 1]) {
instances[N - 1].emplace();
instance = &*instances[N - 1];
pre_cb = fn_pre_cb<N - 1>;
post_cb = fn_post_cb<N - 1>;
return true;
}
}
return false;
}
}
bool patch(const std::shared_ptr<SpiBus>& bus, const std::shared_ptr<SpiBusConfig>& bus_config, spi_device_interface_config_t& device_config)
{
CallbackData* instance;
transaction_cb_t pre_cb;
transaction_cb_t post_cb;
if (!alloc<SPI_MANAGER_CALLBACK_COUNT>(instance, pre_cb, post_cb))
return false;
instance->bus = bus;
instance->config = bus_config;
instance->inner_pre_cb = device_config.pre_cb;
instance->inner_post_cb = device_config.post_cb;
device_config.pre_cb = pre_cb;
device_config.post_cb = post_cb;
return true;
}
}

4
lib/SpiManager/src/SpiCallback.h
View File

@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <driver/spi_master.h>
#include <memory>
// Pre and post callbacks for 2 buses with 3 devices each
@ -11,5 +11,5 @@ class SpiBus;
class SpiBusConfig;
namespace SpiCallback {
bool patch(const std::shared_ptr<SpiBus> &bus, const std::shared_ptr<SpiBusConfig> &bus_config, spi_device_interface_config_t &device_config);
bool patch(const std::shared_ptr<SpiBus>& bus, const std::shared_ptr<SpiBusConfig>& bus_config, spi_device_interface_config_t& device_config);
}

22
lib/SpiManager/src/SpiManager.cpp
View File

@ -1,15 +1,18 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#include "SpiManager.h"
#ifdef ARDUINO
#include <SPI.h>
#endif
SpiManager::SpiManager() {
SpiManager::SpiManager()
{
}
#ifdef ARDUINO
std::optional<uint8_t> SpiManager::to_arduino(spi_host_device_t host_device) {
std::optional<uint8_t> SpiManager::to_arduino(spi_host_device_t host_device)
{
switch (host_device) {
#if CONFIG_IDF_TARGET_ESP32
case SPI1_HOST:
@ -34,7 +37,8 @@ std::optional<uint8_t> SpiManager::to_arduino(spi_host_device_t host_device) {
#endif
bool SpiManager::register_bus(spi_host_device_t host_device) {
bool SpiManager::register_bus(spi_host_device_t host_device)
{
for (int i = 0; i < SPI_MANAGER_NUM_BUSES; ++i) {
if (available_buses[i])
continue;
@ -46,7 +50,8 @@ bool SpiManager::register_bus(spi_host_device_t host_device) {
return false;
}
bool SpiManager::claim_bus(spi_host_device_t &host_device) {
bool SpiManager::claim_bus(spi_host_device_t& host_device)
{
for (int i = SPI_MANAGER_NUM_BUSES - 1; i >= 0; --i) {
if (!available_buses[i])
continue;
@ -61,7 +66,8 @@ bool SpiManager::claim_bus(spi_host_device_t &host_device) {
#ifdef ARDUINO
std::optional<uint8_t> SpiManager::claim_bus_arduino() {
std::optional<uint8_t> SpiManager::claim_bus_arduino()
{
spi_host_device_t host_device;
if (!claim_bus(host_device))
return std::nullopt;
@ -70,7 +76,8 @@ std::optional<uint8_t> SpiManager::claim_bus_arduino() {
#endif
spi_device_handle_t SpiManager::alloc_device(const std::string &bus_id, const std::shared_ptr<SpiBusConfig> &bus_config, spi_device_interface_config_t &device_config) {
spi_device_handle_t SpiManager::alloc_device(const std::string& bus_id, const std::shared_ptr<SpiBusConfig>& bus_config, spi_device_interface_config_t& device_config)
{
std::shared_ptr<SpiBus> shared_bus = get_shared_bus(bus_id);
if (!shared_bus)
return nullptr;
@ -78,7 +85,8 @@ spi_device_handle_t SpiManager::alloc_device(const std::string &bus_id, const st
return shared_bus->add_device(bus_config, device_config);
}
std::shared_ptr<SpiBus> SpiManager::get_shared_bus(const std::string &bus_id) {
std::shared_ptr<SpiBus> SpiManager::get_shared_bus(const std::string& bus_id)
{
// look for existing shared bus
for (int i = 0; i < SPI_MANAGER_NUM_BUSES; ++i) {
if (!shared_buses[i])

9
lib/SpiManager/src/SpiManager.h
View File

@ -1,3 +1,4 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include "SpiBus.h"
@ -16,22 +17,22 @@ class SpiManager {
public:
explicit SpiManager();
SpiManager(const SpiManager&) = delete;
SpiManager &operator=(const SpiManager&) = delete;
SpiManager& operator=(const SpiManager&) = delete;
#ifdef ARDUINO
static std::optional<uint8_t> to_arduino(spi_host_device_t host_device);
#endif
bool register_bus(spi_host_device_t host_device);
bool claim_bus(spi_host_device_t &host_device);
bool claim_bus(spi_host_device_t& host_device);
#ifdef ARDUINO
std::optional<uint8_t> claim_bus_arduino();
#endif
spi_device_handle_t alloc_device(const std::string &bus_id, const std::shared_ptr<SpiBusConfig> &bus_config, spi_device_interface_config_t &device_config);
spi_device_handle_t alloc_device(const std::string& bus_id, const std::shared_ptr<SpiBusConfig>& bus_config, spi_device_interface_config_t& device_config);
private:
std::shared_ptr<SpiBus> get_shared_bus(const std::string &bus_id);
std::shared_ptr<SpiBus> get_shared_bus(const std::string& bus_id);
std::array<std::optional<spi_host_device_t>, SPI_MANAGER_NUM_BUSES> available_buses;
std::array<std::shared_ptr<SpiBus>, SPI_MANAGER_NUM_BUSES> shared_buses;