dominic/Tactility
1
0
Fork 0
mirror of https://github.com/ByteWelder/Tactility.git synced 2026-02-20 23:45:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

SPI device migration

Browse Source
This commit is contained in:
Ken Van Hoeylandt 2026-02-08 00:27:15 +01:00
parent 74127a5f6c
commit 933f8ad0b2
62 changed files with 369 additions and 713 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Devices/btt-panda-touch/bigtreetech,panda-touch.dts
View File

@ -14,7 +14,7 @@
gpio-count = <49>; gpio-count = <49>;
}; };
i2c_internal { i2c_internal: i2c0 {
compatible = "espressif,esp32-i2c"; compatible = "espressif,esp32-i2c";
port = <I2C_NUM_0>; port = <I2C_NUM_0>;
clock-frequency = <400000>; clock-frequency = <400000>;
@ -24,7 +24,7 @@
pin-scl-pullup; pin-scl-pullup;
}; };
i2c_external { i2c_external: i2c1 {
compatible = "espressif,esp32-i2c"; compatible = "espressif,esp32-i2c";
port = <I2C_NUM_1>; port = <I2C_NUM_1>;
clock-frequency = <400000>; clock-frequency = <400000>;

50
Devices/cyd-2432s024c/Source/Configuration.cpp
View File

@ -29,53 +29,5 @@ static tt::hal::DeviceVector createDevices() {
extern const tt::hal::Configuration hardwareConfiguration = { extern const tt::hal::Configuration hardwareConfiguration = {
.initBoot = initBoot, .initBoot = initBoot,
.createDevices = createDevices, .createDevices = createDevices
.spi {
tt::hal::spi::Configuration {
.device = SPI2_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_13,
.miso_io_num = GPIO_NUM_NC,
.sclk_io_num = GPIO_NUM_14,
.quadwp_io_num = GPIO_NUM_NC, // Quad SPI LCD driver is not yet supported
.quadhd_io_num = GPIO_NUM_NC, // Quad SPI LCD driver is not yet supported
.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 = LCD_SPI_TRANSFER_SIZE_LIMIT,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = tt::hal::spi::InitMode::ByTactility,
.isMutable = false,
.lock = tt::lvgl::getSyncLock() // esp_lvgl_port owns the lock for the display
},
tt::hal::spi::Configuration {
.device = SPI3_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_23,
.miso_io_num = GPIO_NUM_19,
.sclk_io_num = GPIO_NUM_18,
.quadwp_io_num = GPIO_NUM_NC, // Quad SPI LCD driver is not yet supported
.quadhd_io_num = GPIO_NUM_NC, // Quad SPI LCD driver is not yet supported
.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 = 8192,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = tt::hal::spi::InitMode::ByTactility,
.isMutable = false,
.lock = nullptr
},
}
}; };

9
Devices/cyd-2432s024c/Source/devices/SdCard.cpp
View File

@ -2,6 +2,7 @@
#define TAG "twodotfour_sdcard" #define TAG "twodotfour_sdcard"
#include <tactility/device.h>
#include <Tactility/hal/sdcard/SpiSdCardDevice.h> #include <Tactility/hal/sdcard/SpiSdCardDevice.h>
#include <Tactility/RecursiveMutex.h> #include <Tactility/RecursiveMutex.h>
@ -17,13 +18,17 @@ std::shared_ptr<SdCardDevice> createSdCard() {
GPIO_NUM_NC, GPIO_NUM_NC,
GPIO_NUM_NC, GPIO_NUM_NC,
SdCardDevice::MountBehaviour::AtBoot, SdCardDevice::MountBehaviour::AtBoot,
std::make_shared<tt::RecursiveMutex>(), nullptr,
std::vector<gpio_num_t>(), std::vector<gpio_num_t>(),
SDCARD_SPI_HOST SDCARD_SPI_HOST
); );
auto* spi_controller = device_find_by_name("spi1");
check(spi_controller, "spi1 not found");
return std::make_shared<SpiSdCardDevice>( return std::make_shared<SpiSdCardDevice>(
std::move(configuration) std::move(configuration),
spi_controller
); );
} }

23
Devices/cyd-2432s024c/cyd,2432s024c.dts
View File

@ -3,6 +3,7 @@
#include <tactility/bindings/root.h> #include <tactility/bindings/root.h>
#include <tactility/bindings/esp32_gpio.h> #include <tactility/bindings/esp32_gpio.h>
#include <tactility/bindings/esp32_i2c.h> #include <tactility/bindings/esp32_i2c.h>
#include <tactility/bindings/esp32_spi.h>
/ { / {
compatible = "root"; compatible = "root";
@ -20,4 +21,26 @@
pin-sda = <33>; pin-sda = <33>;
pin-scl = <32>; pin-scl = <32>;
}; };
display_spi: spi0 {
compatible = "espressif,esp32-spi";
host = <SPI2_HOST>;
pin-mosi = <13>;
pin-miso = <GPIO_PIN_NONE>;
pin-sclk = <14>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
sdcard_spi: spi1 {
compatible = "espressif,esp32-spi";
host = <SPI3_HOST>;
pin-mosi = <23>;
pin-miso = <19>;
pin-sclk = <18>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
}; };

52
Devices/cyd-2432s028r/Source/Configuration.cpp
View File

@ -31,55 +31,5 @@ static DeviceVector createDevices() {
extern const Configuration hardwareConfiguration = { extern const Configuration hardwareConfiguration = {
.initBoot = initBoot, .initBoot = initBoot,
.createDevices = createDevices, .createDevices = createDevices
.spi {
// Display
spi::Configuration {
.device = SPI2_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_13,
.miso_io_num = GPIO_NUM_12,
.sclk_io_num = GPIO_NUM_14,
.quadwp_io_num = GPIO_NUM_NC,
.quadhd_io_num = GPIO_NUM_NC,
.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 = LCD_SPI_TRANSFER_SIZE_LIMIT,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = spi::InitMode::ByTactility,
.isMutable = false,
.lock = tt::lvgl::getSyncLock()
},
// SDCard
spi::Configuration {
.device = SPI3_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_23,
.miso_io_num = GPIO_NUM_19,
.sclk_io_num = GPIO_NUM_18,
.quadwp_io_num = GPIO_NUM_NC,
.quadhd_io_num = GPIO_NUM_NC,
.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 = 0,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = spi::InitMode::ByTactility,
.isMutable = false,
.lock = tt::lvgl::getSyncLock() // esp_lvgl_port owns the lock for the display
},
}
}; };

7
Devices/cyd-2432s028r/Source/devices/SdCard.cpp
View File

@ -1,4 +1,6 @@
#include "SdCard.h" #include "SdCard.h"
#include <tactility/device.h>
#include <Tactility/hal/sdcard/SpiSdCardDevice.h> #include <Tactility/hal/sdcard/SpiSdCardDevice.h>
#include <Tactility/lvgl/LvglSync.h> #include <Tactility/lvgl/LvglSync.h>
#include <Tactility/RecursiveMutex.h> #include <Tactility/RecursiveMutex.h>
@ -17,6 +19,9 @@ std::shared_ptr<SdCardDevice> createSdCard() {
SPI3_HOST SPI3_HOST
); );
return std::make_shared<SpiSdCardDevice>(std::move(config)); auto* spi_controller = device_find_by_name("spi1");
check(spi_controller, "spi1 not found");
return std::make_shared<SpiSdCardDevice>(std::move(config), spi_controller);
} }

23
Devices/cyd-2432s028r/cyd,2432s028r.dts
View File

@ -3,6 +3,7 @@
#include <tactility/bindings/root.h> #include <tactility/bindings/root.h>
#include <tactility/bindings/esp32_gpio.h> #include <tactility/bindings/esp32_gpio.h>
#include <tactility/bindings/esp32_i2c.h> #include <tactility/bindings/esp32_i2c.h>
#include <tactility/bindings/esp32_spi.h>
#include <tactility/bindings/esp32_uart.h> #include <tactility/bindings/esp32_uart.h>
/ { / {
@ -22,6 +23,28 @@
pin-scl = <22>; pin-scl = <22>;
}; };
display_spi: spi0 {
compatible = "espressif,esp32-spi";
host = <SPI2_HOST>;
pin-mosi = <13>;
pin-miso = <12>;
pin-sclk = <14>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
sdcard_spi: spi1 {
compatible = "espressif,esp32-spi";
host = <SPI3_HOST>;
pin-mosi = <23>;
pin-miso = <19>;
pin-sclk = <18>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
uart1 { uart1 {
compatible = "espressif,esp32-uart"; compatible = "espressif,esp32-uart";
port = <UART_NUM_1>; port = <UART_NUM_1>;

52
Devices/cyd-2432s028rv3/Source/Configuration.cpp
View File

@ -31,55 +31,5 @@ static DeviceVector createDevices() {
extern const Configuration hardwareConfiguration = { extern const Configuration hardwareConfiguration = {
.initBoot = initBoot, .initBoot = initBoot,
.createDevices = createDevices, .createDevices = createDevices
.spi {
// Display
spi::Configuration {
.device = SPI2_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_13,
.miso_io_num = GPIO_NUM_12,
.sclk_io_num = GPIO_NUM_14,
.quadwp_io_num = GPIO_NUM_NC,
.quadhd_io_num = GPIO_NUM_NC,
.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 = LCD_SPI_TRANSFER_SIZE_LIMIT,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = spi::InitMode::ByTactility,
.isMutable = false,
.lock = tt::lvgl::getSyncLock()
},
// SDCard
spi::Configuration {
.device = SPI3_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_23,
.miso_io_num = GPIO_NUM_19,
.sclk_io_num = GPIO_NUM_18,
.quadwp_io_num = GPIO_NUM_NC,
.quadhd_io_num = GPIO_NUM_NC,
.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 = 0,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = spi::InitMode::ByTactility,
.isMutable = false,
.lock = tt::lvgl::getSyncLock() // esp_lvgl_port owns the lock for the display
},
}
}; };

7
Devices/cyd-2432s028rv3/Source/devices/SdCard.cpp
View File

@ -1,4 +1,6 @@
#include "SdCard.h" #include "SdCard.h"
#include <tactility/device.h>
#include <Tactility/hal/sdcard/SpiSdCardDevice.h> #include <Tactility/hal/sdcard/SpiSdCardDevice.h>
#include <Tactility/lvgl/LvglSync.h> #include <Tactility/lvgl/LvglSync.h>
#include <Tactility/RecursiveMutex.h> #include <Tactility/RecursiveMutex.h>
@ -17,6 +19,9 @@ std::shared_ptr<SdCardDevice> createSdCard() {
SPI3_HOST SPI3_HOST
); );
return std::make_shared<SpiSdCardDevice>(std::move(config)); auto* spi_controller = device_find_by_name("spi1");
check(spi_controller, "spi1 not found");
return std::make_shared<SpiSdCardDevice>(std::move(config), spi_controller);
} }

23
Devices/cyd-2432s028rv3/cyd,2432s028rv3.dts
View File

@ -4,6 +4,7 @@
#include <tactility/bindings/esp32_gpio.h> #include <tactility/bindings/esp32_gpio.h>
#include <tactility/bindings/esp32_i2c.h> #include <tactility/bindings/esp32_i2c.h>
#include <tactility/bindings/esp32_uart.h> #include <tactility/bindings/esp32_uart.h>
#include <tactility/bindings/esp32_spi.h>
/ { / {
compatible = "root"; compatible = "root";
@ -22,6 +23,28 @@
pin-scl = <22>; pin-scl = <22>;
}; };
display_spi: spi0 {
compatible = "espressif,esp32-spi";
host = <SPI2_HOST>;
pin-mosi = <13>;
pin-miso = <12>;
pin-sclk = <14>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
sdcard_spi: spi1 {
compatible = "espressif,esp32-spi";
host = <SPI3_HOST>;
pin-mosi = <23>;
pin-miso = <19>;
pin-sclk = <18>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
uart1 { uart1 {
compatible = "espressif,esp32-uart"; compatible = "espressif,esp32-uart";
port = <UART_NUM_1>; port = <UART_NUM_1>;

52
Devices/cyd-2432s032c/Source/Configuration.cpp
View File

@ -45,55 +45,5 @@ static tt::hal::DeviceVector createDevices() {
extern const tt::hal::Configuration hardwareConfiguration = { extern const tt::hal::Configuration hardwareConfiguration = {
.initBoot = initBoot, .initBoot = initBoot,
.createDevices = createDevices, .createDevices = createDevices
.spi {
// Display
tt::hal::spi::Configuration {
.device = SPI2_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_13,
.miso_io_num = GPIO_NUM_NC,
.sclk_io_num = GPIO_NUM_14,
.quadwp_io_num = GPIO_NUM_NC,
.quadhd_io_num = GPIO_NUM_NC,
.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 = LCD_SPI_TRANSFER_SIZE_LIMIT,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = tt::hal::spi::InitMode::ByTactility,
.isMutable = false,
.lock = tt::lvgl::getSyncLock() // esp_lvgl_port owns the lock for the display
},
// SD card
tt::hal::spi::Configuration {
.device = SPI3_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_23,
.miso_io_num = GPIO_NUM_19,
.sclk_io_num = GPIO_NUM_18,
.quadwp_io_num = GPIO_NUM_NC,
.quadhd_io_num = GPIO_NUM_NC,
.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 = 0,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = tt::hal::spi::InitMode::ByTactility,
.isMutable = false,
.lock = nullptr
},
}
}; };

7
Devices/cyd-2432s032c/Source/devices/SdCard.cpp
View File

@ -1,5 +1,6 @@
#include "SdCard.h" #include "SdCard.h"
#include <tactility/device.h>
#include <Tactility/hal/sdcard/SpiSdCardDevice.h> #include <Tactility/hal/sdcard/SpiSdCardDevice.h>
#include <Tactility/lvgl/LvglSync.h> #include <Tactility/lvgl/LvglSync.h>
#include <Tactility/RecursiveMutex.h> #include <Tactility/RecursiveMutex.h>
@ -21,8 +22,12 @@ std::shared_ptr<SdCardDevice> createSdCard() {
SDCARD_SPI_HOST SDCARD_SPI_HOST
); );
auto* spi_controller = device_find_by_name("spi1");
check(spi_controller, "spi1 not found");
return std::make_shared<SpiSdCardDevice>( return std::make_shared<SpiSdCardDevice>(
std::move(configuration) std::move(configuration),
spi_controller
); );
} }

23
Devices/cyd-2432s032c/cyd,2432s032c.dts
View File

@ -3,6 +3,7 @@
#include <tactility/bindings/root.h> #include <tactility/bindings/root.h>
#include <tactility/bindings/esp32_gpio.h> #include <tactility/bindings/esp32_gpio.h>
#include <tactility/bindings/esp32_i2c.h> #include <tactility/bindings/esp32_i2c.h>
#include <tactility/bindings/esp32_spi.h>
/ { / {
compatible = "root"; compatible = "root";
@ -20,4 +21,26 @@
pin-sda = <33>; pin-sda = <33>;
pin-scl = <32>; pin-scl = <32>;
}; };
display_spi: spi0 {
compatible = "espressif,esp32-spi";
host = <SPI2_HOST>;
pin-mosi = <13>;
pin-miso = <GPIO_PIN_NONE>;
pin-sclk = <14>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
sdcard_spi: spi1 {
compatible = "espressif,esp32-spi";
host = <SPI3_HOST>;
pin-mosi = <23>;
pin-miso = <19>;
pin-sclk = <18>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
}; };

28
Devices/cyd-4848s040c/Source/Configuration.cpp
View File

@ -22,31 +22,5 @@ static DeviceVector createDevices() {
extern const Configuration hardwareConfiguration = { extern const Configuration hardwareConfiguration = {
.initBoot = initBoot, .initBoot = initBoot,
.createDevices = createDevices, .createDevices = createDevices
.spi {
// SD Card & display init
spi::Configuration {
.device = SPI2_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_47,
.miso_io_num = GPIO_NUM_41,
.sclk_io_num = GPIO_NUM_48,
.quadwp_io_num = -1,
.quadhd_io_num = GPIO_NUM_42,
.data4_io_num = -1,
.data5_io_num = -1,
.data6_io_num = -1,
.data7_io_num = -1,
.data_io_default_level = false,
.max_transfer_sz = 1024 * 128,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = spi::InitMode::ByTactility,
.isMutable = false,
.lock = tt::lvgl::getSyncLock()
}
}
}; };

11
Devices/cyd-4848s040c/Source/devices/SdCard.cpp
View File

@ -1,5 +1,6 @@
#include "SdCard.h" #include "SdCard.h"
#include <tactility/device.h>
#include <Tactility/hal/sdcard/SpiSdCardDevice.h> #include <Tactility/hal/sdcard/SpiSdCardDevice.h>
#include <Tactility/lvgl/LvglSync.h> #include <Tactility/lvgl/LvglSync.h>
@ -16,10 +17,12 @@ std::shared_ptr<SdCardDevice> createSdCard() {
std::vector { GPIO_NUM_39 } std::vector { GPIO_NUM_39 }
); );
auto sdcard = std::make_shared<SpiSdCardDevice>( auto* spi_controller = device_find_by_name("spi0");
std::move(config) check(spi_controller, "spi0 not found");
);
return std::static_pointer_cast<SdCardDevice>(sdcard); return std::make_shared<SpiSdCardDevice>(
std::move(config),
spi_controller
);
} }

2
Devices/cyd-4848s040c/Source/devices/St7701Display.h
View File

@ -21,7 +21,7 @@ class St7701Display final : public EspLcdDisplay {
public: public:
St7701Display() : EspLcdDisplay(std::make_shared<tt::RecursiveMutex>()) {} St7701Display() : EspLcdDisplay() {}
std::string getName() const override { return "ST7701S"; } std::string getName() const override { return "ST7701S"; }

12
Devices/cyd-4848s040c/cyd,4848s040c.dts
View File

@ -3,6 +3,7 @@
#include <tactility/bindings/root.h> #include <tactility/bindings/root.h>
#include <tactility/bindings/esp32_gpio.h> #include <tactility/bindings/esp32_gpio.h>
#include <tactility/bindings/esp32_i2c.h> #include <tactility/bindings/esp32_i2c.h>
#include <tactility/bindings/esp32_spi.h>
/ { / {
compatible = "root"; compatible = "root";
@ -22,4 +23,15 @@
pin-sda-pullup; pin-sda-pullup;
pin-scl-pullup; pin-scl-pullup;
}; };
spi0 {
compatible = "espressif,esp32-spi";
host = <SPI2_HOST>;
pin-mosi = <47>;
pin-miso = <41>;
pin-sclk = <48>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <42>;
max-transfer-size = <0>;
};
}; };

28
Devices/cyd-8048s043c/Source/Configuration.cpp
View File

@ -21,31 +21,5 @@ static DeviceVector createDevices() {
extern const Configuration hardwareConfiguration = { extern const Configuration hardwareConfiguration = {
.initBoot = initBoot, .initBoot = initBoot,
.createDevices = createDevices, .createDevices = createDevices
.spi {
// SD Card
spi::Configuration {
.device = SPI2_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_11,
.miso_io_num = GPIO_NUM_13,
.sclk_io_num = GPIO_NUM_12,
.quadwp_io_num = GPIO_NUM_NC,
.quadhd_io_num = GPIO_NUM_NC,
.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 = 8192,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = spi::InitMode::ByTactility,
.isMutable = false,
.lock = nullptr
}
}
}; };

11
Devices/cyd-8048s043c/Source/devices/SdCard.cpp
View File

@ -1,5 +1,6 @@
#include "SdCard.h" #include "SdCard.h"
#include <tactility/device.h>
#include <Tactility/hal/sdcard/SpiSdCardDevice.h> #include <Tactility/hal/sdcard/SpiSdCardDevice.h>
#include <Tactility/lvgl/LvglSync.h> #include <Tactility/lvgl/LvglSync.h>
@ -14,9 +15,11 @@ std::shared_ptr<SdCardDevice> createSdCard() {
SdCardDevice::MountBehaviour::AtBoot SdCardDevice::MountBehaviour::AtBoot
); );
auto sdcard = std::make_shared<SpiSdCardDevice>( auto* spi_controller = device_find_by_name("spi0");
std::move(config) check(spi_controller, "spi0 not found");
);
return std::static_pointer_cast<SdCardDevice>(sdcard); return std::make_shared<SpiSdCardDevice>(
std::move(config),
spi_controller
);
} }

12
Devices/cyd-8048s043c/cyd,8048s043c.dts
View File

@ -4,6 +4,7 @@
#include <tactility/bindings/esp32_gpio.h> #include <tactility/bindings/esp32_gpio.h>
#include <tactility/bindings/esp32_i2c.h> #include <tactility/bindings/esp32_i2c.h>
#include <tactility/bindings/esp32_uart.h> #include <tactility/bindings/esp32_uart.h>
#include <tactility/bindings/esp32_spi.h>
/ { / {
compatible = "root"; compatible = "root";
@ -32,6 +33,17 @@
pin-scl = <18>; pin-scl = <18>;
}; };
spi0 {
compatible = "espressif,esp32-spi";
host = <SPI2_HOST>;
pin-mosi = <11>;
pin-miso = <13>;
pin-sclk = <12>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
uart1 { uart1 {
compatible = "espressif,esp32-uart"; compatible = "espressif,esp32-uart";
port = <UART_NUM_1>; port = <UART_NUM_1>;

52
Devices/cyd-e32r28t/Source/Configuration.cpp
View File

@ -1,6 +1,5 @@
#include "devices/SdCard.h" #include "devices/SdCard.h"
#include "devices/Display.h" #include "devices/Display.h"
#include <driver/gpio.h>
#include <Tactility/hal/Configuration.h> #include <Tactility/hal/Configuration.h>
#include <Tactility/lvgl/LvglSync.h> #include <Tactility/lvgl/LvglSync.h>
@ -19,54 +18,5 @@ static tt::hal::DeviceVector createDevices() {
extern const tt::hal::Configuration hardwareConfiguration = { extern const tt::hal::Configuration hardwareConfiguration = {
.initBoot = initBoot, .initBoot = initBoot,
.createDevices = createDevices, .createDevices = createDevices
.spi = {
tt::hal::spi::Configuration {
.device = SPI2_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_13,
.miso_io_num = GPIO_NUM_12,
.sclk_io_num = GPIO_NUM_14,
.quadwp_io_num = GPIO_NUM_NC,
.quadhd_io_num = GPIO_NUM_NC,
.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 = LCD_SPI_TRANSFER_SIZE_LIMIT,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = tt::hal::spi::InitMode::ByTactility,
.isMutable = false,
.lock = tt::lvgl::getSyncLock()
},
tt::hal::spi::Configuration {
.device = SPI3_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_23,
.miso_io_num = GPIO_NUM_19,
.sclk_io_num = GPIO_NUM_18,
.quadwp_io_num = GPIO_NUM_NC,
.quadhd_io_num = GPIO_NUM_NC,
.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 = 0,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = tt::hal::spi::InitMode::ByTactility,
.isMutable = false,
.lock = tt::lvgl::getSyncLock()
},
}
}; };

10
Devices/cyd-e32r28t/Source/devices/SdCard.cpp
View File

@ -1,4 +1,6 @@
#include "SdCard.h" #include "SdCard.h"
#include <tactility/device.h>
#include <Tactility/hal/sdcard/SpiSdCardDevice.h> #include <Tactility/hal/sdcard/SpiSdCardDevice.h>
#include <Tactility/RecursiveMutex.h> #include <Tactility/RecursiveMutex.h>
@ -11,12 +13,16 @@ std::shared_ptr<SdCardDevice> createSdCard() {
GPIO_NUM_NC, GPIO_NUM_NC,
GPIO_NUM_NC, GPIO_NUM_NC,
SdCardDevice::MountBehaviour::AtBoot, SdCardDevice::MountBehaviour::AtBoot,
std::make_shared<tt::RecursiveMutex>(), nullptr,
std::vector<gpio_num_t>(), std::vector<gpio_num_t>(),
SPI3_HOST SPI3_HOST
); );
auto* spi_controller = device_find_by_name("spi1");
check(spi_controller, "spi1 not found");
return std::make_shared<SpiSdCardDevice>( return std::make_shared<SpiSdCardDevice>(
std::move(configuration) std::move(configuration),
spi_controller
); );
} }

23
Devices/cyd-e32r28t/cyd,e32r28t.dts
View File

@ -2,6 +2,7 @@
#include <tactility/bindings/root.h> #include <tactility/bindings/root.h>
#include <tactility/bindings/esp32_gpio.h> #include <tactility/bindings/esp32_gpio.h>
#include <tactility/bindings/esp32_spi.h>
/ { / {
compatible = "root"; compatible = "root";
@ -11,4 +12,26 @@
compatible = "espressif,esp32-gpio"; compatible = "espressif,esp32-gpio";
gpio-count = <40>; gpio-count = <40>;
}; };
display_spi: spi0 {
compatible = "espressif,esp32-spi";
host = <SPI2_HOST>;
pin-mosi = <13>;
pin-miso = <12>;
pin-sclk = <14>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
sdcard_spi: spi1 {
compatible = "espressif,esp32-spi";
host = <SPI3_HOST>;
pin-mosi = <23>;
pin-miso = <19>;
pin-sclk = <18>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
}; };

53
Devices/cyd-e32r32p/Source/Configuration.cpp
View File

@ -23,56 +23,5 @@ static tt::hal::DeviceVector createDevices() {
extern const Configuration hardwareConfiguration = { extern const Configuration hardwareConfiguration = {
.initBoot = initBoot, .initBoot = initBoot,
.createDevices = createDevices, .createDevices = createDevices
// Display
.spi = {
tt::hal::spi::Configuration {
.device = SPI2_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_13,
.miso_io_num = GPIO_NUM_12,
.sclk_io_num = GPIO_NUM_14,
.quadwp_io_num = GPIO_NUM_NC,
.quadhd_io_num = GPIO_NUM_NC,
.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 = DISPLAY_SPI_TRANSFER_SIZE_LIMIT,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = tt::hal::spi::InitMode::ByTactility,
.isMutable = false,
.lock = tt::lvgl::getSyncLock()
},
// SD Card
tt::hal::spi::Configuration {
.device = SPI3_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_23,
.miso_io_num = GPIO_NUM_19,
.sclk_io_num = GPIO_NUM_18,
.quadwp_io_num = GPIO_NUM_NC,
.quadhd_io_num = GPIO_NUM_NC,
.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 = 8192,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = tt::hal::spi::InitMode::ByTactility,
.isMutable = false,
.lock = nullptr
},
}
}; };

8
Devices/cyd-e32r32p/Source/devices/SdCard.cpp
View File

@ -1,4 +1,6 @@
#include "SdCard.h" #include "SdCard.h"
#include <tactility/device.h>
#include <Tactility/hal/sdcard/SpiSdCardDevice.h> #include <Tactility/hal/sdcard/SpiSdCardDevice.h>
#include <Tactility/RecursiveMutex.h> #include <Tactility/RecursiveMutex.h>
@ -17,7 +19,11 @@ std::shared_ptr<SdCardDevice> createSdCard() {
SD_SPI_HOST // SPI host for SD card (SPI3_HOST) SD_SPI_HOST // SPI host for SD card (SPI3_HOST)
); );
auto* spi_controller = device_find_by_name("spi1");
check(spi_controller, "spi1 not found");
return std::make_shared<SpiSdCardDevice>( return std::make_shared<SpiSdCardDevice>(
std::move(configuration) std::move(configuration),
spi_controller
); );
} }

23
Devices/cyd-e32r32p/cyd,e32r32p.dts
View File

@ -3,6 +3,7 @@
#include <tactility/bindings/root.h> #include <tactility/bindings/root.h>
#include <tactility/bindings/esp32_gpio.h> #include <tactility/bindings/esp32_gpio.h>
#include <tactility/bindings/esp32_i2c.h> #include <tactility/bindings/esp32_i2c.h>
#include <tactility/bindings/esp32_spi.h>
/ { / {
compatible = "root"; compatible = "root";
@ -20,4 +21,26 @@
pin-sda = <32>; pin-sda = <32>;
pin-scl = <25>; pin-scl = <25>;
}; };
display_spi: spi0 {
compatible = "espressif,esp32-spi";
host = <SPI2_HOST>;
pin-mosi = <13>;
pin-miso = <12>;
pin-sclk = <14>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
sdcard_spi: spi1 {
compatible = "espressif,esp32-spi";
host = <SPI3_HOST>;
pin-mosi = <23>;
pin-miso = <19>;
pin-sclk = <18>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
}; };

5
Devices/guition-jc3248w535c/Source/Axs15231b/Axs15231bDisplay.h
View File

@ -1,11 +1,10 @@
#pragma once #pragma once
#include <Tactility/hal/spi/Spi.h>
#include <Tactility/hal/display/DisplayDevice.h> #include <Tactility/hal/display/DisplayDevice.h>
#include <Tactility/hal/display/DisplayDriver.h> #include <Tactility/hal/display/DisplayDriver.h>
#include <driver/gpio.h> #include <driver/gpio.h>
#include <driver/spi_common.h>
#include <esp_lcd_panel_io.h> #include <esp_lcd_panel_io.h>
#include <esp_lcd_types.h> #include <esp_lcd_types.h>
#include <freertos/FreeRTOS.h> #include <freertos/FreeRTOS.h>
@ -26,7 +25,7 @@ public:
gpio_num_t csPin, gpio_num_t csPin,
gpio_num_t dcPin, gpio_num_t dcPin,
gpio_num_t resetPin, gpio_num_t resetPin,
gpio_num_t tePin,
unsigned int horizontalResolution, unsigned int horizontalResolution,
unsigned int verticalResolution, unsigned int verticalResolution,
std::shared_ptr<tt::hal::touch::TouchDevice> touch, std::shared_ptr<tt::hal::touch::TouchDevice> touch,

28
Devices/lilygo-tdeck/Source/Configuration.cpp
View File

@ -4,7 +4,6 @@
#include "devices/Sdcard.h" #include "devices/Sdcard.h"
#include "devices/TdeckKeyboard.h" #include "devices/TdeckKeyboard.h"
#include "devices/TrackballDevice.h" #include "devices/TrackballDevice.h"
#include <driver/gpio.h>
#include <Tactility/hal/Configuration.h> #include <Tactility/hal/Configuration.h>
#include <Tactility/lvgl/LvglSync.h> #include <Tactility/lvgl/LvglSync.h>
@ -26,30 +25,5 @@ static std::vector<std::shared_ptr<tt::hal::Device>> createDevices() {
extern const Configuration hardwareConfiguration = { extern const Configuration hardwareConfiguration = {
.initBoot = initBoot, .initBoot = initBoot,
.createDevices = createDevices, .createDevices = createDevices
.spi {
spi::Configuration {
.device = SPI2_HOST,
.dma = SPI_DMA_CH_AUTO,
.config = {
.mosi_io_num = GPIO_NUM_41,
.miso_io_num = GPIO_NUM_38,
.sclk_io_num = GPIO_NUM_40,
.quadwp_io_num = GPIO_NUM_NC, // Quad SPI LCD driver is not yet supported
.quadhd_io_num = GPIO_NUM_NC, // Quad SPI LCD driver is not yet supported
.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 = LCD_SPI_TRANSFER_SIZE_LIMIT,
.flags = 0,
.isr_cpu_id = ESP_INTR_CPU_AFFINITY_AUTO,
.intr_flags = 0
},
.initMode = spi::InitMode::ByTactility,
.isMutable = false,
.lock = tt::lvgl::getSyncLock() // esp_lvgl_port owns the lock for the display
}
}
}; };

7
Devices/lilygo-tdeck/Source/devices/Sdcard.cpp
View File

@ -1,5 +1,7 @@
#include "Sdcard.h" #include "Sdcard.h"
#include <tactility/device.h>
#include <Tactility/lvgl/LvglSync.h> #include <Tactility/lvgl/LvglSync.h>
#include <Tactility/hal/sdcard/SpiSdCardDevice.h> #include <Tactility/hal/sdcard/SpiSdCardDevice.h>
@ -23,7 +25,10 @@ std::shared_ptr<SdCardDevice> createSdCard() {
} }
); );
::Device* spiController = device_find_by_name("spi0");
check(spiController != nullptr, "spi0 not found");
return std::make_shared<SpiSdCardDevice>( return std::make_shared<SpiSdCardDevice>(
std::move(configuration) std::move(configuration),
spiController
); );
} }

12
Devices/lilygo-tdeck/lilygo,tdeck.dts
View File

@ -4,6 +4,7 @@
#include <tactility/bindings/esp32_gpio.h> #include <tactility/bindings/esp32_gpio.h>
#include <tactility/bindings/esp32_i2c.h> #include <tactility/bindings/esp32_i2c.h>
#include <tactility/bindings/esp32_i2s.h> #include <tactility/bindings/esp32_i2s.h>
#include <tactility/bindings/esp32_spi.h>
#include <tactility/bindings/esp32_uart.h> #include <tactility/bindings/esp32_uart.h>
// Reference: https://wiki.lilygo.cc/get_started/en/Wearable/T-Deck-Plus/T-Deck-Plus.html#Pin-Overview // Reference: https://wiki.lilygo.cc/get_started/en/Wearable/T-Deck-Plus/T-Deck-Plus.html#Pin-Overview
@ -42,6 +43,17 @@
pin-mclk = <GPIO_PIN_NONE>; pin-mclk = <GPIO_PIN_NONE>;
}; };
spi0 {
compatible = "espressif,esp32-spi";
host = <SPI2_HOST>;
pin-mosi = <41>;
pin-miso = <38>;
pin-sclk = <40>;
pin-wp = <GPIO_PIN_NONE>;
pin-hd = <GPIO_PIN_NONE>;
max-transfer-size = <0>;
};
uart1 { uart1 {
compatible = "espressif,esp32-uart"; compatible = "espressif,esp32-uart";
port = <UART_NUM_1>; port = <UART_NUM_1>;

3
Devices/lilygo-tdisplay-s3/Source/Init.cpp
View File

@ -4,7 +4,6 @@
#include "PwmBacklight.h" #include "PwmBacklight.h"
#include "Tactility/kernel/SystemEvents.h" #include "Tactility/kernel/SystemEvents.h"
#include <Tactility/TactilityCore.h> #include <Tactility/TactilityCore.h>
#include <Tactility/hal/spi/Spi.h>
#define TAG "tdisplay-s3" #define TAG "tdisplay-s3"
@ -28,7 +27,7 @@ static bool powerOn() {
return false; return false;
} }
return true;
} }
bool initBoot() { bool initBoot() {

4
Devices/unphone/Source/devices/Hx8357Display.h
View File

@ -7,7 +7,7 @@
#include <esp_lcd_types.h> #include <esp_lcd_types.h>
#include <lvgl.h> #include <lvgl.h>
#include <Tactility/hal/spi/Spi.h> #include <driver/spi_common.h>
#define UNPHONE_LCD_SPI_HOST SPI2_HOST #define UNPHONE_LCD_SPI_HOST SPI2_HOST
#define UNPHONE_LCD_PIN_CS GPIO_NUM_48 #define UNPHONE_LCD_PIN_CS GPIO_NUM_48
@ -27,13 +27,11 @@ class Hx8357Display : public tt::hal::display::DisplayDevice {
std::shared_ptr<tt::hal::display::DisplayDriver> nativeDisplay; std::shared_ptr<tt::hal::display::DisplayDriver> nativeDisplay;
class Hx8357Driver : public tt::hal::display::DisplayDriver { class Hx8357Driver : public tt::hal::display::DisplayDriver {
std::shared_ptr<tt::Lock> lock = tt::hal::spi::getLock(SPI2_HOST);
public: public:
tt::hal::display::ColorFormat getColorFormat() const override { return tt::hal::display::ColorFormat::RGB888; } tt::hal::display::ColorFormat getColorFormat() const override { return tt::hal::display::ColorFormat::RGB888; }
uint16_t getPixelWidth() const override { return UNPHONE_LCD_HORIZONTAL_RESOLUTION; } uint16_t getPixelWidth() const override { return UNPHONE_LCD_HORIZONTAL_RESOLUTION; }
uint16_t getPixelHeight() const override { return UNPHONE_LCD_VERTICAL_RESOLUTION; } uint16_t getPixelHeight() const override { return UNPHONE_LCD_VERTICAL_RESOLUTION; }
bool drawBitmap(int xStart, int yStart, int xEnd, int yEnd, const void* pixelData) override; bool drawBitmap(int xStart, int yStart, int xEnd, int yEnd, const void* pixelData) override;
std::shared_ptr<tt::Lock> getLock() const override { return lock; }
}; };
public: public:

3
Devices/waveshare-s3-touch-lcd-147/Source/devices/Jd9853Display.h
View File

@ -1,11 +1,11 @@
#pragma once #pragma once
#include <Tactility/hal/display/DisplayDevice.h> #include <Tactility/hal/display/DisplayDevice.h>
#include <Tactility/hal/spi/Spi.h>
#include <EspLcdDisplay.h> #include <EspLcdDisplay.h>
#include <driver/gpio.h> #include <driver/gpio.h>
#include <driver/spi_common.h>
#include <esp_lcd_panel_io.h> #include <esp_lcd_panel_io.h>
#include <esp_lcd_types.h> #include <esp_lcd_types.h>
#include <functional> #include <functional>
@ -83,7 +83,6 @@ private:
public: public:
explicit Jd9853Display(std::unique_ptr<Configuration> inConfiguration) : explicit Jd9853Display(std::unique_ptr<Configuration> inConfiguration) :
EspLcdDisplay(tt::hal::spi::getLock(inConfiguration->spiHostDevice)),
configuration(std::move(inConfiguration) configuration(std::move(inConfiguration)
) { ) {
assert(configuration != nullptr); assert(configuration != nullptr);

1
Drivers/EspLcdCompat/Source/EspLcdDisplay.cpp
View File

@ -121,7 +121,6 @@ std::shared_ptr<tt::hal::display::DisplayDriver> EspLcdDisplay::getDisplayDriver
displayDriver = std::make_shared<EspLcdDisplayDriver>( displayDriver = std::make_shared<EspLcdDisplayDriver>(
panelHandle, panelHandle,
lock,
lvgl_port_config.hres, lvgl_port_config.hres,
lvgl_port_config.vres, lvgl_port_config.vres,
color_format color_format

5
Drivers/EspLcdCompat/Source/EspLcdDisplay.h
View File

@ -14,7 +14,6 @@ class EspLcdDisplay : public tt::hal::display::DisplayDevice {
esp_lcd_panel_handle_t panelHandle = nullptr; esp_lcd_panel_handle_t panelHandle = nullptr;
lv_display_t* lvglDisplay = nullptr; lv_display_t* lvglDisplay = nullptr;
std::shared_ptr<tt::hal::display::DisplayDriver> displayDriver; std::shared_ptr<tt::hal::display::DisplayDriver> displayDriver;
std::shared_ptr<tt::Lock> lock;
lcd_rgb_element_order_t rgbElementOrder; lcd_rgb_element_order_t rgbElementOrder;
protected: protected:
@ -34,12 +33,10 @@ protected:
public: public:
EspLcdDisplay(std::shared_ptr<tt::Lock> lock) : lock(lock) {} EspLcdDisplay() = default;
~EspLcdDisplay() override; ~EspLcdDisplay() override;
std::shared_ptr<tt::Lock> getLock() const { return lock; }
bool start() final; bool start() final;
bool stop() final; bool stop() final;

7
Drivers/EspLcdCompat/Source/EspLcdDisplayDriver.h
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <Tactility/Mutex.h>
#include <Tactility/hal/display/DisplayDriver.h> #include <Tactility/hal/display/DisplayDriver.h>
#include <esp_lcd_panel_ops.h> #include <esp_lcd_panel_ops.h>
@ -8,7 +7,6 @@
class EspLcdDisplayDriver : public tt::hal::display::DisplayDriver { class EspLcdDisplayDriver : public tt::hal::display::DisplayDriver {
esp_lcd_panel_handle_t panelHandle; esp_lcd_panel_handle_t panelHandle;
std::shared_ptr<tt::Lock> lock;
uint16_t hRes; uint16_t hRes;
uint16_t vRes; uint16_t vRes;
tt::hal::display::ColorFormat colorFormat; tt::hal::display::ColorFormat colorFormat;
@ -17,11 +15,10 @@ public:
EspLcdDisplayDriver( EspLcdDisplayDriver(
esp_lcd_panel_handle_t panelHandle, esp_lcd_panel_handle_t panelHandle,
std::shared_ptr<tt::Lock> lock,
uint16_t hRes, uint16_t hRes,
uint16_t vRes, uint16_t vRes,
tt::hal::display::ColorFormat colorFormat tt::hal::display::ColorFormat colorFormat
) : panelHandle(panelHandle), lock(lock), hRes(hRes), vRes(vRes), colorFormat(colorFormat) {} ) : panelHandle(panelHandle), hRes(hRes), vRes(vRes), colorFormat(colorFormat) {}
tt::hal::display::ColorFormat getColorFormat() const override { tt::hal::display::ColorFormat getColorFormat() const override {
return colorFormat; return colorFormat;
@ -35,6 +32,4 @@ public:
uint16_t getPixelWidth() const override { return hRes; } uint16_t getPixelWidth() const override { return hRes; }
uint16_t getPixelHeight() const override { return vRes; } uint16_t getPixelHeight() const override { return vRes; }
std::shared_ptr<tt::Lock> getLock() const override { return lock; }
}; };

1
Drivers/EspLcdCompat/Source/EspLcdDisplayV2.cpp
View File

@ -221,7 +221,6 @@ std::shared_ptr<tt::hal::display::DisplayDriver> EspLcdDisplayV2::getDisplayDriv
displayDriver = std::make_shared<EspLcdDisplayDriver>( displayDriver = std::make_shared<EspLcdDisplayDriver>(
panelHandle, panelHandle,
lock,
lvgl_port_config.hres, lvgl_port_config.hres,
lvgl_port_config.vres, lvgl_port_config.vres,
color_format color_format

8
Drivers/EspLcdCompat/Source/EspLcdDisplayV2.h
View File

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <Tactility/Lock.h>
#include <tactility/check.h> #include <tactility/check.h>
#include <Tactility/hal/display/DisplayDevice.h> #include <Tactility/hal/display/DisplayDevice.h>
#include <esp_lcd_panel_dev.h> #include <esp_lcd_panel_dev.h>
@ -35,7 +34,6 @@ class EspLcdDisplayV2 : public tt::hal::display::DisplayDevice {
esp_lcd_panel_handle_t _Nullable panelHandle = nullptr; esp_lcd_panel_handle_t _Nullable panelHandle = nullptr;
lv_display_t* _Nullable lvglDisplay = nullptr; lv_display_t* _Nullable lvglDisplay = nullptr;
std::shared_ptr<tt::hal::display::DisplayDriver> _Nullable displayDriver; std::shared_ptr<tt::hal::display::DisplayDriver> _Nullable displayDriver;
std::shared_ptr<tt::Lock> lock;
std::shared_ptr<EspLcdConfiguration> configuration; std::shared_ptr<EspLcdConfiguration> configuration;
bool applyConfiguration() const; bool applyConfiguration() const;
@ -67,18 +65,14 @@ protected:
public: public:
EspLcdDisplayV2(const std::shared_ptr<EspLcdConfiguration>& configuration, const std::shared_ptr<tt::Lock>& lock) : EspLcdDisplayV2(const std::shared_ptr<EspLcdConfiguration>& configuration) :
lock(lock),
configuration(configuration) configuration(configuration)
{ {
assert(configuration != nullptr); assert(configuration != nullptr);
assert(lock != nullptr);
} }
~EspLcdDisplayV2() override; ~EspLcdDisplayV2() override;
std::shared_ptr<tt::Lock> getLock() const { return lock; }
bool start() final; bool start() final;
bool stop() final; bool stop() final;

5
Drivers/EspLcdCompat/Source/EspLcdSpiDisplay.h
View File

@ -1,7 +1,8 @@
#pragma once #pragma once
#include "EspLcdDisplayV2.h" #include "EspLcdDisplayV2.h"
#include <Tactility/hal/spi/Spi.h>
#include <driver/spi_common.h>
#include <esp_lcd_io_spi.h> #include <esp_lcd_io_spi.h>
#include <esp_lcd_types.h> #include <esp_lcd_types.h>
@ -23,7 +24,7 @@ public:
}; };
explicit EspLcdSpiDisplay(const std::shared_ptr<EspLcdConfiguration>& configuration, const std::shared_ptr<SpiConfiguration> spiConfiguration, int gammaCurveCount) : explicit EspLcdSpiDisplay(const std::shared_ptr<EspLcdConfiguration>& configuration, const std::shared_ptr<SpiConfiguration> spiConfiguration, int gammaCurveCount) :
EspLcdDisplayV2(configuration, tt::hal::spi::getLock(spiConfiguration->spiHostDevice)), EspLcdDisplayV2(configuration),
spiConfiguration(spiConfiguration), spiConfiguration(spiConfiguration),
gammaCurveCount(gammaCurveCount) gammaCurveCount(gammaCurveCount)
{} {}

3
Drivers/GC9A01/Source/Gc9a01Display.h
View File

@ -1,11 +1,10 @@
#pragma once #pragma once
#include "Tactility/hal/spi/Spi.h"
#include <EspLcdDisplay.h> #include <EspLcdDisplay.h>
#include <Tactility/hal/display/DisplayDevice.h> #include <Tactility/hal/display/DisplayDevice.h>
#include <driver/gpio.h> #include <driver/gpio.h>
#include <driver/spi_common.h>
#include <esp_lcd_panel_io.h> #include <esp_lcd_panel_io.h>
#include <esp_lcd_types.h> #include <esp_lcd_types.h>
#include <functional> #include <functional>

2
Drivers/ILI934x/Source/Ili934xDisplay.h
View File

@ -8,8 +8,6 @@
class Ili934xDisplay final : public EspLcdSpiDisplay { class Ili934xDisplay final : public EspLcdSpiDisplay {
std::shared_ptr<tt::Lock> lock;
public: public:
/** Minimal set of overrides for EspLcdConfiguration */ /** Minimal set of overrides for EspLcdConfiguration */

2
Drivers/ILI9488/Source/Ili9488Display.h
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <Tactility/hal/display/DisplayDevice.h> #include <Tactility/hal/display/DisplayDevice.h>
#include <Tactility/hal/spi/Spi.h> #include <driver/spi_common.h>
#include <EspLcdDisplay.h> #include <EspLcdDisplay.h>

3
Drivers/ST7735/Source/St7735Display.h
View File

@ -1,11 +1,10 @@
#pragma once #pragma once
#include "Tactility/hal/spi/Spi.h"
#include <EspLcdDisplay.h> #include <EspLcdDisplay.h>
#include <Tactility/hal/display/DisplayDevice.h> #include <Tactility/hal/display/DisplayDevice.h>
#include <driver/gpio.h> #include <driver/gpio.h>
#include <driver/spi_common.h>
#include <esp_lcd_panel_io.h> #include <esp_lcd_panel_io.h>
#include <esp_lcd_types.h> #include <esp_lcd_types.h>
#include <functional> #include <functional>

2
Drivers/ST7789/Source/St7789Display.h
View File

@ -8,8 +8,6 @@
class St7789Display final : public EspLcdSpiDisplay { class St7789Display final : public EspLcdSpiDisplay {
std::shared_ptr<tt::Lock> lock;
public: public:
/** Minimal set of overrides for EspLcdConfiguration */ /** Minimal set of overrides for EspLcdConfiguration */

2
Drivers/ST7796/Source/St7796Display.h
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <Tactility/hal/display/DisplayDevice.h> #include <Tactility/hal/display/DisplayDevice.h>
#include <Tactility/hal/spi/Spi.h> #include <driver/spi_common.h>
#include <EspLcdDisplay.h> #include <EspLcdDisplay.h>
#include <functional> #include <functional>

36
Platforms/PlatformEsp32/Bindings/espressif,esp32-spi.yaml Normal file
View File

@ -0,0 +1,36 @@
description: ESP32 SPI Controller
include: ["spi-controller.yaml"]
compatible: "espressif,esp32-spi"
properties:
host:
type: int
required: true
description: |
The SPI host (controller) to use.
Defined by spi_host_device_t (e.g. SPI2_HOST, SPI3_HOST).
pin-mosi:
type: int
required: true
description: MOSI (Data 0) pin
pin-miso:
type: int
required: true
description: MISO (Data 1) pin
pin-sclk:
type: int
required: true
description: Clock pin
pin-wp:
type: int
description: WP (Data 2) pin
pin-hd:
type: int
description: HD (Data 3) pin
max-transfer-size:
type: int
description: |
Data transfer size limit in bytes.
0 means the platform decides the limit.

1
Platforms/PlatformEsp32/Include/tactility/bindings/esp32_gpio.h
View File

@ -2,6 +2,7 @@
#pragma once #pragma once
#include <tactility/bindings/bindings.h> #include <tactility/bindings/bindings.h>
#include <tactility/bindings/gpio.h>
#include <tactility/drivers/esp32_gpio.h> #include <tactility/drivers/esp32_gpio.h>
#ifdef __cplusplus #ifdef __cplusplus

15
Platforms/PlatformEsp32/Include/tactility/bindings/esp32_spi.h Normal file
View File

@ -0,0 +1,15 @@
// SPDX-License-Identifier: Apache-2.0
#pragma once
#include <tactility/bindings/bindings.h>
#include <tactility/drivers/esp32_spi.h>
#ifdef __cplusplus
extern "C" {
#endif
DEFINE_DEVICETREE(esp32_spi, struct Esp32SpiConfig)
#ifdef __cplusplus
}
#endif

6
Platforms/PlatformEsp32/Include/tactility/drivers/esp32_spi.h
View File

@ -10,11 +10,17 @@ extern "C" {
struct Esp32SpiConfig { struct Esp32SpiConfig {
spi_host_device_t host; spi_host_device_t host;
/** Data 0 pin */
int pin_mosi; int pin_mosi;
/** Data 1 pin */
int pin_miso; int pin_miso;
/** Clock pin */
int pin_sclk; int pin_sclk;
/** Data 2 pin */
int pin_wp; int pin_wp;
/** Data 3 pin */
int pin_hd; int pin_hd;
/** Data transfer size limit in bytes. 0 means the platform decides the limit. */
int max_transfer_size; int max_transfer_size;
}; };

14
Platforms/PlatformEsp32/Source/drivers/esp32_spi.cpp
View File

@ -1,7 +1,7 @@
// SPDX-License-Identifier: Apache-2.0 // SPDX-License-Identifier: Apache-2.0
#include <tactility/device.h> #include <tactility/device.h>
#include <tactility/drivers/esp32_spi.h> #include <tactility/drivers/esp32_spi.h>
#include <tactility/concurrent/mutex.h> #include <tactility/concurrent/recursive_mutex.h>
#include <cstring> #include <cstring>
#include <esp_log.h> #include <esp_log.h>
@ -16,27 +16,27 @@
extern "C" { extern "C" {
struct Esp32SpiInternal { struct Esp32SpiInternal {
Mutex mutex; RecursiveMutex mutex = {};
bool initialized = false; bool initialized = false;
Esp32SpiInternal() { Esp32SpiInternal() {
mutex_construct(&mutex); recursive_mutex_construct(&mutex);
} }
~Esp32SpiInternal() { ~Esp32SpiInternal() {
mutex_destruct(&mutex); recursive_mutex_destruct(&mutex);
} }
}; };
static error_t lock(Device* device) { static error_t lock(Device* device) {
auto* driver_data = GET_DATA(device); auto* driver_data = GET_DATA(device);
mutex_lock(&driver_data->mutex); recursive_mutex_lock(&driver_data->mutex);
return ERROR_NONE; return ERROR_NONE;
} }
static error_t try_lock(Device* device, TickType_t timeout) { static error_t try_lock(Device* device, TickType_t timeout) {
auto* driver_data = GET_DATA(device); auto* driver_data = GET_DATA(device);
if (mutex_try_lock(&driver_data->mutex, timeout)) { if (recursive_mutex_try_lock(&driver_data->mutex, timeout)) {
return ERROR_NONE; return ERROR_NONE;
} }
return ERROR_TIMEOUT; return ERROR_TIMEOUT;
@ -44,7 +44,7 @@ static error_t try_lock(Device* device, TickType_t timeout) {
static error_t unlock(Device* device) { static error_t unlock(Device* device) {
auto* driver_data = GET_DATA(device); auto* driver_data = GET_DATA(device);
mutex_unlock(&driver_data->mutex); recursive_mutex_unlock(&driver_data->mutex);
return ERROR_NONE; return ERROR_NONE;
} }

4
Tactility/Include/Tactility/hal/Configuration.h
View File

@ -1,7 +1,6 @@
#pragma once #pragma once
#include <Tactility/hal/sdcard/SdCardDevice.h> #include <Tactility/hal/sdcard/SdCardDevice.h>
#include <Tactility/hal/spi/Spi.h>
namespace tt::hal { namespace tt::hal {
@ -38,9 +37,6 @@ struct Configuration {
const UiScale uiScale = UiScale::Default; const UiScale uiScale = UiScale::Default;
std::function<DeviceVector()> createDevices = [] { return std::vector<std::shared_ptr<Device>>(); }; std::function<DeviceVector()> createDevices = [] { return std::vector<std::shared_ptr<Device>>(); };
/** A list of SPI interface configurations */
const std::vector<spi::Configuration> spi = {};
}; };
} // namespace } // namespace

1
Tactility/Include/Tactility/hal/display/DisplayDriver.h
View File

@ -24,7 +24,6 @@ public:
virtual uint16_t getPixelWidth() const = 0; virtual uint16_t getPixelWidth() const = 0;
virtual uint16_t getPixelHeight() const = 0; virtual uint16_t getPixelHeight() const = 0;
virtual bool drawBitmap(int xStart, int yStart, int xEnd, int yEnd, const void* pixelData) = 0; virtual bool drawBitmap(int xStart, int yStart, int xEnd, int yEnd, const void* pixelData) = 0;
virtual std::shared_ptr<Lock> getLock() const = 0;
}; };
} }

1
Tactility/Include/Tactility/hal/sdcard/SdmmcDevice.h
View File

@ -6,7 +6,6 @@
#include <Tactility/RecursiveMutex.h> #include <Tactility/RecursiveMutex.h>
#include <tactility/hal/Device.h> #include <tactility/hal/Device.h>
#include <Tactility/hal/spi/Spi.h>
#include <sd_protocol_types.h> #include <sd_protocol_types.h>
#include <soc/gpio_num.h> #include <soc/gpio_num.h>
#include <utility> #include <utility>

26
Tactility/Include/Tactility/hal/sdcard/SpiSdCardDevice.h
View File

@ -3,14 +3,14 @@
#pragma once #pragma once
#include "SdCardDevice.h" #include "SdCardDevice.h"
#include "Tactility/kernel/SpiDeviceLock.h"
#include <Tactility/hal/spi/Spi.h> #include <driver/gpio.h>
#include <driver/spi_common.h>
#include <sd_protocol_types.h> #include <sd_protocol_types.h>
#include <utility> #include <utility>
#include <vector> #include <vector>
#include <hal/spi_types.h>
#include <soc/gpio_num.h>
namespace tt::hal::sdcard { namespace tt::hal::sdcard {
@ -64,15 +64,23 @@ private:
std::string mountPath; std::string mountPath;
sdmmc_card_t* card = nullptr; sdmmc_card_t* card = nullptr;
std::shared_ptr<Config> config; std::shared_ptr<Config> config;
std::shared_ptr<Lock> lock;
bool applyGpioWorkAround(); bool applyGpioWorkAround();
bool mountInternal(const std::string& mountPath); bool mountInternal(const std::string& mountPath);
public: public:
explicit SpiSdCardDevice(std::unique_ptr<Config> config) : SdCardDevice(config->mountBehaviourAtBoot), explicit SpiSdCardDevice(std::unique_ptr<Config> newConfig, ::Device* spiController) : SdCardDevice(newConfig->mountBehaviourAtBoot),
config(std::move(config)) config(std::move(newConfig))
{} {
if (config->customLock == nullptr) {
auto spi_lock = std::make_shared<SpiDeviceLock>(spiController);
lock = std::static_pointer_cast<Lock>(spi_lock);
} else {
lock = config->customLock;
}
}
std::string getName() const override { return "SD Card"; } std::string getName() const override { return "SD Card"; }
std::string getDescription() const override { return "SD card via SPI interface"; } std::string getDescription() const override { return "SD card via SPI interface"; }
@ -82,11 +90,7 @@ public:
std::string getMountPath() const override { return mountPath; } std::string getMountPath() const override { return mountPath; }
std::shared_ptr<Lock> getLock() const override { std::shared_ptr<Lock> getLock() const override {
if (config->customLock != nullptr) { return lock;
return config->customLock;
} else {
return spi::getLock(config->spiHost);
}
} }
State getState(TickType_t timeout) const override; State getState(TickType_t timeout) const override;

51
Tactility/Include/Tactility/hal/spi/Spi.h
View File

@ -1,51 +0,0 @@
#pragma once
#include "SpiCompat.h"
#include <Tactility/Lock.h>
#include <Tactility/freertoscompat/RTOS.h>
namespace tt::hal::spi {
constexpr TickType_t defaultTimeout = 10 / portTICK_PERIOD_MS;
enum class InitMode {
ByTactility, // Tactility will initialize it in the correct bootup phase
ByExternal, // The device is already initialized and Tactility should assume it works
Disabled // Not initialized by default
};
struct Configuration {
spi_host_device_t device;
spi_common_dma_t dma;
spi_bus_config_t config;
/** Whether this bus should be initialized when device starts up */
InitMode initMode;
/** Whether configuration can be changed. */
bool isMutable;
/** Optional custom lock - otherwise creates one internally */
std::shared_ptr<Lock> lock;
};
enum class Status {
Started,
Stopped,
Unknown
};
/** Start communications */
bool start(spi_host_device_t device);
/** Stop communications */
bool stop(spi_host_device_t device);
/** @return true if communications were started successfully */
bool isStarted(spi_host_device_t device);
/**
* Return the lock for the specified SPI device. Never returns nullptr.
* @return the lock that represents the specified device. Can be used with third party SPI implementations or native API calls (e.g. ESP-IDF).
*/
std::shared_ptr<Lock> getLock(spi_host_device_t device);
} // namespace tt::hal::spi

21
Tactility/Include/Tactility/hal/spi/SpiCompat.h
View File

@ -1,21 +0,0 @@
#pragma once
#include "../gpio/Gpio.h"
#ifdef ESP_PLATFORM
#include <driver/spi_common.h>
#else
#define SPI_HOST_MAX 3
typedef tt::hal::gpio::Pin gpio_num_t;
typedef int spi_host_device_t;
struct spi_bus_config_t {
gpio_num_t miso_io_num;
gpio_num_t mosi_io_num;
gpio_num_t sclk_io_num;
};
struct spi_common_dma_t {};
#endif

17
Tactility/Private/Tactility/hal/spi/SpiInit.h
View File

@ -1,17 +0,0 @@
#pragma once
#include <Tactility/hal/spi/Spi.h>
#include <vector>
#include <memory>
namespace tt::hal::spi {
/**
* Called by main HAL init to ready the internal state of the SPI HAL.
* @param[in] configurations HAL configuration for a board
* @return true on success
*/
bool init(const std::vector<Configuration>& configurations);
}

3
Tactility/Source/hal/Hal.cpp
View File

@ -3,7 +3,6 @@
#include <tactility/check.h> #include <tactility/check.h>
#include <Tactility/hal/Configuration.h> #include <Tactility/hal/Configuration.h>
#include <tactility/hal/Device.h> #include <tactility/hal/Device.h>
#include <Tactility/hal/spi/SpiInit.h>
#include <Tactility/hal/display/DisplayDevice.h> #include <Tactility/hal/display/DisplayDevice.h>
#include <Tactility/hal/sdcard/SdCardMounting.h> #include <Tactility/hal/sdcard/SdCardMounting.h>
@ -64,8 +63,6 @@ static void startDisplays() {
void init(const Configuration& configuration) { void init(const Configuration& configuration) {
kernel::publishSystemEvent(kernel::SystemEvent::BootInitHalBegin); kernel::publishSystemEvent(kernel::SystemEvent::BootInitHalBegin);
check(spi::init(configuration.spi), "SPI init failed");
if (configuration.initBoot != nullptr) { if (configuration.initBoot != nullptr) {
check(configuration.initBoot(), "Init boot failed"); check(configuration.initBoot(), "Init boot failed");
} }

146
Tactility/Source/hal/spi/Spi.cpp
View File

@ -1,146 +0,0 @@
#include <Tactility/hal/spi/Spi.h>
#include <Tactility/Logger.h>
#include <Tactility/RecursiveMutex.h>
namespace tt::hal::spi {
static const auto LOGGER = Logger("SPI");
struct Data {
std::shared_ptr<Lock> lock;
bool isConfigured = false;
bool isStarted = false;
Configuration configuration;
};
static Data dataArray[SPI_HOST_MAX];
bool init(const std::vector<Configuration>& configurations) {
LOGGER.info("Init");
for (const auto& configuration: configurations) {
Data& data = dataArray[configuration.device];
data.configuration = configuration;
data.isConfigured = true;
if (configuration.lock != nullptr) {
data.lock = configuration.lock;
} else {
data.lock = std::make_shared<RecursiveMutex>();
}
}
for (const auto& config: configurations) {
if (config.initMode == InitMode::ByTactility) {
if (!start(config.device)) {
return false;
}
} else if (config.initMode == InitMode::ByExternal) {
dataArray[config.device].isStarted = true;
}
}
return true;
}
bool configure(spi_host_device_t device, const spi_bus_config_t& configuration) {
auto lock = getLock(device)->asScopedLock();
lock.lock();
Data& data = dataArray[device];
if (data.isStarted) {
LOGGER.error("({}) Cannot reconfigure while interface is started", static_cast<int>(device));
return false;
} else if (!data.configuration.isMutable) {
LOGGER.error("({}) Mutation not allowed by original configuration", static_cast<int>(device));
return false;
} else {
data.configuration.config = configuration;
return true;
}
}
bool start(spi_host_device_t device) {
auto lock = getLock(device)->asScopedLock();
lock.lock();
Data& data = dataArray[device];
if (data.isStarted) {
LOGGER.error("({}) Starting: Already started", static_cast<int>(device));
return false;
}
if (!data.isConfigured) {
LOGGER.error("({}) Starting: Not configured", static_cast<int>(device));
return false;
}
#ifdef ESP_PLATFORM
auto result = spi_bus_initialize(device, &data.configuration.config, data.configuration.dma);
if (result != ESP_OK) {
LOGGER.error("({}) Starting: Failed to initialize: {}", static_cast<int>(device), esp_err_to_name(result));
return false;
} else {
data.isStarted = true;
}
#else
data.isStarted = true;
#endif
LOGGER.info("({}) Started", static_cast<int>(device));
return true;
}
bool stop(spi_host_device_t device) {
auto lock = getLock(device)->asScopedLock();
lock.lock();
Data& data = dataArray[device];
Configuration& config = data.configuration;
if (!config.isMutable) {
LOGGER.error("({}) Stopping: Not allowed, immutable", static_cast<int>(device));
return false;
}
if (!data.isStarted) {
LOGGER.error("({}) Stopping: Not started", static_cast<int>(device));
return false;
}
#ifdef ESP_PLATFORM
auto result = spi_bus_free(device);
if (result != ESP_OK) {
LOGGER.error("({}) Stopping: Failed to free device: {}", static_cast<int>(device), esp_err_to_name(result));
return false;
} else {
data.isStarted = false;
}
#else
data.isStarted = false;
#endif
LOGGER.info("({}) Stopped", static_cast<int>(device));
return true;
}
bool isStarted(spi_host_device_t device) {
auto lock = getLock(device)->asScopedLock();
lock.lock();
return dataArray[device].isStarted;
}
std::shared_ptr<Lock> getLock(spi_host_device_t device) {
return dataArray[device].lock;
}
}

7
TactilityC/Source/tt_hal_display.cpp
View File

@ -57,13 +57,12 @@ void tt_hal_display_driver_free(DisplayDriverHandle handle) {
} }
bool tt_hal_display_driver_lock(DisplayDriverHandle handle, TickType_t timeout) { bool tt_hal_display_driver_lock(DisplayDriverHandle handle, TickType_t timeout) {
auto wrapper = static_cast<DriverWrapper*>(handle); // TODO: re-implement with SPI lock
return wrapper->driver->getLock()->lock(timeout); return true;
} }
void tt_hal_display_driver_unlock(DisplayDriverHandle handle) { void tt_hal_display_driver_unlock(DisplayDriverHandle handle) {
auto wrapper = static_cast<DriverWrapper*>(handle); // TODO: re-implement with SPI lock
wrapper->driver->getLock()->unlock();
} }
ColorFormat tt_hal_display_driver_get_colorformat(DisplayDriverHandle handle) { ColorFormat tt_hal_display_driver_get_colorformat(DisplayDriverHandle handle) {

24
TactilityCore/Include/Tactility/kernel/SpiDeviceLock.h Normal file
View File

@ -0,0 +1,24 @@
#pragma once
#include <tactility/drivers/spi_controller.h>
#include <tactility/device.h>
#include <Tactility/Lock.h>
namespace tt {
class SpiDeviceLock : public Lock {
::Device* device;
public:
SpiDeviceLock(::Device* device) : device(device) { }
bool lock(TickType_t timeout) const override {
return spi_controller_try_lock(device, timeout) == ERROR_NONE;
}
void unlock() const override {
spi_controller_unlock(device);
}
};
}

1
TactilityKernel/Bindings/spi-controller.yaml Normal file
View File

@ -0,0 +1 @@
description: SPI controller