modules: lvgl: Provide API mutex (un)locking

Add helper functions that can be used to lock/unlock the LVGL's internal
mutex before calling API funcions.

Signed-off-by: Pieter De Gendt <[email protected]>

Author: pdgendt

modules/lvgl/Kconfig

@@ -158,9 +158,15 @@ config LV_Z_INIT_PRIORITY
 	help
 	  Priority used for the automatic initialization of LVGL.
 
+config LV_Z_LVGL_MUTEX
+	bool "Provide LVGL API mutex (un)locking functions"
+	help
+	  LVGL API functions are not thread-safe, provide functions for locking and unlocking.
+
 config LV_Z_RUN_LVGL_ON_WORKQUEUE
 	bool "Use a dedicated workqueue to run LVGL core"
 	imply LV_Z_AUTO_INIT
+	imply LV_Z_LVGL_MUTEX
 	help
 	  Runs the LVGL in a separate workqueue automatically
 	  without requiring user to add a timed loop for that. User can

modules/lvgl/include/lvgl_zephyr.h

@@ -46,6 +46,58 @@ struct k_work_q *lvgl_get_workqueue(void);
 
 #endif /* CONFIG_LV_Z_RUN_LVGL_ON_WORKQUEUE */
 
+
+#if (defined(CONFIG_LV_Z_LVGL_MUTEX) && !defined(CONFIG_LV_Z_USE_OSAL)) || defined(__DOXYGEN__)
+/**
+ * @brief Lock internal mutex before accessing LVGL API.
+ *
+ * @details LVGL API is not thread-safe. Therefore, before accessing any
+ * API function, you need to lock the internal mutex, to prevent the
+ * LVGL thread from pre-empting the API call.
+ */
+void lvgl_lock(void);
+
+/**
+ * @brief Try to lock internal mutex before accessing LVGL API.
+ *
+ * @details This function behaves like lvgl_lock(), provided that
+ * the internal mutex is unlocked. Otherwise, it returns false without
+ * waiting.
+ */
+bool lvgl_trylock(void);
+
+/**
+ * @brief Unlock internal mutex after accessing LVGL API.
+ */
+void lvgl_unlock(void);
+
+#elif defined(CONFIG_LV_Z_LVGL_MUTEX) && defined(CONFIG_LV_Z_USE_OSAL)
+
+#include <osal/lv_os.h>
+
+static inline void lvgl_lock(void)
+{
+	lv_lock();
+}
+
+static inline bool lvgl_trylock(void)
+{
+	return lv_lock_isr() == LV_RESULT_OK;
+}
+
+static inline void lvgl_unlock(void)
+{
+	lv_unlock();
+}
+
+#else /* CONFIG_LV_Z_LVGL_MUTEX */
+
+#define lvgl_lock(...) (void)0
+#define lvgl_trylock(...) true
+#define lvgl_unlock(...) (void)0
+
+#endif /* CONFIG_LV_Z_LVGL_MUTEX */
+
 #ifdef __cplusplus
 }
 #endif

modules/lvgl/lvgl.c

@@ -227,7 +227,11 @@ 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 = lv_timer_handler();
+	uint32_t wait_time;
+
+	lvgl_lock();
+	wait_time = lv_timer_handler();
+	lvgl_unlock();
 
 	/* schedule next timer verification */
 	if (wait_time == LV_NO_TIMER_READY) {
@@ -244,6 +248,27 @@ struct k_work_q *lvgl_get_workqueue(void)
 }
 #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