New kernel drivers and more (#560)

- Added kernel base drivers for: display, pointer (touch, mouse, etc.), keyboard, adc, power supply and backlight
- Implement new kernel driver modules: `st7789-module` and `gt911-module`
- Implement ESP32 ADC "oneshot" kernel driver
- Implement ESP32  backlight kernel driver with ledc API
- Implemented `battery-sense` driver that allows for voltage measurement and creates a power supply child device
- Updated github actions
- Updated flash scripts
- Fix for esp32 legacy driver conflict with ADC
- Created separate `lilygo-tdeck` and `lilygo-tdeck-plus` devices
- Created `lilygo-module` with LilyGO kernel drivers
- Fix for intermittent errors in build related to code generation of `devicetree.c`
- `lvgl-module` can now map kernel drivers onto LVGL devices
- Created `KernelDisplayApp` as a mirror of `HalDisplayApp` (formerly `DisplayApp`)
- Removed `struct` and `enum` prefix in a lot of kernel driver cpp source files
- `lilygo-tdeck` and `lilygo-tdeck-plus` are now fully relying on kernel drivers and don't use any of the old HAL

Drivers/gt911-module/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.20)
+
+include("${CMAKE_CURRENT_LIST_DIR}/../../Buildscripts/module.cmake")
+
+file(GLOB_RECURSE SOURCE_FILES "source/*.c*")
+
+tactility_add_module(gt911-module
+    SRCS ${SOURCE_FILES}
+    INCLUDE_DIRS include/
+    REQUIRES TactilityKernel platform-esp32 esp_lcd_touch_gt911 esp_lcd driver
+)

Drivers/gt911-module/bindings/goodix,gt911.yaml

@@ -0,0 +1,45 @@
+description: Goodix GT911 capacitive touch controller
+
+include: ["i2c-device.yaml"]
+
+compatible: "goodix,gt911"
+
+bus: i2c
+
+properties:
+  x-max:
+    type: int
+    required: true
+    description: Maximum X coordinate reported by the controller (typically the panel's horizontal resolution)
+  y-max:
+    type: int
+    required: true
+    description: Maximum Y coordinate reported by the controller (typically the panel's vertical resolution)
+  swap-xy:
+    type: boolean
+    default: false
+    description: Swap the X and Y axes
+  mirror-x:
+    type: boolean
+    default: false
+    description: Mirror the X axis
+  mirror-y:
+    type: boolean
+    default: false
+    description: Mirror the Y axis
+  pin-reset:
+    type: phandles
+    default: GPIO_PIN_SPEC_NONE
+    description: Reset GPIO pin
+  pin-interrupt:
+    type: phandles
+    default: GPIO_PIN_SPEC_NONE
+    description: Interrupt GPIO pin
+  reset-active-high:
+    type: boolean
+    default: false
+    description: Whether the reset pin is active high
+  interrupt-active-high:
+    type: boolean
+    default: false
+    description: Whether the interrupt pin is active high

Drivers/gt911-module/devicetree.yaml

@@ -0,0 +1,3 @@
+dependencies:
+  - TactilityKernel
+bindings: bindings

Drivers/gt911-module/include/bindings/gt911.h

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <tactility/bindings/bindings.h>
+#include <drivers/gt911.h>
+
+DEFINE_DEVICETREE(gt911, struct Gt911Config)

Drivers/gt911-module/include/drivers/gt911.h

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include <tactility/drivers/gpio.h>
+
+struct Gt911Config {
+    // Devicetree address hint. The driver auto-probes both known GT911 addresses
+    // (0x5D primary, 0x14 backup) regardless, since the effective address depends on
+    // the controller's INT pin strapping level at power-up, not a fixed board wiring choice.
+    uint8_t address;
+    uint16_t x_max;
+    uint16_t y_max;
+    bool swap_xy;
+    bool mirror_x;
+    bool mirror_y;
+    struct GpioPinSpec pin_reset;
+    struct GpioPinSpec pin_interrupt;
+    bool reset_active_high;
+    bool interrupt_active_high;
+};
+
+#ifdef __cplusplus
+}
+#endif

Drivers/gt911-module/include/gt911_module.h

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <tactility/module.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct Module gt911_module;
+
+#ifdef __cplusplus
+}
+#endif

Drivers/gt911-module/source/gt911.cpp

@@ -0,0 +1,214 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <drivers/gt911.h>
+#include <gt911_module.h>
+
+#include <tactility/check.h>
+#include <tactility/device.h>
+#include <tactility/driver.h>
+#include <tactility/drivers/esp32_i2c.h>
+#include <tactility/drivers/esp32_i2c_master.h>
+#include <tactility/drivers/i2c_controller.h>
+#include <tactility/drivers/pointer.h>
+#include <tactility/log.h>
+
+#include <esp_err.h>
+#include <esp_lcd_io_i2c.h>
+#include <esp_lcd_panel_io.h>
+#include <esp_lcd_touch.h>
+#include <esp_lcd_touch_gt911.h>
+
+#include <cstdlib>
+
+#define TAG "GT911"
+#define GET_CONFIG(device) (static_cast<const Gt911Config*>((device)->config))
+
+struct Gt911Internal {
+    esp_lcd_panel_io_handle_t io_handle;
+    esp_lcd_touch_handle_t touch_handle;
+};
+
+static inline gpio_num_t pin_or_nc(const struct GpioPinSpec& pin) {
+    return pin.gpio_controller == nullptr ? GPIO_NUM_NC : static_cast<gpio_num_t>(pin.pin);
+}
+
+// region Driver lifecycle
+
+// GT911's I2C address depends on the controller's INT pin level at power-up (board-strapped, not
+// devicetree-fixed), so both known addresses are probed regardless of the devicetree "reg" hint.
+static esp_err_t create_io_handle(Device* parent, esp_lcd_panel_io_handle_t* out_handle) {
+    esp_lcd_panel_io_i2c_config_t io_config = ESP_LCD_TOUCH_IO_I2C_GT911_CONFIG();
+
+    if (i2c_controller_has_device_at_address(parent, ESP_LCD_TOUCH_IO_I2C_GT911_ADDRESS, pdMS_TO_TICKS(10)) == ERROR_NONE) {
+        io_config.dev_addr = ESP_LCD_TOUCH_IO_I2C_GT911_ADDRESS;
+    } else if (i2c_controller_has_device_at_address(parent, ESP_LCD_TOUCH_IO_I2C_GT911_ADDRESS_BACKUP, pdMS_TO_TICKS(10)) == ERROR_NONE) {
+        io_config.dev_addr = ESP_LCD_TOUCH_IO_I2C_GT911_ADDRESS_BACKUP;
+    } else {
+        LOG_E(TAG, "No GT911 found on I2C bus");
+        return ESP_ERR_NOT_FOUND;
+    }
+
+    auto* parent_driver = device_get_driver(parent);
+    if (driver_is_compatible(parent_driver, "espressif,esp32-i2c")) {
+        auto port = static_cast<const Esp32I2cConfig*>(parent->config)->port;
+        return esp_lcd_new_panel_io_i2c_v1(port, &io_config, out_handle);
+    }
+    if (driver_is_compatible(parent_driver, "espressif,esp32-i2c-master")) {
+        auto bus = esp32_i2c_master_get_bus_handle(parent);
+        io_config.scl_speed_hz = esp32_i2c_master_get_clock_frequency(parent);
+        return esp_lcd_new_panel_io_i2c_v2(bus, &io_config, out_handle);
+    }
+
+    LOG_E(TAG, "Unsupported I2C driver");
+    return ESP_ERR_NOT_SUPPORTED;
+}
+
+static error_t start(Device* device) {
+    auto* parent = device_get_parent(device);
+    check(device_get_type(parent) == &I2C_CONTROLLER_TYPE);
+
+    const auto* config = GET_CONFIG(device);
+
+    auto* internal = static_cast<Gt911Internal*>(malloc(sizeof(Gt911Internal)));
+    if (internal == nullptr) {
+        return ERROR_OUT_OF_MEMORY;
+    }
+
+    esp_err_t ret = create_io_handle(parent, &internal->io_handle);
+    if (ret != ESP_OK) {
+        free(internal);
+        return ERROR_RESOURCE;
+    }
+
+    esp_lcd_touch_config_t touch_config = {
+        .x_max = config->x_max,
+        .y_max = config->y_max,
+        .rst_gpio_num = pin_or_nc(config->pin_reset),
+        .int_gpio_num = pin_or_nc(config->pin_interrupt),
+        .levels = {
+            .reset = config->reset_active_high ? 1u : 0u,
+            .interrupt = config->interrupt_active_high ? 1u : 0u,
+        },
+        .flags = {
+            .swap_xy = config->swap_xy ? 1u : 0u,
+            .mirror_x = config->mirror_x ? 1u : 0u,
+            .mirror_y = config->mirror_y ? 1u : 0u,
+        },
+        .process_coordinates = nullptr,
+        .interrupt_callback = nullptr,
+        .user_data = nullptr,
+        .driver_data = nullptr,
+    };
+
+    ret = esp_lcd_touch_new_i2c_gt911(internal->io_handle, &touch_config, &internal->touch_handle);
+    if (ret != ESP_OK) {
+        LOG_E(TAG, "Failed to create touch handle: %s", esp_err_to_name(ret));
+        esp_lcd_panel_io_del(internal->io_handle);
+        free(internal);
+        return ERROR_RESOURCE;
+    }
+
+    device_set_driver_data(device, internal);
+    return ERROR_NONE;
+}
+
+static error_t stop(Device* device) {
+    auto* internal = static_cast<Gt911Internal*>(device_get_driver_data(device));
+
+    bool ok = true;
+
+    // esp_lcd_touch_del() only releases the touch-side resources; the panel IO handle is owned
+    // separately and needs its own deletion.
+    if (esp_lcd_touch_del(internal->touch_handle) != ESP_OK) {
+        LOG_E(TAG, "Failed to delete touch handle");
+        ok = false;
+    }
+
+    if (esp_lcd_panel_io_del(internal->io_handle) != ESP_OK) {
+        LOG_E(TAG, "Failed to delete panel IO handle");
+        ok = false;
+    }
+
+    free(internal);
+    return ok ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+// endregion
+
+// region PointerApi
+
+static error_t gt911_enter_sleep(Device* device) {
+    auto* internal = static_cast<Gt911Internal*>(device_get_driver_data(device));
+    return esp_lcd_touch_enter_sleep(internal->touch_handle) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t gt911_exit_sleep(Device* device) {
+    auto* internal = static_cast<Gt911Internal*>(device_get_driver_data(device));
+    return esp_lcd_touch_exit_sleep(internal->touch_handle) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t gt911_read_data(Device* device, TickType_t timeout) {
+    (void)timeout; // esp_lcd_touch_read_data() has no timeout parameter
+    auto* internal = static_cast<Gt911Internal*>(device_get_driver_data(device));
+    return esp_lcd_touch_read_data(internal->touch_handle) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static bool gt911_get_touched_points(Device* device, uint16_t* x, uint16_t* y, uint16_t* strength, uint8_t* point_count, uint8_t max_point_count) {
+    auto* internal = static_cast<Gt911Internal*>(device_get_driver_data(device));
+    return esp_lcd_touch_get_coordinates(internal->touch_handle, x, y, strength, point_count, max_point_count);
+}
+
+static error_t gt911_set_swap_xy(Device* device, bool swap) {
+    auto* internal = static_cast<Gt911Internal*>(device_get_driver_data(device));
+    return esp_lcd_touch_set_swap_xy(internal->touch_handle, swap) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t gt911_get_swap_xy(Device* device, bool* swap) {
+    auto* internal = static_cast<Gt911Internal*>(device_get_driver_data(device));
+    return esp_lcd_touch_get_swap_xy(internal->touch_handle, swap) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t gt911_set_mirror_x(Device* device, bool mirror) {
+    auto* internal = static_cast<Gt911Internal*>(device_get_driver_data(device));
+    return esp_lcd_touch_set_mirror_x(internal->touch_handle, mirror) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t gt911_get_mirror_x(Device* device, bool* mirror) {
+    auto* internal = static_cast<Gt911Internal*>(device_get_driver_data(device));
+    return esp_lcd_touch_get_mirror_x(internal->touch_handle, mirror) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t gt911_set_mirror_y(Device* device, bool mirror) {
+    auto* internal = static_cast<Gt911Internal*>(device_get_driver_data(device));
+    return esp_lcd_touch_set_mirror_y(internal->touch_handle, mirror) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t gt911_get_mirror_y(Device* device, bool* mirror) {
+    auto* internal = static_cast<Gt911Internal*>(device_get_driver_data(device));
+    return esp_lcd_touch_get_mirror_y(internal->touch_handle, mirror) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+// endregion
+
+static const PointerApi gt911_pointer_api = {
+    .enter_sleep = gt911_enter_sleep,
+    .exit_sleep = gt911_exit_sleep,
+    .read_data = gt911_read_data,
+    .get_touched_points = gt911_get_touched_points,
+    .set_swap_xy = gt911_set_swap_xy,
+    .get_swap_xy = gt911_get_swap_xy,
+    .set_mirror_x = gt911_set_mirror_x,
+    .get_mirror_x = gt911_get_mirror_x,
+    .set_mirror_y = gt911_set_mirror_y,
+    .get_mirror_y = gt911_get_mirror_y,
+};
+
+Driver gt911_driver = {
+    .name = "gt911",
+    .compatible = (const char*[]) { "goodix,gt911", nullptr },
+    .start_device = start,
+    .stop_device = stop,
+    .api = &gt911_pointer_api,
+    .device_type = &POINTER_TYPE,
+    .owner = &gt911_module,
+    .internal = nullptr
+};

Drivers/gt911-module/source/module.cpp

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/check.h>
+#include <tactility/driver.h>
+#include <tactility/module.h>
+
+extern "C" {
+
+extern Driver gt911_driver;
+
+static error_t start() {
+    /* We crash when construct fails, because if a single driver fails to construct,
+     * there is no guarantee that the previously constructed drivers can be destroyed */
+    check(driver_construct_add(&gt911_driver) == ERROR_NONE);
+    return ERROR_NONE;
+}
+
+static error_t stop() {
+    /* We crash when destruct fails, because if a single driver fails to destruct,
+     * there is no guarantee that the previously destroyed drivers can be recovered */
+    check(driver_remove_destruct(&gt911_driver) == ERROR_NONE);
+    return ERROR_NONE;
+}
+
+Module gt911_module = {
+    .name = "gt911",
+    .start = start,
+    .stop = stop,
+    .symbols = nullptr,
+    .internal = nullptr
+};
+
+} // extern "C"

Drivers/lilygo-module/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.20)
+
+include("${CMAKE_CURRENT_LIST_DIR}/../../Buildscripts/module.cmake")
+
+file(GLOB_RECURSE SOURCE_FILES "source/*.c*")
+
+tactility_add_module(lilygo-module
+    SRCS ${SOURCE_FILES}
+    INCLUDE_DIRS include/
+    REQUIRES TactilityKernel Tactility lvgl
+)

Drivers/lilygo-module/bindings/lilygo,tdeck-keyboard-backlight.yaml

@@ -0,0 +1,13 @@
+description: LilyGO T-Deck onboard keyboard backlight controller
+
+include: ["i2c-device.yaml"]
+
+compatible: "lilygo,tdeck-keyboard-backlight"
+
+bus: i2c
+
+properties:
+  brightness-default:
+    type: int
+    default: 127
+    description: Default brightness level, applied on start and by set_brightness_default(). Range 0-255.

Drivers/lilygo-module/bindings/lilygo,tdeck-keyboard.yaml

@@ -0,0 +1,7 @@
+description: LilyGO T-Deck onboard keyboard controller
+
+include: ["i2c-device.yaml"]
+
+compatible: "lilygo,tdeck-keyboard"
+
+bus: i2c

Drivers/lilygo-module/bindings/lilygo,tdeck-trackball.yaml

@@ -0,0 +1,25 @@
+description: LilyGO T-Deck 5-way GPIO trackball (4 directions + click button)
+
+compatible: "lilygo,tdeck-trackball"
+
+properties:
+  pin-right:
+    type: phandles
+    required: true
+    description: Right-direction GPIO pin
+  pin-up:
+    type: phandles
+    required: true
+    description: Up-direction GPIO pin
+  pin-left:
+    type: phandles
+    required: true
+    description: Left-direction GPIO pin
+  pin-down:
+    type: phandles
+    required: true
+    description: Down-direction GPIO pin
+  pin-click:
+    type: phandles
+    required: true
+    description: Click button GPIO pin

Drivers/lilygo-module/devicetree.yaml

@@ -0,0 +1,3 @@
+dependencies:
+  - TactilityKernel
+bindings: bindings

Drivers/lilygo-module/include/lilygo/bindings/tdeck_keyboard.h

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <tactility/bindings/bindings.h>
+#include <lilygo/drivers/tdeck_keyboard.h>
+
+DEFINE_DEVICETREE(tdeck_keyboard, struct TdeckKeyboardConfig)

Drivers/lilygo-module/include/lilygo/bindings/tdeck_keyboard_backlight.h

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <tactility/bindings/bindings.h>
+#include <lilygo/drivers/tdeck_keyboard_backlight.h>
+
+DEFINE_DEVICETREE(tdeck_keyboard_backlight, struct TdeckKeyboardBacklightConfig)

Drivers/lilygo-module/include/lilygo/bindings/tdeck_trackball.h

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <tactility/bindings/bindings.h>
+#include <lilygo/drivers/tdeck_trackball.h>
+
+DEFINE_DEVICETREE(tdeck_trackball, struct TdeckTrackballConfig)

Drivers/lilygo-module/include/lilygo/drivers/tdeck_keyboard.h

@@ -0,0 +1,16 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+struct TdeckKeyboardConfig {
+    uint8_t address;
+};
+
+#ifdef __cplusplus
+}
+#endif

Drivers/lilygo-module/include/lilygo/drivers/tdeck_keyboard_backlight.h

@@ -0,0 +1,17 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+struct TdeckKeyboardBacklightConfig {
+    uint8_t address;
+    uint8_t brightness_default;
+};
+
+#ifdef __cplusplus
+}
+#endif

Drivers/lilygo-module/include/lilygo/drivers/tdeck_power_on.h

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+bool tdeck_power_on();
+
+#ifdef __cplusplus
+}
+#endif

Drivers/lilygo-module/include/lilygo/drivers/tdeck_trackball.h

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <tactility/drivers/gpio.h>
+#include <tactility/error.h>
+#include <stdbool.h>
+#include <stdint.h>
+
+struct Device;
+struct DeviceType;
+
+struct TdeckTrackballConfig {
+    struct GpioPinSpec pin_right;
+    struct GpioPinSpec pin_up;
+    struct GpioPinSpec pin_left;
+    struct GpioPinSpec pin_down;
+    struct GpioPinSpec pin_click;
+};
+
+/**
+ * @brief API for the T-Deck 5-way trackball driver.
+ * Reports raw, unscaled movement: sensitivity and mode (encoder vs. pointer) are UI concerns
+ * layered on top by the consumer, not something this driver knows about.
+ */
+struct TdeckTrackballApi {
+    /**
+     * @brief Reads the accumulated movement since the last read, then resets it to zero.
+     * @param[in] device the trackball device
+     * @param[out] out_dx horizontal movement (right positive), in raw pulses
+     * @param[out] out_dy vertical movement (down positive), in raw pulses
+     * @retval ERROR_NONE when the operation was successful
+     */
+    error_t (*read_delta)(struct Device* device, int32_t* out_dx, int32_t* out_dy);
+
+    /**
+     * @brief Gets whether the click button is currently pressed.
+     * @param[in] device the trackball device
+     * @param[out] out_pressed true when pressed
+     * @retval ERROR_NONE when the operation was successful
+     */
+    error_t (*get_button_pressed)(struct Device* device, bool* out_pressed);
+};
+
+/**
+ * @brief Reads the accumulated movement using the specified trackball device.
+ */
+error_t tdeck_trackball_read_delta(struct Device* device, int32_t* out_dx, int32_t* out_dy);
+
+/**
+ * @brief Gets whether the click button is currently pressed on the specified trackball device.
+ */
+error_t tdeck_trackball_get_button_pressed(struct Device* device, bool* out_pressed);
+
+extern const struct DeviceType TDECK_TRACKBALL_TYPE;
+
+#ifdef __cplusplus
+}
+#endif

Drivers/lilygo-module/include/lilygo/drivers/trackball.h

@@ -0,0 +1,56 @@
+#pragma once
+
+#include <lvgl.h>
+
+namespace trackball {
+
+/**
+ * @brief Trackball operating mode
+ */
+enum class Mode {
+    Encoder,  // Navigation via enc_diff (scroll wheel behavior)
+    Pointer   // Mouse cursor via point.x/y
+};
+
+/**
+ * @brief Initialize trackball as an LVGL input device, backed by the kernel tdeck_trackball driver.
+ * @return LVGL input device pointer, or nullptr if the kernel device isn't found/started
+ */
+lv_indev_t* init();
+
+/**
+ * @brief Deinitialize trackball
+ */
+void deinit();
+
+/**
+ * @brief Set encoder mode sensitivity
+ * @param sensitivity Steps per trackball tick (1-10, default: 1)
+ */
+void setEncoderSensitivity(uint8_t sensitivity);
+
+/**
+ * @brief Set pointer mode sensitivity
+ * @param sensitivity Pixels per trackball tick (1-10, default: 10)
+ */
+void setPointerSensitivity(uint8_t sensitivity);
+
+/**
+ * @brief Enable or disable trackball input processing
+ * @param enabled Boolean value to enable or disable
+ */
+void setEnabled(bool enabled);
+
+/**
+ * @brief Set trackball operating mode
+ * @param mode Encoder or Pointer mode
+ */
+void setMode(Mode mode);
+
+/**
+ * @brief Get current trackball operating mode
+ * @return Current mode
+ */
+Mode getMode();
+
+}

Drivers/lilygo-module/include/lilygo_module.h

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <tactility/module.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct Module lilygo_module;
+
+#ifdef __cplusplus
+}
+#endif

Drivers/lilygo-module/source/module.cpp

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/check.h>
+#include <tactility/driver.h>
+#include <tactility/module.h>
+
+extern "C" {
+
+extern Driver tdeck_keyboard_driver;
+extern Driver tdeck_keyboard_backlight_driver;
+extern Driver tdeck_trackball_driver;
+
+static error_t start() {
+    /* We crash when construct fails, because if a single driver fails to construct,
+     * there is no guarantee that the previously constructed drivers can be destroyed */
+    check(driver_construct_add(&tdeck_keyboard_driver) == ERROR_NONE);
+    check(driver_construct_add(&tdeck_keyboard_backlight_driver) == ERROR_NONE);
+    check(driver_construct_add(&tdeck_trackball_driver) == ERROR_NONE);
+    return ERROR_NONE;
+}
+
+static error_t stop() {
+    /* We crash when destruct fails, because if a single driver fails to destruct,
+     * there is no guarantee that the previously destroyed drivers can be recovered */
+    check(driver_remove_destruct(&tdeck_keyboard_driver) == ERROR_NONE);
+    check(driver_remove_destruct(&tdeck_keyboard_backlight_driver) == ERROR_NONE);
+    check(driver_remove_destruct(&tdeck_trackball_driver) == ERROR_NONE);
+    return ERROR_NONE;
+}
+
+Module lilygo_module = {
+    .name = "lilygo",
+    .start = start,
+    .stop = stop,
+    .symbols = nullptr,
+    .internal = nullptr
+};
+
+} // extern "C"

Drivers/lilygo-module/source/tdeck_keyboard.cpp

@@ -0,0 +1,101 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <lilygo/drivers/tdeck_keyboard.h>
+
+#include <tactility/check.h>
+#include <tactility/device.h>
+#include <tactility/driver.h>
+#include <tactility/drivers/i2c_controller.h>
+#include <tactility/drivers/keyboard.h>
+#include <tactility/log.h>
+
+#include <cstdlib>
+
+#define TAG "TdeckKeyboard"
+#define GET_CONFIG(device) (static_cast<const TdeckKeyboardConfig*>((device)->config))
+
+static constexpr TickType_t I2C_TIMEOUT = pdMS_TO_TICKS(100);
+
+struct TdeckKeyboardInternal {
+    // The T-Deck keyboard controller only ever reports the currently pressed key (0x00 = none) and
+    // never a release event, so release events are synthesized by comparing against this.
+    uint8_t last_key;
+};
+
+// region Driver lifecycle
+
+static error_t start(Device* device) {
+    auto* parent = device_get_parent(device);
+    check(device_get_type(parent) == &I2C_CONTROLLER_TYPE);
+
+    auto address = GET_CONFIG(device)->address;
+    if (i2c_controller_has_device_at_address(parent, address, I2C_TIMEOUT) != ERROR_NONE) {
+        LOG_E(TAG, "No device found on I2C bus at address 0x%02X", address);
+        return ERROR_RESOURCE;
+    }
+
+    auto* internal = static_cast<TdeckKeyboardInternal*>(malloc(sizeof(TdeckKeyboardInternal)));
+    if (internal == nullptr) {
+        return ERROR_OUT_OF_MEMORY;
+    }
+    internal->last_key = 0;
+
+    device_set_driver_data(device, internal);
+    return ERROR_NONE;
+}
+
+static error_t stop(Device* device) {
+    auto* internal = static_cast<TdeckKeyboardInternal*>(device_get_driver_data(device));
+    free(internal);
+    return ERROR_NONE;
+}
+
+// endregion
+
+// region KeyboardApi
+
+static error_t tdeck_keyboard_read_key(Device* device, KeyboardKeyData* data) {
+    auto* parent = device_get_parent(device);
+    auto address = GET_CONFIG(device)->address;
+    auto* internal = static_cast<TdeckKeyboardInternal*>(device_get_driver_data(device));
+
+    uint8_t read_buffer = 0;
+    if (i2c_controller_read(parent, address, &read_buffer, 1, I2C_TIMEOUT) != ERROR_NONE) {
+        return ERROR_RESOURCE;
+    }
+
+    // This controller never buffers more than one key event.
+    data->continue_reading = false;
+
+    if (read_buffer == 0 && internal->last_key != 0) {
+        data->key = internal->last_key;
+        data->pressed = false;
+    } else if (read_buffer != 0) {
+        data->key = read_buffer;
+        data->pressed = true;
+    } else {
+        data->key = 0;
+        data->pressed = false;
+    }
+
+    internal->last_key = read_buffer;
+    return ERROR_NONE;
+}
+
+// endregion
+
+static const KeyboardApi tdeck_keyboard_api = {
+    .read_key = tdeck_keyboard_read_key,
+};
+
+extern Module lilygo_module;
+
+Driver tdeck_keyboard_driver = {
+    .name = "tdeck_keyboard",
+    .compatible = (const char*[]) { "lilygo,tdeck-keyboard", nullptr },
+    .start_device = start,
+    .stop_device = stop,
+    .api = &tdeck_keyboard_api,
+    .device_type = &KEYBOARD_TYPE,
+    .owner = &lilygo_module,
+    .internal = nullptr
+};

Drivers/lilygo-module/source/tdeck_keyboard_backlight.cpp

@@ -0,0 +1,122 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <lilygo/drivers/tdeck_keyboard_backlight.h>
+
+#include <tactility/check.h>
+#include <tactility/device.h>
+#include <tactility/driver.h>
+#include <tactility/drivers/backlight.h>
+#include <tactility/drivers/i2c_controller.h>
+#include <tactility/log.h>
+
+#include <cstdlib>
+
+#define TAG "TdeckKeyboardBacklight"
+#define GET_CONFIG(device) (static_cast<const TdeckKeyboardBacklightConfig*>((device)->config))
+
+static constexpr TickType_t I2C_TIMEOUT = pdMS_TO_TICKS(100);
+static constexpr uint8_t CMD_BRIGHTNESS = 0x01;
+static constexpr uint8_t CMD_DEFAULT_BRIGHTNESS = 0x02;
+
+struct TdeckKeyboardBacklightInternal {
+    // The controller is write-only for brightness, so the current value is cached here.
+    uint8_t current_brightness;
+};
+
+// region Driver lifecycle
+
+static error_t start(Device* device) {
+    auto* parent = device_get_parent(device);
+    check(device_get_type(parent) == &I2C_CONTROLLER_TYPE);
+
+    auto address = GET_CONFIG(device)->address;
+    if (i2c_controller_has_device_at_address(parent, address, I2C_TIMEOUT) != ERROR_NONE) {
+        LOG_E(TAG, "No device found on I2C bus at address 0x%02X", address);
+        return ERROR_RESOURCE;
+    }
+
+    auto* internal = static_cast<TdeckKeyboardBacklightInternal*>(malloc(sizeof(TdeckKeyboardBacklightInternal)));
+    if (internal == nullptr) {
+        return ERROR_OUT_OF_MEMORY;
+    }
+    internal->current_brightness = 0;
+    device_set_driver_data(device, internal);
+
+    auto brightness_default = GET_CONFIG(device)->brightness_default;
+
+    // Configures the keyboard controller's own persisted default, used by its onboard ALT+B toggle.
+    if (i2c_controller_write_register(parent, address, CMD_DEFAULT_BRIGHTNESS, &brightness_default, 1, I2C_TIMEOUT) != ERROR_NONE) {
+        LOG_E(TAG, "Failed to set default brightness");
+    }
+
+    if (i2c_controller_write_register(parent, address, CMD_BRIGHTNESS, &brightness_default, 1, I2C_TIMEOUT) != ERROR_NONE) {
+        LOG_E(TAG, "Failed to set initial brightness");
+    } else {
+        internal->current_brightness = brightness_default;
+    }
+
+    return ERROR_NONE;
+}
+
+static error_t stop(Device* device) {
+    auto* internal = static_cast<TdeckKeyboardBacklightInternal*>(device_get_driver_data(device));
+    free(internal);
+    return ERROR_NONE;
+}
+
+// endregion
+
+// region BacklightApi
+
+static error_t tdeck_keyboard_backlight_set_brightness(Device* device, uint8_t brightness) {
+    auto* parent = device_get_parent(device);
+    auto address = GET_CONFIG(device)->address;
+    auto* internal = static_cast<TdeckKeyboardBacklightInternal*>(device_get_driver_data(device));
+
+    if (i2c_controller_write_register(parent, address, CMD_BRIGHTNESS, &brightness, 1, I2C_TIMEOUT) != ERROR_NONE) {
+        return ERROR_RESOURCE;
+    }
+
+    internal->current_brightness = brightness;
+    return ERROR_NONE;
+}
+
+static error_t tdeck_keyboard_backlight_set_brightness_default(Device* device) {
+    return tdeck_keyboard_backlight_set_brightness(device, GET_CONFIG(device)->brightness_default);
+}
+
+static error_t tdeck_keyboard_backlight_get_brightness(Device* device, uint8_t* out_brightness) {
+    auto* internal = static_cast<TdeckKeyboardBacklightInternal*>(device_get_driver_data(device));
+    *out_brightness = internal->current_brightness;
+    return ERROR_NONE;
+}
+
+static uint8_t tdeck_keyboard_backlight_get_min_brightness(Device*) {
+    return 0;
+}
+
+static uint8_t tdeck_keyboard_backlight_get_max_brightness(Device*) {
+    return 255;
+}
+
+// endregion
+
+static const BacklightApi tdeck_keyboard_backlight_api = {
+    .set_brightness = tdeck_keyboard_backlight_set_brightness,
+    .set_brightness_default = tdeck_keyboard_backlight_set_brightness_default,
+    .get_brightness = tdeck_keyboard_backlight_get_brightness,
+    .get_min_brightness = tdeck_keyboard_backlight_get_min_brightness,
+    .get_max_brightness = tdeck_keyboard_backlight_get_max_brightness,
+};
+
+extern struct Module lilygo_module;
+
+Driver tdeck_keyboard_backlight_driver = {
+    .name = "tdeck_keyboard_backlight",
+    .compatible = (const char*[]) { "lilygo,tdeck-keyboard-backlight", nullptr },
+    .start_device = start,
+    .stop_device = stop,
+    .api = &tdeck_keyboard_backlight_api,
+    .device_type = &BACKLIGHT_TYPE,
+    .owner = &lilygo_module,
+    .internal = nullptr
+};

Drivers/lilygo-module/source/tdeck_power_on.c

@@ -0,0 +1,23 @@
+#include <driver/gpio.h>
+
+#define TDECK_POWERON_GPIO GPIO_NUM_10
+
+bool tdeck_power_on() {
+    gpio_config_t device_power_signal_config = {
+        .pin_bit_mask = BIT64(TDECK_POWERON_GPIO),
+        .mode = GPIO_MODE_OUTPUT,
+        .pull_up_en = GPIO_PULLUP_DISABLE,
+        .pull_down_en = GPIO_PULLDOWN_DISABLE,
+        .intr_type = GPIO_INTR_DISABLE,
+    };
+
+    if (gpio_config(&device_power_signal_config) != ESP_OK) {
+        return false;
+    }
+
+    if (gpio_set_level(TDECK_POWERON_GPIO, 1) != ESP_OK) {
+        return false;
+    }
+
+    return true;
+}

Drivers/lilygo-module/source/tdeck_trackball.cpp

@@ -0,0 +1,196 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <lilygo/drivers/tdeck_trackball.h>
+
+#include <tactility/device.h>
+#include <tactility/driver.h>
+#include <tactility/drivers/gpio_controller.h>
+#include <tactility/drivers/gpio_descriptor.h>
+#include <tactility/log.h>
+
+#include <atomic>
+#include <new>
+
+#define TAG "tdeck_trackball"
+#define GET_CONFIG(device) (static_cast<const TdeckTrackballConfig*>((device)->config))
+#define GET_INTERNAL(device) (static_cast<TdeckTrackballInternal*>(device_get_driver_data(device)))
+
+struct TdeckTrackballInternal {
+    GpioDescriptor* pin_right = nullptr;
+    GpioDescriptor* pin_up = nullptr;
+    GpioDescriptor* pin_left = nullptr;
+    GpioDescriptor* pin_down = nullptr;
+    GpioDescriptor* pin_click = nullptr;
+
+    std::atomic<int32_t> dx {0};
+    std::atomic<int32_t> dy {0};
+    std::atomic<bool> button_pressed {false};
+};
+
+// region ISR callbacks
+
+static void on_right(void* arg) {
+    static_cast<TdeckTrackballInternal*>(arg)->dx.fetch_add(1, std::memory_order_relaxed);
+}
+
+static void on_left(void* arg) {
+    static_cast<TdeckTrackballInternal*>(arg)->dx.fetch_sub(1, std::memory_order_relaxed);
+}
+
+static void on_down(void* arg) {
+    static_cast<TdeckTrackballInternal*>(arg)->dy.fetch_add(1, std::memory_order_relaxed);
+}
+
+static void on_up(void* arg) {
+    static_cast<TdeckTrackballInternal*>(arg)->dy.fetch_sub(1, std::memory_order_relaxed);
+}
+
+static void on_click(void* arg) {
+    auto* internal = static_cast<TdeckTrackballInternal*>(arg);
+    bool high = true;
+    gpio_descriptor_get_level(internal->pin_click, &high);
+    // Active low: pressed when level is low
+    internal->button_pressed.store(!high, std::memory_order_relaxed);
+}
+
+// endregion
+
+// region Pin acquisition
+
+static error_t acquire_pin(const GpioPinSpec& spec, GpioInterruptType interrupt_type, void (*callback)(void*), void* arg, GpioDescriptor** out_descriptor) {
+    auto* descriptor = gpio_descriptor_acquire(spec.gpio_controller, spec.pin, GPIO_OWNER_GPIO);
+    if (descriptor == nullptr) {
+        return ERROR_RESOURCE;
+    }
+
+    gpio_flags_t flags = GPIO_FLAG_DIRECTION_INPUT | GPIO_FLAG_PULL_UP;
+    flags = GPIO_FLAG_INTERRUPT_TO_OPTIONS(flags, interrupt_type);
+
+    error_t error = gpio_descriptor_set_flags(descriptor, flags);
+    if (error == ERROR_NONE) {
+        error = gpio_descriptor_add_callback(descriptor, callback, arg);
+    }
+    if (error == ERROR_NONE) {
+        error = gpio_descriptor_enable_interrupt(descriptor);
+    }
+
+    if (error != ERROR_NONE) {
+        gpio_descriptor_remove_callback(descriptor);
+        gpio_descriptor_release(descriptor);
+        return error;
+    }
+
+    *out_descriptor = descriptor;
+    return ERROR_NONE;
+}
+
+static void release_pin(GpioDescriptor*& descriptor) {
+    if (descriptor == nullptr) {
+        return;
+    }
+    gpio_descriptor_disable_interrupt(descriptor);
+    gpio_descriptor_remove_callback(descriptor);
+    gpio_descriptor_release(descriptor);
+    descriptor = nullptr;
+}
+
+static void release_all_pins(TdeckTrackballInternal* internal) {
+    release_pin(internal->pin_right);
+    release_pin(internal->pin_up);
+    release_pin(internal->pin_left);
+    release_pin(internal->pin_down);
+    release_pin(internal->pin_click);
+}
+
+// endregion
+
+extern "C" {
+
+static error_t read_delta(Device* device, int32_t* out_dx, int32_t* out_dy) {
+    auto* internal = GET_INTERNAL(device);
+    *out_dx = internal->dx.exchange(0, std::memory_order_relaxed);
+    *out_dy = internal->dy.exchange(0, std::memory_order_relaxed);
+    return ERROR_NONE;
+}
+
+static error_t get_button_pressed(Device* device, bool* out_pressed) {
+    *out_pressed = GET_INTERNAL(device)->button_pressed.load(std::memory_order_relaxed);
+    return ERROR_NONE;
+}
+
+error_t tdeck_trackball_read_delta(Device* device, int32_t* out_dx, int32_t* out_dy) {
+    return read_delta(device, out_dx, out_dy);
+}
+
+error_t tdeck_trackball_get_button_pressed(Device* device, bool* out_pressed) {
+    return get_button_pressed(device, out_pressed);
+}
+
+static error_t start(Device* device) {
+    LOG_I(TAG, "start %s", device->name);
+    auto* config = GET_CONFIG(device);
+
+    auto* internal = new(std::nothrow) TdeckTrackballInternal();
+    if (internal == nullptr) {
+        return ERROR_OUT_OF_MEMORY;
+    }
+
+    error_t error = acquire_pin(config->pin_right, GPIO_INTERRUPT_NEG_EDGE, on_right, internal, &internal->pin_right);
+    if (error == ERROR_NONE) {
+        error = acquire_pin(config->pin_up, GPIO_INTERRUPT_NEG_EDGE, on_up, internal, &internal->pin_up);
+    }
+    if (error == ERROR_NONE) {
+        error = acquire_pin(config->pin_left, GPIO_INTERRUPT_NEG_EDGE, on_left, internal, &internal->pin_left);
+    }
+    if (error == ERROR_NONE) {
+        error = acquire_pin(config->pin_down, GPIO_INTERRUPT_NEG_EDGE, on_down, internal, &internal->pin_down);
+    }
+    if (error == ERROR_NONE) {
+        error = acquire_pin(config->pin_click, GPIO_INTERRUPT_ANY_EDGE, on_click, internal, &internal->pin_click);
+    }
+
+    if (error != ERROR_NONE) {
+        LOG_E(TAG, "Failed to acquire trackball pins: %s", error_to_string(error));
+        release_all_pins(internal);
+        delete internal;
+        return error;
+    }
+
+    // Read the click pin's initial level now that the descriptor is acquired.
+    on_click(internal);
+
+    device_set_driver_data(device, internal);
+    return ERROR_NONE;
+}
+
+static error_t stop(Device* device) {
+    LOG_I(TAG, "stop %s", device->name);
+    auto* internal = GET_INTERNAL(device);
+    release_all_pins(internal);
+    device_set_driver_data(device, nullptr);
+    delete internal;
+    return ERROR_NONE;
+}
+
+static constexpr TdeckTrackballApi TDECK_TRACKBALL_API = {
+    .read_delta = read_delta,
+    .get_button_pressed = get_button_pressed,
+};
+
+const struct DeviceType TDECK_TRACKBALL_TYPE {
+    .name = "tdeck-trackball"
+};
+
+extern Module lilygo_module;
+
+Driver tdeck_trackball_driver = {
+    .name = "tdeck_trackball",
+    .compatible = (const char*[]) { "lilygo,tdeck-trackball", nullptr },
+    .start_device = start,
+    .stop_device = stop,
+    .api = &TDECK_TRACKBALL_API,
+    .device_type = &TDECK_TRACKBALL_TYPE,
+    .owner = &lilygo_module,
+    .internal = nullptr
+};
+
+}

Drivers/lilygo-module/source/trackball.cpp

@@ -0,0 +1,199 @@
+#include <lilygo/drivers/trackball.h>
+#include <lilygo/drivers/tdeck_trackball.h>
+
+#include <Tactility/Assets.h>
+
+#include <tactility/device.h>
+#include <tactility/log.h>
+
+
+constexpr auto* TAG = "Trackball";
+
+namespace trackball {
+
+static lv_indev_t* g_indev = nullptr;
+static Device* g_device = nullptr;
+static bool g_enabled = true;
+static Mode g_mode = Mode::Encoder;
+static uint8_t g_encoderSensitivity = 1;
+static uint8_t g_pointerSensitivity = 10;
+
+// Pointer mode cursor position (screen-relative)
+static int32_t g_cursorX = 160;
+static int32_t g_cursorY = 120;
+
+static lv_obj_t* g_cursor = nullptr;
+
+// Screen dimensions (T-Deck: 320x240)
+static constexpr int32_t SCREEN_WIDTH = 320;
+static constexpr int32_t SCREEN_HEIGHT = 240;
+static constexpr int32_t CURSOR_SIZE = 16;
+
+static inline int32_t clamp(int32_t val, int32_t minVal, int32_t maxVal) {
+    if (val < minVal) return minVal;
+    if (val > maxVal) return maxVal;
+    return val;
+}
+
+// Note: must be called from the LVGL thread (main thread), same as the setters below.
+static void read_cb(lv_indev_t* /*indev*/, lv_indev_data_t* data) {
+    // Always drain accumulated movement so it doesn't jump on re-enable, but discard it while disabled.
+    int32_t dx = 0;
+    int32_t dy = 0;
+    tdeck_trackball_read_delta(g_device, &dx, &dy);
+    if (!g_enabled) {
+        dx = 0;
+        dy = 0;
+    }
+
+    if (g_mode == Mode::Encoder) {
+        int32_t ticks = (dx + dy) * static_cast<int32_t>(g_encoderSensitivity);
+        data->enc_diff = static_cast<int16_t>(clamp(ticks, INT16_MIN, INT16_MAX));
+        if (ticks != 0) {
+            lv_display_trigger_activity(nullptr);
+        }
+    } else {
+        g_cursorX = clamp(g_cursorX + dx * static_cast<int32_t>(g_pointerSensitivity), 0, SCREEN_WIDTH - CURSOR_SIZE - 1);
+        g_cursorY = clamp(g_cursorY + dy * static_cast<int32_t>(g_pointerSensitivity), 0, SCREEN_HEIGHT - CURSOR_SIZE - 1);
+        data->point.x = static_cast<int16_t>(g_cursorX);
+        data->point.y = static_cast<int16_t>(g_cursorY);
+    }
+
+    bool pressed = false;
+    if (g_enabled) {
+        tdeck_trackball_get_button_pressed(g_device, &pressed);
+    }
+    data->state = pressed ? LV_INDEV_STATE_PRESSED : LV_INDEV_STATE_RELEASED;
+
+    if (pressed) {
+        lv_display_trigger_activity(nullptr);
+    }
+}
+
+lv_indev_t* init() {
+    if (g_indev != nullptr) {
+        LOG_W(TAG, "Already initialized");
+        return g_indev;
+    }
+
+    g_device = device_find_first_active_by_type(&TDECK_TRACKBALL_TYPE);
+    if (g_device == nullptr) {
+        LOG_E(TAG, "tdeck_trackball kernel device not found or not started");
+        return nullptr;
+    }
+
+    g_cursorX = SCREEN_WIDTH / 2;
+    g_cursorY = SCREEN_HEIGHT / 2;
+
+    g_indev = lv_indev_create();
+    if (g_indev == nullptr) {
+        LOG_E(TAG, "Failed to register LVGL input device");
+        g_device = nullptr;
+        return nullptr;
+    }
+
+    lv_indev_set_type(g_indev, LV_INDEV_TYPE_ENCODER);
+    lv_indev_set_read_cb(g_indev, read_cb);
+    LOG_I(TAG, "Initialized");
+
+    return g_indev;
+}
+
+// Create cursor for pointer mode
+static void createCursor() {
+    if (g_cursor != nullptr || g_indev == nullptr) return;
+
+    g_cursor = lv_image_create(lv_layer_sys());
+    if (g_cursor != nullptr) {
+        lv_obj_remove_flag(g_cursor, LV_OBJ_FLAG_CLICKABLE);
+        lv_image_set_src(g_cursor, TT_ASSETS_UI_CURSOR);
+        lv_indev_set_cursor(g_indev, g_cursor);
+        LOG_D(TAG, "Cursor created");
+    }
+}
+
+// Destroy cursor when switching back to encoder mode
+static void destroyCursor() {
+    if (g_cursor == nullptr) return;
+
+    // Delete the cursor object - this automatically detaches it from the indev
+    lv_obj_delete(g_cursor);
+    g_cursor = nullptr;
+    LOG_D(TAG, "Cursor destroyed");
+}
+
+void deinit() {
+    if (g_indev == nullptr) return;
+
+    destroyCursor();
+
+    lv_indev_delete(g_indev);
+    g_indev = nullptr;
+    g_device = nullptr;
+
+    g_mode = Mode::Encoder;
+    g_enabled = true;
+    LOG_I(TAG, "Deinitialized");
+}
+
+void setEncoderSensitivity(uint8_t sensitivity) {
+    if (sensitivity > 0) {
+        g_encoderSensitivity = sensitivity;
+        LOG_D(TAG, "Encoder sensitivity set to %d", sensitivity);
+    }
+}
+
+void setPointerSensitivity(uint8_t sensitivity) {
+    if (sensitivity > 0) {
+        g_pointerSensitivity = sensitivity;
+        LOG_D(TAG, "Pointer sensitivity set to %d", sensitivity);
+    }
+}
+
+void setEnabled(bool enabled) {
+    g_enabled = enabled;
+
+    if (g_cursor != nullptr) {
+        if (enabled) {
+            lv_obj_clear_flag(g_cursor, LV_OBJ_FLAG_HIDDEN);
+        } else {
+            lv_obj_add_flag(g_cursor, LV_OBJ_FLAG_HIDDEN);
+        }
+    }
+
+    LOG_I(TAG, "%s", enabled ? "Enabled" : "Disabled");
+}
+
+void setMode(Mode mode) {
+    if (g_indev == nullptr) {
+        LOG_W(TAG, "Cannot set mode - not initialized");
+        return;
+    }
+
+    if (g_mode == mode) {
+        return;
+    }
+
+    g_mode = mode;
+
+    if (mode == Mode::Pointer) {
+        lv_indev_set_type(g_indev, LV_INDEV_TYPE_POINTER);
+        createCursor();
+        if (!g_enabled && g_cursor != nullptr) {
+            lv_obj_add_flag(g_cursor, LV_OBJ_FLAG_HIDDEN);
+        }
+        g_cursorX = SCREEN_WIDTH / 2;
+        g_cursorY = SCREEN_HEIGHT / 2;
+        LOG_I(TAG, "Switched to Pointer mode");
+    } else {
+        destroyCursor();
+        lv_indev_set_type(g_indev, LV_INDEV_TYPE_ENCODER);
+        LOG_I(TAG, "Switched to Encoder mode");
+    }
+}
+
+Mode getMode() {
+    return g_mode;
+}
+
+}

Drivers/st7789-module/CMakeLists.txt

@@ -0,0 +1,11 @@
+cmake_minimum_required(VERSION 3.20)
+
+include("${CMAKE_CURRENT_LIST_DIR}/../../Buildscripts/module.cmake")
+
+file(GLOB_RECURSE SOURCE_FILES "source/*.c*")
+
+tactility_add_module(st7789-module
+    SRCS ${SOURCE_FILES}
+    INCLUDE_DIRS include/
+    REQUIRES TactilityKernel platform-esp32 esp_lcd driver
+)

Drivers/st7789-module/bindings/sitronix,st7789.yaml

@@ -0,0 +1,71 @@
+description: Sitronix ST7789 display panel
+
+compatible: "sitronix,st7789"
+
+bus: spi
+
+properties:
+  horizontal-resolution:
+    type: int
+    required: true
+    description: Horizontal resolution in pixels
+  vertical-resolution:
+    type: int
+    required: true
+    description: Vertical resolution in pixels
+  gap-x:
+    type: int
+    default: 0
+    description: X offset applied to all draw operations
+  gap-y:
+    type: int
+    default: 0
+    description: Y offset applied to all draw operations
+  swap-xy:
+    type: boolean
+    default: false
+    description: Swap the X and Y axes
+  mirror-x:
+    type: boolean
+    default: false
+    description: Mirror the X axis
+  mirror-y:
+    type: boolean
+    default: false
+    description: Mirror the Y axis
+  invert-color:
+    type: boolean
+    default: false
+    description: Invert the panel's color output
+  bgr-order:
+    type: boolean
+    default: false
+    description: Use BGR element order instead of RGB
+  bits-per-pixel:
+    type: int
+    default: 16
+    description: Color depth in bits per pixel
+  pixel-clock-hz:
+    type: int
+    default: 80000000
+    description: SPI pixel clock frequency in Hz
+  transaction-queue-depth:
+    type: int
+    default: 10
+    description: Size of the internal SPI transaction queue
+  pin-dc:
+    type: phandles
+    required: true
+    description: Data/Command GPIO pin
+  pin-reset:
+    type: phandles
+    default: GPIO_PIN_SPEC_NONE
+    description: Reset GPIO pin
+  reset-active-high:
+    type: boolean
+    default: false
+    description: Whether the reset pin is active high
+  backlight:
+    type: phandle
+    default: NULL
+    description: Optional reference to this display's backlight device

Drivers/st7789-module/devicetree.yaml

@@ -0,0 +1,3 @@
+dependencies:
+  - TactilityKernel
+bindings: bindings

Drivers/st7789-module/include/bindings/st7789.h

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <tactility/bindings/bindings.h>
+#include <drivers/st7789.h>
+
+DEFINE_DEVICETREE(st7789, struct St7789Config)

Drivers/st7789-module/include/drivers/st7789.h

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+#include <stdbool.h>
+
+#include <tactility/device.h>
+#include <tactility/drivers/gpio.h>
+
+struct St7789Config {
+    uint16_t horizontal_resolution;
+    uint16_t vertical_resolution;
+    int32_t gap_x;
+    int32_t gap_y;
+    bool swap_xy;
+    bool mirror_x;
+    bool mirror_y;
+    bool invert_color;
+    bool bgr_order;
+    uint32_t bits_per_pixel;
+    uint32_t pixel_clock_hz;
+    uint8_t transaction_queue_depth;
+    struct GpioPinSpec pin_dc;
+    struct GpioPinSpec pin_reset;
+    bool reset_active_high;
+    // Optional reference to this display's backlight device, NULL if none.
+    struct Device* backlight;
+};
+
+#ifdef __cplusplus
+}
+#endif

Drivers/st7789-module/include/st7789_module.h

@@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+#pragma once
+
+#include <tactility/module.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern struct Module st7789_module;
+
+#ifdef __cplusplus
+}
+#endif

Drivers/st7789-module/source/module.cpp

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/check.h>
+#include <tactility/driver.h>
+#include <tactility/module.h>
+
+extern "C" {
+
+extern Driver st7789_driver;
+
+static error_t start() {
+    /* We crash when construct fails, because if a single driver fails to construct,
+     * there is no guarantee that the previously constructed drivers can be destroyed */
+    check(driver_construct_add(&st7789_driver) == ERROR_NONE);
+    return ERROR_NONE;
+}
+
+static error_t stop() {
+    /* We crash when destruct fails, because if a single driver fails to destruct,
+     * there is no guarantee that the previously destroyed drivers can be recovered */
+    check(driver_remove_destruct(&st7789_driver) == ERROR_NONE);
+    return ERROR_NONE;
+}
+
+Module st7789_module = {
+    .name = "st7789",
+    .start = start,
+    .stop = stop,
+    .symbols = nullptr,
+    .internal = nullptr
+};
+
+} // extern "C"

Drivers/st7789-module/source/st7789.cpp

@@ -0,0 +1,278 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <drivers/st7789.h>
+#include <st7789_module.h>
+
+#include <tactility/check.h>
+#include <tactility/device.h>
+#include <tactility/driver.h>
+#include <tactility/drivers/display.h>
+#include <tactility/drivers/esp32_spi.h>
+#include <tactility/drivers/spi_controller.h>
+#include <tactility/error.h>
+#include <tactility/log.h>
+
+#include <esp_err.h>
+#include <esp_lcd_io_spi.h>
+#include <esp_lcd_panel_io.h>
+#include <esp_lcd_panel_ops.h>
+#include <esp_lcd_panel_st7789.h>
+
+#include <cstdlib>
+
+#define TAG "ST7789"
+
+#define GET_CONFIG(device) (static_cast<const St7789Config*>((device)->config))
+
+struct St7789Internal {
+    esp_lcd_panel_io_handle_t io_handle;
+    esp_lcd_panel_handle_t panel_handle;
+};
+
+static int pin_or_unused(const struct GpioPinSpec& pin) {
+    return pin.gpio_controller == nullptr ? -1 : static_cast<int>(pin.pin);
+}
+
+// region Driver lifecycle
+
+static error_t start(Device* device) {
+    auto* parent = device_get_parent(device);
+    check(device_get_type(parent) == &SPI_CONTROLLER_TYPE);
+
+    const auto* spi_config = static_cast<const Esp32SpiConfig*>(parent->config);
+    const auto* config = GET_CONFIG(device);
+
+    struct GpioPinSpec cs_pin;
+    if (esp32_spi_get_cs_pin(device, &cs_pin) != ERROR_NONE) {
+        LOG_E(TAG, "Failed to resolve CS pin");
+        return ERROR_RESOURCE;
+    }
+
+    auto* internal = static_cast<St7789Internal*>(malloc(sizeof(St7789Internal)));
+    if (internal == nullptr) {
+        return ERROR_OUT_OF_MEMORY;
+    }
+
+    esp_lcd_panel_io_spi_config_t io_config = {
+        .cs_gpio_num = pin_or_unused(cs_pin),
+        .dc_gpio_num = pin_or_unused(config->pin_dc),
+        .spi_mode = 0,
+        .pclk_hz = config->pixel_clock_hz,
+        .trans_queue_depth = config->transaction_queue_depth,
+        .on_color_trans_done = nullptr,
+        .user_ctx = nullptr,
+        .lcd_cmd_bits = 8,
+        .lcd_param_bits = 8,
+        .cs_ena_pretrans = 0,
+        .cs_ena_posttrans = 0,
+        .flags = {
+            .dc_high_on_cmd = 0,
+            .dc_low_on_data = 0,
+            .dc_low_on_param = 0,
+            .octal_mode = 0,
+            .quad_mode = 0,
+            .sio_mode = 1,
+            .lsb_first = 0,
+            .cs_high_active = 0,
+        },
+    };
+
+    esp_err_t ret = esp_lcd_new_panel_io_spi((esp_lcd_spi_bus_handle_t)spi_config->host, &io_config, &internal->io_handle);
+    if (ret != ESP_OK) {
+        LOG_E(TAG, "Failed to create panel IO: %s", esp_err_to_name(ret));
+        free(internal);
+        return ERROR_RESOURCE;
+    }
+
+    esp_lcd_panel_dev_config_t panel_config = {
+        .reset_gpio_num = pin_or_unused(config->pin_reset),
+        .rgb_ele_order = config->bgr_order ? LCD_RGB_ELEMENT_ORDER_BGR : LCD_RGB_ELEMENT_ORDER_RGB,
+        .data_endian = LCD_RGB_DATA_ENDIAN_LITTLE,
+        .bits_per_pixel = config->bits_per_pixel,
+        .flags = { .reset_active_high = config->reset_active_high },
+        .vendor_config = nullptr,
+    };
+
+    ret = esp_lcd_new_panel_st7789(internal->io_handle, &panel_config, &internal->panel_handle);
+    if (ret != ESP_OK) {
+        LOG_E(TAG, "Failed to create panel: %s", esp_err_to_name(ret));
+        esp_lcd_panel_io_del(internal->io_handle);
+        free(internal);
+        return ERROR_RESOURCE;
+    }
+
+    // Bring-up sequence, order matches EspLcdDisplayV2::applyConfiguration (proven correct on real ST7789 panels).
+    // Every failure path below must clean up fully: unlike stop_device, this is never retried by the kernel
+    // if start_device fails (see device_start() in TactilityKernel), so a partial failure here would leak.
+    bool ok =
+        esp_lcd_panel_reset(internal->panel_handle) == ESP_OK &&
+        esp_lcd_panel_init(internal->panel_handle) == ESP_OK &&
+        (!config->invert_color || esp_lcd_panel_invert_color(internal->panel_handle, true) == ESP_OK);
+
+    if (ok) {
+        int gap_x = config->swap_xy ? config->gap_y : config->gap_x;
+        int gap_y = config->swap_xy ? config->gap_x : config->gap_y;
+        ok = (gap_x == 0 && gap_y == 0) || esp_lcd_panel_set_gap(internal->panel_handle, gap_x, gap_y) == ESP_OK;
+    }
+    ok = ok && (!config->swap_xy || esp_lcd_panel_swap_xy(internal->panel_handle, true) == ESP_OK);
+    ok = ok && ((!config->mirror_x && !config->mirror_y) || esp_lcd_panel_mirror(internal->panel_handle, config->mirror_x, config->mirror_y) == ESP_OK);
+    ok = ok && (!config->invert_color || esp_lcd_panel_invert_color(internal->panel_handle, true) == ESP_OK);
+    ok = ok && esp_lcd_panel_disp_on_off(internal->panel_handle, true) == ESP_OK;
+
+    if (!ok) {
+        LOG_E(TAG, "Failed to bring up panel");
+        esp_lcd_panel_del(internal->panel_handle);
+        esp_lcd_panel_io_del(internal->io_handle);
+        free(internal);
+        return ERROR_RESOURCE;
+    }
+
+    device_set_driver_data(device, internal);
+    return ERROR_NONE;
+}
+
+static error_t stop(Device* device) {
+    auto* internal = static_cast<St7789Internal*>(device_get_driver_data(device));
+
+    if (esp_lcd_panel_del(internal->panel_handle) != ESP_OK) {
+        LOG_E(TAG, "Failed to delete panel");
+        return ERROR_RESOURCE;
+    }
+    if (esp_lcd_panel_io_del(internal->io_handle) != ESP_OK) {
+        LOG_E(TAG, "Failed to delete panel IO");
+        return ERROR_RESOURCE;
+    }
+
+    free(internal);
+    return ERROR_NONE;
+}
+
+// endregion
+
+// region DisplayApi
+
+static error_t st7789_reset(Device* device) {
+    auto* internal = static_cast<St7789Internal*>(device_get_driver_data(device));
+    return esp_lcd_panel_reset(internal->panel_handle) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t st7789_init(Device* device) {
+    auto* internal = static_cast<St7789Internal*>(device_get_driver_data(device));
+    return esp_lcd_panel_init(internal->panel_handle) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t st7789_draw_bitmap(Device* device, int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, const void* color_data) {
+    auto* internal = static_cast<St7789Internal*>(device_get_driver_data(device));
+    return esp_lcd_panel_draw_bitmap(internal->panel_handle, x_start, y_start, x_end, y_end, color_data) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t st7789_mirror(Device* device, bool x_axis, bool y_axis) {
+    auto* internal = static_cast<St7789Internal*>(device_get_driver_data(device));
+    return esp_lcd_panel_mirror(internal->panel_handle, x_axis, y_axis) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t st7789_swap_xy(Device* device, bool swap_axes) {
+    auto* internal = static_cast<St7789Internal*>(device_get_driver_data(device));
+    return esp_lcd_panel_swap_xy(internal->panel_handle, swap_axes) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+// Reads the devicetree-configured baseline, not live hardware state: swap_xy()/mirror() calls made after
+// start_device() (e.g. by an LVGL rotation binding) intentionally don't change what "rotation 0" means here.
+static bool st7789_get_swap_xy(Device* device) {
+    return GET_CONFIG(device)->swap_xy;
+}
+
+static bool st7789_get_mirror_x(Device* device) {
+    return GET_CONFIG(device)->mirror_x;
+}
+
+static bool st7789_get_mirror_y(Device* device) {
+    return GET_CONFIG(device)->mirror_y;
+}
+
+static error_t st7789_set_gap(Device* device, int32_t x_gap, int32_t y_gap) {
+    auto* internal = static_cast<St7789Internal*>(device_get_driver_data(device));
+    return esp_lcd_panel_set_gap(internal->panel_handle, x_gap, y_gap) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t st7789_invert_color(Device* device, bool invert_color_data) {
+    auto* internal = static_cast<St7789Internal*>(device_get_driver_data(device));
+    return esp_lcd_panel_invert_color(internal->panel_handle, invert_color_data) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t st7789_disp_on_off(Device* device, bool on_off) {
+    auto* internal = static_cast<St7789Internal*>(device_get_driver_data(device));
+    return esp_lcd_panel_disp_on_off(internal->panel_handle, on_off) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+static error_t st7789_disp_sleep(Device* device, bool sleep) {
+    auto* internal = static_cast<St7789Internal*>(device_get_driver_data(device));
+    return esp_lcd_panel_disp_sleep(internal->panel_handle, sleep) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
+}
+
+// SPI panels have no direct-mapped frame buffer; every draw is an SPI transaction, so the color
+// format here is derived purely from the devicetree config (bgr_order), not queried from hardware.
+// Only 16bpp (RGB565/BGR565) is representable in DisplayColorFormat; other bit depths are not
+// distinguishable and fall back to the 16bpp mapping.
+static enum DisplayColorFormat st7789_get_color_format(Device* device) {
+    const auto* config = GET_CONFIG(device);
+    return config->bgr_order ? DISPLAY_COLOR_FORMAT_BGR565 : DISPLAY_COLOR_FORMAT_RGB565;
+}
+
+static uint16_t st7789_get_resolution_x(Device* device) {
+    return GET_CONFIG(device)->horizontal_resolution;
+}
+
+static uint16_t st7789_get_resolution_y(Device* device) {
+    return GET_CONFIG(device)->vertical_resolution;
+}
+
+static void st7789_get_frame_buffer(Device*, uint8_t, void** out_buffer) {
+    *out_buffer = nullptr;
+}
+
+static uint8_t st7789_get_frame_buffer_count(Device*) {
+    return 0;
+}
+
+static error_t st7789_get_backlight(Device* device, Device** backlight) {
+    auto* configured_backlight = GET_CONFIG(device)->backlight;
+    if (configured_backlight == nullptr) {
+        return ERROR_NOT_SUPPORTED;
+    }
+    *backlight = configured_backlight;
+    return ERROR_NONE;
+}
+
+// endregion
+
+static const DisplayApi st7789_display_api = {
+    .reset = st7789_reset,
+    .init = st7789_init,
+    .draw_bitmap = st7789_draw_bitmap,
+    .mirror = st7789_mirror,
+    .swap_xy = st7789_swap_xy,
+    .get_swap_xy = st7789_get_swap_xy,
+    .get_mirror_x = st7789_get_mirror_x,
+    .get_mirror_y = st7789_get_mirror_y,
+    .set_gap = st7789_set_gap,
+    .invert_color = st7789_invert_color,
+    .disp_on_off = st7789_disp_on_off,
+    .disp_sleep = st7789_disp_sleep,
+    .get_color_format = st7789_get_color_format,
+    .get_resolution_x = st7789_get_resolution_x,
+    .get_resolution_y = st7789_get_resolution_y,
+    .get_frame_buffer = st7789_get_frame_buffer,
+    .get_frame_buffer_count = st7789_get_frame_buffer_count,
+    .get_backlight = st7789_get_backlight,
+};
+
+Driver st7789_driver = {
+    .name = "st7789",
+    .compatible = (const char*[]) { "sitronix,st7789", nullptr },
+    .start_device = start,
+    .stop_device = stop,
+    .api = &st7789_display_api,
+    .device_type = &DISPLAY_TYPE,
+    .owner = &st7789_module,
+    .internal = nullptr
+};