modules/lvgl/lvgl.c - third_party/github/zephyrproject-rtos/zephyr - Git at Google

 /*
  * Copyright (c) 2018-2019 Jan Van Winkel <jan.van_winkel@dxplore.eu>
  * Copyright (c) 2025 Abderrahmane JARMOUNI
  *
  * SPDX-License-Identifier: Apache-2.0
  */

 #include <zephyr/init.h>
 #include <zephyr/kernel.h>
 #include <lvgl.h>
 #include "lvgl_display.h"
 #include "lvgl_common_input.h"
 #include "lvgl_zephyr.h"
 #ifdef CONFIG_LV_Z_USE_FILESYSTEM
 #include "lvgl_fs.h"
 #endif
 #ifdef CONFIG_LV_Z_MEM_POOL_SYS_HEAP
 #include "lvgl_mem.h"
 #endif
 #include LV_STDLIB_INCLUDE

 #include <zephyr/logging/log.h>
 LOG_MODULE_REGISTER(lvgl, CONFIG_LV_Z_LOG_LEVEL);

 static lv_display_t *lv_displays[DT_ZEPHYR_DISPLAYS_COUNT];
 struct lvgl_disp_data disp_data[DT_ZEPHYR_DISPLAYS_COUNT] = {{
 	.blanking_on = false,
 }};

 #define DISPLAY_BUFFER_ALIGN(alignbytes) __aligned(alignbytes)

 #if DT_HAS_COMPAT_STATUS_OKAY(zephyr_displays)
 #define DISPLAY_NODE(n) DT_ZEPHYR_DISPLAY(n)
 #elif DT_HAS_CHOSEN(zephyr_display)
 #define DISPLAY_NODE(n) DT_CHOSEN(zephyr_display)
 #else
 #error Could not find "zephyr,display" chosen property, or a "zephyr,displays" compatible node in DT
 #define DISPLAY_NODE(n) DT_INVALID_NODE
 #endif

 #define IS_MONOCHROME_DISPLAY                                                                      \
 	UTIL_OR(IS_EQ(CONFIG_LV_Z_BITS_PER_PIXEL, 1), IS_EQ(CONFIG_LV_COLOR_DEPTH_1, 1))

 #define ALLOC_MONOCHROME_CONV_BUFFER                                                               \
 	UTIL_AND(IS_EQ(IS_MONOCHROME_DISPLAY, 1),                                                  \
 		 IS_EQ(CONFIG_LV_Z_MONOCHROME_CONVERSION_BUFFER, 1))

 #ifdef CONFIG_LV_Z_BUFFER_ALLOC_STATIC

 #define DISPLAY_WIDTH(n)  DT_PROP(DISPLAY_NODE(n), width)
 #define DISPLAY_HEIGHT(n) DT_PROP(DISPLAY_NODE(n), height)

 #if IS_MONOCHROME_DISPLAY
 /* monochrome buffers are expected to have 8 preceding bytes for the color palette */
 #define BUFFER_SIZE(n)                                                                             \
 	(((CONFIG_LV_Z_VDB_SIZE * ROUND_UP(DISPLAY_WIDTH(n), 8) *                                  \
 	   ROUND_UP(DISPLAY_HEIGHT(n), 8)) /                                                       \
 	  100) / 8 +                                                                               \
 	 8)
 #else
 #define BUFFER_SIZE(n)                                                                             \
 	(CONFIG_LV_Z_BITS_PER_PIXEL *                                                              \
 	 ((CONFIG_LV_Z_VDB_SIZE * DISPLAY_WIDTH(n) * DISPLAY_HEIGHT(n)) / 100) / 8)
 #endif /* IS_MONOCHROME_DISPLAY */

 static uint32_t disp_buf_size[DT_ZEPHYR_DISPLAYS_COUNT] = {0};
 static uint8_t *buf0_p[DT_ZEPHYR_DISPLAYS_COUNT] = {NULL};

 #ifdef CONFIG_LV_Z_DOUBLE_VDB
 static uint8_t *buf1_p[DT_ZEPHYR_DISPLAYS_COUNT] = {NULL};
 #endif

 #if ALLOC_MONOCHROME_CONV_BUFFER
 static uint8_t *mono_vtile_buf_p[DT_ZEPHYR_DISPLAYS_COUNT] = {NULL};
 #endif

 /* NOTE: depending on chosen color depth, buffers may be accessed using uint8_t *,*/
 /* uint16_t * or uint32_t *, therefore buffer needs to be aligned accordingly to */
 /* prevent unaligned memory accesses. */

 #if defined(CONFIG_LV_Z_VDB_CUSTOM_SECTION)
 #define LV_BUF_SECTION	Z_GENERIC_SECTION(.lvgl_buf)
 #elif defined(CONFIG_LV_Z_VDB_ZEPHYR_REGION)
 #define LV_BUF_SECTION	Z_GENERIC_SECTION(CONFIG_LV_Z_VDB_ZEPHYR_REGION_NAME)
 #else
 #define LV_BUF_SECTION
 #endif

 /* clang-format off */
 #define LV_BUFFERS_DEFINE(n)									\
 	static DISPLAY_BUFFER_ALIGN(LV_DRAW_BUF_ALIGN) uint8_t buf0_##n[BUFFER_SIZE(n)]		\
 	LV_BUF_SECTION __aligned(CONFIG_LV_Z_VDB_ALIGN);					\
 												\
 	IF_ENABLED(CONFIG_LV_Z_DOUBLE_VDB, (							\
 	static DISPLAY_BUFFER_ALIGN(LV_DRAW_BUF_ALIGN) uint8_t buf1_##n[BUFFER_SIZE(n)]		\
 	LV_BUF_SECTION __aligned(CONFIG_LV_Z_VDB_ALIGN);					\
 	))											\
 												\
 	IF_ENABLED(ALLOC_MONOCHROME_CONV_BUFFER, (						\
 	static uint8_t mono_vtile_buf_##n[BUFFER_SIZE(n)]					\
 	LV_BUF_SECTION __aligned(CONFIG_LV_Z_VDB_ALIGN);					\
 	))

 FOR_EACH(LV_BUFFERS_DEFINE, (), LV_DISPLAYS_IDX_LIST);

 #define LV_BUFFERS_REFERENCES(n)                                                                   \
 	disp_buf_size[n] = (uint32_t)BUFFER_SIZE(n);                                               \
 	buf0_p[n] = buf0_##n;                                                                      \
 	IF_ENABLED(CONFIG_LV_Z_DOUBLE_VDB, (buf1_p[n] = buf1_##n;))                                \
 	IF_ENABLED(ALLOC_MONOCHROME_CONV_BUFFER, (mono_vtile_buf_p[n] = mono_vtile_buf_##n;))
 /* clang-format on */

 #endif /* CONFIG_LV_Z_BUFFER_ALLOC_STATIC */

 #if CONFIG_LV_Z_LOG_LEVEL != 0
 static void lvgl_log(lv_log_level_t level, const char *buf)
 {
 	switch (level) {
 	case LV_LOG_LEVEL_ERROR:
 		LOG_ERR("%s", buf + (sizeof("[Error] ") - 1));
 		break;
 	case LV_LOG_LEVEL_WARN:
 		LOG_WRN("%s", buf + (sizeof("[Warn] ") - 1));
 		break;
 	case LV_LOG_LEVEL_INFO:
 		LOG_INF("%s", buf + (sizeof("[Info] ") - 1));
 		break;
 	case LV_LOG_LEVEL_TRACE:
 		LOG_DBG("%s", buf + (sizeof("[Trace] ") - 1));
 		break;
 	case LV_LOG_LEVEL_USER:
 		LOG_INF("%s", buf + (sizeof("[User] ") - 1));
 		break;
 	}
 }
 #endif

 #ifdef CONFIG_LV_Z_BUFFER_ALLOC_STATIC

 static void lvgl_allocate_rendering_buffers_static(lv_display_t *display, int disp_idx)
 {
 #ifdef CONFIG_LV_Z_DOUBLE_VDB
 	lv_display_set_buffers(display, buf0_p[disp_idx], buf1_p[disp_idx], disp_buf_size[disp_idx],
 			       LV_DISPLAY_RENDER_MODE_PARTIAL);
 #else
 	lv_display_set_buffers(display, buf0_p[disp_idx], NULL, disp_buf_size[disp_idx],
 			       LV_DISPLAY_RENDER_MODE_PARTIAL);
 #endif /* CONFIG_LV_Z_DOUBLE_VDB */

 #if ALLOC_MONOCHROME_CONV_BUFFER
 	lvgl_set_mono_conversion_buffer(mono_vtile_buf_p[disp_idx], disp_buf_size[disp_idx]);
 #endif
 }

 #else

 static int lvgl_allocate_rendering_buffers(lv_display_t *display)
 {
 	void *buf0 = NULL;
 	void *buf1 = NULL;
 	uint16_t buf_nbr_pixels;
 	uint32_t buf_size;
 	struct lvgl_disp_data *data = (struct lvgl_disp_data *)lv_display_get_user_data(display);
 	uint16_t hor_res = lv_display_get_horizontal_resolution(display);
 	uint16_t ver_res = lv_display_get_vertical_resolution(display);

 	buf_nbr_pixels = (CONFIG_LV_Z_VDB_SIZE * hor_res * ver_res) / 100;
 	/* one horizontal line is the minimum buffer requirement for lvgl */
 	if (buf_nbr_pixels < hor_res) {
 		buf_nbr_pixels = hor_res;
 	}

 	switch (data->cap.current_pixel_format) {
 	case PIXEL_FORMAT_ARGB_8888:
 		buf_size = 4 * buf_nbr_pixels;
 		break;
 	case PIXEL_FORMAT_RGB_888:
 		buf_size = 3 * buf_nbr_pixels;
 		break;
 	case PIXEL_FORMAT_RGB_565:
 		buf_size = 2 * buf_nbr_pixels;
 		break;
 	case PIXEL_FORMAT_L_8:
 		buf_size = buf_nbr_pixels;
 		break;
 	case PIXEL_FORMAT_MONO01:
 	case PIXEL_FORMAT_MONO10:
 		buf_size = buf_nbr_pixels / 8 + 8;
 		buf_size += (buf_nbr_pixels % 8) == 0 ? 0 : 1;
 		break;
 	default:
 		return -ENOTSUP;
 	}

 	buf0 = lv_malloc(buf_size);
 	if (buf0 == NULL) {
 		LOG_ERR("Failed to allocate memory for rendering buffer");
 		return -ENOMEM;
 	}

 #ifdef CONFIG_LV_Z_DOUBLE_VDB
 	buf1 = lv_malloc(buf_size);
 	if (buf1 == NULL) {
 		lv_free(buf0);
 		LOG_ERR("Failed to allocate memory for rendering buffer");
 		return -ENOMEM;
 	}
 #endif

 #if ALLOC_MONOCHROME_CONV_BUFFER
 	void *vtile_buf = lv_malloc(buf_size);

 	if (vtile_buf == NULL) {
 		lv_free(buf0);
 		lv_free(buf1);
 		LOG_ERR("Failed to allocate memory for vtile buffer");
 		return -ENOMEM;
 	}
 	lvgl_set_mono_conversion_buffer(vtile_buf, buf_size);
 #endif /* ALLOC_MONOCHROME_CONV_BUFFER */

 	lv_display_set_buffers(display, buf0, buf1, buf_size, LV_DISPLAY_RENDER_MODE_PARTIAL);
 	return 0;
 }
 #endif /* CONFIG_LV_Z_BUFFER_ALLOC_STATIC */

 #ifdef CONFIG_LV_Z_RUN_LVGL_ON_WORKQUEUE

 static K_THREAD_STACK_DEFINE(lvgl_workqueue_stack, CONFIG_LV_Z_LVGL_WORKQUEUE_STACK_SIZE);
 static struct k_work_q lvgl_workqueue;

 static void lvgl_timer_handler_work(struct k_work *work)
 {
 	struct k_work_delayable *dwork = k_work_delayable_from_work(work);
 	uint32_t wait_time;

 	lvgl_lock();
 	wait_time = lv_timer_handler();
 	lvgl_unlock();

 	/* schedule next timer verification */
 	if (wait_time == LV_NO_TIMER_READY) {
 		wait_time = CONFIG_LV_DEF_REFR_PERIOD;
 	}

 	k_work_schedule_for_queue(&lvgl_workqueue, dwork, K_MSEC(wait_time));
 }
 static K_WORK_DELAYABLE_DEFINE(lvgl_work, lvgl_timer_handler_work);

 struct k_work_q *lvgl_get_workqueue(void)
 {
 	return &lvgl_workqueue;
 }
 #endif /* CONFIG_LV_Z_RUN_LVGL_ON_WORKQUEUE */

 #if defined(CONFIG_LV_Z_LVGL_MUTEX) && !defined(CONFIG_LV_Z_USE_OSAL)

 static K_MUTEX_DEFINE(lvgl_mutex);

 void lvgl_lock(void)
 {
 	(void)k_mutex_lock(&lvgl_mutex, K_FOREVER);
 }

 bool lvgl_trylock(void)
 {
 	return k_mutex_lock(&lvgl_mutex, K_NO_WAIT) == 0;
 }

 void lvgl_unlock(void)
 {
 	(void)k_mutex_unlock(&lvgl_mutex);
 }

 #endif /* CONFIG_LV_Z_LVGL_MUTEX */

 void lv_mem_init(void)
 {
 #ifdef CONFIG_LV_Z_MEM_POOL_SYS_HEAP
 	lvgl_heap_init();
 #endif /* CONFIG_LV_Z_MEM_POOL_SYS_HEAP */
 }

 void lv_mem_deinit(void)
 {
 	/* Reinitializing the heap clears all allocations, no action needed */
 }

 void lv_mem_monitor_core(lv_mem_monitor_t *mon_p)
 {
 	memset(mon_p, 0, sizeof(lv_mem_monitor_t));

 #if CONFIG_LV_Z_MEM_POOL_SYS_HEAP
 	struct sys_memory_stats stats;

 	lvgl_heap_stats(&stats);
 	mon_p->used_pct =
 		(stats.allocated_bytes * 100) / (stats.allocated_bytes + stats.free_bytes);
 	mon_p->max_used = stats.max_allocated_bytes;
 #else
 	LOG_WRN_ONCE("Memory statistics only supported for CONFIG_LV_Z_MEM_POOL_SYS_HEAP");
 #endif /* CONFIG_LV_Z_MEM_POOL_SYS_HEAP */
 }

 lv_result_t lv_mem_test_core(void)
 {
 	/* Not supported for now */
 	return LV_RESULT_OK;
 }

 #define ENUMERATE_DISPLAY_DEVS(n) display_dev[n] = DEVICE_DT_GET(DISPLAY_NODE(n));

 int lvgl_init(void)
 {
 	const struct device *display_dev[DT_ZEPHYR_DISPLAYS_COUNT];
 	struct lvgl_disp_data *p_disp_data;
 	int err;

 	/* clang-format off */
 	FOR_EACH(ENUMERATE_DISPLAY_DEVS, (), LV_DISPLAYS_IDX_LIST);
 	/* clang-format on */
 	for (int i = 0; i < DT_ZEPHYR_DISPLAYS_COUNT; i++) {
 		if (!device_is_ready(display_dev[i])) {
 			LOG_ERR("Display device %d is not ready", i);
 			return -ENODEV;
 		}
 	}

 	lv_init();
 	lv_tick_set_cb(k_uptime_get_32);

 #if CONFIG_LV_Z_LOG_LEVEL != 0
 	lv_log_register_print_cb(lvgl_log);
 #endif

 #ifdef CONFIG_LV_Z_USE_FILESYSTEM
 	lvgl_fs_init();
 #endif

 #ifdef CONFIG_LV_Z_BUFFER_ALLOC_STATIC
 	/* clang-format off */
 	FOR_EACH(LV_BUFFERS_REFERENCES, (), LV_DISPLAYS_IDX_LIST);
 	/* clang-format on */
 #endif

 	for (int i = 0; i < DT_ZEPHYR_DISPLAYS_COUNT; i++) {
 		p_disp_data = &disp_data[i];
 		p_disp_data->display_dev = display_dev[i];
 		display_get_capabilities(display_dev[i], &p_disp_data->cap);

 		lv_displays[i] = lv_display_create(p_disp_data->cap.x_resolution,
 						   p_disp_data->cap.y_resolution);
 		if (!lv_displays[i]) {
 			LOG_ERR("Failed to create display %d LV object.", i);
 			return -ENOMEM;
 		}

 		lv_display_set_user_data(lv_displays[i], p_disp_data);
 		if (set_lvgl_rendering_cb(lv_displays[i]) != 0) {
 			LOG_ERR("Display %d not supported.", i);
 			return -ENOTSUP;
 		}

 #ifdef CONFIG_LV_Z_BUFFER_ALLOC_STATIC
 		lvgl_allocate_rendering_buffers_static(lv_displays[i], i);
 #else
 		err = lvgl_allocate_rendering_buffers(lv_displays[i]);
 		if (err < 0) {
 			return err;
 		}
 #endif

 #ifdef CONFIG_LV_Z_FULL_REFRESH
 		lv_display_set_render_mode(lv_displays[i], LV_DISPLAY_RENDER_MODE_FULL);
 #endif
 	}

 	err = lvgl_init_input_devices();
 	if (err < 0) {
 		LOG_ERR("Failed to initialize input devices.");
 		return err;
 	}

 #ifdef CONFIG_LV_Z_RUN_LVGL_ON_WORKQUEUE
 	const struct k_work_queue_config lvgl_workqueue_cfg = {
 		.name = "lvgl",
 	};

 	k_work_queue_init(&lvgl_workqueue);
 	k_work_queue_start(&lvgl_workqueue, lvgl_workqueue_stack,
 			   K_THREAD_STACK_SIZEOF(lvgl_workqueue_stack),
 			   CONFIG_LV_Z_LVGL_WORKQUEUE_PRIORITY, &lvgl_workqueue_cfg);

 	k_work_submit_to_queue(&lvgl_workqueue, &lvgl_work.work);
 #endif

 	return 0;
 }

 #ifdef CONFIG_LV_Z_AUTO_INIT
 SYS_INIT(lvgl_init, APPLICATION, CONFIG_LV_Z_INIT_PRIORITY);
 #endif /* CONFIG_LV_Z_AUTO_INIT */
	/*
	* Copyright (c) 2018-2019 Jan Van Winkel <jan.van_winkel@dxplore.eu>
	* Copyright (c) 2025 Abderrahmane JARMOUNI
	*
	* SPDX-License-Identifier: Apache-2.0
	*/

	#include <zephyr/init.h>
	#include <zephyr/kernel.h>
	#include <lvgl.h>
	#include "lvgl_display.h"
	#include "lvgl_common_input.h"
	#include "lvgl_zephyr.h"
	#ifdef CONFIG_LV_Z_USE_FILESYSTEM
	#include "lvgl_fs.h"
	#endif
	#ifdef CONFIG_LV_Z_MEM_POOL_SYS_HEAP
	#include "lvgl_mem.h"
	#endif
	#include LV_STDLIB_INCLUDE

	#include <zephyr/logging/log.h>
	LOG_MODULE_REGISTER(lvgl, CONFIG_LV_Z_LOG_LEVEL);

	static lv_display_t *lv_displays[DT_ZEPHYR_DISPLAYS_COUNT];
	struct lvgl_disp_data disp_data[DT_ZEPHYR_DISPLAYS_COUNT] = {{
	.blanking_on = false,
	}};

	#define DISPLAY_BUFFER_ALIGN(alignbytes) __aligned(alignbytes)

	#if DT_HAS_COMPAT_STATUS_OKAY(zephyr_displays)
	#define DISPLAY_NODE(n) DT_ZEPHYR_DISPLAY(n)
	#elif DT_HAS_CHOSEN(zephyr_display)
	#define DISPLAY_NODE(n) DT_CHOSEN(zephyr_display)
	#else
	#error Could not find "zephyr,display" chosen property, or a "zephyr,displays" compatible node in DT
	#define DISPLAY_NODE(n) DT_INVALID_NODE
	#endif

	#define IS_MONOCHROME_DISPLAY \
	UTIL_OR(IS_EQ(CONFIG_LV_Z_BITS_PER_PIXEL, 1), IS_EQ(CONFIG_LV_COLOR_DEPTH_1, 1))

	#define ALLOC_MONOCHROME_CONV_BUFFER \
	UTIL_AND(IS_EQ(IS_MONOCHROME_DISPLAY, 1), \
	IS_EQ(CONFIG_LV_Z_MONOCHROME_CONVERSION_BUFFER, 1))

	#ifdef CONFIG_LV_Z_BUFFER_ALLOC_STATIC

	#define DISPLAY_WIDTH(n) DT_PROP(DISPLAY_NODE(n), width)
	#define DISPLAY_HEIGHT(n) DT_PROP(DISPLAY_NODE(n), height)

	#if IS_MONOCHROME_DISPLAY
	/* monochrome buffers are expected to have 8 preceding bytes for the color palette */
	#define BUFFER_SIZE(n) \
	(((CONFIG_LV_Z_VDB_SIZE * ROUND_UP(DISPLAY_WIDTH(n), 8) * \
	ROUND_UP(DISPLAY_HEIGHT(n), 8)) / \
	100) / 8 + \
	8)
	#else
	#define BUFFER_SIZE(n) \
	(CONFIG_LV_Z_BITS_PER_PIXEL * \
	((CONFIG_LV_Z_VDB_SIZE * DISPLAY_WIDTH(n) * DISPLAY_HEIGHT(n)) / 100) / 8)
	#endif /* IS_MONOCHROME_DISPLAY */

	static uint32_t disp_buf_size[DT_ZEPHYR_DISPLAYS_COUNT] = {0};
	static uint8_t *buf0_p[DT_ZEPHYR_DISPLAYS_COUNT] = {NULL};

	#ifdef CONFIG_LV_Z_DOUBLE_VDB
	static uint8_t *buf1_p[DT_ZEPHYR_DISPLAYS_COUNT] = {NULL};
	#endif

	#if ALLOC_MONOCHROME_CONV_BUFFER
	static uint8_t *mono_vtile_buf_p[DT_ZEPHYR_DISPLAYS_COUNT] = {NULL};
	#endif

	/* NOTE: depending on chosen color depth, buffers may be accessed using uint8_t ,/
	/* uint16_t * or uint32_t , therefore buffer needs to be aligned accordingly to /
	/* prevent unaligned memory accesses. */

	#if defined(CONFIG_LV_Z_VDB_CUSTOM_SECTION)
	#define LV_BUF_SECTION Z_GENERIC_SECTION(.lvgl_buf)
	#elif defined(CONFIG_LV_Z_VDB_ZEPHYR_REGION)
	#define LV_BUF_SECTION Z_GENERIC_SECTION(CONFIG_LV_Z_VDB_ZEPHYR_REGION_NAME)
	#else
	#define LV_BUF_SECTION
	#endif

	/* clang-format off */
	#define LV_BUFFERS_DEFINE(n) \
	static DISPLAY_BUFFER_ALIGN(LV_DRAW_BUF_ALIGN) uint8_t buf0_##n[BUFFER_SIZE(n)] \
	LV_BUF_SECTION __aligned(CONFIG_LV_Z_VDB_ALIGN); \
	\
	IF_ENABLED(CONFIG_LV_Z_DOUBLE_VDB, ( \
	static DISPLAY_BUFFER_ALIGN(LV_DRAW_BUF_ALIGN) uint8_t buf1_##n[BUFFER_SIZE(n)] \
	LV_BUF_SECTION __aligned(CONFIG_LV_Z_VDB_ALIGN); \
	)) \
	\
	IF_ENABLED(ALLOC_MONOCHROME_CONV_BUFFER, ( \
	static uint8_t mono_vtile_buf_##n[BUFFER_SIZE(n)] \
	LV_BUF_SECTION __aligned(CONFIG_LV_Z_VDB_ALIGN); \
	))

	FOR_EACH(LV_BUFFERS_DEFINE, (), LV_DISPLAYS_IDX_LIST);

	#define LV_BUFFERS_REFERENCES(n) \
	disp_buf_size[n] = (uint32_t)BUFFER_SIZE(n); \
	buf0_p[n] = buf0_##n; \
	IF_ENABLED(CONFIG_LV_Z_DOUBLE_VDB, (buf1_p[n] = buf1_##n;)) \
	IF_ENABLED(ALLOC_MONOCHROME_CONV_BUFFER, (mono_vtile_buf_p[n] = mono_vtile_buf_##n;))
	/* clang-format on */

	#endif /* CONFIG_LV_Z_BUFFER_ALLOC_STATIC */

	#if CONFIG_LV_Z_LOG_LEVEL != 0
	static void lvgl_log(lv_log_level_t level, const char *buf)
	{
	switch (level) {
	case LV_LOG_LEVEL_ERROR:
	LOG_ERR("%s", buf + (sizeof("[Error] ") - 1));
	break;
	case LV_LOG_LEVEL_WARN:
	LOG_WRN("%s", buf + (sizeof("[Warn] ") - 1));
	break;
	case LV_LOG_LEVEL_INFO:
	LOG_INF("%s", buf + (sizeof("[Info] ") - 1));
	break;
	case LV_LOG_LEVEL_TRACE:
	LOG_DBG("%s", buf + (sizeof("[Trace] ") - 1));
	break;
	case LV_LOG_LEVEL_USER:
	LOG_INF("%s", buf + (sizeof("[User] ") - 1));
	break;
	}
	}
	#endif

	#ifdef CONFIG_LV_Z_BUFFER_ALLOC_STATIC

	static void lvgl_allocate_rendering_buffers_static(lv_display_t *display, int disp_idx)
	{
	#ifdef CONFIG_LV_Z_DOUBLE_VDB
	lv_display_set_buffers(display, buf0_p[disp_idx], buf1_p[disp_idx], disp_buf_size[disp_idx],
	LV_DISPLAY_RENDER_MODE_PARTIAL);
	#else
	lv_display_set_buffers(display, buf0_p[disp_idx], NULL, disp_buf_size[disp_idx],
	LV_DISPLAY_RENDER_MODE_PARTIAL);
	#endif /* CONFIG_LV_Z_DOUBLE_VDB */

	#if ALLOC_MONOCHROME_CONV_BUFFER
	lvgl_set_mono_conversion_buffer(mono_vtile_buf_p[disp_idx], disp_buf_size[disp_idx]);
	#endif
	}

	#else

	static int lvgl_allocate_rendering_buffers(lv_display_t *display)
	{
	void *buf0 = NULL;
	void *buf1 = NULL;
	uint16_t buf_nbr_pixels;
	uint32_t buf_size;
	struct lvgl_disp_data data = (struct lvgl_disp_data )lv_display_get_user_data(display);
	uint16_t hor_res = lv_display_get_horizontal_resolution(display);
	uint16_t ver_res = lv_display_get_vertical_resolution(display);

	buf_nbr_pixels = (CONFIG_LV_Z_VDB_SIZE * hor_res * ver_res) / 100;
	/* one horizontal line is the minimum buffer requirement for lvgl */
	if (buf_nbr_pixels < hor_res) {
	buf_nbr_pixels = hor_res;
	}

	switch (data->cap.current_pixel_format) {
	case PIXEL_FORMAT_ARGB_8888:
	buf_size = 4 * buf_nbr_pixels;
	break;
	case PIXEL_FORMAT_RGB_888:
	buf_size = 3 * buf_nbr_pixels;
	break;
	case PIXEL_FORMAT_RGB_565:
	buf_size = 2 * buf_nbr_pixels;
	break;
	case PIXEL_FORMAT_L_8:
	buf_size = buf_nbr_pixels;
	break;
	case PIXEL_FORMAT_MONO01:
	case PIXEL_FORMAT_MONO10:
	buf_size = buf_nbr_pixels / 8 + 8;
	buf_size += (buf_nbr_pixels % 8) == 0 ? 0 : 1;
	break;
	default:
	return -ENOTSUP;
	}

	buf0 = lv_malloc(buf_size);
	if (buf0 == NULL) {
	LOG_ERR("Failed to allocate memory for rendering buffer");
	return -ENOMEM;
	}

	#ifdef CONFIG_LV_Z_DOUBLE_VDB
	buf1 = lv_malloc(buf_size);
	if (buf1 == NULL) {
	lv_free(buf0);
	LOG_ERR("Failed to allocate memory for rendering buffer");
	return -ENOMEM;
	}
	#endif

	#if ALLOC_MONOCHROME_CONV_BUFFER
	void *vtile_buf = lv_malloc(buf_size);

	if (vtile_buf == NULL) {
	lv_free(buf0);
	lv_free(buf1);
	LOG_ERR("Failed to allocate memory for vtile buffer");
	return -ENOMEM;
	}
	lvgl_set_mono_conversion_buffer(vtile_buf, buf_size);
	#endif /* ALLOC_MONOCHROME_CONV_BUFFER */

	lv_display_set_buffers(display, buf0, buf1, buf_size, LV_DISPLAY_RENDER_MODE_PARTIAL);
	return 0;
	}
	#endif /* CONFIG_LV_Z_BUFFER_ALLOC_STATIC */

	#ifdef CONFIG_LV_Z_RUN_LVGL_ON_WORKQUEUE

	static K_THREAD_STACK_DEFINE(lvgl_workqueue_stack, CONFIG_LV_Z_LVGL_WORKQUEUE_STACK_SIZE);
	static struct k_work_q lvgl_workqueue;

	static void lvgl_timer_handler_work(struct k_work *work)
	{
	struct k_work_delayable *dwork = k_work_delayable_from_work(work);
	uint32_t wait_time;

	lvgl_lock();
	wait_time = lv_timer_handler();
	lvgl_unlock();

	/* schedule next timer verification */
	if (wait_time == LV_NO_TIMER_READY) {
	wait_time = CONFIG_LV_DEF_REFR_PERIOD;
	}

	k_work_schedule_for_queue(&lvgl_workqueue, dwork, K_MSEC(wait_time));
	}
	static K_WORK_DELAYABLE_DEFINE(lvgl_work, lvgl_timer_handler_work);

	struct k_work_q *lvgl_get_workqueue(void)
	{
	return &lvgl_workqueue;
	}
	#endif /* CONFIG_LV_Z_RUN_LVGL_ON_WORKQUEUE */

	#if defined(CONFIG_LV_Z_LVGL_MUTEX) && !defined(CONFIG_LV_Z_USE_OSAL)

	static K_MUTEX_DEFINE(lvgl_mutex);

	void lvgl_lock(void)
	{
	(void)k_mutex_lock(&lvgl_mutex, K_FOREVER);
	}

	bool lvgl_trylock(void)
	{
	return k_mutex_lock(&lvgl_mutex, K_NO_WAIT) == 0;
	}

	void lvgl_unlock(void)
	{
	(void)k_mutex_unlock(&lvgl_mutex);
	}

	#endif /* CONFIG_LV_Z_LVGL_MUTEX */

	void lv_mem_init(void)
	{
	#ifdef CONFIG_LV_Z_MEM_POOL_SYS_HEAP
	lvgl_heap_init();
	#endif /* CONFIG_LV_Z_MEM_POOL_SYS_HEAP */
	}

	void lv_mem_deinit(void)
	{
	/* Reinitializing the heap clears all allocations, no action needed */
	}

	void lv_mem_monitor_core(lv_mem_monitor_t *mon_p)
	{
	memset(mon_p, 0, sizeof(lv_mem_monitor_t));

	#if CONFIG_LV_Z_MEM_POOL_SYS_HEAP
	struct sys_memory_stats stats;

	lvgl_heap_stats(&stats);
	mon_p->used_pct =
	(stats.allocated_bytes * 100) / (stats.allocated_bytes + stats.free_bytes);
	mon_p->max_used = stats.max_allocated_bytes;
	#else
	LOG_WRN_ONCE("Memory statistics only supported for CONFIG_LV_Z_MEM_POOL_SYS_HEAP");
	#endif /* CONFIG_LV_Z_MEM_POOL_SYS_HEAP */
	}

	lv_result_t lv_mem_test_core(void)
	{
	/* Not supported for now */
	return LV_RESULT_OK;
	}

	#define ENUMERATE_DISPLAY_DEVS(n) display_dev[n] = DEVICE_DT_GET(DISPLAY_NODE(n));

	int lvgl_init(void)
	{
	const struct device *display_dev[DT_ZEPHYR_DISPLAYS_COUNT];
	struct lvgl_disp_data *p_disp_data;
	int err;

	/* clang-format off */
	FOR_EACH(ENUMERATE_DISPLAY_DEVS, (), LV_DISPLAYS_IDX_LIST);
	/* clang-format on */
	for (int i = 0; i < DT_ZEPHYR_DISPLAYS_COUNT; i++) {
	if (!device_is_ready(display_dev[i])) {
	LOG_ERR("Display device %d is not ready", i);
	return -ENODEV;
	}
	}

	lv_init();
	lv_tick_set_cb(k_uptime_get_32);

	#if CONFIG_LV_Z_LOG_LEVEL != 0
	lv_log_register_print_cb(lvgl_log);
	#endif

	#ifdef CONFIG_LV_Z_USE_FILESYSTEM
	lvgl_fs_init();
	#endif

	#ifdef CONFIG_LV_Z_BUFFER_ALLOC_STATIC
	/* clang-format off */
	FOR_EACH(LV_BUFFERS_REFERENCES, (), LV_DISPLAYS_IDX_LIST);
	/* clang-format on */
	#endif

	for (int i = 0; i < DT_ZEPHYR_DISPLAYS_COUNT; i++) {
	p_disp_data = &disp_data[i];
	p_disp_data->display_dev = display_dev[i];
	display_get_capabilities(display_dev[i], &p_disp_data->cap);

	lv_displays[i] = lv_display_create(p_disp_data->cap.x_resolution,
	p_disp_data->cap.y_resolution);
	if (!lv_displays[i]) {
	LOG_ERR("Failed to create display %d LV object.", i);
	return -ENOMEM;
	}

	lv_display_set_user_data(lv_displays[i], p_disp_data);
	if (set_lvgl_rendering_cb(lv_displays[i]) != 0) {
	LOG_ERR("Display %d not supported.", i);
	return -ENOTSUP;
	}

	#ifdef CONFIG_LV_Z_BUFFER_ALLOC_STATIC
	lvgl_allocate_rendering_buffers_static(lv_displays[i], i);
	#else
	err = lvgl_allocate_rendering_buffers(lv_displays[i]);
	if (err < 0) {
	return err;
	}
	#endif

	#ifdef CONFIG_LV_Z_FULL_REFRESH
	lv_display_set_render_mode(lv_displays[i], LV_DISPLAY_RENDER_MODE_FULL);
	#endif
	}

	err = lvgl_init_input_devices();
	if (err < 0) {
	LOG_ERR("Failed to initialize input devices.");
	return err;
	}

	#ifdef CONFIG_LV_Z_RUN_LVGL_ON_WORKQUEUE
	const struct k_work_queue_config lvgl_workqueue_cfg = {
	.name = "lvgl",
	};

	k_work_queue_init(&lvgl_workqueue);
	k_work_queue_start(&lvgl_workqueue, lvgl_workqueue_stack,
	K_THREAD_STACK_SIZEOF(lvgl_workqueue_stack),
	CONFIG_LV_Z_LVGL_WORKQUEUE_PRIORITY, &lvgl_workqueue_cfg);

	k_work_submit_to_queue(&lvgl_workqueue, &lvgl_work.work);
	#endif

	return 0;
	}

	#ifdef CONFIG_LV_Z_AUTO_INIT
	SYS_INIT(lvgl_init, APPLICATION, CONFIG_LV_Z_INIT_PRIORITY);
	#endif /* CONFIG_LV_Z_AUTO_INIT */