mirror of
https://github.com/ByteWelder/Tactility.git
synced 2026-02-18 10:53:17 +00:00
124 lines
3.3 KiB
C++
124 lines
3.3 KiB
C++
// SPDX-License-Identifier: Apache-2.0
|
|
#include <tactility/device.h>
|
|
#include <tactility/drivers/esp32_spi.h>
|
|
#include <tactility/concurrent/recursive_mutex.h>
|
|
|
|
#include "tactility/drivers/gpio_descriptor.h"
|
|
#include <cstring>
|
|
#include <esp_log.h>
|
|
#include <new>
|
|
#include <soc/gpio_num.h>
|
|
|
|
#define TAG "esp32_spi"
|
|
|
|
#define GET_CONFIG(device) ((const struct Esp32SpiConfig*)device->config)
|
|
#define GET_DATA(device) ((struct Esp32SpiInternal*)device_get_driver_data(device))
|
|
|
|
extern "C" {
|
|
|
|
struct Esp32SpiInternal {
|
|
RecursiveMutex mutex = {};
|
|
bool initialized = false;
|
|
|
|
explicit Esp32SpiInternal() {
|
|
recursive_mutex_construct(&mutex);
|
|
}
|
|
|
|
~Esp32SpiInternal() {
|
|
recursive_mutex_destruct(&mutex);
|
|
}
|
|
};
|
|
|
|
static error_t lock(Device* device) {
|
|
auto* driver_data = GET_DATA(device);
|
|
recursive_mutex_lock(&driver_data->mutex);
|
|
return ERROR_NONE;
|
|
}
|
|
|
|
static error_t try_lock(Device* device, TickType_t timeout) {
|
|
auto* driver_data = GET_DATA(device);
|
|
if (recursive_mutex_try_lock(&driver_data->mutex, timeout)) {
|
|
return ERROR_NONE;
|
|
}
|
|
return ERROR_TIMEOUT;
|
|
}
|
|
|
|
static error_t unlock(Device* device) {
|
|
auto* driver_data = GET_DATA(device);
|
|
recursive_mutex_unlock(&driver_data->mutex);
|
|
return ERROR_NONE;
|
|
}
|
|
|
|
static error_t start(Device* device) {
|
|
ESP_LOGI(TAG, "start %s", device->name);
|
|
auto* data = new (std::nothrow) Esp32SpiInternal();
|
|
if (!data) return ERROR_OUT_OF_MEMORY;
|
|
|
|
device_set_driver_data(device, data);
|
|
|
|
auto* dts_config = GET_CONFIG(device);
|
|
|
|
spi_bus_config_t buscfg = {
|
|
.mosi_io_num = dts_config->pin_mosi,
|
|
.miso_io_num = dts_config->pin_miso,
|
|
.sclk_io_num = dts_config->pin_sclk,
|
|
.data2_io_num = dts_config->pin_wp,
|
|
.data3_io_num = dts_config->pin_hd,
|
|
.data4_io_num = GPIO_NUM_NC,
|
|
.data5_io_num = GPIO_NUM_NC,
|
|
.data6_io_num = GPIO_NUM_NC,
|
|
.data7_io_num = GPIO_NUM_NC,
|
|
.data_io_default_level = false,
|
|
.max_transfer_sz = dts_config->max_transfer_size,
|
|
.flags = 0,
|
|
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
|
|
.intr_flags = 0
|
|
};
|
|
|
|
esp_err_t ret = spi_bus_initialize(dts_config->host, &buscfg, SPI_DMA_CH_AUTO);
|
|
if (ret != ESP_OK) {
|
|
delete data;
|
|
device_set_driver_data(device, nullptr);
|
|
ESP_LOGE(TAG, "Failed to initialize SPI bus: %s", esp_err_to_name(ret));
|
|
return ERROR_RESOURCE;
|
|
}
|
|
|
|
data->initialized = true;
|
|
return ERROR_NONE;
|
|
}
|
|
|
|
static error_t stop(Device* device) {
|
|
ESP_LOGI(TAG, "stop %s", device->name);
|
|
auto* driver_data = GET_DATA(device);
|
|
auto* dts_config = GET_CONFIG(device);
|
|
|
|
if (driver_data->initialized) {
|
|
spi_bus_free(dts_config->host);
|
|
}
|
|
|
|
device_set_driver_data(device, nullptr);
|
|
delete driver_data;
|
|
return ERROR_NONE;
|
|
}
|
|
|
|
const static struct SpiControllerApi esp32_spi_api = {
|
|
.lock = lock,
|
|
.try_lock = try_lock,
|
|
.unlock = unlock
|
|
};
|
|
|
|
extern struct Module platform_module;
|
|
|
|
Driver esp32_spi_driver = {
|
|
.name = "esp32_spi",
|
|
.compatible = (const char*[]) { "espressif,esp32-spi", nullptr },
|
|
.start_device = start,
|
|
.stop_device = stop,
|
|
.api = (void*)&esp32_spi_api,
|
|
.device_type = &SPI_CONTROLLER_TYPE,
|
|
.owner = &platform_module,
|
|
.internal = nullptr
|
|
};
|
|
|
|
} // extern "C"
|