From 663b503074b3ce82cbe8e7babf6261e6e6b436bd Mon Sep 17 00:00:00 2001
From: YOUR_NAME <xieyingdong1@huawei.com>
Date: Fri, 30 Jul 2021 06:34:51 +0000
Subject: [PATCH] add hdf drm panel driver for display

Signed-off-by: YOUR_NAME <xieyingdong1@huawei.com>
---
 .../driver/{ => adapter_soc}/hi35xx_disp.c    | 280 ++---------
 .../hi35xx_disp.h}                            | 114 +----
 model/display/driver/hdf_disp.c               | 152 +++---
 model/display/driver/hdf_disp.h               | 122 ++++-
 model/display/driver/hdf_drm_panel.c          | 257 ++++++++++
 model/display/driver/hdf_drm_panel.h          |  25 +
 model/display/driver/hi35xx_disp.h            |  29 --
 model/display/driver/lcd_abs_if.c             |  57 ---
 model/display/driver/lcdkit/lite_lcdkit.c     |   2 +-
 model/display/driver/lcdkit/lite_lcdkit.h     |   1 -
 model/display/driver/panel/ili9881c_boe.c     | 340 +++++++++++++
 model/display/driver/panel/ili9881c_boe.h     | 446 ++++++++++++++++++
 model/display/driver/panel/mipi_icn9700.c     |   5 +-
 model/display/driver/panel/ssp_st7789.c       |   9 +-
 14 files changed, 1332 insertions(+), 507 deletions(-)
 rename model/display/driver/{ => adapter_soc}/hi35xx_disp.c (57%)
 rename model/display/driver/{lcd_abs_if.h => adapter_soc/hi35xx_disp.h} (59%)
 create mode 100644 model/display/driver/hdf_drm_panel.c
 create mode 100644 model/display/driver/hdf_drm_panel.h
 delete mode 100644 model/display/driver/hi35xx_disp.h
 delete mode 100644 model/display/driver/lcd_abs_if.c
 create mode 100644 model/display/driver/panel/ili9881c_boe.c
 create mode 100644 model/display/driver/panel/ili9881c_boe.h

diff --git a/model/display/driver/hi35xx_disp.c b/model/display/driver/adapter_soc/hi35xx_disp.c
similarity index 57%
rename from model/display/driver/hi35xx_disp.c
rename to model/display/driver/adapter_soc/hi35xx_disp.c
index 98ddc0e3e..febf1ef92 100644
--- a/model/display/driver/hi35xx_disp.c
+++ b/model/display/driver/adapter_soc/hi35xx_disp.c
@@ -12,20 +12,12 @@
 #include "hdf_device_desc.h"
 #include "hdf_disp.h"
 #include "hdf_log.h"
-#include "lcd_abs_if.h"
 #include "osal_io.h"
-#include "osal_mem.h"
 #include "pwm_if.h"
 
 #define TRANSFORM_KILO 1000
 #define TRANSFORM_MILL 1000000
 
-struct Hi35xxDispCtrl {
-    struct DispControl ctrl;
-    unsigned long mipiCfgBase;
-    unsigned long pwmCfgBase;
-};
-
 static void MipiMuxCfg(unsigned long ioCfgBase)
 {
     /* config dsi data lane0 */
@@ -107,11 +99,11 @@ void Lcd24BitMuxCfg(unsigned long ioCfgBase)
     OSAL_WRITEL(0x532, ioCfgBase + 0x0030);
 }
 
-static void LcdPinMuxCfg(const struct Hi35xxDispCtrl *hi35xxCtrl, uint32_t intf)
+static void LcdPinMuxCfg(uint32_t intf)
 {
     unsigned long ioCfgBase;
 
-    ioCfgBase = hi35xxCtrl->mipiCfgBase;
+    ioCfgBase = (unsigned long)OsalIoRemap(IO_CFG2_BASE, IO_CFG_SIZE);
     if (intf == MIPI_DSI) {
         MipiMuxCfg(ioCfgBase);
     } else if (intf == LCD_6BIT) {
@@ -125,12 +117,11 @@ static void LcdPinMuxCfg(const struct Hi35xxDispCtrl *hi35xxCtrl, uint32_t intf)
     }
 }
 
-static void PwmPinMuxCfg(const struct Hi35xxDispCtrl *hi35xxCtrl, uint32_t dev)
+static void PwmPinMuxCfg(uint32_t dev)
 {
     /* pwm pin config */
     unsigned long ioCfgBase;
-
-    ioCfgBase = hi35xxCtrl->pwmCfgBase;
+    ioCfgBase = (unsigned long)OsalIoRemap(IO_CFG1_BASE, IO_CFG_SIZE);
     switch (dev) {
         case PWM_DEV0:
             OSAL_WRITEL(0x601, ioCfgBase + 0x0024);
@@ -206,7 +197,7 @@ static uint32_t CalcDataRate(struct PanelInfo *info)
 static int32_t MipiDsiInit(struct PanelInfo *info)
 {
     int32_t ret;
-    struct DevHandle *mipiHandle = NULL;
+    DevHandle mipiHandle = NULL;
     struct MipiCfg cfg;
 
     mipiHandle = MipiDsiOpen(0);
@@ -240,18 +231,19 @@ static int32_t MipiDsiInit(struct PanelInfo *info)
     return ret;
 }
 
-static int32_t PwmInit(struct Hi35xxDispCtrl *hi35xxCtrl, struct PanelInfo *info)
+static int32_t PwmInit(struct PanelInfo *info)
 {
     int32_t ret;
 
     /* pwm pin config */
-    PwmPinMuxCfg(hi35xxCtrl, info->pwm.dev);
+    PwmPinMuxCfg(info->pwm.dev);
     /* pwm config */
-    struct DevHandle *pwmHandle = PwmOpen(info->pwm.dev);
+    DevHandle pwmHandle = PwmOpen(info->pwm.dev);
     if (pwmHandle == NULL) {
         HDF_LOGE("%s: PwmOpen failed", __func__);
         return HDF_FAILURE;
     }
+
     struct PwmConfig config;
     (void)memset_s(&config, sizeof(struct PwmConfig), 0, sizeof(struct PwmConfig));
     config.duty = 1;
@@ -267,59 +259,6 @@ static int32_t PwmInit(struct Hi35xxDispCtrl *hi35xxCtrl, struct PanelInfo *info
     return HDF_SUCCESS;
 }
 
-static int32_t Hi35xxHardwareInit(struct Hi35xxDispCtrl *hi35xxCtrl)
-{
-    int32_t i;
-    int32_t panelNum;
-    int32_t ret = HDF_FAILURE;
-    struct PanelData **panel = NULL;
-    struct PanelInfo *info = NULL;
-
-    if (hi35xxCtrl->ctrl.panelManager == NULL) {
-        HDF_LOGE("%s: panelManager is null", __func__);
-        return HDF_FAILURE;
-    }
-    if (hi35xxCtrl->ctrl.panelManager->panelNum <= 0) {
-        HDF_LOGE("%s: none of panels registered", __func__);
-        return HDF_FAILURE;
-    }
-    panelNum = hi35xxCtrl->ctrl.panelManager->panelNum;
-    panel = hi35xxCtrl->ctrl.panelManager->panel;
-    for (i = 0; i < panelNum; i++) {
-        info = panel[i]->info;
-        if (info == NULL) {
-            HDF_LOGE("%s:get info failed", __func__);
-            return HDF_FAILURE;
-        }
-        if (info->blk.type == BLK_PWM) {
-            ret = PwmInit(hi35xxCtrl, info);
-            if (ret) {
-                HDF_LOGE("%s:PwmInit failed", __func__);
-                return HDF_FAILURE;
-            }
-        }
-        /* lcd pin mux config */
-        LcdPinMuxCfg(hi35xxCtrl, info->intfType);
-        if (info->intfType == MIPI_DSI) {
-            /* mipi dsi init */
-            ret = MipiDsiInit(info);
-            if (ret) {
-                HDF_LOGE("%s:MipiDsiInit failed", __func__);
-                return HDF_FAILURE;
-            }
-        }
-        if (panel[i]->init != NULL) {
-            /* panel driver init */
-            ret = panel[i]->init(panel[i]);
-            if (ret != HDF_SUCCESS) {
-                HDF_LOGE("%s: panelData->init failed", __func__);
-                return HDF_FAILURE;
-            }
-        }
-    }
-    return ret;
-}
-
 static int32_t GetLcdIntfType(enum LcdIntfType type, uint32_t *out)
 {
     int32_t ret = HDF_SUCCESS;
@@ -351,187 +290,64 @@ static int32_t GetLcdIntfType(enum LcdIntfType type, uint32_t *out)
     return ret;
 }
 
-static int32_t Hi35xxGetDispInfo(struct DispControl *dispCtrl, uint32_t devId)
-{
-    struct PanelInfo *panelInfo = NULL;
-    struct DispInfo *info = NULL;
-    struct PanelData *panel = NULL;
-
-    if (dispCtrl == NULL) {
-        HDF_LOGE("%s:dispCtrl is null", __func__);
-        return HDF_FAILURE;
-    }
-    if (dispCtrl->panelManager == NULL || (devId >= dispCtrl->panelManager->panelNum)) {
-        HDF_LOGE("%s: get panel fail", __func__);
-        return HDF_FAILURE;
-    }
-    panel = dispCtrl->panelManager->panel[devId];
-    if (panel == NULL) {
-        HDF_LOGE("%s:panel is null", __func__);
-        return HDF_FAILURE;
-    }
-    panelInfo = panel->info;
-    if (panelInfo == NULL) {
-        HDF_LOGE("%s:get info failed", __func__);
-        return HDF_FAILURE;
-    }
-    info = dispCtrl->info;
-    if (info == NULL) {
-        HDF_LOGE("%s:info is null", __func__);
-        return HDF_FAILURE;
-    }
-    info->width = panelInfo->width;
-    info->height = panelInfo->height;
-    info->hbp = panelInfo->hbp;
-    info->hfp = panelInfo->hfp;
-    info->hsw = panelInfo->hsw;
-    info->vbp = panelInfo->vbp;
-    info->vfp = panelInfo->vfp;
-    info->vsw = panelInfo->vsw;
-    if (GetLcdIntfType(panelInfo->intfType, &info->intfType) != HDF_SUCCESS) {
-        HDF_LOGE("%s:GetLcdIntfType failed", __func__);
-        return HDF_FAILURE;
-    }
-    info->intfSync = panelInfo->intfSync;
-    info->frameRate = panelInfo->frameRate;
-    info->minLevel = panelInfo->blk.minLevel;
-    info->maxLevel = panelInfo->blk.maxLevel;
-    info->defLevel = panelInfo->blk.defLevel;
-    HDF_LOGI("info->width = %d, info->height = %d", info->width, info->height);
-    HDF_LOGI("info->hbp = %d, info->hfp = %d", info->hbp, info->hfp);
-    HDF_LOGI("info->frameRate = %d, info->intfSync = %d", info->frameRate, info->intfSync);
-    return HDF_SUCCESS;
-}
-
-static int32_t Hi35xxOn(struct DispControl *dispCtrl, uint32_t devId)
+static int32_t Hi35xxHardWareInit(void)
 {
-    int32_t ret = HDF_FAILURE;
+    int32_t i;
+    int32_t ret;
+    struct PanelManager *panelManager = NULL;
     struct PanelData *panel = NULL;
+    struct PanelInfo *info = NULL;
 
-    if (dispCtrl == NULL) {
-        HDF_LOGE("%s: dispCtrl is null", __func__);
-        return HDF_FAILURE;
-    }
-    if (dispCtrl->panelManager == NULL || (devId >= dispCtrl->panelManager->panelNum)) {
-        HDF_LOGE("%s: get panel fail", __func__);
-        return HDF_FAILURE;
-    }
-    panel = dispCtrl->panelManager->panel[devId];
-    if (panel == NULL) {
-        HDF_LOGE("%s: panel is null", __func__);
+    panelManager = GetPanelManager();
+    if (panelManager == NULL) {
+        HDF_LOGE("%s: panelManager is null", __func__);
         return HDF_FAILURE;
     }
-    if (panel->on != NULL) {
-        /* panel driver on */
-        ret = panel->on(panel);
-        if (ret != HDF_SUCCESS) {
-            HDF_LOGE("%s: panel->on failed", __func__);
+    for (i = 0; i < panelManager->panelNum; i++) {
+        panel = panelManager->panel[i];
+        info = panel->info;
+        if (info == NULL) {
+            HDF_LOGE("%s:GetPanelInfo failed", __func__);
             return HDF_FAILURE;
         }
-    }
-    return ret;
-}
-
-static int32_t Hi35xxOff(struct DispControl *dispCtrl, uint32_t devId)
-{
-    int32_t ret = HDF_FAILURE;
-    struct PanelData *panel = NULL;
-
-    if (dispCtrl == NULL) {
-        HDF_LOGE("%s: dispCtrl is null", __func__);
-        return HDF_FAILURE;
-    }
-    if (dispCtrl->panelManager == NULL || (devId >= dispCtrl->panelManager->panelNum)) {
-        HDF_LOGE("%s: get panel fail", __func__);
-        return HDF_FAILURE;
-    }
-    panel = dispCtrl->panelManager->panel[devId];
-    if (panel == NULL) {
-        HDF_LOGE("%s: panel is null", __func__);
-        return HDF_FAILURE;
-    }
-    if (panel->off != NULL) {
-        /* panel driver off */
-        ret = panel->off(panel);
-        if (ret != HDF_SUCCESS) {
-            HDF_LOGE("%s: panel->off failed", __func__);
-            return HDF_FAILURE;
+        if (info->blk.type == BLK_PWM) {
+            ret = PwmInit(info);
+            if (ret) {
+                HDF_LOGE("%s:PwmInit failed", __func__);
+                return HDF_FAILURE;
+            }
         }
-    }
-    return ret;
-}
-
-static int32_t Hi35xxSetBacklight(struct DispControl *dispCtrl, uint32_t devId, uint32_t level)
-{
-    int32_t ret = HDF_FAILURE;
-    struct PanelData *panel = NULL;
-
-    if (dispCtrl == NULL) {
-        HDF_LOGE("%s: dispCtrl is null", __func__);
-        return HDF_FAILURE;
-    }
-    if (dispCtrl->panelManager == NULL || (devId >= dispCtrl->panelManager->panelNum)) {
-        HDF_LOGE("%s: get panel fail", __func__);
-        return HDF_FAILURE;
-    }
-    panel = dispCtrl->panelManager->panel[devId];
-    if (panel == NULL) {
-        HDF_LOGE("%s: panel is null", __func__);
-        return HDF_FAILURE;
-    }
-    if (panel->setBacklight != NULL) {
-        /* panel driver set backlight */
-        ret = panel->setBacklight(panel, level);
-        if (ret != HDF_SUCCESS) {
-            HDF_LOGE("%s: setBacklight failed", __func__);
+        /* lcd pin mux config */
+        LcdPinMuxCfg(info->intfType);
+        if (info->intfType == MIPI_DSI) {
+            /* mipi dsi init */
+            ret = MipiDsiInit(info);
+            if (ret) {
+                HDF_LOGE("%s:MipiDsiInit failed", __func__);
+                return HDF_FAILURE;
+            }
+        }
+        if (GetLcdIntfType(info->intfType, &info->intfType) != HDF_SUCCESS) {
+            HDF_LOGE("%s:GetLcdIntfType failed", __func__);
             return HDF_FAILURE;
         }
+        if (panel->init != NULL) {
+            if ((panel->init(panel)) != HDF_SUCCESS) {
+                HDF_LOGE("%s:panel[%d] init failed", __func__, i);
+                return HDF_FAILURE;
+            }
+        }
     }
-    return ret;
-}
-
-static int32_t Hi35xxResInit(struct Hi35xxDispCtrl *hi35xxCtrl, struct PanelManager *panelManager)
-{
-    hi35xxCtrl->ctrl.ops.on = Hi35xxOn;
-    hi35xxCtrl->ctrl.ops.off = Hi35xxOff;
-    hi35xxCtrl->ctrl.ops.setBacklight = Hi35xxSetBacklight;
-    hi35xxCtrl->ctrl.ops.getDispInfo = Hi35xxGetDispInfo;
-    hi35xxCtrl->ctrl.panelManager = panelManager;
-    hi35xxCtrl->mipiCfgBase = (unsigned long)OsalIoRemap(IO_CFG2_BASE, IO_CFG_SIZE);
-    hi35xxCtrl->pwmCfgBase = (unsigned long)OsalIoRemap(IO_CFG1_BASE, IO_CFG_SIZE);
     return HDF_SUCCESS;
 }
 
 static int32_t Hi35xxEntryInit(struct HdfDeviceObject *object)
 {
-    struct PanelManager *panelManager = NULL;
-    struct Hi35xxDispCtrl *hi35xxCtrl = NULL;
-
     if (object == NULL) {
-        HDF_LOGE("%s: object is null!", __func__);
-        return HDF_FAILURE;
-    }
-    hi35xxCtrl = (struct Hi35xxDispCtrl *)OsalMemCalloc(sizeof(struct Hi35xxDispCtrl));
-    if (hi35xxCtrl == NULL) {
-        HDF_LOGE("%s hi35xxCtrl malloc fail", __func__);
-        return HDF_FAILURE;
-    }
-    panelManager = GetPanelManager();
-    if (panelManager == NULL) {
-        HDF_LOGE("%s: panelManager is null", __func__);
-        return HDF_FAILURE;
-    }
-    if (Hi35xxResInit(hi35xxCtrl, panelManager) == HDF_FAILURE) {
-        HDF_LOGE("%s Hi35xxResInit fail", __func__);
-        return HDF_FAILURE;
-    }
-    if (Hi35xxHardwareInit(hi35xxCtrl) == HDF_FAILURE) {
-        HDF_LOGE("%s Hi35xxHardwareInit fail", __func__);
+        HDF_LOGE("%s: object is null", __func__);
         return HDF_FAILURE;
     }
-    hi35xxCtrl->ctrl.object = object;
-    hi35xxCtrl->ctrl.object->priv = hi35xxCtrl;
-    return RegisterDispCtrl(&hi35xxCtrl->ctrl);
+    return Hi35xxHardWareInit();
 }
 
 struct HdfDriverEntry g_hi35xxDevEntry = {
diff --git a/model/display/driver/lcd_abs_if.h b/model/display/driver/adapter_soc/hi35xx_disp.h
similarity index 59%
rename from model/display/driver/lcd_abs_if.h
rename to model/display/driver/adapter_soc/hi35xx_disp.h
index aa20f497f..682546b93 100644
--- a/model/display/driver/lcd_abs_if.h
+++ b/model/display/driver/adapter_soc/hi35xx_disp.h
@@ -6,29 +6,24 @@
  * See the LICENSE file in the root of this repository for complete details.
  */
 
-#ifndef LCD_ABS_IF_H
-#define LCD_ABS_IF_H
+#ifndef HI35XX_DISP_H
+#define HI35XX_DISP_H
 #include "hdf_base.h"
-#include "hdf_device_desc.h"
-#include "hdf_log.h"
-#include "mipi_dsi_if.h"
 
-/* support max panel number */
-#define PANEL_MAX 2
+#define IO_CFG1_BASE                0x111F0000
+#define IO_CFG2_BASE                0x112F0000
+#define IO_CFG_SIZE                 0x10000
 
-enum LcdIntfType {
-    MIPI_DSI,
-    LCD_6BIT,
-    LCD_8BIT,
-    LCD_16BIT,
-    LCD_18BIT,
-    LCD_24BIT,
-};
+#define PWM_DEV0                    0
+#define PWM_DEV1                    1
 
-enum BacklightType {
-    BLK_PWM,
-    BLK_MIPI,
-};
+/* output interface type */
+#define INTF_LCD_6BIT               (0x01L << 9)
+#define INTF_LCD_8BIT               (0x01L << 10)
+#define INTF_LCD_16BIT              (0x01L << 11)
+#define INTF_LCD_18BIT              (0x01L << 12)
+#define INTF_LCD_24BIT              (0x01L << 13)
+#define INTF_MIPI                   (0x01L << 14)
 
 /* output timing */
 enum IntfSync {
@@ -82,83 +77,4 @@ enum IntfSync {
     OUTPUT_7680X4320_30,      /* For HDMI2.1 at 30 Hz */
 };
 
-struct MipiDsiDesc {
-    enum DsiLane lane;
-    enum DsiMode mode;             /* output mode: DSI_VIDEO/DSI_CMD */
-    enum DsiBurstMode burstMode;
-    enum DsiOutFormat format;
-};
-
-enum PowerStatus {
-    POWER_STATUS_ON,              /* The power status is on */
-    POWER_STATUS_STANDBY,         /* The power status is standby */
-    POWER_STATUS_SUSPEND,         /* The power status is suspend */
-    POWER_STATUS_OFF,             /* The power status is off */
-    POWER_STATUS_BUTT
-};
-
-struct BlkDesc {
-    uint32_t type;
-    uint32_t minLevel;
-    uint32_t maxLevel;
-    uint32_t defLevel;
-};
-
-struct PwmCfg {
-    uint32_t dev;
-    uint32_t period;
-};
-
-struct PanelInfo {
-    uint32_t width;
-    uint32_t height;
-    uint32_t hbp;
-    uint32_t hfp;
-    uint32_t hsw;
-    uint32_t vbp;
-    uint32_t vfp;
-    uint32_t vsw;
-    uint32_t frameRate;
-    enum LcdIntfType intfType;
-    enum IntfSync intfSync;
-    struct MipiDsiDesc mipi;
-    struct BlkDesc blk;
-    struct PwmCfg pwm;
-};
-
-struct PanelStatus {
-    enum PowerStatus powerStatus;
-    uint32_t currLevel;
-};
-
-struct PanelData;
-struct PanelEsd {
-    bool support;
-    uint32_t interval;
-    uint32_t state;
-    uint32_t recoveryNum;
-    uint32_t cmpMode;
-    int32_t (*checkFunc)(struct PanelData *panel);
-    void *expect_data;
-};
-
-struct PanelData {
-    struct HdfDeviceObject *object;
-    int32_t (*init)(struct PanelData *panel);
-    int32_t (*on)(struct PanelData *panel);
-    int32_t (*off)(struct PanelData *panel);
-    int32_t (*setBacklight)(struct PanelData *panel, uint32_t level);
-    struct PanelInfo *info;
-    struct PanelStatus status;
-    struct PanelEsd *esd;
-};
-
-struct PanelManager {
-    struct PanelData *panel[PANEL_MAX];
-    uint32_t panelNum;
-};
-
-int32_t RegisterPanel(struct PanelData *data);
-struct PanelManager *GetPanelManager(void);
-struct PanelData *GetPanel(int32_t index);
-#endif /* LCD_ABS_IF_H */
+#endif /* HI35XX_DISP_H */
diff --git a/model/display/driver/hdf_disp.c b/model/display/driver/hdf_disp.c
index 77b80cb54..dbbf41a3c 100644
--- a/model/display/driver/hdf_disp.c
+++ b/model/display/driver/hdf_disp.c
@@ -14,27 +14,40 @@
 
 #define OFFSET_TWO_BYTE    16
 static struct DispManager *g_dispManager = NULL;
-
-int32_t RegisterDispCtrl(struct DispControl *dispCtrl)
+static struct PanelManager g_panelManager;
+int32_t RegisterPanel(struct PanelData *data)
 {
-    if (dispCtrl == NULL) {
-        HDF_LOGE("%s: dispCtrl is null", __func__);
+    int32_t panelNum;
+
+    if (data == NULL) {
+        HDF_LOGE("%s: panel data is null", __func__);
+        return HDF_ERR_INVALID_PARAM;
+    }
+    if (data->info == NULL) {
+        HDF_LOGE("%s panel info is null", __func__);
         return HDF_FAILURE;
     }
-    if (g_dispManager == NULL) {
-        g_dispManager = (struct DispManager *)OsalMemCalloc(sizeof(struct DispManager));
-        if (g_dispManager == NULL) {
-            HDF_LOGE("%s g_dispManager malloc fail", __func__);
-            return HDF_FAILURE;
-        }
-        g_dispManager->dispCtrl = dispCtrl;
-        g_dispManager->panelManager = dispCtrl->panelManager;
+    panelNum = g_panelManager.panelNum;
+    if (panelNum >= PANEL_MAX) {
+        HDF_LOGE("%s registered panel up PANEL_MAX", __func__);
+        return HDF_FAILURE;
     }
-    HDF_LOGI("%s: success", __func__);
+    g_panelManager.panel[panelNum] = data;
+    g_panelManager.panelNum++;
+    HDF_LOGI("%s: register success", __func__);
     return HDF_SUCCESS;
 }
 
-static struct DispManager *GetDispManager(void)
+struct PanelManager *GetPanelManager(void)
+{
+    if (g_panelManager.panelNum == 0) {
+        return NULL;
+    } else {
+        return &g_panelManager;
+    }
+}
+
+struct DispManager *GetDispManager(void)
 {
     if (g_dispManager != NULL && g_dispManager->initialzed) {
         return g_dispManager;
@@ -87,7 +100,6 @@ static int32_t SetDispBacklight(uint32_t devId, uint32_t level)
     int32_t ret = HDF_FAILURE;
     struct DispManager *disp = NULL;
     struct PanelInfo *info = NULL;
-    struct DispControlOps *ops = NULL;
     struct PanelData *panel = NULL;
 
     disp = GetDispManager();
@@ -104,10 +116,6 @@ static int32_t SetDispBacklight(uint32_t devId, uint32_t level)
     } else if (level < info->blk.minLevel && level != 0) {
         level = info->blk.minLevel;
     }
-    if (disp->dispCtrl == NULL) {
-        HDF_LOGE("%s:dispCtrl is null", __func__);
-        return HDF_FAILURE;
-    }
     OsalMutexLock(&disp->dispMutex);
     if (panel->status.powerStatus != POWER_STATUS_ON) {
         HDF_LOGE("%s:devId[%d] not in power on mode", __func__, devId);
@@ -119,9 +127,8 @@ static int32_t SetDispBacklight(uint32_t devId, uint32_t level)
         OsalMutexUnlock(&disp->dispMutex);
         return HDF_SUCCESS;
     }
-    ops = &disp->dispCtrl->ops;
-    if (ops->setBacklight) {
-        ret = ops->setBacklight(disp->dispCtrl, devId, level);
+    if (panel->setBacklight) {
+        ret = panel->setBacklight(panel, level);
         if (ret != HDF_SUCCESS) {
             HDF_LOGE("%s:setBacklight failed", __func__);
             OsalMutexUnlock(&disp->dispMutex);
@@ -135,9 +142,8 @@ static int32_t SetDispBacklight(uint32_t devId, uint32_t level)
 
 static int32_t GetDispInfo(uint32_t devId, struct DispInfo *info)
 {
-    int32_t ret = HDF_FAILURE;
-    struct DispControlOps *ops = NULL;
     struct DispManager *disp = NULL;
+    struct PanelData *panel = NULL;
 
     if (info == NULL) {
         HDF_LOGE("%s:info is null", __func__);
@@ -148,32 +154,37 @@ static int32_t GetDispInfo(uint32_t devId, struct DispInfo *info)
         HDF_LOGE("%s: disp is null", __func__);
         return HDF_FAILURE;
     }
-    if (disp->dispCtrl == NULL) {
-        HDF_LOGE("%s: dispCtrl is null", __func__);
+    if (devId >= disp->panelManager->panelNum) {
+        HDF_LOGE("%s: devId exceed registered panelNum", __func__);
         return HDF_FAILURE;
     }
-    disp->dispCtrl->info = info;
-    ops = &disp->dispCtrl->ops;
-    if (ops->getDispInfo != NULL) {
-        ret = ops->getDispInfo(disp->dispCtrl, devId);
-        if (ret != HDF_SUCCESS) {
-            HDF_LOGE("%s: getDispInfo failed", __func__);
-            return HDF_FAILURE;
-        }
-    }
-    return ret;
+    panel = disp->panelManager->panel[devId];
+    info->width = panel->info->width;
+    info->height = panel->info->height;
+    info->hbp = panel->info->hbp;
+    info->hfp = panel->info->hfp;
+    info->hsw = panel->info->hsw;
+    info->vbp = panel->info->vbp;
+    info->vfp = panel->info->vfp;
+    info->vsw = panel->info->vsw;
+    info->intfType = panel->info->intfType;
+    info->intfSync = panel->info->intfSync;
+    info->frameRate = panel->info->frameRate;
+    info->minLevel = panel->info->blk.minLevel;
+    info->maxLevel = panel->info->blk.maxLevel;
+    info->defLevel = panel->info->blk.defLevel;
+    return HDF_SUCCESS;
 }
 
 static int32_t SetDispPower(uint32_t devId, uint32_t powerStatus)
 {
     int32_t ret = HDF_FAILURE;
-    struct DispControlOps *ops = NULL;
     struct DispManager *disp = NULL;
     struct PanelData *panel = NULL;
 
     disp = GetDispManager();
-    if (disp == NULL || disp->dispCtrl == NULL) {
-        HDF_LOGE("%s:disp or dispCtrl is null", __func__);
+    if (disp == NULL) {
+        HDF_LOGE("%s:disp is null", __func__);
         return HDF_FAILURE;
     }
     if (devId >= disp->panelManager->panelNum) {
@@ -187,19 +198,18 @@ static int32_t SetDispPower(uint32_t devId, uint32_t powerStatus)
         HDF_LOGE("%s:devId[%d] already in mode = %d", __func__, devId, powerStatus);
         return HDF_SUCCESS;
     }
-    ops = &disp->dispCtrl->ops;
     switch (powerStatus) {
         case POWER_STATUS_ON:
-            if (ops->on) {
-                ret = ops->on(disp->dispCtrl, devId);
+            if (panel->on) {
+                ret = panel->on(panel);
             }
             if (ret == HDF_SUCCESS) {
                 EsdCheckStartUp(disp->esd, devId);
             }
             break;
         case POWER_STATUS_OFF:
-            if (ops->off) {
-                ret = ops->off(disp->dispCtrl, devId);
+            if (panel->off) {
+                ret = panel->off(panel);
             }
             if (ret == HDF_SUCCESS) {
                 EsdCheckEnd(disp->esd, devId);
@@ -388,18 +398,15 @@ static int HdfDispBind(struct HdfDeviceObject *dev)
     return HDF_SUCCESS;
 }
 
-static void PanelRecovery(struct DispControl *dispCtrl, uint32_t devId)
+static void PanelRecovery(struct PanelData *panel)
 {
-    struct DispControlOps *ops = NULL;
-
     HDF_LOGI("%s enter", __func__);
-    ops = &dispCtrl->ops;
-    if (ops->off) {
-        ops->off(dispCtrl, devId);
+    if (panel->off) {
+        panel->off(panel);
     }
     OsalMSleep(150); // delay 150ms
-    if (ops->on) {
-        ops->on(dispCtrl, devId);
+    if (panel->on) {
+        panel->on(panel);
     }
 }
 
@@ -425,7 +432,7 @@ static void EsdWorkHandler(void *arg)
     struct DispManager *disp = NULL;
 
     disp = GetDispManager();
-    if ((disp->dispCtrl == NULL) || (devId >= disp->panelManager->panelNum)) {
+    if (devId >= disp->panelManager->panelNum) {
         HDF_LOGE("%s: dispCtrl is null or panel is null", __func__);
         return;
     }
@@ -436,7 +443,7 @@ static void EsdWorkHandler(void *arg)
     if (ret != HDF_SUCCESS) {
         OsalMutexLock(&disp->dispMutex);
         if (panel->esd->state == ESD_RUNNING) {
-            PanelRecovery(disp->dispCtrl, devId);
+            PanelRecovery(panel);
         } else {
             HDF_LOGI("%s: esd check has disabled", __func__);
             OsalMutexUnlock(&disp->dispMutex);
@@ -445,7 +452,7 @@ static void EsdWorkHandler(void *arg)
         OsalMutexUnlock(&disp->dispMutex);
         panel->esd->recoveryNum++;
     }
-    HDF_LOGD("%s devId[%d] recoveryNum = %d",__func__, devId, panel->esd->recoveryNum);
+    HDF_LOGD("%s devId[%d] recoveryNum = %d", __func__, devId, panel->esd->recoveryNum);
     if (panel->esd->recoveryNum >= ESD_MAX_RECOVERY) {
         panel->esd->recoveryNum = 0;
         OsalMutexLock(&disp->dispMutex);
@@ -475,7 +482,7 @@ static void EsdCheckStartUp(struct DispEsd *esd, uint32_t devId)
                 EsdTimerHandler, (uintptr_t)devId);
             OsalTimerStartLoop(esd->timer[devId]);
             esd->panelEsd[devId]->state = ESD_RUNNING;
-            HDF_LOGI("%s , devId[%d] enable esd check", __func__, devId);
+            HDF_LOGI("%s devId[%d] enable esd check", __func__, devId);
         }
     }
 }
@@ -633,18 +640,16 @@ static int32_t EsdCheckInit(struct DispManager *disp)
     return HDF_SUCCESS;
 }
 
-static int32_t HdfDispEntryInit(struct HdfDeviceObject *object)
+static int32_t DispManagerInit(struct PanelManager *panelManager)
 {
     int32_t ret;
 
-    if (object == NULL) {
-        HDF_LOGE("%s: object is null!", __func__);
-        return HDF_FAILURE;
-    }
+    g_dispManager = (struct DispManager *)OsalMemCalloc(sizeof(struct DispManager));
     if (g_dispManager == NULL) {
-        HDF_LOGE("%s: g_dispManager is null", __func__);
+        HDF_LOGE("%s g_dispManager malloc fail", __func__);
         return HDF_FAILURE;
     }
+    g_dispManager->panelManager = panelManager;
     ret = HdfWorkQueueInit(&g_dispManager->dispWorkQueue, "dispWQ");
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("%s: HdfWorkQueueInit fail", __func__);
@@ -661,6 +666,29 @@ static int32_t HdfDispEntryInit(struct HdfDeviceObject *object)
     return HDF_SUCCESS;
 }
 
+static int32_t HdfDispEntryInit(struct HdfDeviceObject *object)
+{
+    int32_t ret;
+    struct PanelManager *panelManager = NULL;
+
+    if (object == NULL) {
+        HDF_LOGE("%s: object is null!", __func__);
+        return HDF_FAILURE;
+    }
+    panelManager = GetPanelManager();
+    if (panelManager == NULL) {
+        HDF_LOGE("%s: panelManager is null!", __func__);
+        return HDF_FAILURE;
+    }
+    ret = DispManagerInit(panelManager);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: DispManagerInit fail", __func__);
+        return HDF_FAILURE;
+    }
+    HDF_LOGI("%s success", __func__);
+    return HDF_SUCCESS;
+}
+
 struct HdfDriverEntry g_dispDevEntry = {
     .moduleVersion = 1,
     .moduleName = "HDF_DISP",
diff --git a/model/display/driver/hdf_disp.h b/model/display/driver/hdf_disp.h
index 4c9f2e852..6d7bb13ea 100644
--- a/model/display/driver/hdf_disp.h
+++ b/model/display/driver/hdf_disp.h
@@ -10,9 +10,10 @@
 #define HDF_DISP_H
 #include "hdf_base.h"
 #include "hdf_device_desc.h"
+#include "hdf_log.h"
 #include "hdf_sbuf.h"
 #include "hdf_workqueue.h"
-#include "lcd_abs_if.h"
+#include "mipi_dsi_if.h"
 #include "osal_mem.h"
 #include "osal_mutex.h"
 #include "osal_timer.h"
@@ -23,6 +24,102 @@
 #define HDF_LOG_TAG HDF_DISP
 #define ESD_DEFAULT_INTERVAL   5000
 #define ESD_MAX_RECOVERY       10
+/* support max panel number */
+#define PANEL_MAX 2
+
+enum LcdIntfType {
+    MIPI_DSI,
+    LCD_6BIT,
+    LCD_8BIT,
+    LCD_16BIT,
+    LCD_18BIT,
+    LCD_24BIT,
+};
+
+enum BacklightType {
+    BLK_PWM,
+    BLK_MIPI,
+};
+
+struct MipiDsiDesc {
+    enum DsiLane lane;
+    enum DsiMode mode;             /* output mode: DSI_VIDEO/DSI_CMD */
+    enum DsiBurstMode burstMode;
+    enum DsiOutFormat format;
+};
+
+enum PowerStatus {
+    POWER_STATUS_ON,              /* The power status is on */
+    POWER_STATUS_STANDBY,         /* The power status is standby */
+    POWER_STATUS_SUSPEND,         /* The power status is suspend */
+    POWER_STATUS_OFF,             /* The power status is off */
+    POWER_STATUS_BUTT
+};
+
+struct BlkDesc {
+    uint32_t type;
+    uint32_t minLevel;
+    uint32_t maxLevel;
+    uint32_t defLevel;
+};
+
+struct PwmCfg {
+    uint32_t dev;
+    uint32_t period;
+};
+
+struct PanelInfo {
+    uint32_t width;
+    uint32_t height;
+    uint32_t hbp;
+    uint32_t hfp;
+    uint32_t hsw;
+    uint32_t vbp;
+    uint32_t vfp;
+    uint32_t vsw;
+    uint32_t frameRate;
+    uint32_t clockFreq;
+    uint32_t pWidth;
+    uint32_t pHeight;
+    enum LcdIntfType intfType;
+    uint32_t intfSync;
+    struct MipiDsiDesc mipi;
+    struct BlkDesc blk;
+    struct PwmCfg pwm;
+};
+
+struct PanelStatus {
+    enum PowerStatus powerStatus;
+    uint32_t currLevel;
+};
+
+struct PanelData;
+struct PanelEsd {
+    bool support;
+    uint32_t interval;
+    uint32_t state;
+    uint32_t recoveryNum;
+    uint32_t cmpMode;
+    int32_t (*checkFunc)(struct PanelData *panel);
+    void *expect_data;
+};
+
+struct PanelData {
+    struct HdfDeviceObject *object;
+    int32_t (*init)(struct PanelData *panel);
+    int32_t (*on)(struct PanelData *panel);
+    int32_t (*off)(struct PanelData *panel);
+    int32_t (*setBacklight)(struct PanelData *panel, uint32_t level);
+    struct PanelInfo *info;
+    struct PanelStatus status;
+    struct PanelEsd *esd;
+    void *priv;
+};
+
+struct PanelManager {
+    struct PanelData *panel[PANEL_MAX];
+    uint32_t panelNum;
+};
 
 typedef int32_t (*DispCmdHandle)(struct HdfDeviceObject *device, struct HdfSBuf *reqData, struct HdfSBuf *rspData);
 
@@ -37,7 +134,7 @@ struct DispInfo {
     uint32_t vsw;
     uint32_t frameRate;
     uint32_t intfType;
-    enum IntfSync intfSync;
+    uint32_t intfSync;
     uint32_t minLevel;
     uint32_t maxLevel;
     uint32_t defLevel;
@@ -64,23 +161,7 @@ struct DispEsd {
     int32_t panelNum;
 };
 
-struct DispControl;
-struct DispControlOps {
-    int32_t (*on)(struct DispControl *dispCtrl, uint32_t devId);
-    int32_t (*off)(struct DispControl *dispCtrl, uint32_t devId);
-    int32_t (*setBacklight)(struct DispControl *dispCtrl, uint32_t devId, uint32_t level);
-    int32_t (*getDispInfo)(struct DispControl *dispCtrl, uint32_t devId);
-};
-
-struct DispControl {
-    struct HdfDeviceObject *object;
-    struct PanelManager *panelManager;
-    struct DispInfo *info;
-    struct DispControlOps ops;
-};
-
 struct DispManager {
-    struct DispControl *dispCtrl;
     struct PanelManager *panelManager;
     struct OsalMutex dispMutex;
     HdfWorkQueue dispWorkQueue;
@@ -88,5 +169,8 @@ struct DispManager {
     struct DispEsd *esd;
 };
 
-int32_t RegisterDispCtrl(struct DispControl *dispCtrl);
+int32_t RegisterPanel(struct PanelData *data);
+struct PanelManager *GetPanelManager(void);
+struct DispManager *GetDispManager(void);
+
 #endif /* HDF_DISP_H */
diff --git a/model/display/driver/hdf_drm_panel.c b/model/display/driver/hdf_drm_panel.c
new file mode 100644
index 000000000..f6a3b8391
--- /dev/null
+++ b/model/display/driver/hdf_drm_panel.c
@@ -0,0 +1,257 @@
+
+/*
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
+ *
+ * HDF is dual licensed: you can use it either under the terms of
+ * the GPL, or the BSD license, at your option.
+ * See the LICENSE file in the root of this repository for complete details.
+ */
+
+#include "hdf_drm_panel.h"
+#include <drm/drmP.h>
+#include <drm/drm_atomic_helper.h>
+#include <linux/backlight.h>
+#include <linux/module.h>
+#include <linux/of.h>
+#include <linux/of_gpio.h>
+#include <linux/pm_runtime.h>
+#include <linux/regulator/consumer.h>
+#include <video/mipi_display.h>
+#include <video/of_display_timing.h>
+#include <video/videomode.h>
+#include "osal_mem.h"
+
+static inline struct HdfDrmPanel *ToHdfDrmPanel(const struct drm_panel *panel)
+{
+    return container_of(panel, struct HdfDrmPanel, panel);
+}
+
+static int HdfDrmPanelUnprepare(struct drm_panel *panel)
+{
+    return 0;
+}
+ 
+static int HdfDrmPanelPrepare(struct drm_panel *panel)
+{
+    return 0;
+}
+ 
+static int HdfDrmPanelDisable(struct drm_panel *panel)
+{
+    struct HdfDrmPanel *hdfDrmPanel = ToHdfDrmPanel(panel);
+    struct PanelData *panelData;
+
+    HDF_LOGD("%s line = %d\n", __func__, __LINE__);
+    OsalMutexLock(&hdfDrmPanel->manager->dispMutex);
+    panelData = hdfDrmPanel->manager->panelManager->panel[hdfDrmPanel->index];
+    panelData->off(panelData);
+    OsalMutexUnlock(&hdfDrmPanel->manager->dispMutex);
+    return HDF_SUCCESS;
+}
+ 
+static int HdfDrmPanelEnable(struct drm_panel *panel)
+{
+    struct HdfDrmPanel *hdfDrmPanel = ToHdfDrmPanel(panel);
+    struct PanelData *panelData;
+
+    HDF_LOGD("%s line = %d\n", __func__, __LINE__);
+    panelData = hdfDrmPanel->manager->panelManager->panel[hdfDrmPanel->index];
+    OsalMutexLock(&hdfDrmPanel->manager->dispMutex);
+    panelData->on(panelData);
+    OsalMutexUnlock(&hdfDrmPanel->manager->dispMutex);
+    return HDF_SUCCESS;
+}
+
+static int HdfDrmPanelGetModes(struct drm_panel *panel)
+{
+    struct drm_connector *connector = panel->connector;
+    struct HdfDrmPanel *hdfDrmPanel = ToHdfDrmPanel(panel);
+    struct drm_display_mode *mode = NULL;
+    struct PanelInfo *panelInfo = NULL;
+
+    HDF_LOGD("%s line = %d\n", __func__, __LINE__);
+    panelInfo = hdfDrmPanel->manager->panelManager->panel[hdfDrmPanel->index]->info;
+    mode = drm_mode_duplicate(panel->drm, &hdfDrmPanel->mode);
+    if (!mode) {
+        HDF_LOGE("failed to add mode %ux%ux@%u",
+            hdfDrmPanel->mode.hdisplay, hdfDrmPanel->mode.vdisplay,
+            hdfDrmPanel->mode.vrefresh);
+        return -ENOMEM;
+    }
+    drm_mode_set_name(mode);
+    mode->type = DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED;
+    drm_mode_probed_add(connector, mode);
+    connector->display_info.width_mm = panelInfo->pWidth;
+    connector->display_info.height_mm = panelInfo->pHeight;
+    return 1;
+}
+ 
+static struct drm_panel_funcs g_hdfDrmPanelFuncs = {
+    .get_modes = HdfDrmPanelGetModes,
+    .enable = HdfDrmPanelEnable,
+    .disable = HdfDrmPanelDisable,
+    .prepare = HdfDrmPanelPrepare,
+    .unprepare = HdfDrmPanelUnprepare,
+};
+
+static ssize_t SuspendStore(struct device *dev,
+    struct device_attribute *attr, const char *buf, size_t count)
+{
+    int32_t ret;
+    struct HdfDrmPanel *hdfDrmPanel = dev_get_drvdata(dev);
+
+    ret = HdfDrmPanelDisable(&hdfDrmPanel->panel);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s HdfDrmPanelDisable fail", __func__);
+        return count;
+    }
+    ret = HdfDrmPanelUnprepare(&hdfDrmPanel->panel);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s HdfDrmPanelUnprepare fail", __func__);
+        return count;
+    }
+    return count;
+}
+static DEVICE_ATTR(suspend, S_IWUSR, NULL, SuspendStore);
+
+static ssize_t ResumeStore(struct device *dev,
+    struct device_attribute *attr, const char *buf, size_t count)
+{
+    int32_t ret;
+    struct HdfDrmPanel *hdfDrmPanel = dev_get_drvdata(dev);
+
+    ret = HdfDrmPanelPrepare(&hdfDrmPanel->panel);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s HdfDrmPanelPrepare fail", __func__);
+        return count;
+    }
+    ret = HdfDrmPanelEnable(&hdfDrmPanel->panel);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s HdfDrmPanelEnable fail", __func__);
+        return count;
+    }
+    return count;
+}
+static DEVICE_ATTR(resume, S_IWUSR, NULL, ResumeStore);
+
+static ssize_t BacklightStore(struct device *dev,
+    struct device_attribute *attr, const char *buf, size_t count)
+{
+    int32_t ret;
+    unsigned long level;
+    struct PanelData *panelData = NULL;
+    struct HdfDrmPanel *hdfDrmPanel = dev_get_drvdata(dev);
+
+    ret = kstrtoul(buf, 0, &level);
+    if (ret != 0) {
+        return ret;
+    }
+    HDF_LOGI("%s line = %d\n", __func__, __LINE__);
+    panelData = hdfDrmPanel->manager->panelManager->panel[hdfDrmPanel->index];
+    OsalMutexLock(&hdfDrmPanel->manager->dispMutex);
+    panelData->setBacklight(panelData, level);
+    OsalMutexUnlock(&hdfDrmPanel->manager->dispMutex);
+    return count;
+}
+static DEVICE_ATTR(backlight, S_IWUSR, NULL, BacklightStore);
+
+#define ATTR_NUM  3
+static struct device_attribute *g_panelAttrs[] = {
+    &dev_attr_suspend,
+    &dev_attr_resume,
+    &dev_attr_backlight,
+    NULL,
+};
+
+static void CreateDrmMode(struct HdfDrmPanel *hdfDrmPanel)
+{
+    uint32_t panelIndex;
+    struct PanelInfo *panelInfo = NULL;
+
+    panelIndex = hdfDrmPanel->index;
+    panelInfo = hdfDrmPanel->manager->panelManager->panel[panelIndex]->info;
+    hdfDrmPanel->mode.clock = panelInfo->clockFreq / 1000;
+    hdfDrmPanel->mode.hdisplay = panelInfo->width;
+    hdfDrmPanel->mode.hsync_start = panelInfo->width + panelInfo->hfp;
+    hdfDrmPanel->mode.hsync_end = panelInfo->width + panelInfo->hfp + panelInfo->hsw;
+    hdfDrmPanel->mode.htotal = panelInfo->width + panelInfo->hfp + panelInfo->hsw + panelInfo->hbp;
+    hdfDrmPanel->mode.vdisplay = panelInfo->height;
+    hdfDrmPanel->mode.vsync_start = panelInfo->height + panelInfo->vfp;
+    hdfDrmPanel->mode.vsync_end = panelInfo->height + panelInfo->vfp + panelInfo->vsw;
+    hdfDrmPanel->mode.vtotal = panelInfo->height + panelInfo->vfp + panelInfo->vsw + panelInfo->vbp;
+    hdfDrmPanel->mode.flags = 0;
+    hdfDrmPanel->mode.vrefresh = drm_mode_vrefresh(&hdfDrmPanel->mode);
+}
+
+static struct HdfDrmPanel *InstanceHdfDrmPanel(struct DispManager *manager, int32_t index)
+{
+    struct HdfDrmPanel *hdfDrmPanel = NULL;
+
+    hdfDrmPanel = (struct HdfDrmPanel *)OsalMemCalloc(sizeof(struct HdfDrmPanel));
+    if (hdfDrmPanel == NULL) {
+        HDF_LOGE("%s hdfDrmPanel malloc fail", __func__);
+        return NULL;
+    }
+    hdfDrmPanel->index = index;
+    hdfDrmPanel->manager = manager;
+    CreateDrmMode(hdfDrmPanel);
+    hdfDrmPanel->panel.funcs = &g_hdfDrmPanelFuncs;
+    return hdfDrmPanel;
+}
+
+int32_t HdfDrmPanelEntryInit(struct HdfDeviceObject *object)
+{
+    uint32_t ret;
+    uint32_t panelNum;
+    struct PanelData *panel = NULL;
+    struct HdfDrmPanel *hdfDrmPanel = NULL;
+    struct mipi_dsi_device *dsiDev = NULL;
+    struct DispManager *manager = NULL;
+
+    manager = GetDispManager();
+    if (manager == NULL) {
+        HDF_LOGE("%s manager is null", __func__);
+        return HDF_FAILURE;
+    }
+    panelNum = manager->panelManager->panelNum;
+    for (uint32_t i = 0; i < panelNum; i++) {
+        hdfDrmPanel = InstanceHdfDrmPanel(manager, i);
+        if (hdfDrmPanel == NULL) {
+            return HDF_FAILURE;
+        }
+        dsiDev = (struct mipi_dsi_device *)manager->panelManager->panel[i]->priv;
+        hdfDrmPanel->panel.dev = &dsiDev->dev;
+        drm_panel_init(&hdfDrmPanel->panel);
+        ret = drm_panel_add(&hdfDrmPanel->panel);
+        if (ret) {
+            HDF_LOGE("%s drm_panel_add() failed", __func__);
+            return ret;
+        }
+        ret = mipi_dsi_attach(dsiDev);
+        if (ret) {
+            HDF_LOGE("%s mipi_dsi_attach failed", __func__);
+            drm_panel_remove(&hdfDrmPanel->panel);
+            return ret;
+        }
+        mipi_dsi_set_drvdata(dsiDev, hdfDrmPanel);
+        for (uint32_t j = 0; j < ATTR_NUM; j++) {
+            if (device_create_file(&dsiDev->dev, g_panelAttrs[j]) != 0) {
+                HDF_LOGE("%s line = %d device_create_file fail", __func__, __LINE__);
+            }
+        }
+        panel = manager->panelManager->panel[i];
+        if (panel->info->blk.type == BLK_PWM) {
+            panel->setBacklight(panel, panel->info->blk.defLevel);
+        }
+    }
+    HDF_LOGI("%s success", __func__);
+    return HDF_SUCCESS;
+}
+
+struct HdfDriverEntry g_hdfDrmPanelEntry = {
+    .moduleVersion = 1,
+    .moduleName = "HDF_DRMPANEL",
+    .Init = HdfDrmPanelEntryInit,
+};
+
+HDF_INIT(g_hdfDrmPanelEntry);
diff --git a/model/display/driver/hdf_drm_panel.h b/model/display/driver/hdf_drm_panel.h
new file mode 100644
index 000000000..a1367baa2
--- /dev/null
+++ b/model/display/driver/hdf_drm_panel.h
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
+ *
+ * HDF is dual licensed: you can use it either under the terms of
+ * the GPL, or the BSD license, at your option.
+ * See the LICENSE file in the root of this repository for complete details.
+ */
+
+#ifndef HDF_DRM_PANEL_H
+#define HDF_DRM_PANEL_H
+#include <drm/drm_mipi_dsi.h>
+#include <drm/drm_modes.h>
+#include <drm/drm_panel.h>
+#include "hdf_disp.h"
+
+struct HdfDrmPanel {
+    struct drm_panel panel;
+    struct DispManager *manager;
+    struct drm_display_mode mode;
+    struct mipi_dsi_device *dsiDev;
+    uint32_t index;
+};
+
+#endif /* HDF_DRM_PANEL_H */
+
diff --git a/model/display/driver/hi35xx_disp.h b/model/display/driver/hi35xx_disp.h
deleted file mode 100644
index bd32ca286..000000000
--- a/model/display/driver/hi35xx_disp.h
+++ /dev/null
@@ -1,29 +0,0 @@
-/*
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
- *
- * HDF is dual licensed: you can use it either under the terms of
- * the GPL, or the BSD license, at your option.
- * See the LICENSE file in the root of this repository for complete details.
- */
-
-#ifndef HI35XX_DISP_H
-#define HI35XX_DISP_H
-#include "hdf_base.h"
-#include "lcd_abs_if.h"
-
-/* output interface type */
-#define INTF_LCD_6BIT               (0x01L << 9)
-#define INTF_LCD_8BIT               (0x01L << 10)
-#define INTF_LCD_16BIT              (0x01L << 11)
-#define INTF_LCD_18BIT              (0x01L << 12)
-#define INTF_LCD_24BIT              (0x01L << 13)
-#define INTF_MIPI                   (0x01L << 14)
-
-#define IO_CFG1_BASE                0x111F0000
-#define IO_CFG2_BASE                0x112F0000
-#define IO_CFG_SIZE                 0x10000
-
-#define PWM_DEV0                    0
-#define PWM_DEV1                    1
-
-#endif /* HI35XX_DISP_H */
diff --git a/model/display/driver/lcd_abs_if.c b/model/display/driver/lcd_abs_if.c
deleted file mode 100644
index 8f7134d31..000000000
--- a/model/display/driver/lcd_abs_if.c
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
- *
- * HDF is dual licensed: you can use it either under the terms of
- * the GPL, or the BSD license, at your option.
- * See the LICENSE file in the root of this repository for complete details.
- */
-
-#include "lcd_abs_if.h"
-#include <asm/io.h>
-#include "hdf_device_desc.h"
-#include "osal.h"
-
-static struct PanelManager g_panelManager;
-int32_t RegisterPanel(struct PanelData *data)
-{
-    int32_t panelNum;
-
-    if (data == NULL) {
-        HDF_LOGE("%s: panel data is null", __func__);
-        return HDF_ERR_INVALID_PARAM;
-    }
-    panelNum = g_panelManager.panelNum;
-    if (panelNum >= PANEL_MAX) {
-        HDF_LOGE("%s registered panel up PANEL_MAX", __func__);
-        return HDF_FAILURE;
-    }
-    g_panelManager.panel[panelNum] = data;
-    g_panelManager.panelNum++;
-    HDF_LOGI("%s: register success", __func__);
-    return HDF_SUCCESS;
-}
-
-struct PanelManager *GetPanelManager(void)
-{
-    if (g_panelManager.panelNum == 0) {
-        return NULL;
-    } else {
-        return &g_panelManager;
-    }
-}
-
-struct PanelData *GetPanel(int32_t index)
-{
-    struct PanelManager *panelManager = NULL;
-
-    panelManager = GetPanelManager();
-    if (panelManager == NULL) {
-        HDF_LOGE("%s panelManager is null", __func__);
-        return NULL;
-    }
-    if (index >= g_panelManager.panelNum) {
-        HDF_LOGE("%s index is greater than g_panelManager.panelNum", __func__);
-        return NULL;
-    }
-    return panelManager->panel[index];
-}
diff --git a/model/display/driver/lcdkit/lite_lcdkit.c b/model/display/driver/lcdkit/lite_lcdkit.c
index c7db0d7b3..7fdf1fb02 100644
--- a/model/display/driver/lcdkit/lite_lcdkit.c
+++ b/model/display/driver/lcdkit/lite_lcdkit.c
@@ -10,7 +10,6 @@
 #include "gpio_if.h"
 #include "hdf_device_desc.h"
 #include "hdf_log.h"
-#include "lcd_abs_if.h"
 #include "mipi_dsi_if.h"
 #include "osal.h"
 #include "pwm_if.h"
@@ -62,6 +61,7 @@ static int32_t LcdkitInit(void)
         HDF_LOGE("%s:MipiDsiOpen failed", __func__);
         return HDF_FAILURE;
     }
+
     if (panelCfg->info.blk.type == BLK_PWM) {
         panelCfg->pwmHandle = PwmOpen(panelCfg->info.pwm.dev);
         if (panelCfg->pwmHandle == NULL) {
diff --git a/model/display/driver/lcdkit/lite_lcdkit.h b/model/display/driver/lcdkit/lite_lcdkit.h
index b8e8f36b9..0f21f5dc2 100644
--- a/model/display/driver/lcdkit/lite_lcdkit.h
+++ b/model/display/driver/lcdkit/lite_lcdkit.h
@@ -10,7 +10,6 @@
 #define LITE_LCDKIT_H
 #include "hdf_base.h"
 #include "device_resource_if.h"
-#include "lcd_abs_if.h"
 #include "osal_mem.h"
 #ifdef HDF_LOG_TAG
 #undef HDF_LOG_TAG
diff --git a/model/display/driver/panel/ili9881c_boe.c b/model/display/driver/panel/ili9881c_boe.c
new file mode 100644
index 000000000..f4a42f4fb
--- /dev/null
+++ b/model/display/driver/panel/ili9881c_boe.c
@@ -0,0 +1,340 @@
+/*
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
+ *
+ * HDF is dual licensed: you can use it either under the terms of
+ * the GPL, or the BSD license, at your option.
+ * See the LICENSE file in the root of this repository for complete details.
+ */
+
+#include "ili9881c_boe.h"
+#include "gpio_if.h"
+#include "hdf_disp.h"
+#include "osal.h"
+
+static int Ili9881cBoeSendCmds(struct mipi_dsi_device *dsi,
+	const struct DsiCmdDesc *cmds, int size)
+{
+    int32_t i;
+
+    if (dsi == NULL) {
+        return -EINVAL;
+    }
+
+    for (i = 0; i < size; i++) {
+        mipi_dsi_generic_write(dsi, cmds[i].payload, cmds[i].dataLen);
+        if (cmds[i].delay) {
+            OsalMSleep(cmds[i].delay);
+        }
+    }
+    return HDF_SUCCESS;
+}
+
+static struct Ili9881cBoeDev *ToIli9881cBoeDev(const struct PanelData *panel)
+{
+    return (struct Ili9881cBoeDev *)panel->object->priv;
+}
+
+static SetGpioState(uint16_t gpio, uint16_t dir, uint16_t level, uint32_t delay)
+{
+    int32_t ret;
+
+    ret = GpioSetDir(gpio, dir);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s GpioSetDir failed, ret:%d", __func__, ret);
+        return HDF_FAILURE;
+    }
+    ret = GpioWrite(gpio, level);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s GpioWrite failed, ret:%d", __func__, ret);
+        return HDF_FAILURE;
+    }
+    OsalMSleep(delay);
+    return HDF_SUCCESS;
+}
+
+static int32_t Ili9881cBoePrepare(const struct Ili9881cBoeDev *ili9881cBoeDev)
+{
+    int32_t i;
+    int32_t ret;
+    int32_t items;
+    struct GpioTiming *timing = NULL;
+
+    HDF_LOGI("%s()", __func__);
+    ret = regulator_enable(ili9881cBoeDev->supply);
+    if (ret < 0) {
+        HDF_LOGE("regulator_enable failed");
+    }
+    ret = SetGpioState(ili9881cBoeDev->avddGpio, GPIO_DIR_OUT, GPIO_VAL_HIGH, 5); /* delay 5ms */
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s SetGpioState failed, gpio:%d", __func__, ili9881cBoeDev->avddGpio);
+        return HDF_FAILURE;
+    }
+    ret = SetGpioState(ili9881cBoeDev->aveeGpio, GPIO_DIR_OUT, GPIO_VAL_HIGH, 5);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s SetGpioState failed, gpio:%d", __func__, ili9881cBoeDev->aveeGpio);
+        return HDF_FAILURE;
+    }
+    ret = SetGpioState(ili9881cBoeDev->vghlGpio, GPIO_DIR_OUT, GPIO_VAL_HIGH, 5);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s SetGpioState failed, gpio:%d", __func__, ili9881cBoeDev->vghlGpio);
+        return HDF_FAILURE;
+    }
+    ret = SetGpioState(ili9881cBoeDev->tsrstGpio, GPIO_DIR_OUT, GPIO_VAL_HIGH, 5);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s SetGpioState failed, gpio:%d", __func__, ili9881cBoeDev->tsrstGpio);
+        return HDF_FAILURE;
+    }
+    ret = GpioSetDir(ili9881cBoeDev->resetGpio, GPIO_DIR_OUT);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("GpioSetDir failed, ret:%d", ret);
+        return HDF_FAILURE;
+    }
+    items = ili9881cBoeDev->rstOnSeq.items;
+    timing = ili9881cBoeDev->rstOnSeq.timing;
+    for (i = 0; i < items; i++) {
+        GpioWrite(ili9881cBoeDev->resetGpio, timing[i].level);
+        OsalMSleep(timing[i].delay);
+    }
+    return HDF_SUCCESS;
+}
+
+static int32_t Ili9881cBoeUnprepare(const struct Ili9881cBoeDev *ili9881cBoeDev)
+{
+    int32_t i;
+    int32_t ret;
+    int32_t items;
+    struct GpioTiming *timing = NULL;
+
+    HDF_LOGI("%s()", __func__);
+    ret = SetGpioState(ili9881cBoeDev->avddGpio, GPIO_DIR_OUT, GPIO_VAL_LOW, 5); /* delay 5ms */
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s SetGpioState failed, gpio:%d", __func__, ili9881cBoeDev->avddGpio);
+        return HDF_FAILURE;
+    }
+    ret = SetGpioState(ili9881cBoeDev->aveeGpio, GPIO_DIR_OUT, GPIO_VAL_LOW, 5);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s SetGpioState failed, gpio:%d", __func__, ili9881cBoeDev->aveeGpio);
+        return HDF_FAILURE;
+    }
+    ret = SetGpioState(ili9881cBoeDev->vghlGpio, GPIO_DIR_OUT, GPIO_VAL_LOW, 5);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s SetGpioState failed, gpio:%d", __func__, ili9881cBoeDev->vghlGpio);
+        return HDF_FAILURE;
+    }
+    ret = SetGpioState(ili9881cBoeDev->tsrstGpio, GPIO_DIR_OUT, GPIO_VAL_LOW, 5);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s SetGpioState failed, gpio:%d", __func__, ili9881cBoeDev->tsrstGpio);
+        return HDF_FAILURE;
+    }
+    ret = GpioSetDir(ili9881cBoeDev->resetGpio, GPIO_DIR_OUT);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("GpioSetDir failed, ret:%d", ret);
+        return HDF_FAILURE;
+    }
+    items = ili9881cBoeDev->rstOffSeq.items;
+    timing = ili9881cBoeDev->rstOffSeq.timing;
+    for (i = 0; i < items; i++) {
+        GpioWrite(ili9881cBoeDev->resetGpio, timing[i].level);
+        OsalMSleep(timing[i].delay);
+    }
+    regulator_disable(ili9881cBoeDev->supply);
+    return HDF_SUCCESS;
+}
+
+static int32_t Ili9881cBoeOn(struct PanelData *panel)
+{
+    int32_t ret;
+    struct Ili9881cBoeDev *ili9881cBoeDev = NULL;
+
+    HDF_LOGI("%s()", __func__);
+    ili9881cBoeDev = ToIli9881cBoeDev(panel);
+    ret = Ili9881cBoePrepare(ili9881cBoeDev);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s Ili9881cBoePrepare failed", __func__);
+        return HDF_FAILURE;
+    }
+    ret = Ili9881cBoeSendCmds(ili9881cBoeDev->dsiDev, g_panelOnCode,
+                              sizeof(g_panelOnCode) / sizeof(g_panelOnCode[0]));
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s Ili9881cBoeSendCmds failed", __func__);
+        return HDF_FAILURE;
+    }
+    return HDF_SUCCESS;
+}
+
+static int32_t Ili9881cBoeOff(struct PanelData *panel)
+{
+    int32_t ret;
+    struct Ili9881cBoeDev *ili9881cBoeDev = NULL;
+
+    ili9881cBoeDev = ToIli9881cBoeDev(panel);
+    HDF_LOGI(" %s line = %d", __func__, __LINE__);
+    ret = Ili9881cBoeSendCmds(ili9881cBoeDev->dsiDev, g_panelOffCode,
+                              sizeof(g_panelOffCode) / sizeof(g_panelOffCode[0]));
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s Ili9881cBoeSendCmds failed", __func__);
+        return HDF_FAILURE;
+    }
+    ret = Ili9881cBoeUnprepare(ili9881cBoeDev);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s Ili9881cBoeUnprepare failed", __func__);
+        return HDF_FAILURE;
+    }
+    return HDF_SUCCESS;
+}
+
+static int32_t Ili9881cBoeInit(struct PanelData *panel)
+{
+    return 0;
+}
+
+#define BLK_PWM_INDEX             2
+#define PWM_MAX_PERIOD            40000
+/* backlight setting */
+#define MIN_LEVEL                 0
+#define MAX_LEVEL                 255
+#define DEFAULT_LEVEL             127
+
+static int32_t Ili9881cBoeSetBl(struct PanelData *panel, uint32_t level)
+{
+    int32_t ret;
+    uint32_t duty;
+    static uint32_t lastLevel = 0;
+    struct Ili9881cBoeDev *ili9881cBoeDev = NULL;
+
+    ili9881cBoeDev = ToIli9881cBoeDev(panel);
+    duty = (level * PWM_MAX_PERIOD) / MAX_LEVEL;
+    ret = PwmSetDuty(ili9881cBoeDev->blHandle, duty);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: PwmSetDutyCycle failed, ret %d", __func__, ret);
+        return HDF_FAILURE;
+    }
+    if ((level != 0) && (lastLevel == 0)) {
+        ret = PwmEnable(ili9881cBoeDev->blHandle);
+    } else if ((level == 0) && (lastLevel != 0)) {
+        ret = PwmDisable(ili9881cBoeDev->blHandle);
+    }
+    lastLevel = level;
+    panel->status.currLevel = level;
+    return ret;
+}
+
+static struct PanelInfo g_panelInfo = {
+    .width = 800,           /* width */
+    .height = 1280,         /* height */
+    .hbp = 80,              /* horizontal back porch */
+    .hfp = 80,              /* horizontal front porch */
+    .hsw = 20,              /* horizontal sync width */
+    .vbp = 12,              /* vertical back porch */
+    .vfp = 20,              /* vertical front porch */
+    .vsw = 4,               /* vertical sync width */
+    .clockFreq = 76800000,  /* clock */
+    .pWidth = 150,          /* physical width */
+    .pHeight = 240,         /* physical height */
+    .blk = { BLK_PWM, MIN_LEVEL, MAX_LEVEL, DEFAULT_LEVEL },
+};
+
+static struct GpioTiming g_rstOnSeq[] = {
+    {1, 5},   /* high, delay 5ms */
+    {0, 20},  /* low, delay 20ms */
+    {1, 30},  /* high, delay 30ms */
+};
+
+static struct GpioTiming g_rstOffSeq = {0, 10}; /* low, delay 10ms */
+
+static void Ili9881cBoeResInit(struct Ili9881cBoeDev *ili9881cBoeDev)
+{
+    ili9881cBoeDev->avddGpio = AVDD_GPIO;
+    ili9881cBoeDev->aveeGpio = AVEE_GPIO;
+    ili9881cBoeDev->vghlGpio = VGHL_GPIO;
+    ili9881cBoeDev->tsrstGpio = TSRST_GPIO;
+    ili9881cBoeDev->resetGpio = RESET_GPIO;
+    ili9881cBoeDev->rstOnSeq.items = sizeof(g_rstOnSeq) / sizeof(struct GpioTiming);
+    ili9881cBoeDev->rstOnSeq.timing = g_rstOnSeq;
+    ili9881cBoeDev->rstOffSeq.items = 1; /* number of reset off sequence */
+    ili9881cBoeDev->rstOffSeq.timing = &g_rstOffSeq;
+    ili9881cBoeDev->dsiDev->lanes = 4; /* number of active data lanes */
+    ili9881cBoeDev->dsiDev->format = 0; /* pixel format for video mode */
+    ili9881cBoeDev->dsiDev->mode_flags = 3; /* DSI operation mode related flags */
+    ili9881cBoeDev->panel.info = &g_panelInfo;
+    ili9881cBoeDev->panel.init = Ili9881cBoeInit;
+    ili9881cBoeDev->panel.on = Ili9881cBoeOn;
+    ili9881cBoeDev->panel.off = Ili9881cBoeOff;
+    ili9881cBoeDev->panel.setBacklight = Ili9881cBoeSetBl;
+    ili9881cBoeDev->panel.priv = ili9881cBoeDev->dsiDev;
+}
+
+static int32_t Ili9881cBoeBlInit(struct Ili9881cBoeDev *ili9881cBoeDev)
+{
+    int32_t ret;
+    struct PwmConfig config;
+
+    ili9881cBoeDev->blHandle = PwmOpen(BLK_PWM_INDEX);
+    if (ili9881cBoeDev->blHandle == NULL) {
+        HDF_LOGE("%s: PwmOpen failed", __func__);
+    }
+    ret = PwmGetConfig(ili9881cBoeDev->blHandle, &config);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: PwmGetConfig fail, ret %d", __func__, ret);
+        return HDF_FAILURE;
+    }
+    config.duty = 1;
+    config.period = PWM_MAX_PERIOD;
+    config.status = 1;
+    ret = PwmSetConfig(ili9881cBoeDev->blHandle, &config);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: PwmSetConfig fail, ret %d", __func__, ret);
+        return HDF_FAILURE;
+    }
+    return HDF_SUCCESS;
+}
+
+int32_t Ili9881cBoeEntryInit(struct HdfDeviceObject *object)
+{
+    struct device_node *panelNode = NULL;
+    struct Ili9881cBoeDev *ili9881cBoeDev = NULL;
+
+    ili9881cBoeDev = (struct Ili9881cBoeDev *)OsalMemCalloc(sizeof(struct Ili9881cBoeDev));
+    if (ili9881cBoeDev == NULL) {
+        HDF_LOGE("%s ili9881cBoeDev malloc fail", __func__);
+        return HDF_FAILURE;
+    }
+    panelNode = of_find_compatible_node(NULL, NULL, "sprd,generic-mipi-panel");
+    if (panelNode == NULL) {
+        HDF_LOGE("%s line = %d", __func__, __LINE__);
+        goto FAIL;
+    }
+    ili9881cBoeDev->dsiDev = of_find_mipi_dsi_device_by_node(panelNode);
+    if (ili9881cBoeDev->dsiDev == NULL) {
+        HDF_LOGE("%s line = %d", __func__, __LINE__);
+        goto FAIL;
+    }
+    ili9881cBoeDev->supply = devm_regulator_get(&ili9881cBoeDev->dsiDev->dev, "power");
+    if (ili9881cBoeDev->supply == NULL) {
+        HDF_LOGE("Get regulator fail");
+        goto FAIL;
+    }
+    Ili9881cBoeResInit(ili9881cBoeDev);
+    if (Ili9881cBoeBlInit(ili9881cBoeDev) != HDF_SUCCESS) {
+        HDF_LOGE("%s Ili9881cBoeBlInit fail", __func__);
+        goto FAIL;
+    }
+    ili9881cBoeDev->panel.object = object;
+    object->priv = ili9881cBoeDev;
+    if (RegisterPanel(&ili9881cBoeDev->panel) == HDF_SUCCESS) {
+        HDF_LOGI("%s success", __func__);
+        return HDF_SUCCESS;
+    }
+
+FAIL:
+    OsalMemFree(ili9881cBoeDev);
+    return HDF_FAILURE;
+}
+ 
+struct HdfDriverEntry g_ili9881cBoeDevEntry = {
+    .moduleVersion = 1,
+    .moduleName = "LCD_ILI9881CBOE",
+    .Init = Ili9881cBoeEntryInit,
+};
+
+HDF_INIT(g_ili9881cBoeDevEntry);
diff --git a/model/display/driver/panel/ili9881c_boe.h b/model/display/driver/panel/ili9881c_boe.h
new file mode 100644
index 000000000..7a38d0836
--- /dev/null
+++ b/model/display/driver/panel/ili9881c_boe.h
@@ -0,0 +1,446 @@
+/*
+ * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
+ *
+ * HDF is dual licensed: you can use it either under the terms of
+ * the GPL, or the BSD license, at your option.
+ * See the LICENSE file in the root of this repository for complete details.
+ */
+
+#ifndef ILI9881C_BOE_H
+#define ILI9881C_BOE_H
+#include <linux/backlight.h>
+#include <drm/drm_mipi_dsi.h>
+#include <linux/of.h>
+#include <linux/regulator/consumer.h>
+#include "hdf_disp.h"
+#include "pwm_if.h"
+
+#define AVDD_GPIO    179
+#define AVEE_GPIO    156
+#define VGHL_GPIO    155
+#define TSRST_GPIO   240
+#define RESET_GPIO   178
+
+struct GpioTiming {
+    uint16_t level;
+    uint32_t delay;
+};
+  
+struct ResetSeq {
+    uint32_t items;
+    struct GpioTiming *timing;
+};
+
+struct Ili9881cBoeDev {
+    struct PanelData panel;
+    struct mipi_dsi_device *dsiDev;
+    DevHandle blHandle;
+    struct regulator *supply;
+    uint16_t avddGpio;
+    uint16_t aveeGpio;
+    uint16_t vghlGpio;
+    uint16_t tsrstGpio;
+    uint16_t resetGpio;
+    struct ResetSeq rstOnSeq;
+    struct ResetSeq rstOffSeq;
+};
+
+/* panel on command payload */
+static uint8_t g_payLoad0[] = { 0xFF, 0x98, 0x81, 0x03 };
+static uint8_t g_payLoad1[] = { 0x01, 0x00 };
+static uint8_t g_payLoad2[] = { 0x02, 0x00 };
+static uint8_t g_payLoad3[] = { 0x03, 0x73 };
+static uint8_t g_payLoad4[] = { 0x04, 0x00 };
+static uint8_t g_payLoad5[] = { 0x05, 0x00 };
+static uint8_t g_payLoad6[] = { 0x06, 0x08 };
+static uint8_t g_payLoad7[] = { 0x07, 0x00 };
+static uint8_t g_payLoad8[] = { 0x08, 0x00 };
+static uint8_t g_payLoad9[] = { 0x09, 0x00 };
+static uint8_t g_payLoad10[] = { 0x0A, 0x01 };
+static uint8_t g_payLoad11[] = { 0x0B, 0x01 };
+static uint8_t g_payLoad12[] = { 0x0C, 0x00 };
+static uint8_t g_payLoad13[] = { 0x0D, 0x01 };
+static uint8_t g_payLoad14[] = { 0x0E, 0x01 };
+static uint8_t g_payLoad15[] = { 0x0F, 0x00 };
+static uint8_t g_payLoad16[] = { 0x10, 0x00 };
+static uint8_t g_payLoad17[] = { 0x11, 0x00 };
+static uint8_t g_payLoad18[] = { 0x12, 0x00 };
+static uint8_t g_payLoad19[] = { 0x13, 0x1F };
+static uint8_t g_payLoad20[] = { 0x14, 0x1F };
+static uint8_t g_payLoad21[] = { 0x15, 0x00 };
+static uint8_t g_payLoad22[] = { 0x16, 0x00 };
+static uint8_t g_payLoad23[] = { 0x17, 0x00 };
+static uint8_t g_payLoad24[] = { 0x18, 0x00 };
+static uint8_t g_payLoad25[] = { 0x19, 0x00 };
+static uint8_t g_payLoad26[] = { 0x1A, 0x00 };
+static uint8_t g_payLoad27[] = { 0x1B, 0x00 };
+static uint8_t g_payLoad28[] = { 0x1C, 0x00 };
+static uint8_t g_payLoad29[] = { 0x1D, 0x00 };
+static uint8_t g_payLoad30[] = { 0x1E, 0x40 };
+static uint8_t g_payLoad31[] = { 0x1F, 0xC0 };
+static uint8_t g_payLoad32[] = { 0x20, 0x06 };
+static uint8_t g_payLoad33[] = { 0x21, 0x01 };
+static uint8_t g_payLoad34[] = { 0x22, 0x06 };
+static uint8_t g_payLoad35[] = { 0x23, 0x01 };
+static uint8_t g_payLoad36[] = { 0x24, 0x88 };
+static uint8_t g_payLoad37[] = { 0x25, 0x88 };
+static uint8_t g_payLoad38[] = { 0x26, 0x00 };
+static uint8_t g_payLoad39[] = { 0x27, 0x00 };
+static uint8_t g_payLoad40[] = { 0x28, 0x3B };
+static uint8_t g_payLoad41[] = { 0x29, 0x03 };
+static uint8_t g_payLoad42[] = { 0x2A, 0x00 };
+static uint8_t g_payLoad43[] = { 0x2B, 0x00 };
+static uint8_t g_payLoad44[] = { 0x2C, 0x00 };
+static uint8_t g_payLoad45[] = { 0x2D, 0x00 };
+static uint8_t g_payLoad46[] = { 0x2E, 0x00 };
+static uint8_t g_payLoad47[] = { 0x2F, 0x00 };
+static uint8_t g_payLoad48[] = { 0x30, 0x00 };
+static uint8_t g_payLoad49[] = { 0x31, 0x00 };
+static uint8_t g_payLoad50[] = { 0x32, 0x00 };
+static uint8_t g_payLoad51[] = { 0x33, 0x00 };
+static uint8_t g_payLoad52[] = { 0x34, 0x00 };
+static uint8_t g_payLoad53[] = { 0x35, 0x00 };
+static uint8_t g_payLoad54[] = { 0x36, 0x00 };
+static uint8_t g_payLoad55[] = { 0x37, 0x00 };
+static uint8_t g_payLoad56[] = { 0x38, 0x00 };
+static uint8_t g_payLoad57[] = { 0x39, 0x00 };
+static uint8_t g_payLoad58[] = { 0x3A, 0x00 };
+static uint8_t g_payLoad59[] = { 0x3B, 0x00 };
+static uint8_t g_payLoad60[] = { 0x3C, 0x00 };
+static uint8_t g_payLoad61[] = { 0x3D, 0x00 };
+static uint8_t g_payLoad62[] = { 0x3E, 0x00 };
+static uint8_t g_payLoad63[] = { 0x3F, 0x00 };
+static uint8_t g_payLoad64[] = { 0x40, 0x00 };
+static uint8_t g_payLoad65[] = { 0x41, 0x00 };
+static uint8_t g_payLoad66[] = { 0x42, 0x00 };
+static uint8_t g_payLoad67[] = { 0x43, 0x00 };
+static uint8_t g_payLoad68[] = { 0x44, 0x00 };
+static uint8_t g_payLoad69[] = { 0x50, 0x01 };
+static uint8_t g_payLoad70[] = { 0x51, 0x23 };
+static uint8_t g_payLoad71[] = { 0x52, 0x45 };
+static uint8_t g_payLoad72[] = { 0x53, 0x67 };
+static uint8_t g_payLoad73[] = { 0x54, 0x89 };
+static uint8_t g_payLoad74[] = { 0x55, 0xAB };
+static uint8_t g_payLoad75[] = { 0x56, 0x01 };
+static uint8_t g_payLoad76[] = { 0x57, 0x23 };
+static uint8_t g_payLoad77[] = { 0x58, 0x45 };
+static uint8_t g_payLoad78[] = { 0x59, 0x67 };
+static uint8_t g_payLoad79[] = { 0x5A, 0x89 };
+static uint8_t g_payLoad80[] = { 0x5B, 0xAB };
+static uint8_t g_payLoad81[] = { 0x5C, 0xCD };
+static uint8_t g_payLoad82[] = { 0x5D, 0xEF };
+static uint8_t g_payLoad83[] = { 0x5E, 0x00 };
+static uint8_t g_payLoad84[] = { 0x5F, 0x01 };
+static uint8_t g_payLoad85[] = { 0x60, 0x01 };
+static uint8_t g_payLoad86[] = { 0x61, 0x06 };
+static uint8_t g_payLoad87[] = { 0x62, 0x06 };
+static uint8_t g_payLoad88[] = { 0x63, 0x07 };
+static uint8_t g_payLoad89[] = { 0x64, 0x07 };
+static uint8_t g_payLoad90[] = { 0x65, 0x00 };
+static uint8_t g_payLoad91[] = { 0x66, 0x00 };
+static uint8_t g_payLoad92[] = { 0x67, 0x02 };
+static uint8_t g_payLoad93[] = { 0x68, 0x02 };
+static uint8_t g_payLoad94[] = { 0x69, 0x05 };
+static uint8_t g_payLoad95[] = { 0x6A, 0x05 };
+static uint8_t g_payLoad96[] = { 0x6B, 0x02 };
+static uint8_t g_payLoad97[] = { 0x6C, 0x0D };
+static uint8_t g_payLoad98[] = { 0x6D, 0x0D };
+static uint8_t g_payLoad99[] = { 0x6E, 0x0C };
+static uint8_t g_payLoad100[] = { 0x6F, 0x0C };
+static uint8_t g_payLoad101[] = { 0x70, 0x0F };
+static uint8_t g_payLoad102[] = { 0x71, 0x0F };
+static uint8_t g_payLoad103[] = { 0x72, 0x0E };
+static uint8_t g_payLoad104[] = { 0x73, 0x0E };
+static uint8_t g_payLoad105[] = { 0x74, 0x02 };
+static uint8_t g_payLoad106[] = { 0x75, 0x01 };
+static uint8_t g_payLoad107[] = { 0x76, 0x01 };
+static uint8_t g_payLoad108[] = { 0x77, 0x06 };
+static uint8_t g_payLoad109[] = { 0x78, 0x06 };
+static uint8_t g_payLoad110[] = { 0x79, 0x07 };
+static uint8_t g_payLoad111[] = { 0x7A, 0x07 };
+static uint8_t g_payLoad112[] = { 0x7B, 0x00 };
+static uint8_t g_payLoad113[] = { 0x7C, 0x00 };
+static uint8_t g_payLoad114[] = { 0x7D, 0x02 };
+static uint8_t g_payLoad115[] = { 0x7E, 0x02 };
+static uint8_t g_payLoad116[] = { 0x7F, 0x05 };
+static uint8_t g_payLoad117[] = { 0x80, 0x05 };
+static uint8_t g_payLoad118[] = { 0x81, 0x02 };
+static uint8_t g_payLoad119[] = { 0x82, 0x0D };
+static uint8_t g_payLoad120[] = { 0x83, 0x0D };
+static uint8_t g_payLoad121[] = { 0x84, 0x0C };
+static uint8_t g_payLoad122[] = { 0x85, 0x0C };
+static uint8_t g_payLoad123[] = { 0x86, 0x0F };
+static uint8_t g_payLoad124[] = { 0x87, 0x0F };
+static uint8_t g_payLoad125[] = { 0x88, 0x0E };
+static uint8_t g_payLoad126[] = { 0x89, 0x0E };
+static uint8_t g_payLoad127[] = { 0x8A, 0x02 };
+static uint8_t g_payLoad128[] = { 0xFF, 0x98, 0x81, 0x04 };
+static uint8_t g_payLoad129[] = { 0x6C, 0x15 };
+static uint8_t g_payLoad130[] = { 0x6E, 0x2A };
+static uint8_t g_payLoad131[] = { 0x6F, 0x33 };
+static uint8_t g_payLoad132[] = { 0x8D, 0x1B };
+static uint8_t g_payLoad133[] = { 0x87, 0xBA };
+static uint8_t g_payLoad134[] = { 0x3A, 0x24 };
+static uint8_t g_payLoad135[] = { 0x26, 0x76 };
+static uint8_t g_payLoad136[] = { 0xB2, 0xD1 };
+static uint8_t g_payLoad137[] = { 0xFF, 0x98, 0x81, 0x01 };
+static uint8_t g_payLoad138[] = { 0x22, 0x0A };
+static uint8_t g_payLoad139[] = { 0x31, 0x00 };
+static uint8_t g_payLoad140[] = { 0x43, 0x66 };
+static uint8_t g_payLoad141[] = { 0x53, 0x40 };
+static uint8_t g_payLoad142[] = { 0x50, 0x87 };
+static uint8_t g_payLoad143[] = { 0x51, 0x82 };
+static uint8_t g_payLoad144[] = { 0x60, 0x15 };
+static uint8_t g_payLoad145[] = { 0x61, 0x01 };
+static uint8_t g_payLoad146[] = { 0x62, 0x0C };
+static uint8_t g_payLoad147[] = { 0x63, 0x00 };
+static uint8_t g_payLoad148[] = { 0xA0, 0x00 };
+static uint8_t g_payLoad149[] = { 0xA1, 0x13 };
+static uint8_t g_payLoad150[] = { 0xA2, 0x23 };
+static uint8_t g_payLoad151[] = { 0xA3, 0x14 };
+static uint8_t g_payLoad152[] = { 0xA4, 0x16 };
+static uint8_t g_payLoad153[] = { 0xA5, 0x29 };
+static uint8_t g_payLoad154[] = { 0xA6, 0x1E };
+static uint8_t g_payLoad155[] = { 0xA7, 0x1D };
+static uint8_t g_payLoad156[] = { 0xA8, 0x86 };
+static uint8_t g_payLoad157[] = { 0xA9, 0x1E };
+static uint8_t g_payLoad158[] = { 0xAA, 0x29 };
+static uint8_t g_payLoad159[] = { 0xAB, 0x74 };
+static uint8_t g_payLoad160[] = { 0xAC, 0x19 };
+static uint8_t g_payLoad161[] = { 0xAD, 0x17 };
+static uint8_t g_payLoad162[] = { 0xAE, 0x4B };
+static uint8_t g_payLoad163[] = { 0xAF, 0x20 };
+static uint8_t g_payLoad164[] = { 0xB0, 0x26 };
+static uint8_t g_payLoad165[] = { 0xB1, 0x4C };
+static uint8_t g_payLoad166[] = { 0xB2, 0x5D };
+static uint8_t g_payLoad167[] = { 0xB3, 0x3F };
+static uint8_t g_payLoad168[] = { 0xC0, 0x00 };
+static uint8_t g_payLoad169[] = { 0xC1, 0x13 };
+static uint8_t g_payLoad170[] = { 0xC2, 0x23 };
+static uint8_t g_payLoad171[] = { 0xC3, 0x14 };
+static uint8_t g_payLoad172[] = { 0xC4, 0x16 };
+static uint8_t g_payLoad173[] = { 0xC5, 0x29 };
+static uint8_t g_payLoad174[] = { 0xC6, 0x1E };
+static uint8_t g_payLoad175[] = { 0xC7, 0x1D };
+static uint8_t g_payLoad176[] = { 0xC8, 0x86 };
+static uint8_t g_payLoad177[] = { 0xC9, 0x1E };
+static uint8_t g_payLoad178[] = { 0xCA, 0x29 };
+static uint8_t g_payLoad179[] = { 0xCB, 0x74 };
+static uint8_t g_payLoad180[] = { 0xCC, 0x19 };
+static uint8_t g_payLoad181[] = { 0xCD, 0x17 };
+static uint8_t g_payLoad182[] = { 0xCE, 0x4B };
+static uint8_t g_payLoad183[] = { 0xCF, 0x20 };
+static uint8_t g_payLoad184[] = { 0xD0, 0x26 };
+static uint8_t g_payLoad185[] = { 0xD1, 0x4C };
+static uint8_t g_payLoad186[] = { 0xD2, 0x5D };
+static uint8_t g_payLoad187[] = { 0xD3, 0x3F };
+static uint8_t g_payLoad188[] = { 0xFF, 0x98, 0x81, 0x00 };
+static uint8_t g_payLoad189[] = { 0x11, 0x00 };
+static uint8_t g_payLoad190[] = { 0x29, 0x00 };
+static uint8_t g_payLoad191[] = { 0x35, 0x00 };
+
+static struct DsiCmdDesc g_panelOnCode[] = {
+    { 0x39, 0x00, sizeof(g_payLoad0), g_payLoad0 }, 
+    { 0x23, 0x00, sizeof(g_payLoad1), g_payLoad1 },
+    { 0x23, 0x00, sizeof(g_payLoad2), g_payLoad2 },
+    { 0x23, 0x00, sizeof(g_payLoad3), g_payLoad3 },
+    { 0x23, 0x00, sizeof(g_payLoad4), g_payLoad4 },
+    { 0x23, 0x00, sizeof(g_payLoad5), g_payLoad5 },
+    { 0x23, 0x00, sizeof(g_payLoad6), g_payLoad6 },
+    { 0x23, 0x00, sizeof(g_payLoad7), g_payLoad7 },
+    { 0x23, 0x00, sizeof(g_payLoad8), g_payLoad8 },
+    { 0x23, 0x00, sizeof(g_payLoad9), g_payLoad9 },
+    { 0x23, 0x00, sizeof(g_payLoad10), g_payLoad10 },  
+    { 0x23, 0x00, sizeof(g_payLoad11), g_payLoad11 },
+    { 0x23, 0x00, sizeof(g_payLoad12), g_payLoad12 },
+    { 0x23, 0x00, sizeof(g_payLoad13), g_payLoad13 },
+    { 0x23, 0x00, sizeof(g_payLoad14), g_payLoad14 },
+    { 0x23, 0x00, sizeof(g_payLoad15), g_payLoad15 },
+    { 0x23, 0x00, sizeof(g_payLoad16), g_payLoad16 },
+    { 0x23, 0x00, sizeof(g_payLoad17), g_payLoad17 },
+    { 0x23, 0x00, sizeof(g_payLoad18), g_payLoad18 },
+    { 0x23, 0x00, sizeof(g_payLoad19), g_payLoad19 },
+    { 0x23, 0x00, sizeof(g_payLoad20), g_payLoad20 },
+    { 0x23, 0x00, sizeof(g_payLoad21), g_payLoad21 },
+    { 0x23, 0x00, sizeof(g_payLoad22), g_payLoad22 },
+    { 0x23, 0x00, sizeof(g_payLoad23), g_payLoad23 },
+    { 0x23, 0x00, sizeof(g_payLoad24), g_payLoad24 },
+    { 0x23, 0x00, sizeof(g_payLoad25), g_payLoad25 },
+    { 0x23, 0x00, sizeof(g_payLoad26), g_payLoad26 },
+    { 0x23, 0x00, sizeof(g_payLoad27), g_payLoad27 },
+    { 0x23, 0x00, sizeof(g_payLoad28), g_payLoad28 },
+    { 0x23, 0x00, sizeof(g_payLoad29), g_payLoad29 },
+    { 0x23, 0x00, sizeof(g_payLoad30), g_payLoad30 },
+    { 0x23, 0x00, sizeof(g_payLoad31), g_payLoad31 },
+    { 0x23, 0x00, sizeof(g_payLoad32), g_payLoad32 },
+    { 0x23, 0x00, sizeof(g_payLoad33), g_payLoad33 },
+    { 0x23, 0x00, sizeof(g_payLoad34), g_payLoad34 },
+    { 0x23, 0x00, sizeof(g_payLoad35), g_payLoad35 },
+    { 0x23, 0x00, sizeof(g_payLoad36), g_payLoad36 },
+    { 0x23, 0x00, sizeof(g_payLoad37), g_payLoad37 },
+    { 0x23, 0x00, sizeof(g_payLoad38), g_payLoad38 },
+    { 0x23, 0x00, sizeof(g_payLoad39), g_payLoad39 },
+    { 0x23, 0x00, sizeof(g_payLoad40), g_payLoad40 },
+    { 0x23, 0x00, sizeof(g_payLoad41), g_payLoad41 },
+    { 0x23, 0x00, sizeof(g_payLoad42), g_payLoad42 },
+    { 0x23, 0x00, sizeof(g_payLoad43), g_payLoad43 },
+    { 0x23, 0x00, sizeof(g_payLoad44), g_payLoad44 },
+    { 0x23, 0x00, sizeof(g_payLoad45), g_payLoad45 },
+    { 0x23, 0x00, sizeof(g_payLoad46), g_payLoad46 },
+    { 0x23, 0x00, sizeof(g_payLoad47), g_payLoad47 },
+    { 0x23, 0x00, sizeof(g_payLoad48), g_payLoad48 },
+    { 0x23, 0x00, sizeof(g_payLoad49), g_payLoad49 },
+    { 0x23, 0x00, sizeof(g_payLoad50), g_payLoad50 },
+    { 0x23, 0x00, sizeof(g_payLoad51), g_payLoad51 },
+    { 0x23, 0x00, sizeof(g_payLoad52), g_payLoad52 },
+    { 0x23, 0x00, sizeof(g_payLoad53), g_payLoad53 },
+    { 0x23, 0x00, sizeof(g_payLoad54), g_payLoad54 },
+    { 0x23, 0x00, sizeof(g_payLoad55), g_payLoad55 },
+    { 0x23, 0x00, sizeof(g_payLoad56), g_payLoad56 },
+    { 0x23, 0x00, sizeof(g_payLoad57), g_payLoad57 },
+    { 0x23, 0x00, sizeof(g_payLoad58), g_payLoad58 },
+    { 0x23, 0x00, sizeof(g_payLoad59), g_payLoad59 },
+    { 0x23, 0x00, sizeof(g_payLoad60), g_payLoad60 },
+    { 0x23, 0x00, sizeof(g_payLoad61), g_payLoad61 },
+    { 0x23, 0x00, sizeof(g_payLoad62), g_payLoad62 },
+    { 0x23, 0x00, sizeof(g_payLoad63), g_payLoad63 },
+    { 0x23, 0x00, sizeof(g_payLoad64), g_payLoad64 },
+    { 0x23, 0x00, sizeof(g_payLoad65), g_payLoad65 },
+    { 0x23, 0x00, sizeof(g_payLoad66), g_payLoad66 },
+    { 0x23, 0x00, sizeof(g_payLoad67), g_payLoad67 },
+    { 0x23, 0x00, sizeof(g_payLoad68), g_payLoad68 },
+    { 0x23, 0x00, sizeof(g_payLoad69), g_payLoad69 },
+    { 0x23, 0x00, sizeof(g_payLoad70), g_payLoad70 },
+    { 0x23, 0x00, sizeof(g_payLoad71), g_payLoad71 },
+    { 0x23, 0x00, sizeof(g_payLoad72), g_payLoad72 },
+    { 0x23, 0x00, sizeof(g_payLoad73), g_payLoad73 },
+    { 0x23, 0x00, sizeof(g_payLoad74), g_payLoad74 },
+    { 0x23, 0x00, sizeof(g_payLoad75), g_payLoad75 },
+    { 0x23, 0x00, sizeof(g_payLoad76), g_payLoad76 },
+    { 0x23, 0x00, sizeof(g_payLoad77), g_payLoad77 },
+    { 0x23, 0x00, sizeof(g_payLoad78), g_payLoad78 },
+    { 0x23, 0x00, sizeof(g_payLoad79), g_payLoad79 },
+    { 0x23, 0x00, sizeof(g_payLoad80), g_payLoad80 },
+    { 0x23, 0x00, sizeof(g_payLoad81), g_payLoad81 },
+    { 0x23, 0x00, sizeof(g_payLoad82), g_payLoad82 },
+    { 0x23, 0x00, sizeof(g_payLoad83), g_payLoad83 },
+    { 0x23, 0x00, sizeof(g_payLoad84), g_payLoad84 },
+    { 0x23, 0x00, sizeof(g_payLoad85), g_payLoad85 },
+    { 0x23, 0x00, sizeof(g_payLoad86), g_payLoad86 },
+    { 0x23, 0x00, sizeof(g_payLoad87), g_payLoad87 },
+    { 0x23, 0x00, sizeof(g_payLoad88), g_payLoad88 },
+    { 0x23, 0x00, sizeof(g_payLoad89), g_payLoad89 },
+    { 0x23, 0x00, sizeof(g_payLoad90), g_payLoad90 },
+    { 0x23, 0x00, sizeof(g_payLoad91), g_payLoad91 },
+    { 0x23, 0x00, sizeof(g_payLoad92), g_payLoad92 },
+    { 0x23, 0x00, sizeof(g_payLoad93), g_payLoad93 },
+    { 0x23, 0x00, sizeof(g_payLoad94), g_payLoad94 },
+    { 0x23, 0x00, sizeof(g_payLoad95), g_payLoad95 },
+    { 0x23, 0x00, sizeof(g_payLoad96), g_payLoad96 },
+    { 0x23, 0x00, sizeof(g_payLoad97), g_payLoad97 },
+    { 0x23, 0x00, sizeof(g_payLoad98), g_payLoad98 },
+    { 0x23, 0x00, sizeof(g_payLoad99), g_payLoad99 },
+    { 0x23, 0x00, sizeof(g_payLoad100), g_payLoad100 },
+    { 0x23, 0x00, sizeof(g_payLoad101), g_payLoad101 },
+    { 0x23, 0x00, sizeof(g_payLoad102), g_payLoad102 },
+    { 0x23, 0x00, sizeof(g_payLoad103), g_payLoad103 },
+    { 0x23, 0x00, sizeof(g_payLoad104), g_payLoad104 },
+    { 0x23, 0x00, sizeof(g_payLoad105), g_payLoad105 },
+    { 0x23, 0x00, sizeof(g_payLoad106), g_payLoad106 },
+    { 0x23, 0x00, sizeof(g_payLoad107), g_payLoad107 },
+    { 0x23, 0x00, sizeof(g_payLoad108), g_payLoad108 },
+    { 0x23, 0x00, sizeof(g_payLoad109), g_payLoad109 },
+    { 0x23, 0x00, sizeof(g_payLoad110), g_payLoad110 },
+    { 0x23, 0x00, sizeof(g_payLoad111), g_payLoad111 },
+    { 0x23, 0x00, sizeof(g_payLoad112), g_payLoad112 },
+    { 0x23, 0x00, sizeof(g_payLoad113), g_payLoad113 },
+    { 0x23, 0x00, sizeof(g_payLoad114), g_payLoad114 },
+    { 0x23, 0x00, sizeof(g_payLoad115), g_payLoad115 },
+    { 0x23, 0x00, sizeof(g_payLoad116), g_payLoad116 },
+    { 0x23, 0x00, sizeof(g_payLoad117), g_payLoad117 },
+    { 0x23, 0x00, sizeof(g_payLoad118), g_payLoad118 },
+    { 0x23, 0x00, sizeof(g_payLoad119), g_payLoad119 },
+    { 0x23, 0x00, sizeof(g_payLoad120), g_payLoad120 },
+    { 0x23, 0x00, sizeof(g_payLoad121), g_payLoad121 },
+    { 0x23, 0x00, sizeof(g_payLoad122), g_payLoad122 },
+    { 0x23, 0x00, sizeof(g_payLoad123), g_payLoad123 },
+    { 0x23, 0x00, sizeof(g_payLoad124), g_payLoad124 },
+    { 0x23, 0x00, sizeof(g_payLoad125), g_payLoad125 },
+    { 0x23, 0x00, sizeof(g_payLoad126), g_payLoad126 },
+    { 0x23, 0x00, sizeof(g_payLoad127), g_payLoad127 },
+    { 0x39, 0x00, sizeof(g_payLoad128), g_payLoad128 },
+    { 0x23, 0x00, sizeof(g_payLoad129), g_payLoad129 },
+    { 0x23, 0x00, sizeof(g_payLoad130), g_payLoad130 },
+    { 0x23, 0x00, sizeof(g_payLoad131), g_payLoad131 },
+    { 0x23, 0x00, sizeof(g_payLoad132), g_payLoad132 },
+    { 0x23, 0x00, sizeof(g_payLoad133), g_payLoad133 },
+    { 0x23, 0x00, sizeof(g_payLoad134), g_payLoad134 },
+    { 0x23, 0x00, sizeof(g_payLoad135), g_payLoad135 },
+    { 0x23, 0x00, sizeof(g_payLoad136), g_payLoad136 },
+    { 0x39, 0x00, sizeof(g_payLoad137), g_payLoad137 },
+    { 0x23, 0x00, sizeof(g_payLoad138), g_payLoad138 },
+    { 0x23, 0x00, sizeof(g_payLoad139), g_payLoad139 },
+    { 0x23, 0x00, sizeof(g_payLoad140), g_payLoad140 },
+    { 0x23, 0x00, sizeof(g_payLoad141), g_payLoad141 },
+    { 0x23, 0x00, sizeof(g_payLoad142), g_payLoad142 },
+    { 0x23, 0x00, sizeof(g_payLoad143), g_payLoad143 },
+    { 0x23, 0x00, sizeof(g_payLoad144), g_payLoad144 },
+    { 0x23, 0x00, sizeof(g_payLoad145), g_payLoad145 },
+    { 0x23, 0x00, sizeof(g_payLoad146), g_payLoad146 },
+    { 0x23, 0x00, sizeof(g_payLoad147), g_payLoad147 },
+    { 0x23, 0x00, sizeof(g_payLoad148), g_payLoad148 },
+    { 0x23, 0x00, sizeof(g_payLoad149), g_payLoad149 },
+    { 0x23, 0x00, sizeof(g_payLoad150), g_payLoad150 },
+    { 0x23, 0x00, sizeof(g_payLoad151), g_payLoad151 },
+    { 0x23, 0x00, sizeof(g_payLoad152), g_payLoad152 },
+    { 0x23, 0x00, sizeof(g_payLoad153), g_payLoad153 },
+    { 0x23, 0x00, sizeof(g_payLoad154), g_payLoad154 },
+    { 0x23, 0x00, sizeof(g_payLoad155), g_payLoad155 },
+    { 0x23, 0x00, sizeof(g_payLoad156), g_payLoad156 },
+    { 0x23, 0x00, sizeof(g_payLoad157), g_payLoad157 },
+    { 0x23, 0x00, sizeof(g_payLoad158), g_payLoad158 },
+    { 0x23, 0x00, sizeof(g_payLoad159), g_payLoad159 },
+    { 0x23, 0x00, sizeof(g_payLoad160), g_payLoad160 },
+    { 0x23, 0x00, sizeof(g_payLoad161), g_payLoad161 },
+    { 0x23, 0x00, sizeof(g_payLoad162), g_payLoad162 },
+    { 0x23, 0x00, sizeof(g_payLoad163), g_payLoad163 },
+    { 0x23, 0x00, sizeof(g_payLoad164), g_payLoad164 },
+    { 0x23, 0x00, sizeof(g_payLoad165), g_payLoad165 },
+    { 0x23, 0x00, sizeof(g_payLoad166), g_payLoad166 },
+    { 0x23, 0x00, sizeof(g_payLoad167), g_payLoad167 },
+    { 0x23, 0x00, sizeof(g_payLoad168), g_payLoad168 },
+    { 0x23, 0x00, sizeof(g_payLoad169), g_payLoad169 },
+    { 0x23, 0x00, sizeof(g_payLoad170), g_payLoad170 },
+    { 0x23, 0x00, sizeof(g_payLoad171), g_payLoad171 },
+    { 0x23, 0x00, sizeof(g_payLoad172), g_payLoad172 },
+    { 0x23, 0x00, sizeof(g_payLoad173), g_payLoad173 },
+    { 0x23, 0x00, sizeof(g_payLoad174), g_payLoad174 },
+    { 0x23, 0x00, sizeof(g_payLoad175), g_payLoad175 },
+    { 0x23, 0x00, sizeof(g_payLoad176), g_payLoad176 },
+    { 0x23, 0x00, sizeof(g_payLoad177), g_payLoad177 },
+    { 0x23, 0x00, sizeof(g_payLoad178), g_payLoad178 },
+    { 0x23, 0x00, sizeof(g_payLoad179), g_payLoad179 },
+    { 0x23, 0x00, sizeof(g_payLoad180), g_payLoad180 },
+    { 0x23, 0x00, sizeof(g_payLoad181), g_payLoad181 },
+    { 0x23, 0x00, sizeof(g_payLoad182), g_payLoad182 },
+    { 0x23, 0x00, sizeof(g_payLoad183), g_payLoad183 },
+    { 0x23, 0x00, sizeof(g_payLoad184), g_payLoad184 },
+    { 0x23, 0x00, sizeof(g_payLoad185), g_payLoad185 },
+    { 0x23, 0x00, sizeof(g_payLoad186), g_payLoad186 },
+    { 0x23, 0x00, sizeof(g_payLoad187), g_payLoad187 },
+    { 0x39, 0x00, sizeof(g_payLoad188), g_payLoad188 },
+    { 0x23, 0x78, sizeof(g_payLoad189), g_payLoad189 },
+    { 0x23, 0x0A, sizeof(g_payLoad190), g_payLoad190 },
+    { 0x23, 0x00, sizeof(g_payLoad191), g_payLoad191 },
+};
+
+/* panel off command payload */
+static uint8_t g_offpayLoad0[] = { 0x11 };
+static uint8_t g_offpayLoad1[] = { 0x29 };
+
+static struct DsiCmdDesc g_panelOffCode[] = {
+    { 0x13, 0x0A, sizeof(g_offpayLoad0), g_offpayLoad0 },
+    { 0x13, 0x78, sizeof(g_offpayLoad1), g_offpayLoad1 },
+};
+
+#endif
\ No newline at end of file
diff --git a/model/display/driver/panel/mipi_icn9700.c b/model/display/driver/panel/mipi_icn9700.c
index 6952230ce..d475627b7 100644
--- a/model/display/driver/panel/mipi_icn9700.c
+++ b/model/display/driver/panel/mipi_icn9700.c
@@ -7,8 +7,8 @@
  */
 
 #include "gpio_if.h"
+#include "hdf_disp.h"
 #include "hdf_log.h"
-#include "lcd_abs_if.h"
 #include "mipi_dsi_if.h"
 #include "osal.h"
 #include "pwm_if.h"
@@ -316,6 +316,7 @@ static int32_t Icn9700EsdCheckFunc(struct PanelData *panel)
     return HDF_SUCCESS;
 }
 
+#define OUTPUT_USER 0 /* output timing type */
 static struct PanelInfo g_panelInfo = {
     .width = WIDTH,                     /* width */
     .height = HEIGHT,                   /* height */
@@ -327,7 +328,7 @@ static struct PanelInfo g_panelInfo = {
     .vsw = VERTICAL_SYNC_WIDTH,         /* vertical sync width */
     .frameRate = FRAME_RATE,            /* frame rate */
     .intfType = MIPI_DSI,               /* panel interface type */
-    .intfSync = OUTPUT_USER,            /* output timing type */
+    .intfSync = OUTPUT_USER,
     /* mipi config info */
     .mipi = { DSI_2_LANES, DSI_VIDEO_MODE, VIDEO_BURST_MODE, FORMAT_RGB_24_BIT },
     /* backlight config info */
diff --git a/model/display/driver/panel/ssp_st7789.c b/model/display/driver/panel/ssp_st7789.c
index 7dec843ab..8f39f6cf1 100644
--- a/model/display/driver/panel/ssp_st7789.c
+++ b/model/display/driver/panel/ssp_st7789.c
@@ -9,7 +9,6 @@
 #include "gpio_if.h"
 #include "hdf_device_desc.h"
 #include "hdf_log.h"
-#include "lcd_abs_if.h"
 #include "osal_mem.h"
 #include "osal_time.h"
 #include "spi_if.h"
@@ -77,7 +76,7 @@ static struct LcdCmd g_offCmd[] = {
 
 static DevHandle g_spiHdl = NULL;
 
-static int32_t SpiWrite9Bits(DevHandle *spiHandle, uint8_t cmd, uint8_t data)
+static int32_t SpiWrite9Bits(DevHandle spiHandle, uint8_t cmd, uint8_t data)
 {
     int32_t ret;
     uint16_t wbuff[1] = {0};
@@ -91,10 +90,10 @@ static int32_t SpiWrite9Bits(DevHandle *spiHandle, uint8_t cmd, uint8_t data)
     return HDF_SUCCESS;
 }
 
-static DevHandle *GetSpiHandle(void)
+DevHandle GetSpiHandle(void)
 {
     int32_t ret;
-    DevHandle *spiHandle = NULL;
+    DevHandle spiHandle = NULL;
     struct SpiDevInfo spiDevinfo;
     struct SpiCfg cfg;
 
@@ -249,7 +248,7 @@ static struct PanelInfo g_panelInfo = {
     .height = HEIGHT,                 /* height */
     .frameRate = FRAME_RATE,          /* frame rate */
     .intfType = LCD_6BIT,             /* panel interface type */
-    .intfSync = OUTPUT_240X320_50,    /* output timming type */
+    .intfSync = 42,    /* Hi3559AV100: For ili9341 at 50 Hz (6bit) */
 };
 
 static struct PanelData g_panelData = {
-- 
Gitee