Ken Van Hoeylandt
120 lines
5.1 KiB
C
120 lines
5.1 KiB
C
#include <tactility/device.h>
|
|
#include <tactility/drivers/display.h>
|
|
#include <tactility/drivers/keyboard.h>
|
|
#include <tactility/drivers/pointer.h>
|
|
#include <tactility/log.h>
|
|
#include <tactility/lvgl_display.h>
|
|
#include <tactility/lvgl_keyboard.h>
|
|
#include <tactility/lvgl_module.h>
|
|
#include <tactility/lvgl_pointer.h>
|
|
|
|
#include <lvgl.h>
|
|
|
|
#define TAG "lvgl"
|
|
|
|
void lvgl_devices_attach() {
|
|
lvgl_lock();
|
|
|
|
lv_disp_t* lvgl_display = NULL;
|
|
bool display_updates_slowly = false;
|
|
struct Device* kernel_display_device = NULL;
|
|
device_get_first_by_type(&DISPLAY_TYPE, &kernel_display_device);
|
|
|
|
// Placeholder drivers (boards not yet migrated to the kernel display driver) register with a
|
|
// NULL api: they exist so the devicetree node resolves, but have nothing for LVGL to bind to.
|
|
if (kernel_display_device != NULL && device_get_driver(kernel_display_device)->api == NULL) {
|
|
device_put(kernel_display_device);
|
|
kernel_display_device = NULL;
|
|
}
|
|
|
|
if (kernel_display_device != NULL) {
|
|
uint16_t vres = display_get_resolution_y(kernel_display_device);
|
|
enum DisplayColorFormat color_format = display_get_color_format(kernel_display_device);
|
|
bool swap_bytes = color_format == DISPLAY_COLOR_FORMAT_RGB565_SWAPPED ||
|
|
color_format == DISPLAY_COLOR_FORMAT_BGR565_SWAPPED ||
|
|
color_format == DISPLAY_COLOR_FORMAT_BGR565;
|
|
bool display_requires_full_frame = display_has_capability(kernel_display_device, DISPLAY_CAPABILITY_REQUIRES_FULL_FRAME);
|
|
display_updates_slowly = display_has_capability(kernel_display_device, DISPLAY_CAPABILITY_SLOW_REFRESH);
|
|
// Without CAP_SWAP_XY the driver can't rotate 90/270 in hardware (display_swap_xy() is
|
|
// null and silently skipped by lvgl_display_apply_rotation()) - LVGL would still switch
|
|
// its own logical w/h for those rotations, mismatching the panel's fixed physical
|
|
// orientation (e.g. RGB/DPI panels, whose video timing is fixed at panel-init time).
|
|
// sw_rotate makes LVGL rotate the rendered pixels in software instead, so the driver
|
|
// itself is never asked to do something it can't.
|
|
bool can_hw_rotate = display_has_capability(kernel_display_device, DISPLAY_CAPABILITY_CAP_SWAP_XY) &&
|
|
display_has_capability(kernel_display_device, DISPLAY_CAPABILITY_CAP_MIRROR);
|
|
struct LvglDisplayConfig lvgl_display_config = {
|
|
.buffer_height = vres > 10 ? vres / 10 : vres,
|
|
.sw_rotate = !can_hw_rotate,
|
|
.swap_bytes = swap_bytes,
|
|
.force_full_frame = display_requires_full_frame
|
|
};
|
|
if (lvgl_display_add(kernel_display_device, &lvgl_display_config, &lvgl_display) == ERROR_NONE) {
|
|
LOG_I(TAG, "Bound %s to LVGL", kernel_display_device->name);
|
|
} else {
|
|
LOG_E(TAG, "Failed to bind %s to LVGL", kernel_display_device->name);
|
|
}
|
|
device_put(kernel_display_device);
|
|
}
|
|
|
|
struct Device* kernel_pointer_device = NULL;
|
|
device_get_first_by_type(&POINTER_TYPE, &kernel_pointer_device);
|
|
if (kernel_pointer_device != NULL && device_get_driver(kernel_pointer_device)->api == NULL) {
|
|
device_put(kernel_pointer_device);
|
|
kernel_pointer_device = NULL;
|
|
}
|
|
if (kernel_pointer_device != NULL) {
|
|
lv_indev_t* lvgl_pointer_device;
|
|
if (lvgl_pointer_add(kernel_pointer_device, lvgl_display, &lvgl_pointer_device) == ERROR_NONE) {
|
|
LOG_I(TAG, "Bound %s to LVGL", kernel_pointer_device->name);
|
|
// Slow panels cause taps to be missed due to the long update time, prevent that
|
|
if (display_updates_slowly ) {
|
|
lv_indev_set_long_press_time(lvgl_pointer_device, 2000);
|
|
}
|
|
} else {
|
|
LOG_E(TAG, "Failed to bind %s to LVG", kernel_pointer_device->name);
|
|
}
|
|
device_put(kernel_pointer_device);
|
|
}
|
|
|
|
struct Device* kernel_keyboard_device = NULL;
|
|
device_get_first_by_type(&KEYBOARD_TYPE, &kernel_keyboard_device);
|
|
lv_indev_t* lvgl_keyboard_device;
|
|
if (kernel_keyboard_device != NULL) {
|
|
if (lvgl_keyboard_add(kernel_keyboard_device, lvgl_display, &lvgl_keyboard_device) == ERROR_NONE) {
|
|
LOG_I(TAG, "Bound %s to LVGL", kernel_keyboard_device->name);
|
|
} else {
|
|
LOG_E(TAG, "Failed to bind %s to LVGL", kernel_keyboard_device->name);
|
|
}
|
|
device_put(kernel_keyboard_device);
|
|
}
|
|
|
|
lvgl_unlock();
|
|
}
|
|
|
|
void lvgl_devices_detach() {
|
|
lvgl_lock();
|
|
|
|
lv_indev_t* device = lv_indev_get_next(NULL);
|
|
while (device != NULL) {
|
|
lv_indev_type_t type = lv_indev_get_type(device);
|
|
if (type == LV_INDEV_TYPE_POINTER) {
|
|
lvgl_pointer_remove(device);
|
|
} else if (type == LV_INDEV_TYPE_KEYPAD) {
|
|
lvgl_keyboard_remove(device);
|
|
} else {
|
|
lv_indev_delete(device);
|
|
}
|
|
// Always get the first item, because getting the next one doesn't work as the current pointer just became corrupt
|
|
device = lv_indev_get_next(NULL);
|
|
}
|
|
|
|
lv_disp_t* display = lv_disp_get_next(NULL);
|
|
while (display != NULL) {
|
|
lv_display_delete(display);
|
|
display = lv_disp_get_next(NULL);
|
|
}
|
|
|
|
lvgl_lock();
|
|
}
|