feat(esp_lvgl_port): Add support for esp_lcd_buffered

Support for buffered LCD panel is added as an optional extension. This
functionality is available only if esp_lcd_buffered is included in the
BUILD_COMPONENTS.

esp_lcd_buffered should be added as a private or public dependency to one
of the components in the project to use a buffered LCD panel driver with
LVGL. Call lvgl_port_add_disp_buffered() to register a buffered panel.

Author: Trigger239

components/esp_lvgl_port/CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Features
 - Added display flush wait callback support
+- Added support for buffered LCD panel (esp_lcd_buffered)
 
 ## 2.6.2
 

components/esp_lvgl_port/CMakeLists.txt

@@ -84,6 +84,12 @@ if("usb_host_hid" IN_LIST build_components)
     list(APPEND ADD_SRCS "${PORT_PATH}/esp_lvgl_port_usbhid.c" "images/${PORT_FOLDER}/img_cursor.c")
     list(APPEND ADD_LIBS idf::usb_host_hid)
 endif()
+if("esp_lcd_buffered" IN_LIST build_components)
+    list(APPEND ADD_LIBS idf::esp_lcd_buffered)
+endif()
+if("trigger239__esp_lcd_buffered" IN_LIST build_components)
+    list(APPEND ADD_LIBS idf::trigger239__esp_lcd_buffered)
+endif()
 
 # Include SIMD assembly source code for rendering, only for (9.1.0 <= LVG_version < 9.2.0) and only for esp32 and esp32s3
 if((lvgl_ver VERSION_GREATER_EQUAL "9.1.0") AND (lvgl_ver VERSION_LESS "9.2.0"))

components/esp_lvgl_port/include/esp_lvgl_port_disp.h

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: 2024 Espressif Systems (Shanghai) CO LTD
+ * SPDX-FileCopyrightText: 2024-2026 Espressif Systems (Shanghai) CO LTD
  *
  * SPDX-License-Identifier: Apache-2.0
  */
@@ -20,6 +20,11 @@
 #include "esp_lvgl_port_compatibility.h"
 #endif
 
+#if __has_include ("esp_lcd_panel_buffered.h")
+#include "esp_lcd_panel_buffered.h"
+#define ESP_LVGL_PORT_USE_LCD_BUFFERED 1
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -85,6 +90,15 @@ typedef struct {
     } flags;
 } lvgl_port_display_dsi_cfg_t;
 
+#if ESP_LVGL_PORT_USE_LCD_BUFFERED
+/**
+ * @brief Configuration Buffered display structure
+ */
+typedef struct {
+    esp_lcd_buffered_panel_sync_wait_cb_t wait_sync; /*!< Sync Wait callback function (use to avoid tearing) */
+} lvgl_port_display_buffered_cfg_t;
+#endif
+
 /**
  * @brief Add I2C/SPI/I8080 display handling to LVGL
  *
@@ -117,6 +131,20 @@ lv_display_t *lvgl_port_add_disp_dsi(const lvgl_port_display_cfg_t *disp_cfg, co
  */
 lv_display_t *lvgl_port_add_disp_rgb(const lvgl_port_display_cfg_t *disp_cfg, const lvgl_port_display_rgb_cfg_t *rgb_cfg);
 
+#if ESP_LVGL_PORT_USE_LCD_BUFFERED
+/**
+ * @brief Add Buffered display handling to LVGL
+ *
+ * @note Allocated memory in this function is not free in deinit. You must call lvgl_port_remove_disp for free all memory!
+ *
+ * @param disp_cfg Display configuration structure
+ * @param buffered_cfg Buffered display specific configuration structure
+ * @return Pointer to LVGL display or NULL when error occurred
+ */
+lv_display_t *lvgl_port_add_disp_buffered(const lvgl_port_display_cfg_t *disp_cfg,
+        const lvgl_port_display_buffered_cfg_t *buffered_cfg);
+#endif
+
 /**
  * @brief Remove display handling from LVGL
  *

components/esp_lvgl_port/src/lvgl9/esp_lvgl_port_disp.c

@@ -79,6 +79,11 @@ typedef struct {
 static lv_display_t *lvgl_port_add_disp_priv(const lvgl_port_display_cfg_t *disp_cfg, const lvgl_port_disp_priv_cfg_t *priv_cfg);
 #if LVGL_PORT_HANDLE_FLUSH_READY
 static bool lvgl_port_flush_io_ready_callback(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_io_event_data_t *edata, void *user_ctx);
+#if ESP_LVGL_PORT_USE_LCD_BUFFERED
+static void lvgl_port_flush_buffered_ready_callback(esp_lcd_panel_handle_t panel,
+        esp_lcd_buffered_panel_event_data_t *edata,
+        void *user_ctx);
+#endif
 #if CONFIG_IDF_TARGET_ESP32S3 && ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 0, 0)
 static bool lvgl_port_flush_rgb_vsync_ready_callback(esp_lcd_panel_handle_t panel_io, const esp_lcd_rgb_panel_event_data_t *edata, void *user_ctx);
 #endif
@@ -224,6 +229,51 @@ lv_display_t *lvgl_port_add_disp_rgb(const lvgl_port_display_cfg_t *disp_cfg, co
     return disp;
 }
 
+#if ESP_LVGL_PORT_USE_LCD_BUFFERED
+lv_display_t *lvgl_port_add_disp_buffered(const lvgl_port_display_cfg_t *disp_cfg,
+        const lvgl_port_display_buffered_cfg_t *buffered_cfg)
+{
+    assert(buffered_cfg != NULL);
+    const lvgl_port_disp_priv_cfg_t priv_cfg = {
+#if LVGL_PORT_HANDLE_FLUSH_READY
+        .use_flush_smphr = 1, /* Always use semaphore for now */
+#else
+        .use_flush_smphr = 0, /* Don't need semaphore if not handling flush ready */
+#endif
+    };
+    lvgl_port_lock(0);
+    lv_disp_t *disp = lvgl_port_add_disp_priv(disp_cfg, &priv_cfg);
+
+    if (disp != NULL) {
+        lvgl_port_display_ctx_t *disp_ctx = (lvgl_port_display_ctx_t *)lv_display_get_driver_data(disp);
+        /* Set display type */
+        disp_ctx->disp_type = LVGL_PORT_DISP_TYPE_OTHER;
+
+        assert(disp_cfg->io_handle != NULL);
+
+#if LVGL_PORT_HANDLE_FLUSH_READY
+        const esp_lcd_buffered_panel_event_callbacks_t cbs = {
+            .wait_sync = buffered_cfg->wait_sync,
+            .on_color_trans_done = lvgl_port_flush_buffered_ready_callback,
+        };
+        /* Register done callback */
+        esp_lcd_buffered_panel_register_event_callbacks(disp_ctx->panel_handle, &cbs, disp);
+
+        /* Register wait callback if using semaphore */
+        if (disp_ctx->flush_smphr) {
+            lv_display_set_flush_wait_cb(disp, lvgl_port_flush_wait_smphr_callback);
+        }
+#endif
+
+        /* Apply rotation from initial display configuration */
+        lvgl_port_disp_rotation_update(disp_ctx);
+    }
+    lvgl_port_unlock();
+
+    return disp;
+}
+#endif
+
 esp_err_t lvgl_port_remove_disp(lv_display_t *disp)
 {
     assert(disp);
@@ -256,6 +306,7 @@ esp_err_t lvgl_port_remove_disp(lv_display_t *disp)
     if (disp_ctx->flush_smphr) {
         vSemaphoreDelete(disp_ctx->flush_smphr);
     }
+
 #if LVGL_PORT_PPA
     if (disp_ctx->ppa_handle) {
         lvgl_port_ppa_delete(disp_ctx->ppa_handle);
@@ -482,13 +533,12 @@ static lv_display_t *lvgl_port_add_disp_priv(const lvgl_port_display_cfg_t *disp
 }
 
 #if LVGL_PORT_HANDLE_FLUSH_READY
-static bool lvgl_port_flush_io_ready_callback(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_io_event_data_t *edata, void *user_ctx)
+static bool lvgl_port_flush_common_ready_callback(lv_display_t *disp_drv)
 {
     BaseType_t need_yield = pdFALSE;
 
-    lv_display_t *disp_drv = (lv_display_t *)user_ctx;
     assert(disp_drv != NULL);
-    lvgl_port_display_ctx_t *disp_ctx = lv_display_get_user_data(disp_drv);
+    lvgl_port_display_ctx_t *disp_ctx = lv_display_get_driver_data(disp_drv);
     assert(disp_ctx != NULL);
 
     if (disp_ctx->flush_smphr) {
@@ -504,27 +554,27 @@ static bool lvgl_port_flush_io_ready_callback(esp_lcd_panel_io_handle_t panel_io
     return (need_yield == pdTRUE);
 }
 
-#if (CONFIG_IDF_TARGET_ESP32P4 && ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0))
-static bool lvgl_port_flush_dpi_panel_ready_callback(esp_lcd_panel_handle_t panel_io, esp_lcd_dpi_panel_event_data_t *edata, void *user_ctx)
+static bool lvgl_port_flush_io_ready_callback(esp_lcd_panel_io_handle_t panel_io, esp_lcd_panel_io_event_data_t *edata, void *user_ctx)
 {
-    BaseType_t need_yield = pdFALSE;
-
     lv_display_t *disp_drv = (lv_display_t *)user_ctx;
-    assert(disp_drv != NULL);
-    lvgl_port_display_ctx_t *disp_ctx = lv_display_get_user_data(disp_drv);
-    assert(disp_ctx != NULL);
+    return lvgl_port_flush_common_ready_callback(disp_drv);
+}
 
-    if (disp_ctx->flush_smphr) {
-        if (xPortInIsrContext() == pdTRUE) {
-            need_yield = xSemaphoreGiveFromISR(disp_ctx->flush_smphr, &need_yield);
-        } else {
-            xSemaphoreGive(disp_ctx->flush_smphr);
-        }
-    } else {
-        lv_disp_flush_ready(disp_drv);
-    }
+#if ESP_LVGL_PORT_USE_LCD_BUFFERED
+static void lvgl_port_flush_buffered_ready_callback(esp_lcd_panel_handle_t panel,
+        esp_lcd_buffered_panel_event_data_t *edata,
+        void *user_ctx)
+{
+    lv_display_t *disp_drv = (lv_display_t *)user_ctx;
+    lvgl_port_flush_common_ready_callback(disp_drv);
+}
+#endif
 
-    return (need_yield == pdTRUE);
+#if (CONFIG_IDF_TARGET_ESP32P4 && ESP_IDF_VERSION >= ESP_IDF_VERSION_VAL(5, 3, 0))
+static bool lvgl_port_flush_dpi_panel_ready_callback(esp_lcd_panel_handle_t panel_io, esp_lcd_dpi_panel_event_data_t *edata, void *user_ctx)
+{
+    lv_display_t *disp_drv = (lv_display_t *)user_ctx;
+    return lvgl_port_flush_common_ready_callback(disp_drv);
 }
 
 static bool lvgl_port_flush_dpi_vsync_ready_callback(esp_lcd_panel_handle_t panel_io, esp_lcd_dpi_panel_event_data_t *edata, void *user_ctx)