Device migrations, drivers and fixes (#571)
Device migrations: - cyd-4848S040c - guition-jc1060p470ciwy - guition-jc2432w328c - guition-jc3248w535c (known issue with display and touch, Shadowtrance will look into it) - guition-jc8048w550c - heltec-wifi-lora-32-v3 - lilygo-tdeck-max (excluding graphics) - lilygo-tdisplay - lilygo-tdisplay-s3 - lilygo-tdongle-s3 - lilygo-tlora-pager Driver migrations: - Implemented haptic driver interface in kernel - AXS15231b - BQ25896 - BQ27220 - CST328 - CST6xx - DRV2605 - JD9165 - Custom LilyGO driver for T-Lora Pager - SSD1306 - ST7701 - ST7735 - SY6970 - TCA8418 Fixes/improvements: - Boot app: support for multiple power devices, improved UI - lvgl_devices and related code: fixes for mapping - Support for arrays in dts parser
This commit is contained in:
Ken Van Hoeylandt
committed by
GitHub
GitHub
parent
3b5a401594
commit
d896657bf9
@@ -0,0 +1,501 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
#include <drivers/axs15231b_display.h>
|
||||
#include <axs15231b_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_axs15231b.h>
|
||||
#include <esp_lcd_io_spi.h>
|
||||
#include <esp_lcd_panel_io.h>
|
||||
#include <esp_lcd_panel_ops.h>
|
||||
|
||||
#include <driver/gpio.h>
|
||||
#include <freertos/semphr.h>
|
||||
|
||||
#include <cstdlib>
|
||||
|
||||
#define TAG "AXS15231B"
|
||||
#define GET_CONFIG(device) (static_cast<const Axs15231bDisplayConfig*>((device)->config))
|
||||
|
||||
struct Axs15231bDisplayInternal {
|
||||
esp_lcd_panel_io_handle_t io_handle;
|
||||
esp_lcd_panel_handle_t panel_handle;
|
||||
// Given from ISR context by on_color_trans_done() once a queued transfer physically
|
||||
// completes. draw_bitmap() blocks on this so it can honor DisplayApi's synchronous contract
|
||||
// (see lvgl_display.c: the caller reuses/overwrites the color buffer as soon as draw_bitmap
|
||||
// returns) - esp_lcd_panel_draw_bitmap() itself only queues the transfer and returns early.
|
||||
SemaphoreHandle_t draw_done_semaphore;
|
||||
// Non-null only when a TE (Tearing-Effect) pin is configured. Signaled by te_isr_handler()
|
||||
// on each rising edge, so draw_bitmap() can wait for the next V-blank before transferring.
|
||||
SemaphoreHandle_t te_semaphore;
|
||||
bool te_isr_installed;
|
||||
// Whether we're the one who called gpio_install_isr_service() - if so, we must be the one to
|
||||
// uninstall it, but only if no other pin on the system is still relying on it.
|
||||
bool te_isr_service_installed_by_us;
|
||||
axs15231b_lcd_init_cmd_t* parsed_init_cmds;
|
||||
};
|
||||
|
||||
static bool IRAM_ATTR on_color_trans_done(esp_lcd_panel_io_handle_t, esp_lcd_panel_io_event_data_t*, void* user_ctx) {
|
||||
auto* internal = static_cast<Axs15231bDisplayInternal*>(user_ctx);
|
||||
BaseType_t high_task_woken = pdFALSE;
|
||||
xSemaphoreGiveFromISR(internal->draw_done_semaphore, &high_task_woken);
|
||||
return high_task_woken == pdTRUE;
|
||||
}
|
||||
|
||||
static void IRAM_ATTR te_isr_handler(void* arg) {
|
||||
auto* semaphore = static_cast<SemaphoreHandle_t>(arg);
|
||||
BaseType_t high_task_woken = pdFALSE;
|
||||
xSemaphoreGiveFromISR(semaphore, &high_task_woken);
|
||||
if (high_task_woken == pdTRUE) {
|
||||
portYIELD_FROM_ISR();
|
||||
}
|
||||
}
|
||||
|
||||
static int pin_or_unused(const struct GpioPinSpec& pin) {
|
||||
return pin.gpio_controller == nullptr ? -1 : static_cast<int>(pin.pin);
|
||||
}
|
||||
|
||||
static 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);
|
||||
}
|
||||
|
||||
// Unpacks the devicetree's flat [cmd, data_len, delay_ms, data_len bytes...] encoding (produced
|
||||
// by the devicetree compiler's "array" property type - see init-sequence in
|
||||
// bindings/axs,axs15231b.yaml) into a heap-allocated axs15231b_lcd_init_cmd_t array.
|
||||
static bool parse_init_sequence(const uint8_t* bytes, uint32_t length, axs15231b_lcd_init_cmd_t** out_cmds, uint16_t* out_count) {
|
||||
uint32_t count = 0;
|
||||
for (uint32_t offset = 0; offset < length; count++) {
|
||||
if (offset + 3 > length) {
|
||||
LOG_E(TAG, "init-sequence truncated: entry header runs past the end of the array");
|
||||
return false;
|
||||
}
|
||||
offset += 3 + bytes[offset + 1];
|
||||
if (offset > length) {
|
||||
LOG_E(TAG, "init-sequence truncated: entry data runs past the end of the array");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
auto* cmds = static_cast<axs15231b_lcd_init_cmd_t*>(malloc(count * sizeof(axs15231b_lcd_init_cmd_t)));
|
||||
if (cmds == nullptr) {
|
||||
return false;
|
||||
}
|
||||
|
||||
uint32_t offset = 0;
|
||||
for (uint32_t i = 0; i < count; i++) {
|
||||
uint8_t data_len = bytes[offset + 1];
|
||||
cmds[i] = {
|
||||
.cmd = bytes[offset],
|
||||
.data = data_len > 0 ? &bytes[offset + 3] : nullptr,
|
||||
.data_bytes = data_len,
|
||||
.delay_ms = bytes[offset + 2],
|
||||
};
|
||||
offset += 3 + data_len;
|
||||
}
|
||||
|
||||
*out_cmds = cmds;
|
||||
*out_count = (uint16_t)count;
|
||||
return true;
|
||||
}
|
||||
|
||||
// region Driver lifecycle
|
||||
|
||||
// Best-effort: a TE pin is a hardware refinement, not a requirement, so failures here are logged
|
||||
// and left for the caller to treat as non-fatal (matches the original deprecated-HAL driver,
|
||||
// which continued without TE sync if setup failed).
|
||||
static bool setup_te_sync(Axs15231bDisplayInternal* internal, gpio_num_t te_pin) {
|
||||
if (te_pin == GPIO_NUM_NC) {
|
||||
return true;
|
||||
}
|
||||
|
||||
internal->te_semaphore = xSemaphoreCreateBinary();
|
||||
if (internal->te_semaphore == nullptr) {
|
||||
LOG_E(TAG, "Failed to create TE sync semaphore");
|
||||
return false;
|
||||
}
|
||||
|
||||
gpio_config_t io_conf = {
|
||||
.pin_bit_mask = 1ULL << te_pin,
|
||||
.mode = GPIO_MODE_INPUT,
|
||||
.pull_up_en = GPIO_PULLUP_DISABLE,
|
||||
.pull_down_en = GPIO_PULLDOWN_DISABLE,
|
||||
.intr_type = GPIO_INTR_POSEDGE,
|
||||
};
|
||||
if (gpio_config(&io_conf) != ESP_OK) {
|
||||
LOG_E(TAG, "Failed to configure TE GPIO");
|
||||
vSemaphoreDelete(internal->te_semaphore);
|
||||
internal->te_semaphore = nullptr;
|
||||
return false;
|
||||
}
|
||||
|
||||
esp_err_t ret = gpio_install_isr_service(ESP_INTR_FLAG_IRAM);
|
||||
if (ret == ESP_OK) {
|
||||
internal->te_isr_service_installed_by_us = true;
|
||||
} else if (ret != ESP_ERR_INVALID_STATE) { // ESP_ERR_INVALID_STATE means it's already installed elsewhere
|
||||
LOG_E(TAG, "Failed to install GPIO ISR service");
|
||||
vSemaphoreDelete(internal->te_semaphore);
|
||||
internal->te_semaphore = nullptr;
|
||||
return false;
|
||||
}
|
||||
|
||||
if (gpio_isr_handler_add(te_pin, te_isr_handler, internal->te_semaphore) != ESP_OK) {
|
||||
LOG_E(TAG, "Failed to add TE ISR handler");
|
||||
if (internal->te_isr_service_installed_by_us) {
|
||||
gpio_uninstall_isr_service();
|
||||
internal->te_isr_service_installed_by_us = false;
|
||||
}
|
||||
vSemaphoreDelete(internal->te_semaphore);
|
||||
internal->te_semaphore = nullptr;
|
||||
return false;
|
||||
}
|
||||
|
||||
internal->te_isr_installed = true;
|
||||
return true;
|
||||
}
|
||||
|
||||
static void teardown_te_sync(Axs15231bDisplayInternal* internal, gpio_num_t te_pin) {
|
||||
if (internal->te_isr_installed) {
|
||||
gpio_isr_handler_remove(te_pin);
|
||||
gpio_intr_disable(te_pin);
|
||||
internal->te_isr_installed = false;
|
||||
}
|
||||
if (internal->te_isr_service_installed_by_us) {
|
||||
gpio_uninstall_isr_service();
|
||||
internal->te_isr_service_installed_by_us = false;
|
||||
}
|
||||
if (internal->te_semaphore != nullptr) {
|
||||
vSemaphoreDelete(internal->te_semaphore);
|
||||
internal->te_semaphore = nullptr;
|
||||
}
|
||||
}
|
||||
|
||||
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<Axs15231bDisplayInternal*>(malloc(sizeof(Axs15231bDisplayInternal)));
|
||||
if (internal == nullptr) {
|
||||
return ERROR_OUT_OF_MEMORY;
|
||||
}
|
||||
internal->te_semaphore = nullptr;
|
||||
internal->te_isr_installed = false;
|
||||
internal->te_isr_service_installed_by_us = false;
|
||||
internal->parsed_init_cmds = nullptr;
|
||||
|
||||
const axs15231b_lcd_init_cmd_t* init_cmds = nullptr;
|
||||
uint16_t init_cmds_size = 0;
|
||||
if (config->init_sequence != nullptr && config->init_sequence_length > 0) {
|
||||
if (!parse_init_sequence(config->init_sequence, config->init_sequence_length, &internal->parsed_init_cmds, &init_cmds_size)) {
|
||||
LOG_E(TAG, "Failed to parse init-sequence property");
|
||||
free(internal);
|
||||
return ERROR_INVALID_ARGUMENT;
|
||||
}
|
||||
init_cmds = internal->parsed_init_cmds;
|
||||
}
|
||||
|
||||
internal->draw_done_semaphore = xSemaphoreCreateBinary();
|
||||
if (internal->draw_done_semaphore == nullptr) {
|
||||
free(internal->parsed_init_cmds);
|
||||
free(internal);
|
||||
return ERROR_OUT_OF_MEMORY;
|
||||
}
|
||||
|
||||
// AXS15231B is only ever driven over QSPI in this codebase (no plain-SPI/i80 board has shown
|
||||
// up yet), so quad_mode/lcd_cmd_bits/lcd_param_bits are fixed rather than devicetree knobs -
|
||||
// matches AXS15231B_PANEL_IO_QSPI_CONFIG() in esp_lcd_axs15231b.h. dc_gpio_num is unused in
|
||||
// QSPI mode (command/data framing goes over the command byte instead of a DC line).
|
||||
esp_lcd_panel_io_spi_config_t io_config = {
|
||||
.cs_gpio_num = pin_or_unused(cs_pin),
|
||||
.dc_gpio_num = -1,
|
||||
.spi_mode = 3,
|
||||
.pclk_hz = config->pixel_clock_hz,
|
||||
.trans_queue_depth = config->transaction_queue_depth,
|
||||
.on_color_trans_done = on_color_trans_done,
|
||||
.user_ctx = internal,
|
||||
.lcd_cmd_bits = 32,
|
||||
.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 = 1,
|
||||
.sio_mode = 0,
|
||||
.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));
|
||||
vSemaphoreDelete(internal->draw_done_semaphore);
|
||||
free(internal->parsed_init_cmds);
|
||||
free(internal);
|
||||
return ERROR_RESOURCE;
|
||||
}
|
||||
|
||||
axs15231b_vendor_config_t vendor_config = {
|
||||
.init_cmds = init_cmds,
|
||||
.init_cmds_size = init_cmds_size,
|
||||
.flags = {
|
||||
.use_qspi_interface = 1,
|
||||
},
|
||||
};
|
||||
|
||||
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 = 16,
|
||||
.flags = { .reset_active_high = config->reset_active_high },
|
||||
.vendor_config = &vendor_config,
|
||||
};
|
||||
|
||||
ret = esp_lcd_new_panel_axs15231b(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);
|
||||
vSemaphoreDelete(internal->draw_done_semaphore);
|
||||
free(internal->parsed_init_cmds);
|
||||
free(internal);
|
||||
return ERROR_RESOURCE;
|
||||
}
|
||||
|
||||
// Bring-up sequence. swap_xy is intentionally not called (and not exposed in DisplayApi below):
|
||||
// It doesn't work on this chip/panel combination.
|
||||
//
|
||||
// esp_lcd_axs15231b's disp_on_off callback is wired up backwards: its body branches on a
|
||||
// parameter it names "off" (true -> DISPOFF, false -> DISPON), but esp_lcd_panel_disp_on_off()
|
||||
// forwards its "on_off" argument straight through with no inversion - so passing true here
|
||||
// actually switches the panel OFF. Pass false to really turn it on (confirmed against the
|
||||
// deleted deprecated-HAL driver, which called this same function with false for the same
|
||||
// reason). See axs15231b_disp_on_off() below, which un-inverts this for DisplayApi callers.
|
||||
//
|
||||
// (note: all of this was tested on guition-jc3248w535c only)
|
||||
bool ok =
|
||||
esp_lcd_panel_reset(internal->panel_handle) == ESP_OK &&
|
||||
esp_lcd_panel_init(internal->panel_handle) == ESP_OK &&
|
||||
esp_lcd_panel_mirror(internal->panel_handle, config->mirror_x, config->mirror_y) == ESP_OK &&
|
||||
esp_lcd_panel_invert_color(internal->panel_handle, config->invert_color) == ESP_OK &&
|
||||
esp_lcd_panel_disp_on_off(internal->panel_handle, false) == 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);
|
||||
vSemaphoreDelete(internal->draw_done_semaphore);
|
||||
free(internal->parsed_init_cmds);
|
||||
free(internal);
|
||||
return ERROR_RESOURCE;
|
||||
}
|
||||
|
||||
if (!setup_te_sync(internal, pin_or_nc(config->pin_te))) {
|
||||
LOG_W(TAG, "TE sync setup failed, continuing without TE synchronization");
|
||||
}
|
||||
|
||||
device_set_driver_data(device, internal);
|
||||
return ERROR_NONE;
|
||||
}
|
||||
|
||||
static error_t stop(Device* device) {
|
||||
const auto* config = GET_CONFIG(device);
|
||||
auto* internal = static_cast<Axs15231bDisplayInternal*>(device_get_driver_data(device));
|
||||
|
||||
teardown_te_sync(internal, pin_or_nc(config->pin_te));
|
||||
|
||||
if (internal->panel_handle != nullptr) {
|
||||
if (esp_lcd_panel_del(internal->panel_handle) != ESP_OK) {
|
||||
LOG_E(TAG, "Failed to delete panel");
|
||||
return ERROR_RESOURCE;
|
||||
}
|
||||
internal->panel_handle = nullptr;
|
||||
}
|
||||
|
||||
if (internal->io_handle != nullptr) {
|
||||
if (esp_lcd_panel_io_del(internal->io_handle) != ESP_OK) {
|
||||
LOG_E(TAG, "Failed to delete panel IO");
|
||||
return ERROR_RESOURCE;
|
||||
}
|
||||
internal->io_handle = nullptr;
|
||||
}
|
||||
|
||||
vSemaphoreDelete(internal->draw_done_semaphore);
|
||||
free(internal->parsed_init_cmds);
|
||||
free(internal);
|
||||
device_set_driver_data(device, nullptr);
|
||||
return ERROR_NONE;
|
||||
}
|
||||
|
||||
// endregion
|
||||
|
||||
// region DisplayApi
|
||||
|
||||
static error_t axs15231b_reset(Device* device) {
|
||||
auto* internal = static_cast<Axs15231bDisplayInternal*>(device_get_driver_data(device));
|
||||
return esp_lcd_panel_reset(internal->panel_handle) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
|
||||
}
|
||||
|
||||
static error_t axs15231b_init(Device* device) {
|
||||
auto* internal = static_cast<Axs15231bDisplayInternal*>(device_get_driver_data(device));
|
||||
return esp_lcd_panel_init(internal->panel_handle) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
|
||||
}
|
||||
|
||||
static error_t axs15231b_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<Axs15231bDisplayInternal*>(device_get_driver_data(device));
|
||||
|
||||
// Best-effort wait for the next V-blank pulse before transferring, to reduce visible tearing.
|
||||
// Non-fatal if it times out (matches the original deprecated-HAL driver) - draw_bitmap()
|
||||
// still has to happen even if TE sync missed its window.
|
||||
if (internal->te_semaphore != nullptr) {
|
||||
xSemaphoreTake(internal->te_semaphore, 0); // drain any already-pending signal
|
||||
xSemaphoreTake(internal->te_semaphore, pdMS_TO_TICKS(20));
|
||||
}
|
||||
|
||||
// Drain any stale signal left over from a prior non-draw transaction (bring-up commands like
|
||||
// reset/init also complete through on_color_trans_done), so the take() below can only be
|
||||
// satisfied by this draw's own transfer completing.
|
||||
xSemaphoreTake(internal->draw_done_semaphore, 0);
|
||||
|
||||
if (esp_lcd_panel_draw_bitmap(internal->panel_handle, x_start, y_start, x_end, y_end, color_data) != ESP_OK) {
|
||||
return ERROR_RESOURCE;
|
||||
}
|
||||
|
||||
xSemaphoreTake(internal->draw_done_semaphore, portMAX_DELAY);
|
||||
return ERROR_NONE;
|
||||
}
|
||||
|
||||
static error_t axs15231b_mirror(Device* device, bool x_axis, bool y_axis) {
|
||||
auto* internal = static_cast<Axs15231bDisplayInternal*>(device_get_driver_data(device));
|
||||
return esp_lcd_panel_mirror(internal->panel_handle, x_axis, y_axis) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
|
||||
}
|
||||
|
||||
static bool axs15231b_get_mirror_x(Device* device) {
|
||||
return GET_CONFIG(device)->mirror_x;
|
||||
}
|
||||
|
||||
static bool axs15231b_get_mirror_y(Device* device) {
|
||||
return GET_CONFIG(device)->mirror_y;
|
||||
}
|
||||
|
||||
// swap_xy/set_gap/disp_sleep are not exposed: swap_xy is confirmed non-functional on this
|
||||
// chip/panel combination on real hardware (see start()'s comment), and the AXS15231B component
|
||||
// doesn't implement set_gap or disp_sleep at all.
|
||||
|
||||
static error_t axs15231b_invert_color(Device* device, bool invert_color_data) {
|
||||
auto* internal = static_cast<Axs15231bDisplayInternal*>(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 axs15231b_disp_on_off(Device* device, bool on_off) {
|
||||
auto* internal = static_cast<Axs15231bDisplayInternal*>(device_get_driver_data(device));
|
||||
// Inverted: see the comment on the disp_on_off call in start() above.
|
||||
return esp_lcd_panel_disp_on_off(internal->panel_handle, !on_off) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
|
||||
}
|
||||
|
||||
// _SWAPPED (not plain RGB565): the panel expects each 16-bit pixel high-byte-first over the QSPI
|
||||
// bus, but this CPU is little-endian - the original deprecated-HAL driver did the equivalent
|
||||
// byte-swap by hand in its custom flush callback (lv_draw_sw_rgb565_swap()); the generic
|
||||
// lvgl-module bridge does it for us once we report this format (see lvgl_display_map_color_format()).
|
||||
static enum DisplayColorFormat axs15231b_get_color_format(Device*) {
|
||||
return DISPLAY_COLOR_FORMAT_RGB565_SWAPPED;
|
||||
}
|
||||
|
||||
static uint16_t axs15231b_get_resolution_x(Device* device) {
|
||||
return GET_CONFIG(device)->horizontal_resolution;
|
||||
}
|
||||
|
||||
static uint16_t axs15231b_get_resolution_y(Device* device) {
|
||||
return GET_CONFIG(device)->vertical_resolution;
|
||||
}
|
||||
|
||||
static void axs15231b_get_frame_buffer(Device*, uint8_t, void** out_buffer) {
|
||||
*out_buffer = nullptr;
|
||||
}
|
||||
|
||||
static uint8_t axs15231b_get_frame_buffer_count(Device*) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
static error_t axs15231b_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;
|
||||
}
|
||||
|
||||
// REQUIRES_FULL_FRAME is the only capability that varies per device instance (via the
|
||||
// requires-full-frame devicetree property, see axs15231b_display.h) - a sub-region draw_bitmap()
|
||||
// call desyncs this chip's row auto-increment counter, since its QSPI command set has no
|
||||
// row-address command, but that's been confirmed needed on some boards' wiring/panel combination
|
||||
// and not assumed true for every AXS15231B board (see start()'s notes on what's been tested where).
|
||||
// Every other bit stays fixed for the driver, mirrored here from axs15231b_display_api.capabilities.
|
||||
static bool axs15231b_has_capability(Device* device, uint32_t capability) {
|
||||
uint32_t static_capabilities = DISPLAY_CAPABILITY_CAP_MIRROR | DISPLAY_CAPABILITY_INVERT_COLOR |
|
||||
DISPLAY_CAPABILITY_ON_OFF | DISPLAY_CAPABILITY_BACKLIGHT;
|
||||
if (GET_CONFIG(device)->requires_full_frame) {
|
||||
static_capabilities |= DISPLAY_CAPABILITY_REQUIRES_FULL_FRAME;
|
||||
}
|
||||
return (static_capabilities & capability) == capability;
|
||||
}
|
||||
|
||||
// endregion
|
||||
|
||||
static const DisplayApi axs15231b_display_api = {
|
||||
// Mirrors axs15231b_has_capability()'s static_capabilities for callers that read this field
|
||||
// directly instead of going through display_has_capability()/has_capability(). Excludes
|
||||
// REQUIRES_FULL_FRAME - see axs15231b_has_capability() above, which is the source of truth.
|
||||
.capabilities = DISPLAY_CAPABILITY_CAP_MIRROR | DISPLAY_CAPABILITY_INVERT_COLOR |
|
||||
DISPLAY_CAPABILITY_ON_OFF | DISPLAY_CAPABILITY_BACKLIGHT,
|
||||
.reset = axs15231b_reset,
|
||||
.init = axs15231b_init,
|
||||
.draw_bitmap = axs15231b_draw_bitmap,
|
||||
.mirror = axs15231b_mirror,
|
||||
.swap_xy = nullptr,
|
||||
.get_swap_xy = nullptr,
|
||||
.get_mirror_x = axs15231b_get_mirror_x,
|
||||
.get_mirror_y = axs15231b_get_mirror_y,
|
||||
.set_gap = nullptr,
|
||||
.invert_color = axs15231b_invert_color,
|
||||
.disp_on_off = axs15231b_disp_on_off,
|
||||
.disp_sleep = nullptr,
|
||||
.get_color_format = axs15231b_get_color_format,
|
||||
.get_resolution_x = axs15231b_get_resolution_x,
|
||||
.get_resolution_y = axs15231b_get_resolution_y,
|
||||
.get_frame_buffer = axs15231b_get_frame_buffer,
|
||||
.get_frame_buffer_count = axs15231b_get_frame_buffer_count,
|
||||
.get_backlight = axs15231b_get_backlight,
|
||||
.has_capability = axs15231b_has_capability,
|
||||
};
|
||||
|
||||
Driver axs15231b_display_driver = {
|
||||
.name = "axs15231b_display",
|
||||
.compatible = (const char*[]) { "axs,axs15231b", nullptr },
|
||||
.start_device = start,
|
||||
.stop_device = stop,
|
||||
.api = &axs15231b_display_api,
|
||||
.device_type = &DISPLAY_TYPE,
|
||||
.owner = &axs15231b_module,
|
||||
.internal = nullptr
|
||||
};
|
||||
@@ -0,0 +1,211 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
#include <drivers/axs15231b_touch.h>
|
||||
#include <axs15231b_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/error.h>
|
||||
#include <tactility/log.h>
|
||||
|
||||
#include <esp_err.h>
|
||||
#include <esp_lcd_axs15231b.h>
|
||||
#include <esp_lcd_io_i2c.h>
|
||||
#include <esp_lcd_panel_io.h>
|
||||
#include <esp_lcd_touch.h>
|
||||
|
||||
#include <cstdlib>
|
||||
|
||||
#define TAG "AXS15231BTouch"
|
||||
#define GET_CONFIG(device) (static_cast<const Axs15231bTouchConfig*>((device)->config))
|
||||
|
||||
struct Axs15231bTouchInternal {
|
||||
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
|
||||
|
||||
// AXS15231B always sits at a fixed I2C address (ESP_LCD_TOUCH_IO_I2C_AXS15231B_ADDRESS), unlike
|
||||
// GT911's strapping-dependent address, so no bus probing is needed here.
|
||||
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_AXS15231B_CONFIG();
|
||||
|
||||
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<Axs15231bTouchInternal*>(malloc(sizeof(Axs15231bTouchInternal)));
|
||||
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_axs15231b(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<Axs15231bTouchInternal*>(device_get_driver_data(device));
|
||||
|
||||
// esp_lcd_touch_del() only releases the touch-side resources; the panel IO handle is owned
|
||||
// separately and needs its own deletion.
|
||||
if (internal->touch_handle != nullptr) {
|
||||
if (esp_lcd_touch_del(internal->touch_handle) != ESP_OK) {
|
||||
LOG_E(TAG, "Failed to delete touch handle");
|
||||
return ERROR_RESOURCE;
|
||||
}
|
||||
internal->touch_handle = nullptr;
|
||||
}
|
||||
|
||||
if (internal->io_handle != nullptr) {
|
||||
if (esp_lcd_panel_io_del(internal->io_handle) != ESP_OK) {
|
||||
LOG_E(TAG, "Failed to delete panel IO handle");
|
||||
return ERROR_RESOURCE;
|
||||
}
|
||||
internal->io_handle = nullptr;
|
||||
}
|
||||
|
||||
free(internal);
|
||||
device_set_driver_data(device, nullptr);
|
||||
return ERROR_NONE;
|
||||
}
|
||||
|
||||
// endregion
|
||||
|
||||
// region PointerApi
|
||||
|
||||
static error_t axs15231b_touch_enter_sleep(Device* device) {
|
||||
auto* internal = static_cast<Axs15231bTouchInternal*>(device_get_driver_data(device));
|
||||
return esp_lcd_touch_enter_sleep(internal->touch_handle) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
|
||||
}
|
||||
|
||||
static error_t axs15231b_touch_exit_sleep(Device* device) {
|
||||
auto* internal = static_cast<Axs15231bTouchInternal*>(device_get_driver_data(device));
|
||||
return esp_lcd_touch_exit_sleep(internal->touch_handle) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
|
||||
}
|
||||
|
||||
static error_t axs15231b_touch_read_data(Device* device, TickType_t timeout) {
|
||||
(void)timeout; // esp_lcd_touch_read_data() has no timeout parameter
|
||||
auto* internal = static_cast<Axs15231bTouchInternal*>(device_get_driver_data(device));
|
||||
return esp_lcd_touch_read_data(internal->touch_handle) == ESP_OK ? ERROR_NONE : ERROR_RESOURCE;
|
||||
}
|
||||
|
||||
static bool axs15231b_touch_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<Axs15231bTouchInternal*>(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 axs15231b_touch_set_swap_xy(Device* device, bool swap) {
|
||||
auto* internal = static_cast<Axs15231bTouchInternal*>(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 axs15231b_touch_get_swap_xy(Device* device, bool* swap) {
|
||||
auto* internal = static_cast<Axs15231bTouchInternal*>(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 axs15231b_touch_set_mirror_x(Device* device, bool mirror) {
|
||||
auto* internal = static_cast<Axs15231bTouchInternal*>(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 axs15231b_touch_get_mirror_x(Device* device, bool* mirror) {
|
||||
auto* internal = static_cast<Axs15231bTouchInternal*>(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 axs15231b_touch_set_mirror_y(Device* device, bool mirror) {
|
||||
auto* internal = static_cast<Axs15231bTouchInternal*>(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 axs15231b_touch_get_mirror_y(Device* device, bool* mirror) {
|
||||
auto* internal = static_cast<Axs15231bTouchInternal*>(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 axs15231b_touch_pointer_api = {
|
||||
.enter_sleep = axs15231b_touch_enter_sleep,
|
||||
.exit_sleep = axs15231b_touch_exit_sleep,
|
||||
.read_data = axs15231b_touch_read_data,
|
||||
.get_touched_points = axs15231b_touch_get_touched_points,
|
||||
.set_swap_xy = axs15231b_touch_set_swap_xy,
|
||||
.get_swap_xy = axs15231b_touch_get_swap_xy,
|
||||
.set_mirror_x = axs15231b_touch_set_mirror_x,
|
||||
.get_mirror_x = axs15231b_touch_get_mirror_x,
|
||||
.set_mirror_y = axs15231b_touch_set_mirror_y,
|
||||
.get_mirror_y = axs15231b_touch_get_mirror_y,
|
||||
};
|
||||
|
||||
Driver axs15231b_touch_driver = {
|
||||
.name = "axs15231b_touch",
|
||||
.compatible = (const char*[]) { "axs,axs15231b-touch", nullptr },
|
||||
.start_device = start,
|
||||
.stop_device = stop,
|
||||
.api = &axs15231b_touch_pointer_api,
|
||||
.device_type = &POINTER_TYPE,
|
||||
.owner = &axs15231b_module,
|
||||
.internal = nullptr
|
||||
};
|
||||
@@ -0,0 +1,35 @@
|
||||
// SPDX-License-Identifier: Apache-2.0
|
||||
#include <tactility/check.h>
|
||||
#include <tactility/driver.h>
|
||||
#include <tactility/module.h>
|
||||
|
||||
extern "C" {
|
||||
|
||||
extern Driver axs15231b_display_driver;
|
||||
extern Driver axs15231b_touch_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(&axs15231b_display_driver) == ERROR_NONE);
|
||||
check(driver_construct_add(&axs15231b_touch_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(&axs15231b_touch_driver) == ERROR_NONE);
|
||||
check(driver_remove_destruct(&axs15231b_display_driver) == ERROR_NONE);
|
||||
return ERROR_NONE;
|
||||
}
|
||||
|
||||
Module axs15231b_module = {
|
||||
.name = "axs15231b",
|
||||
.start = start,
|
||||
.stop = stop,
|
||||
.symbols = nullptr,
|
||||
.internal = nullptr
|
||||
};
|
||||
|
||||
} // extern "C"
|
||||
Reference in New Issue
Block a user