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

TactilityKernel/source/drivers/adc_controller.cpp

@@ -0,0 +1,22 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/drivers/adc_controller.h>
+#include <tactility/device.h>
+
+#define ADC_CONTROLLER_DRIVER_API(driver) ((struct AdcControllerApi*)driver->api)
+
+extern "C" {
+
+error_t adc_controller_read_raw(Device* device, uint8_t channel, int* out_raw, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return ADC_CONTROLLER_DRIVER_API(driver)->read_raw(device, channel, out_raw, timeout);
+}
+
+error_t adc_channel_read_raw(const struct AdcChannelSpec* spec, int* out_raw, TickType_t timeout) {
+    return adc_controller_read_raw(spec->adc_controller, spec->channel, out_raw, timeout);
+}
+
+const struct DeviceType ADC_CONTROLLER_TYPE {
+    .name = "adc-controller"
+};
+
+}

TactilityKernel/source/drivers/backlight.cpp

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/drivers/backlight.h>
+#include <tactility/device.h>
+
+#define BACKLIGHT_DRIVER_API(driver) ((struct BacklightApi*)driver->api)
+
+extern "C" {
+
+error_t backlight_set_brightness(Device* device, uint8_t brightness) {
+    const auto* driver = device_get_driver(device);
+    return BACKLIGHT_DRIVER_API(driver)->set_brightness(device, brightness);
+}
+
+error_t backlight_set_brightness_default(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return BACKLIGHT_DRIVER_API(driver)->set_brightness_default(device);
+}
+
+error_t backlight_get_brightness(Device* device, uint8_t* out_brightness) {
+    const auto* driver = device_get_driver(device);
+    return BACKLIGHT_DRIVER_API(driver)->get_brightness(device, out_brightness);
+}
+
+uint8_t backlight_get_min_brightness(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return BACKLIGHT_DRIVER_API(driver)->get_min_brightness(device);
+}
+
+uint8_t backlight_get_max_brightness(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return BACKLIGHT_DRIVER_API(driver)->get_max_brightness(device);
+}
+
+const DeviceType BACKLIGHT_TYPE {
+    .name = "backlight"
+};
+
+}

TactilityKernel/source/drivers/battery_sense.cpp

@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/check.h>
+#include <tactility/device.h>
+#include <tactility/driver.h>
+#include <tactility/drivers/adc_controller.h>
+#include <tactility/drivers/battery_sense.h>
+#include <tactility/drivers/power_supply.h>
+
+#include <new>
+
+// Raw-to-millivolt conversion assumes a 12-bit ADC, since the generic ADC API doesn't expose resolution.
+#define ADC_MAX_RAW 4095
+
+// Rough LiPo discharge curve, used to estimate a charge percentage from the sensed voltage since
+// this driver has no calibrated fuel gauge to read one from directly.
+#define BATTERY_MIN_MV 3200
+#define BATTERY_MAX_MV 4200
+
+// The power-supply child's config pointer isn't set; it reads its settings from its parent's config instead.
+#define GET_PARENT_CONFIG(device) ((const BatterySenseConfig*)device_get_parent(device)->config)
+
+extern "C" {
+
+static bool supports_property(Device*, PowerSupplyProperty property) {
+    return property == POWER_SUPPLY_PROP_VOLTAGE || property == POWER_SUPPLY_PROP_CAPACITY;
+}
+
+static error_t read_battery_mv(Device* device, int* out_mv) {
+    const auto* config = GET_PARENT_CONFIG(device);
+    int raw;
+    error_t error = adc_channel_read_raw(&config->io_channel, &raw, portMAX_DELAY);
+    if (error != ERROR_NONE) {
+        return error;
+    }
+
+    int64_t adc_mv = ((int64_t)raw * config->reference_voltage_mv) / ADC_MAX_RAW;
+    *out_mv = (int)((adc_mv * config->multiplier) / 1000);
+    return ERROR_NONE;
+}
+
+static int estimate_capacity_from_mv(int battery_mv) {
+    if (battery_mv <= BATTERY_MIN_MV) return 0;
+    if (battery_mv >= BATTERY_MAX_MV) return 100;
+    return (battery_mv - BATTERY_MIN_MV) * 100 / (BATTERY_MAX_MV - BATTERY_MIN_MV);
+}
+
+static error_t get_property(Device* device, PowerSupplyProperty property, PowerSupplyPropertyValue* out_value) {
+    if (property != POWER_SUPPLY_PROP_VOLTAGE && property != POWER_SUPPLY_PROP_CAPACITY) {
+        return ERROR_NOT_SUPPORTED;
+    }
+
+    int battery_mv;
+    error_t error = read_battery_mv(device, &battery_mv);
+    if (error != ERROR_NONE) {
+        return error;
+    }
+
+    out_value->int_value = (property == POWER_SUPPLY_PROP_VOLTAGE) ? battery_mv : estimate_capacity_from_mv(battery_mv);
+    return ERROR_NONE;
+}
+
+static bool supports_charge_control(Device*) { return false; }
+static bool is_allowed_to_charge(Device*) { return false; }
+static error_t set_allowed_to_charge(Device*, bool) { return ERROR_NOT_SUPPORTED; }
+static bool supports_quick_charge(Device*) { return false; }
+static bool is_quick_charge_enabled(Device*) { return false; }
+static error_t set_quick_charge_enabled(Device*, bool) { return ERROR_NOT_SUPPORTED; }
+static bool supports_power_off(Device*) { return false; }
+static error_t power_off(Device*) { return ERROR_NOT_SUPPORTED; }
+
+static constexpr PowerSupplyApi BATTERY_SENSE_POWER_SUPPLY_API = {
+    .supports_property = supports_property,
+    .get_property = get_property,
+    .supports_charge_control = supports_charge_control,
+    .is_allowed_to_charge = is_allowed_to_charge,
+    .set_allowed_to_charge = set_allowed_to_charge,
+    .supports_quick_charge = supports_quick_charge,
+    .is_quick_charge_enabled = is_quick_charge_enabled,
+    .set_quick_charge_enabled = set_quick_charge_enabled,
+    .supports_power_off = supports_power_off,
+    .power_off = power_off,
+};
+
+// Registered (driver_construct_add() in kernel_init.cpp) so driver_bind() has a valid ->internal,
+// but never matched against a devicetree node: battery_sense_driver wires it up directly by pointer.
+Driver battery_sense_power_supply_driver = {
+    .name = "battery-sense-power-supply",
+    .compatible = (const char*[]) { "battery-sense-power-supply", nullptr },
+    .start_device = nullptr,
+    .stop_device = nullptr,
+    .api = &BATTERY_SENSE_POWER_SUPPLY_API,
+    .device_type = &POWER_SUPPLY_TYPE,
+    .owner = nullptr,
+    .internal = nullptr
+};
+
+struct BatterySenseInternal {
+    Device* power_supply_device = nullptr;
+};
+
+static error_t create_power_supply_child(Device* parent, Device*& out_child) {
+    auto* child = new(std::nothrow) Device { .address = 0, .name = "battery-sense-power-supply", .config = nullptr, .parent = nullptr, .internal = nullptr };
+    if (child == nullptr) {
+        return ERROR_OUT_OF_MEMORY;
+    }
+
+    error_t error = device_construct(child);
+    if (error != ERROR_NONE) {
+        delete child;
+        return error;
+    }
+
+    device_set_parent(child, parent);
+    device_set_driver(child, &battery_sense_power_supply_driver);
+
+    error = device_add(child);
+    if (error != ERROR_NONE) {
+        device_destruct(child);
+        delete child;
+        return error;
+    }
+
+    error = device_start(child);
+    if (error != ERROR_NONE) {
+        device_remove(child);
+        device_destruct(child);
+        delete child;
+        return error;
+    }
+
+    out_child = child;
+    return ERROR_NONE;
+}
+
+static void destroy_power_supply_child(Device* child) {
+    check(device_stop(child) == ERROR_NONE);
+    check(device_remove(child) == ERROR_NONE);
+    check(device_destruct(child) == ERROR_NONE);
+    delete child;
+}
+
+static error_t start(Device* device) {
+    auto* internal = new(std::nothrow) BatterySenseInternal();
+    if (internal == nullptr) {
+        return ERROR_OUT_OF_MEMORY;
+    }
+
+    error_t error = create_power_supply_child(device, internal->power_supply_device);
+    if (error != ERROR_NONE) {
+        delete internal;
+        return error;
+    }
+
+    device_set_driver_data(device, internal);
+    return ERROR_NONE;
+}
+
+static error_t stop(Device* device) {
+    auto* internal = (BatterySenseInternal*)device_get_driver_data(device);
+    destroy_power_supply_child(internal->power_supply_device);
+    device_set_driver_data(device, nullptr);
+    delete internal;
+    return ERROR_NONE;
+}
+
+Driver battery_sense_driver = {
+    .name = "battery-sense",
+    .compatible = (const char*[]) { "battery-sense", nullptr },
+    .start_device = start,
+    .stop_device = stop,
+    .api = nullptr,
+    .device_type = nullptr,
+    .owner = nullptr,
+    .internal = nullptr
+};
+
+}

TactilityKernel/source/drivers/display.cpp

@@ -1,8 +1,101 @@
 // SPDX-License-Identifier: Apache-2.0
 #include <tactility/drivers/display.h>
+#include <tactility/device.h>
+
+#define DISPLAY_DRIVER_API(driver) ((struct DisplayApi*)driver->api)
 
 extern "C" {
 
+error_t display_reset(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->reset(device);
+}
+
+error_t display_init(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->init(device);
+}
+
+error_t display_draw_bitmap(Device* device, int32_t x_start, int32_t y_start, int32_t x_end, int32_t y_end, const void* color_data) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->draw_bitmap(device, x_start, y_start, x_end, y_end, color_data);
+}
+
+error_t display_mirror(Device* device, bool x_axis, bool y_axis) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->mirror(device, x_axis, y_axis);
+}
+
+error_t display_swap_xy(Device* device, bool swap_axes) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->swap_xy(device, swap_axes);
+}
+
+bool display_get_swap_xy(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->get_swap_xy(device);
+}
+
+bool display_get_mirror_x(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->get_mirror_x(device);
+}
+
+bool display_get_mirror_y(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->get_mirror_y(device);
+}
+
+error_t display_set_gap(Device* device, int32_t x_gap, int32_t y_gap) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->set_gap(device, x_gap, y_gap);
+}
+
+error_t display_invert_color(Device* device, bool invert_color_data) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->invert_color(device, invert_color_data);
+}
+
+error_t display_disp_on_off(Device* device, bool on_off) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->disp_on_off(device, on_off);
+}
+
+error_t display_disp_sleep(Device* device, bool sleep) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->disp_sleep(device, sleep);
+}
+
+enum DisplayColorFormat display_get_color_format(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->get_color_format(device);
+}
+
+uint16_t display_get_resolution_x(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->get_resolution_x(device);
+}
+
+uint16_t display_get_resolution_y(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->get_resolution_y(device);
+}
+
+void display_get_frame_buffer(Device* device, uint8_t index, void** out_buffer) {
+    const auto* driver = device_get_driver(device);
+    DISPLAY_DRIVER_API(driver)->get_frame_buffer(device, index, out_buffer);
+}
+
+uint8_t display_get_frame_buffer_count(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->get_frame_buffer_count(device);
+}
+
+error_t display_get_backlight(Device* device, Device** backlight) {
+    const auto* driver = device_get_driver(device);
+    return DISPLAY_DRIVER_API(driver)->get_backlight(device, backlight);
+}
+
 const struct DeviceType DISPLAY_TYPE {
     .name = "display"
 };

TactilityKernel/source/drivers/grove.cpp

@@ -6,17 +6,17 @@
 
 extern "C" {
 
-error_t grove_set_mode(struct Device* device, enum GroveMode mode) {
+error_t grove_set_mode(Device* device, GroveMode mode) {
     const auto* driver = device_get_driver(device);
     return GROVE_DRIVER_API(driver)->set_mode(device, mode);
 }
 
-error_t grove_get_mode(struct Device* device, enum GroveMode* mode) {
+error_t grove_get_mode(Device* device, GroveMode* mode) {
     const auto* driver = device_get_driver(device);
     return GROVE_DRIVER_API(driver)->get_mode(device, mode);
 }
 
-const struct DeviceType GROVE_TYPE {
+const DeviceType GROVE_TYPE {
     .name = "grove"
 };
 

TactilityKernel/source/drivers/keyboard.cpp

@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/drivers/keyboard.h>
+#include <tactility/device.h>
+
+#define KEYBOARD_DRIVER_API(driver) ((struct KeyboardApi*)driver->api)
+
+extern "C" {
+
+error_t keyboard_read_key(Device* device, KeyboardKeyData* data) {
+    const auto* driver = device_get_driver(device);
+    return KEYBOARD_DRIVER_API(driver)->read_key(device, data);
+}
+
+const DeviceType KEYBOARD_TYPE {
+    .name = "keyboard"
+};
+
+}

TactilityKernel/source/drivers/pointer.cpp

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/drivers/pointer.h>
+#include <tactility/device.h>
+
+#define POINTER_DRIVER_API(driver) ((struct PointerApi*)driver->api)
+
+extern "C" {
+
+error_t pointer_enter_sleep(struct Device* device) {
+    const auto* driver = device_get_driver(device);
+    return POINTER_DRIVER_API(driver)->enter_sleep(device);
+}
+
+error_t pointer_exit_sleep(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return POINTER_DRIVER_API(driver)->exit_sleep(device);
+}
+
+error_t pointer_read_data(Device* device, TickType_t timeout) {
+    const auto* driver = device_get_driver(device);
+    return POINTER_DRIVER_API(driver)->read_data(device, timeout);
+}
+
+bool pointer_get_touched_points(Device* device, uint16_t* x, uint16_t* y, uint16_t* strength, uint8_t* point_count, uint8_t max_point_count) {
+    const auto* driver = device_get_driver(device);
+    return POINTER_DRIVER_API(driver)->get_touched_points(device, x, y, strength, point_count, max_point_count);
+}
+
+error_t pointer_set_swap_xy(Device* device, bool swap) {
+    const auto* driver = device_get_driver(device);
+    return POINTER_DRIVER_API(driver)->set_swap_xy(device, swap);
+}
+
+error_t pointer_get_swap_xy(Device* device, bool* swap) {
+    const auto* driver = device_get_driver(device);
+    return POINTER_DRIVER_API(driver)->get_swap_xy(device, swap);
+}
+
+error_t pointer_set_mirror_x(Device* device, bool mirror) {
+    const auto* driver = device_get_driver(device);
+    return POINTER_DRIVER_API(driver)->set_mirror_x(device, mirror);
+}
+
+error_t pointer_get_mirror_x(Device* device, bool* mirror) {
+    const auto* driver = device_get_driver(device);
+    return POINTER_DRIVER_API(driver)->get_mirror_x(device, mirror);
+}
+
+error_t pointer_set_mirror_y(Device* device, bool mirror) {
+    const auto* driver = device_get_driver(device);
+    return POINTER_DRIVER_API(driver)->set_mirror_y(device, mirror);
+}
+
+error_t pointer_get_mirror_y(Device* device, bool* mirror) {
+    const auto* driver = device_get_driver(device);
+    return POINTER_DRIVER_API(driver)->get_mirror_y(device, mirror);
+}
+
+const struct DeviceType POINTER_TYPE {
+    .name = "pointer"
+};
+
+}

TactilityKernel/source/drivers/pointer_placeholder.cpp

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: Apache-2.0
-#include <tactility/drivers/touch_placeholder.h>
+#include <tactility/drivers/pointer_placeholder.h>
 #include <tactility/device.h>
 #include <tactility/driver.h>
-#include <tactility/drivers/touch.h>
+#include <tactility/drivers/pointer.h>
 #include <tactility/module.h>
 
 extern "C" {
@@ -12,13 +12,13 @@ static error_t stop(Device*) { return ERROR_NONE; }
 
 extern Module root_module;
 
-Driver touch_placeholder_driver = {
-    .name = "touch_placeholder",
-    .compatible = (const char*[]) { "touch-placeholder", nullptr },
+Driver pointer_placeholder_driver = {
+    .name = "pointer_placeholder",
+    .compatible = (const char*[]) { "pointer-placeholder", nullptr },
     .start_device = start,
     .stop_device = stop,
     .api = nullptr,
-    .device_type = &TOUCH_TYPE,
+    .device_type = &POINTER_TYPE,
     .owner = &root_module,
     .internal = nullptr
 };

TactilityKernel/source/drivers/power_supply.cpp

@@ -0,0 +1,63 @@
+// SPDX-License-Identifier: Apache-2.0
+#include <tactility/drivers/power_supply.h>
+#include <tactility/device.h>
+
+#define POWER_SUPPLY_DRIVER_API(driver) ((PowerSupplyApi*)driver->api)
+
+extern "C" {
+
+bool power_supply_supports_property(Device* device, PowerSupplyProperty property) {
+    const auto* driver = device_get_driver(device);
+    return POWER_SUPPLY_DRIVER_API(driver)->supports_property(device, property);
+}
+
+error_t power_supply_get_property(Device* device, PowerSupplyProperty property, union PowerSupplyPropertyValue* out_value) {
+    const auto* driver = device_get_driver(device);
+    return POWER_SUPPLY_DRIVER_API(driver)->get_property(device, property, out_value);
+}
+
+bool power_supply_supports_charge_control(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return POWER_SUPPLY_DRIVER_API(driver)->supports_charge_control(device);
+}
+
+bool power_supply_is_allowed_to_charge(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return POWER_SUPPLY_DRIVER_API(driver)->is_allowed_to_charge(device);
+}
+
+error_t power_supply_set_allowed_to_charge(Device* device, bool allowed) {
+    const auto* driver = device_get_driver(device);
+    return POWER_SUPPLY_DRIVER_API(driver)->set_allowed_to_charge(device, allowed);
+}
+
+bool power_supply_supports_quick_charge(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return POWER_SUPPLY_DRIVER_API(driver)->supports_quick_charge(device);
+}
+
+bool power_supply_is_quick_charge_enabled(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return POWER_SUPPLY_DRIVER_API(driver)->is_quick_charge_enabled(device);
+}
+
+error_t power_supply_set_quick_charge_enabled(Device* device, bool enabled) {
+    const auto* driver = device_get_driver(device);
+    return POWER_SUPPLY_DRIVER_API(driver)->set_quick_charge_enabled(device, enabled);
+}
+
+bool power_supply_supports_power_off(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return POWER_SUPPLY_DRIVER_API(driver)->supports_power_off(device);
+}
+
+error_t power_supply_power_off(Device* device) {
+    const auto* driver = device_get_driver(device);
+    return POWER_SUPPLY_DRIVER_API(driver)->power_off(device);
+}
+
+const DeviceType POWER_SUPPLY_TYPE {
+    .name = "power_supply"
+};
+
+}

TactilityKernel/source/drivers/rtc.cpp

@@ -6,17 +6,17 @@
 
 extern "C" {
 
-error_t rtc_get_time(struct Device* device, struct RtcDateTime* dt) {
+error_t rtc_get_time(Device* device, RtcDateTime* dt) {
     const auto* driver = device_get_driver(device);
     return RTC_DRIVER_API(driver)->get_time(device, dt);
 }
 
-error_t rtc_set_time(struct Device* device, const struct RtcDateTime* dt) {
+error_t rtc_set_time(Device* device, const RtcDateTime* dt) {
     const auto* driver = device_get_driver(device);
     return RTC_DRIVER_API(driver)->set_time(device, dt);
 }
 
-const struct DeviceType RTC_TYPE {
+const DeviceType RTC_TYPE {
     .name = "rtc"
 };
 

TactilityKernel/source/drivers/sdcard.cpp

@@ -3,7 +3,7 @@
 
 extern "C" {
 
-const struct DeviceType SDCARD_TYPE {
+const DeviceType SDCARD_TYPE {
     .name = "sdcard"
 };
 

TactilityKernel/source/drivers/spi_controller.cpp

@@ -7,22 +7,22 @@
 
 extern "C" {
 
-error_t spi_controller_lock(struct Device* device) {
+error_t spi_controller_lock(Device* device) {
     const auto* driver = device_get_driver(device);
     return SPI_DRIVER_API(driver)->lock(device);
 }
 
-error_t spi_controller_try_lock(struct Device* device, TickType_t timeout) {
+error_t spi_controller_try_lock(Device* device, TickType_t timeout) {
     const auto* driver = device_get_driver(device);
     return SPI_DRIVER_API(driver)->try_lock(device, timeout);
 }
 
-error_t spi_controller_unlock(struct Device* device) {
+error_t spi_controller_unlock(Device* device) {
     const auto* driver = device_get_driver(device);
     return SPI_DRIVER_API(driver)->unlock(device);
 }
 
-const struct DeviceType SPI_CONTROLLER_TYPE {
+const DeviceType SPI_CONTROLLER_TYPE {
     .name = "spi-controller"
 };
 

TactilityKernel/source/drivers/touch.cpp

@@ -1,10 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-#include <tactility/drivers/touch.h>
-
-extern "C" {
-
-const struct DeviceType TOUCH_TYPE {
-    .name = "touch"
-};
-
-}

TactilityKernel/source/kernel_init.cpp

@@ -16,10 +16,14 @@ static error_t start() {
     if (driver_construct_add(&root_driver) != ERROR_NONE) return ERROR_RESOURCE;
     extern Driver display_placeholder_driver;
     if (driver_construct_add(&display_placeholder_driver) != ERROR_NONE) return ERROR_RESOURCE;
-    extern Driver touch_placeholder_driver;
-    if (driver_construct_add(&touch_placeholder_driver) != ERROR_NONE) return ERROR_RESOURCE;
+    extern Driver pointer_placeholder_driver;
+    if (driver_construct_add(&pointer_placeholder_driver) != ERROR_NONE) return ERROR_RESOURCE;
     extern Driver spi_peripheral_driver;
     if (driver_construct_add(&spi_peripheral_driver) != ERROR_NONE) return ERROR_RESOURCE;
+    extern Driver battery_sense_driver;
+    if (driver_construct_add(&battery_sense_driver) != ERROR_NONE) return ERROR_RESOURCE;
+    extern Driver battery_sense_power_supply_driver;
+    if (driver_construct_add(&battery_sense_power_supply_driver) != ERROR_NONE) return ERROR_RESOURCE;
     return ERROR_NONE;
 }