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 "SpiBus.h"
#include "SpiBusConfig.h" #include "SpiBusConfig.h"
#include "SpiCallback.h" #include "SpiCallback.h"
SpiBus::SpiBus(const std::string &_id, spi_host_device_t _host_device) : SpiBus::SpiBus(const std::string& _id, spi_host_device_t _host_device)
id(_id), : id(_id)
host_device(_host_device), , host_device(_host_device)
cur_config(nullptr) , cur_config(nullptr)
{ {
spi_bus_config_t bus_config { spi_bus_config_t bus_config {
.mosi_io_num = -1, .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)); 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)); 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)) if (!SpiCallback::patch(shared_from_this(), bus_config, device_config))
return nullptr; 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) // TODO: add remove_device (with spi_device_acquire_bus)
void SpiBus::apply_config(SpiBusConfig *config) { void SpiBus::apply_config(SpiBusConfig* config)
{
if (cur_config) if (cur_config)
cur_config->unpatch(host_device); cur_config->unpatch(host_device);
cur_config = config; cur_config = config;

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

@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once #pragma once
#include <driver/spi_master.h> #include <driver/spi_master.h>
#include <memory> #include <memory>
#include <string> #include <string>
@ -14,23 +14,27 @@ public:
SpiBus& operator=(const SpiBus&) = delete; SpiBus& operator=(const SpiBus&) = delete;
~SpiBus(); ~SpiBus();
inline __attribute__((always_inline)) void require_config(SpiBusConfig *config) { inline __attribute__((always_inline)) void require_config(SpiBusConfig* config)
{
if (config == cur_config) if (config == cur_config)
return; return;
apply_config(config); 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) if (config != cur_config)
return; return;
apply_config(nullptr); apply_config(nullptr);
} }
inline const std::string &get_id() const { inline const std::string& get_id() const
{
return id; return id;
} }
inline spi_host_device_t get_host_device() const { inline spi_host_device_t get_host_device() const
{
return host_device; return host_device;
} }

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

@ -1,13 +1,14 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#include "SpiBusConfig.h" #include "SpiBusConfig.h"
#include <driver/gpio.h> #include <driver/gpio.h>
#include <esp_rom_gpio.h> #include <esp_rom_gpio.h>
#include <soc/spi_periph.h> #include <soc/spi_periph.h>
SpiBusConfig::SpiBusConfig(gpio_num_t _pin_mosi, gpio_num_t _pin_miso, gpio_num_t _pin_sclk) : SpiBusConfig::SpiBusConfig(gpio_num_t _pin_mosi, gpio_num_t _pin_miso, gpio_num_t _pin_sclk)
pin_mosi(_pin_mosi), : pin_mosi(_pin_mosi)
pin_miso(_pin_miso), , pin_miso(_pin_miso)
pin_sclk(_pin_sclk) , pin_sclk(_pin_sclk)
{ {
if (pin_mosi != GPIO_NUM_NC) { if (pin_mosi != GPIO_NUM_NC) {
ESP_ERROR_CHECK(gpio_reset_pin(pin_mosi)); 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) if (pin_mosi != GPIO_NUM_NC)
ESP_ERROR_CHECK(gpio_reset_pin(pin_mosi)); ESP_ERROR_CHECK(gpio_reset_pin(pin_mosi));
@ -36,7 +38,8 @@ SpiBusConfig::~SpiBusConfig() {
ESP_ERROR_CHECK(gpio_reset_pin(pin_sclk)); 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) { 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_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); 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) { if (pin_mosi != GPIO_NUM_NC) {
esp_rom_gpio_connect_out_signal(pin_mosi, SIG_GPIO_OUT_IDX, false, false); 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); esp_rom_gpio_connect_in_signal(GPIO_MATRIX_CONST_ONE_INPUT, spi_periph_signal[host_device].spid_in, false);

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

@ -1,3 +1,4 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once #pragma once
#include <hal/gpio_types.h> #include <hal/gpio_types.h>

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

@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#include "SpiCallback.h" #include "SpiCallback.h"
#include "SpiBus.h" #include "SpiBus.h"
#include <array> #include <array>
#include <optional> #include <optional>
@ -17,20 +17,23 @@ namespace SpiCallback {
std::array<std::optional<CallbackData>, SPI_MANAGER_CALLBACK_COUNT> instances; std::array<std::optional<CallbackData>, SPI_MANAGER_CALLBACK_COUNT> instances;
template <int N> template <int N>
void IRAM_ATTR fn_pre_cb(spi_transaction_t *trans) { void IRAM_ATTR fn_pre_cb(spi_transaction_t* trans)
{
instances[N]->bus->require_config(instances[N]->config.get()); instances[N]->bus->require_config(instances[N]->config.get());
if (instances[N]->inner_pre_cb) if (instances[N]->inner_pre_cb)
instances[N]->inner_pre_cb(trans); instances[N]->inner_pre_cb(trans);
} }
template <int N> template <int N>
void IRAM_ATTR fn_post_cb(spi_transaction_t *trans) { void IRAM_ATTR fn_post_cb(spi_transaction_t* trans)
{
if (instances[N]->inner_post_cb) if (instances[N]->inner_post_cb)
instances[N]->inner_post_cb(trans); instances[N]->inner_post_cb(trans);
} }
template <int N> template <int N>
inline __attribute__((always_inline)) bool alloc(CallbackData *&instance, transaction_cb_t &pre_cb, transaction_cb_t &post_cb) { inline __attribute__((always_inline)) bool alloc(CallbackData*& instance, transaction_cb_t& pre_cb, transaction_cb_t& post_cb)
{
if constexpr (N > 0) { if constexpr (N > 0) {
if (alloc<N - 1>(instance, pre_cb, post_cb)) if (alloc<N - 1>(instance, pre_cb, post_cb))
return true; return true;
@ -46,7 +49,8 @@ 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)
{
CallbackData* instance; CallbackData* instance;
transaction_cb_t pre_cb; transaction_cb_t pre_cb;
transaction_cb_t post_cb; transaction_cb_t post_cb;

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

@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once #pragma once
#include <driver/spi_master.h> #include <driver/spi_master.h>
#include <memory> #include <memory>
// Pre and post callbacks for 2 buses with 3 devices each // Pre and post callbacks for 2 buses with 3 devices each

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

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

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

@ -1,3 +1,4 @@
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once #pragma once
#include "SpiBus.h" #include "SpiBus.h"