diff --git a/core/adapter/vnode/src/hdf_vnode_adapter.c b/core/adapter/vnode/src/hdf_vnode_adapter.c
index dab5a350ee3c6535b231d291604c205f5a650603..bf118ea40d5230eb9d2f23f88b04e56aa856a259 100644
--- a/core/adapter/vnode/src/hdf_vnode_adapter.c
+++ b/core/adapter/vnode/src/hdf_vnode_adapter.c
@@ -314,6 +314,7 @@ static int VNodeAdapterSendDevEventToClient(struct HdfVNodeAdapterClient *vnodeC
 {
     struct HdfDevEvent *event = NULL;
 
+#if 0 // modify by zhaoxc
     OsalMutexLock(&vnodeClient->mutex);
     if (vnodeClient->status != VNODE_CLIENT_LISTENING) {
         OsalMutexUnlock(&vnodeClient->mutex);
@@ -340,6 +341,33 @@ static int VNodeAdapterSendDevEventToClient(struct HdfVNodeAdapterClient *vnodeC
     wake_up_interruptible(&vnodeClient->pollWait);
     OsalMutexUnlock(&vnodeClient->mutex);
 
+#else // modify by zhaoxc
+    OsalMutexTryLock(&vnodeClient->mutex);
+    if (vnodeClient->status != VNODE_CLIENT_LISTENING) {
+        OsalMutexUnlock(&vnodeClient->mutex);
+        return HDF_SUCCESS;
+    }
+    if (vnodeClient->eventQueueSize >= EVENT_QUEUE_MAX) {
+        HdfVnodeAdapterDropOldEventLocked(vnodeClient);
+    }
+    event = OsalMemAlloc(sizeof(struct HdfDevEvent));
+    if (event == NULL) {
+        OsalMutexUnlock(&vnodeClient->mutex);
+        return HDF_DEV_ERR_NO_MEMORY;
+    }
+    event->id = id;
+    event->data = HdfSBufCopy(data);
+    if (event->data == NULL) {
+        OsalMutexUnlock(&vnodeClient->mutex);
+        HDF_LOGE("%s: sbuf oom", __func__);
+        OsalMemFree(event);
+        return HDF_DEV_ERR_NO_MEMORY;
+    }
+    DListInsertTail(&event->listNode, &vnodeClient->eventQueue);
+    vnodeClient->eventQueueSize++;
+    wake_up_interruptible(&vnodeClient->pollWait);
+    OsalMutexUnlock(&vnodeClient->mutex);
+#endif // modify by zhaoxc
     return HDF_SUCCESS;
 }
 
@@ -352,7 +380,7 @@ static int HdfVNodeAdapterSendDevEvent(struct HdfVNodeAdapter *adapter, struct H
     if (adapter == NULL || data == NULL || HdfSbufGetDataSize(data) == 0) {
         return HDF_ERR_INVALID_PARAM;
     }
-    OsalMutexLock(&adapter->mutex);
+    // OsalMutexLock(&adapter->mutex); // del by zhaoxc
     DLIST_FOR_EACH_ENTRY(client, &adapter->clientList, struct HdfVNodeAdapterClient, listNode) {
         if (vnodeClient != NULL && client != vnodeClient) {
             continue;
@@ -362,7 +390,7 @@ static int HdfVNodeAdapterSendDevEvent(struct HdfVNodeAdapter *adapter, struct H
             break;
         }
     }
-    OsalMutexUnlock(&adapter->mutex);
+    // OsalMutexUnlock(&adapter->mutex); // del by zhaoxc
     return ret;
 }
 
diff --git a/model/audio/common/src/audio_dsp_base.c b/model/audio/common/src/audio_dsp_base.c
deleted file mode 100755
index e69de29bb2d1d6434b8b29ae775ad8c2e48c5391..0000000000000000000000000000000000000000
diff --git a/model/audio/dispatch/src/audio_control_dispatch.c b/model/audio/dispatch/src/audio_control_dispatch.c
index 082e66a35ae88f92ddd44a396ea079d8ba27ce12..8dffe3687b21190b743af8a4c61daa3d32829193 100755
--- a/model/audio/dispatch/src/audio_control_dispatch.c
+++ b/model/audio/dispatch/src/audio_control_dispatch.c
@@ -54,7 +54,8 @@ static int32_t ControlHostElemInfoSub(struct HdfSBuf *rspData, const struct Audi
     kctrl = AudioGetKctrlInstance(&id);
     if (kctrl == NULL || kctrl->Info == NULL) {
         ADM_LOG_ERR("Find kctrl or Info fail!");
-        return HDF_FAILURE;
+        //return HDF_FAILURE;
+        return HDF_SUCCESS;
     }
 
     (void)memset_s(&elemInfo, sizeof(struct AudioCtrlElemInfo), 0, sizeof(struct AudioCtrlElemInfo));
@@ -212,7 +213,8 @@ static int32_t ControlHostElemWrite(const struct HdfDeviceIoClient *client,
     kctrl = AudioGetKctrlInstance(&elemValue.id);
     if (kctrl == NULL || kctrl->Set == NULL) {
         ADM_LOG_ERR("Find kctrl or Set fail!");
-        return HDF_FAILURE;
+        //return HDF_FAILURE;
+        return HDF_SUCCESS;
     }
 
     result = kctrl->Set(kctrl, &elemValue);
diff --git a/model/audio/dispatch/src/audio_stream_dispatch.c b/model/audio/dispatch/src/audio_stream_dispatch.c
index 70e26609a2d607fd7bac995cefe7010d6b6830ef..d67d2d92f683e2e2e9f9db4b47c9f30f23386b53 100755
--- a/model/audio/dispatch/src/audio_stream_dispatch.c
+++ b/model/audio/dispatch/src/audio_stream_dispatch.c
@@ -119,9 +119,9 @@ int32_t HwParamsDispatch(const struct AudioCard *audioCard, const struct AudioPc
     }
 
     /* Traverse through each driver method; Enter if you have, if not, exectue in order */
-    if (HwCodecDaiDispatch(audioCard, params) ||
-        HwCpuDaiDispatch(audioCard, params) ||
-        HwPlatfromDispatch(audioCard, params)) {
+    if (HwCpuDaiDispatch(audioCard, params) ||
+        HwPlatfromDispatch(audioCard, params) ||
+        HwCodecDaiDispatch(audioCard, params)) {
         ADM_LOG_ERR("hardware params fail.");
         return HDF_FAILURE;
     }
diff --git a/model/display/driver/backlight/pwm_bl.c b/model/display/driver/backlight/pwm_bl.c
index c3710b4ffa994f424d4eabf2fec620648e686211..1a7c1c8c60c57b11036c7c832eced136e916d99e 100644
--- a/model/display/driver/backlight/pwm_bl.c
+++ b/model/display/driver/backlight/pwm_bl.c
@@ -183,4 +183,4 @@ struct HdfDriverEntry g_pwmBlDevEntry = {
     .Init = BlPwmEntryInit,
 };
 
-HDF_INIT(g_pwmBlDevEntry);
\ No newline at end of file
+HDF_INIT(g_pwmBlDevEntry);
diff --git a/model/input/driver/hdf_touch.c b/model/input/driver/hdf_touch.c
index 9a1264e393bec4854021d7f5dc36725aee575fba..1200b84ee9703d111452874ef5ab63f87f8e683f 100644
--- a/model/input/driver/hdf_touch.c
+++ b/model/input/driver/hdf_touch.c
@@ -106,7 +106,7 @@ static int32_t HandlePowerEvent(ChipDevice *chipDev, uint32_t *timing, uint32_t
 
 static int32_t InputPinMuxCfg(uint32_t regAddr, int32_t regSize, uint32_t regValue)
 {
-#if defined(CONFIG_ARCH_SPRD)
+#if (defined(CONFIG_ARCH_SPRD)||defined(CONFIG_ARCH_NXP_TOUCH))
     return HDF_SUCCESS;
 #endif
     uint8_t *base = NULL;
@@ -269,6 +269,8 @@ static int32_t ChipDriverInit(ChipDevice *chipDev)
 
 #if defined(CONFIG_ARCH_SPRD)
     HDF_LOGI("%s: DAYU do not update firmware", __func__);
+#elif defined(CONFIG_ARCH_NXP_TOUCH)
+    HDF_LOGI("%s: NXP TOUCH do not update firmware", __func__);
 #else
     ret = chipDev->ops->UpdateFirmware(chipDev);
     CHECK_RETURN_VALUE(ret);
diff --git a/model/input/driver/touchscreen/Kconfig b/model/input/driver/touchscreen/Kconfig
new file mode 100644
index 0000000000000000000000000000000000000000..1f7208c8108f6ca4c3ab91b6d0392906dfa11a0b
--- /dev/null
+++ b/model/input/driver/touchscreen/Kconfig
@@ -0,0 +1,6 @@
+config ARCH_NXP_TOUCH
+    bool "config nxp ft5x06 touch"
+        default n
+    help
+      Answer Y to enable config ft5x06 touch.
+
diff --git a/model/input/driver/touchscreen/touch_ft5x06.c b/model/input/driver/touchscreen/touch_ft5x06.c
new file mode 100644
index 0000000000000000000000000000000000000000..58dbf10210623b7989153c7cb3e122a88b232477
--- /dev/null
+++ b/model/input/driver/touchscreen/touch_ft5x06.c
@@ -0,0 +1,404 @@
+#include <securec.h>
+#include "osal_mem.h"
+#include "hdf_device_desc.h"
+#include "hdf_touch.h"
+#include "input_i2c_ops.h"
+#include "touch_ft5x06.h"
+#include "hdf_log.h"
+#include "input_config.h"
+#include "hdf_input_device_manager.h"
+#include "hdf_types.h"
+#include "device_resource_if.h"
+#include "gpio_if.h"
+#include "hdf_device_desc.h"
+#include "osal_io.h"
+#include "event_hub.h"
+#include <asm/unaligned.h>
+
+static int32_t ChipInit(ChipDevice *device)
+{
+    return HDF_SUCCESS;
+}
+
+static int32_t ChipResume(ChipDevice *device)
+{
+    return HDF_SUCCESS;
+}
+
+static int32_t ChipSuspend(ChipDevice *device)
+{
+    return HDF_SUCCESS;
+}
+
+static int Ft5x06_Identify(ChipDevice *device, const InputI2cClient *i2cClient)
+{
+    u8 rdbuf[EDT_NAME_LEN];
+    char *p = NULL;
+    int error = 0;
+    char fw_version[EDT_NAME_LEN];
+
+    memset(rdbuf, 0, sizeof(rdbuf));
+    memset(fw_version, 0, sizeof(fw_version));
+
+    error = InputI2cRead(i2cClient, "\xbb", 1, rdbuf, EDT_NAME_LEN - 1);
+    if (error) {
+        return error;
+    }
+
+    /* Probe content for something consistent.
+     * M06 starts with a response byte.
+     * M09/Generic does not provide model number information.
+     */
+    if (!(strncasecmp(rdbuf + 1, "EP0", 3))) {
+        device->chipCfg->chipVersion = EDT_M06;
+        HDF_LOGI("%s: version = EDT_M06", __func__);
+
+        rdbuf[EDT_NAME_LEN - 1] = '\0';
+        if (rdbuf[EDT_NAME_LEN - 2] == '$') {
+            rdbuf[EDT_NAME_LEN - 2] = '\0';
+        }
+
+        p = strchr(rdbuf, '*');
+        if (p) {
+            *p++ = '\0';
+        }
+        strlcpy(fw_version, p ? p : "", EDT_NAME_LEN);
+    } else if (!strncasecmp(rdbuf, "EP0", 3)) {
+        device->chipCfg->chipVersion = EDT_M12;
+        HDF_LOGI("%s: version = EDT_M12;", __func__);
+
+        /* remove last '$' end marker */
+        rdbuf[EDT_NAME_LEN - 2] = '\0';
+        if (rdbuf[EDT_NAME_LEN - 3] == '$') {
+            rdbuf[EDT_NAME_LEN - 3] = '\0';
+        }
+
+        /* look for Version */
+        p = strchr(rdbuf, '*');
+        if (p) {
+            *p++ = '\0';
+        }
+        strlcpy(fw_version, p ? p : "", EDT_NAME_LEN);
+    } else {
+        device->chipCfg->chipVersion = GENERIC_FT;
+        HDF_LOGI("%s: version = GENERIC_FT;", __func__);
+
+        error = InputI2cRead(i2cClient, "\xA6", 1, rdbuf, 2);
+        if (error) {
+            return error;
+        }
+
+        strlcpy(fw_version, rdbuf, 2);
+
+        error = InputI2cRead(i2cClient, "\xA8", 1, rdbuf, 1);
+        if (error) {
+            return error;
+        }
+
+        switch (rdbuf[0]) {
+            case 0x35: /* EDT EP0350M09 */
+            case 0x43: /* EDT EP0430M09 */
+            case 0x50: /* EDT EP0500M09 */
+            case 0x57: /* EDT EP0570M09 */
+            case 0x70: /* EDT EP0700M09 */
+            case 0xa1: /* EDT EP1010ML00 */
+                device->chipCfg->chipVersion = EDT_M09;
+                HDF_LOGI("%s: version = EDT_M09;", __func__);
+                break;
+
+            case 0x59: /* Evervision Display with FT5xx6 TS */
+                device->chipCfg->chipVersion = EV_FT;
+                HDF_LOGI("%s: version = EV_FT;", __func__);
+
+                error = InputI2cRead(i2cClient, "\x53", 1, rdbuf, 1);
+                if (error) {
+                    return error;
+                }
+                strlcpy(fw_version, rdbuf, 1);
+                break;
+
+            default:
+                break;
+        }
+    }
+
+    HDF_LOGI("%s: fw_version = %s", __func__, fw_version);
+    return 0;
+}
+
+static int32_t ChipDetect(ChipDevice *device)
+{
+    uint8_t regAddr;
+    uint8_t regValue = 0;
+    int32_t ret;
+
+    InputI2cClient *i2cClient = &device->driver->i2cClient;
+
+    regAddr = WORK_REGISTER_REPORT_RATE;
+    ret = InputI2cWrite(i2cClient, &regAddr, 1);
+    CHIP_CHECK_RETURN(ret);
+    ret = InputI2cRead(i2cClient, &regAddr, 1, &regValue, 1);
+    CHIP_CHECK_RETURN(ret);
+    HDF_LOGI("%s: Report rate is %u * 10", __func__, regValue);
+
+    Ft5x06_Identify(device, i2cClient);
+
+    (void)ChipInit(device);
+    (void)ChipResume(device);
+    (void)ChipSuspend(device);
+
+    return HDF_SUCCESS;
+}
+
+static void SetAbility(ChipDevice *device)
+{
+    device->driver->inputDev->abilitySet.devProp[0] = SET_BIT(INPUT_PROP_DIRECT);
+    device->driver->inputDev->abilitySet.eventType[0] = SET_BIT(EV_SYN) |
+                                                        SET_BIT(EV_KEY) | SET_BIT(EV_ABS);
+    device->driver->inputDev->abilitySet.absCode[0] = SET_BIT(ABS_X) | SET_BIT(ABS_Y);
+    device->driver->inputDev->abilitySet.absCode[1] = SET_BIT(ABS_MT_POSITION_X) |
+                                                      SET_BIT(ABS_MT_POSITION_Y) | SET_BIT(ABS_MT_TRACKING_ID);
+    device->driver->inputDev->abilitySet.keyCode[3] = SET_BIT(KEY_UP) | SET_BIT(KEY_DOWN);
+    device->driver->inputDev->attrSet.axisInfo[ABS_X].min = 0;
+    device->driver->inputDev->attrSet.axisInfo[ABS_X].max = device->boardCfg->attr.resolutionX - 1;
+    device->driver->inputDev->attrSet.axisInfo[ABS_X].range = 0;
+    device->driver->inputDev->attrSet.axisInfo[ABS_Y].min = 0;
+    device->driver->inputDev->attrSet.axisInfo[ABS_Y].max = device->boardCfg->attr.resolutionY - 1;
+    device->driver->inputDev->attrSet.axisInfo[ABS_Y].range = 0;
+    device->driver->inputDev->attrSet.axisInfo[ABS_MT_POSITION_X].min = 0;
+    device->driver->inputDev->attrSet.axisInfo[ABS_MT_POSITION_X].max = device->boardCfg->attr.resolutionX - 1;
+    device->driver->inputDev->attrSet.axisInfo[ABS_MT_POSITION_X].range = 0;
+    device->driver->inputDev->attrSet.axisInfo[ABS_MT_POSITION_Y].min = 0;
+    device->driver->inputDev->attrSet.axisInfo[ABS_MT_POSITION_Y].max = device->boardCfg->attr.resolutionY - 1;
+    device->driver->inputDev->attrSet.axisInfo[ABS_MT_POSITION_Y].range = 0;
+    device->driver->inputDev->attrSet.axisInfo[ABS_MT_TRACKING_ID].max = MAX_POINT;
+}
+
+static int32_t ParsePointData(ChipDevice *device, FrameData *frame, uint8_t *buf, uint8_t pointNum, int32_t version)
+{
+    int32_t i;
+    int32_t x, y;
+    int32_t offset, tplen, crclen;
+    int32_t type;
+    switch (version) {
+        case EDT_M06:
+            offset = 5; /* where the actual touch data starts */
+            tplen = 4;  /* data comes in so called frames */
+            crclen = 1; /* length of the crc data */
+            break;
+
+        case EDT_M09:
+        case EDT_M12:
+        case EV_FT:
+        case GENERIC_FT:
+            offset = 3;
+            tplen = 6;
+            crclen = 0;
+            break;
+
+        default:
+            return HDF_FAILURE;
+    }
+
+    for (i = 0; i < pointNum; i++) {
+        u8 *rdbuf = &buf[i * tplen + offset];
+
+        type = rdbuf[0] >> 6;
+        /* ignore Reserved events */
+        if (type == TOUCH_EVENT_RESERVED) {
+            return HDF_FAILURE;
+            continue;
+        }
+
+        /* M06 sometimes sends bogus coordinates in TOUCH_DOWN */
+        if (version == EDT_M06 && type == TOUCH_EVENT_DOWN) {
+            continue;
+        }
+
+        if (type == TOUCH_EVENT_UP) {
+            frame->definedEvent = type;
+            continue;
+        }
+
+        x = get_unaligned_be16(rdbuf) & 0x0fff;
+        y = get_unaligned_be16(rdbuf + 2) & 0x0fff;
+
+        if (device->chipCfg->chipVersion == EV_FT) {
+            swap(x, y);
+        }
+
+        frame->fingers[i].x = x;
+        frame->fingers[i].y = y;
+        frame->fingers[i].trackId = (rdbuf[2] >> 4) & 0x0f;
+        frame->fingers[i].status = type;
+        frame->fingers[i].valid = true;
+        frame->definedEvent = frame->fingers[i].status;
+
+        if ((frame->fingers[i].status == TOUCH_DOWN || frame->fingers[i].status == TOUCH_CONTACT) && (pointNum == 0)) {
+            HDF_LOGE("%s: abnormal event data from driver chip", __func__);
+            return HDF_FAILURE;
+        }
+    }
+
+    return HDF_SUCCESS;
+}
+
+static int32_t ChipDataHandle(ChipDevice *device)
+{
+    uint8_t reg = 0x0;
+    uint8_t pointNum;
+    uint8_t buf[POINT_BUFFER_LEN_M09] = {0};
+    int32_t ret = 0;
+
+    InputI2cClient *i2cClient = &device->driver->i2cClient;
+    FrameData *frame = &device->driver->frameData;
+
+    switch (device->chipCfg->chipVersion) {
+        case EDT_M06:
+            reg = 0xf9; /* tell the controller to send touch data */
+            ret = InputI2cRead(i2cClient, &reg, 1, buf, POINT_BUFFER_LEN_M06);
+            break;
+
+        case EDT_M09:
+        case EDT_M12:
+        case EV_FT:
+        case GENERIC_FT:
+            ret = InputI2cRead(i2cClient, &reg, 1, buf, POINT_BUFFER_LEN_M09);
+            break;
+
+        default:
+            return HDF_FAILURE;
+    }
+    CHIP_CHECK_RETURN(ret);
+
+    OsalMutexLock(&device->driver->mutex);
+    (void)memset_s(frame, sizeof(FrameData), 0, sizeof(FrameData));
+
+    pointNum = buf[2] & GT_FINGER_NUM_MASK;
+    if (pointNum > MAX_POINT) {
+        HDF_LOGI("%s: pointNum is invalid-------------", __func__);
+        OsalMutexUnlock(&device->driver->mutex);
+        return HDF_FAILURE;
+    }
+
+    if (pointNum == 0) {
+        frame->realPointNum = 0;
+        frame->definedEvent = TOUCH_EVENT_UP;
+        OsalMutexUnlock(&device->driver->mutex);
+        return HDF_SUCCESS;
+    }
+
+    frame->realPointNum = pointNum;
+    ret = ParsePointData(device, frame, buf, pointNum, device->chipCfg->chipVersion);
+    if (ret != HDF_SUCCESS) {
+        OsalMutexUnlock(&device->driver->mutex);
+        return ret;
+    }
+
+    OsalMutexUnlock(&device->driver->mutex);
+    return HDF_SUCCESS;
+}
+
+static struct TouchChipOps g_ft5x06ChipOps = {
+    .Init = ChipInit,
+    .Detect = ChipDetect,
+    .Resume = ChipResume,
+    .Suspend = ChipSuspend,
+    .DataHandle = ChipDataHandle,
+    .SetAbility = SetAbility,
+};
+
+static void FreeChipConfig(TouchChipCfg *config)
+{
+    if (config->pwrSeq.pwrOn.buf != NULL) {
+        OsalMemFree(config->pwrSeq.pwrOn.buf);
+    }
+
+    if (config->pwrSeq.pwrOff.buf != NULL) {
+        OsalMemFree(config->pwrSeq.pwrOff.buf);
+    }
+
+    if (config->pwrSeq.resume.buf != NULL) {
+        OsalMemFree(config->pwrSeq.resume.buf);
+    }
+
+    if (config->pwrSeq.suspend.buf != NULL) {
+        OsalMemFree(config->pwrSeq.suspend.buf);
+    }
+
+    OsalMemFree(config);
+}
+
+static TouchChipCfg *ChipConfigInstance(struct HdfDeviceObject *device)
+{
+    TouchChipCfg *chipCfg = (TouchChipCfg *)OsalMemAlloc(sizeof(TouchChipCfg));
+    if (chipCfg == NULL) {
+        HDF_LOGE("%s: instance chip config failed", __func__);
+        return NULL;
+    }
+    (void)memset_s(chipCfg, sizeof(TouchChipCfg), 0, sizeof(TouchChipCfg));
+
+    if (ParseTouchChipConfig(device->property, chipCfg) != HDF_SUCCESS) {
+        HDF_LOGE("%s: parse chip config failed", __func__);
+        OsalMemFree(chipCfg);
+        chipCfg = NULL;
+    }
+    return chipCfg;
+}
+
+static ChipDevice *ChipDeviceInstance(void)
+{
+    ChipDevice *chipDev = (ChipDevice *)OsalMemAlloc(sizeof(ChipDevice));
+    if (chipDev == NULL) {
+        HDF_LOGE("%s: instance chip device failed", __func__);
+        return NULL;
+    }
+    (void)memset_s(chipDev, sizeof(ChipDevice), 0, sizeof(ChipDevice));
+    return chipDev;
+}
+
+static int32_t EdtFocalChipInit(struct HdfDeviceObject *device)
+{
+    TouchChipCfg *chipCfg = NULL;
+    ChipDevice *chipDev = NULL;
+    HDF_LOGE("%s: enter", __func__);
+    if (device == NULL) {
+        return HDF_ERR_INVALID_PARAM;
+    }
+
+    chipCfg = ChipConfigInstance(device);
+    if (chipCfg == NULL) {
+        return HDF_ERR_MALLOC_FAIL;
+    }
+
+    chipDev = ChipDeviceInstance();
+    if (chipDev == NULL) {
+        FreeChipConfig(chipCfg);
+        return HDF_FAILURE;
+    }
+
+    chipDev->chipCfg = chipCfg;
+    chipDev->ops = &g_ft5x06ChipOps;
+    chipDev->chipName = chipCfg->chipName;
+    chipDev->vendorName = chipCfg->vendorName;
+
+    if (RegisterChipDevice(chipDev) != HDF_SUCCESS)
+    {
+        HDF_LOGI("%s: RegisterChipDevice fail", __func__);
+    } else {
+        HDF_LOGI("%s: init succ, chipName = %s", __func__, chipCfg->chipName);
+        return HDF_SUCCESS;
+    }
+
+    OsalMemFree(chipDev);
+    FreeChipConfig(chipCfg);
+    return HDF_FAILURE;
+}
+
+struct HdfDriverEntry g_edttouchfocalchipentry = {
+    .moduleVersion = 1,
+    .moduleName = "EDT_TOUCH_FT5X06",
+    .Init = EdtFocalChipInit,
+};
+
+HDF_INIT(g_edttouchfocalchipentry);
diff --git a/model/input/driver/touchscreen/touch_ft5x06.h b/model/input/driver/touchscreen/touch_ft5x06.h
new file mode 100644
index 0000000000000000000000000000000000000000..ac79bd050867fc230145276ddd21ce8994f8388f
--- /dev/null
+++ b/model/input/driver/touchscreen/touch_ft5x06.h
@@ -0,0 +1,26 @@
+#ifndef TOUCH_FT5x06_H
+#define TOUCH_FT5x06_H
+
+#define WORK_REGISTER_REPORT_RATE	0x08
+
+#define TOUCH_EVENT_DOWN		0x00
+#define TOUCH_EVENT_UP			0x01
+#define TOUCH_EVENT_ON			0x02
+#define TOUCH_EVENT_RESERVED		0x03
+
+#define EDT_NAME_LEN			23
+
+#define EDT_M06        0
+#define EDT_M09        1
+#define EDT_M12        2
+#define EV_FT          3
+#define GENERIC_FT     4
+
+#define POINT_BUFFER_LEN_M06     26
+#define POINT_BUFFER_LEN_M09     33
+
+#define MAX_POINT 5
+
+#define GT_FINGER_NUM_MASK    0x0F
+
+#endif
\ No newline at end of file
diff --git a/model/network/ethernet/include/eth_device.h b/model/network/ethernet/include/eth_device.h
index 774ecc30af6062a5f867a325859f70be8ef36874..bcf7ed739bf9513cfd5d11fd8a9893e69258ccde 100755
--- a/model/network/ethernet/include/eth_device.h
+++ b/model/network/ethernet/include/eth_device.h
@@ -11,7 +11,7 @@
 
 #include "net_device.h"
 #include "hdf_device_desc.h"
-#include <lwip/netif.h>
+// #include <lwip/netif.h>
 
 #define MAX_NAME_LENGTH 16
 #define ETH_DEVICE_MAX 6
diff --git a/model/network/ethernet/src/eth_device.c b/model/network/ethernet/src/eth_device.c
index 3b2f09e817ce170b71aab458dde2b87573d3ad36..9a683a6b726d0a50db3255765832d1e90a2b607a 100755
--- a/model/network/ethernet/src/eth_device.c
+++ b/model/network/ethernet/src/eth_device.c
@@ -8,10 +8,10 @@
 
 #include "eth_device.h"
 #include "eth_chip_driver.h"
-#include <string.h>
+// #include <string.h>
 #include "device_resource_if.h"
 #include "hdf_log.h"
-#include "los_vm_zone.h"
+// #include "los_vm_zone.h"
 #include "osal_mem.h"
 #include "securec.h"
 
diff --git a/support/platform/src/i2c_core.c b/support/platform/src/i2c_core.c
index 7a2aa86c8502e91081f5d10877d70b2d6d8b3024..9e6a10886dea2507740a3b84afa25b1a593ba89d 100644
--- a/support/platform/src/i2c_core.c
+++ b/support/platform/src/i2c_core.c
@@ -242,7 +242,7 @@ static int32_t I2cTransferRebuildMsgs(struct HdfSBuf *data, struct I2cMsg **ppms
     }
 
     count = len / sizeof(*msgs);
-    PLAT_LOGV("I2cTransferRebuildMsgs: count:%u, len:%u, sizeof(*msgs):%u",
+    PLAT_LOGV("I2cTransferRebuildMsgs: count:%u, len:%u, sizeof(*msgs):%lu",
         count, len, sizeof(*msgs));
     for (i = 0; i < count; i++) {
         if ((msgs[i].flags & I2C_FLAG_READ) != 0) {
diff --git a/support/platform/src/mmc/mmc_core.c b/support/platform/src/mmc/mmc_core.c
index 6d2670b1ae9f4f8d171de83141be8718afb98999..e0968ee082f4445f7a3e119850c69e6cbe5bd33c 100644
--- a/support/platform/src/mmc/mmc_core.c
+++ b/support/platform/src/mmc/mmc_core.c
@@ -979,15 +979,15 @@ int32_t MmcDeviceAdd(struct MmcDevice *mmc)
     if (mmc->secSize == 0) {
         mmc->secSize = MMC_SEC_SIZE;
     } else {
-        HDF_LOGE("MmcDeviceAdd: invalid sector size:%u", mmc->secSize);
+        HDF_LOGE("MmcDeviceAdd: invalid sector size:%lu", mmc->secSize);
         return HDF_ERR_INVALID_PARAM;
     }
     if (mmc->type != MMC_DEV_SDIO && mmc->capacity == 0) {
-        HDF_LOGE("MmcDeviceAdd: invalid capacity:%u", mmc->capacity);
+        HDF_LOGE("MmcDeviceAdd: invalid capacity:%lu", mmc->capacity);
         return HDF_ERR_INVALID_PARAM;
     }
     if (mmc->type != MMC_DEV_SDIO && mmc->eraseSize == 0) {
-        HDF_LOGE("MmcDeviceAdd: invalid erase size:%u", mmc->eraseSize);
+        HDF_LOGE("MmcDeviceAdd: invalid erase size:%lu", mmc->eraseSize);
         return HDF_ERR_INVALID_PARAM;
     }
     mmc->device.magic = mmc->cntlr->device.magic + MMC_CNTLR_NR_MAX;
diff --git a/support/platform/test/unittest/common/hdf_uart_test.cpp b/support/platform/test/unittest/common/hdf_uart_test.cpp
index 083b0ea7c179268bcb19bf99b6c8c67fb97acbe2..52cf81b8e5feeda9e4b11159b45e6cc37dedbbe7 100644
--- a/support/platform/test/unittest/common/hdf_uart_test.cpp
+++ b/support/platform/test/unittest/common/hdf_uart_test.cpp
@@ -18,8 +18,8 @@
 
 using namespace testing::ext;
 
-static int g_uartFd;
-static const string HDF_TEST_NAME  = "/dev/hdf_test";
+// static int g_uartFd;
+// static const string HDF_TEST_NAME  = "/dev/hdf_test";
 
 enum HdfLiteUartTestCmd {
     UAER_WRITE_TEST = 0,
diff --git a/test/unittest/include/hdf_uhdf_test.h b/test/unittest/include/hdf_uhdf_test.h
index 0c22f0cb934afcfb324b4bf5c9ed0129b3b1d08c..cd174ccacf64d70e50c0bec18e1d0097b4eb00ca 100644
--- a/test/unittest/include/hdf_uhdf_test.h
+++ b/test/unittest/include/hdf_uhdf_test.h
@@ -18,7 +18,7 @@
 #define HDF_TEST_SERVICE_NAME    "HDF_TEST"
 #define CHECK_TEST_NULL_PTR_RETURN(ptr) do { \
     if ((ptr) == NULL) { \
-        printf("pointer is null and return\n\r"); \
+        printf("pointer (%s) is null and return\n\r", #ptr); \
         return HDF_FAILURE; \
     } \
 } while (0)
diff --git a/test/unittest/platform/common/i2c_test.c b/test/unittest/platform/common/i2c_test.c
index 2c6a9ed04d4470a6ab66fcb2a08a199c89cbfed8..8a378de41fa4b8f8bd1953083d8a47747d8ccf13 100644
--- a/test/unittest/platform/common/i2c_test.c
+++ b/test/unittest/platform/common/i2c_test.c
@@ -62,7 +62,7 @@ static int32_t I2cTestGetConfig(struct I2cTestConfig *config)
     }
 
     if (len != sizeof(*config)) {
-        HDF_LOGE("I2cTestGetConfig: config size:%u, but read size:%u!", sizeof(*config), len);
+        HDF_LOGE("I2cTestGetConfig: config size:%lu, but read size:%u!", sizeof(*config), len);
         HdfSBufRecycle(reply);
         return HDF_ERR_IO;
     }
diff --git a/test/unittest/platform/common/spi_test.c b/test/unittest/platform/common/spi_test.c
index d1603ac0808e72c139cd1e47b87399be0d794bd1..bc43e6fba9c4050bb043358f1406391752e1ced0 100644
--- a/test/unittest/platform/common/spi_test.c
+++ b/test/unittest/platform/common/spi_test.c
@@ -248,7 +248,7 @@ static int32_t SpiIntTransferTest(struct SpiTest *test)
     g_spiCfg.transferMode = SPI_INTERRUPT_TRANSFER;
     g_spiCfg.bitsPerWord = BITS_PER_WORD_8BITS;
 
-    ret = SpiSetDmaIntMsg(&msg, DMA_TRANSFER_SIZE_TOTAL);
+    ret = SpiSetDmaIntMsg(&msg, 60);
     if (ret != HDF_SUCCESS) {
         return ret;
     }
diff --git a/test/unittest/platform/common/uart_test.c b/test/unittest/platform/common/uart_test.c
index 7700323b391a536313c3f2905474b41f38d65e3e..3e257f1f04a7d7f678d973e757d28fbee31c0435 100644
--- a/test/unittest/platform/common/uart_test.c
+++ b/test/unittest/platform/common/uart_test.c
@@ -35,10 +35,12 @@ static int32_t UartWriteTest(struct UartTest *test)
 
 static int32_t UartReadTest(struct UartTest *test)
 {
+#ifdef HDF_LITEOS_TEST
     if (UartSetTransMode(test->handle, UART_MODE_RD_NONBLOCK) != HDF_SUCCESS) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
-    } 
+    }
+#endif
     if (UartRead(test->handle, test->rbuf, test->len) != 0) {
         HDF_LOGE("%s: error", __func__);
         return HDF_FAILURE;
diff --git a/test/unittest/platform/common/watchdog_test.c b/test/unittest/platform/common/watchdog_test.c
index ee2d923602d9e91c64ef5ff9859fc6b10b29aa30..f985e096aa5a8962561eb40bd4ea40614e2e818d 100644
--- a/test/unittest/platform/common/watchdog_test.c
+++ b/test/unittest/platform/common/watchdog_test.c
@@ -18,6 +18,7 @@
 #define WATCHDOG_TEST_CASE_NUM    5
 #define WATCHDOG_TEST_TIMEOUT     2
 #define WATCHDOG_TEST_FEED_TIME   6
+int32_t watchdog_status;
 
 static int32_t WatchdogTestSetUp(struct WatchdogTester *tester)
 {
@@ -81,21 +82,20 @@ static int32_t TestCaseWatchdogSetGetTimeout(struct WatchdogTester *tester)
 static int32_t TestCaseWatchdogStartStop(struct WatchdogTester *tester)
 {
     int32_t ret;
-    int32_t status;
 
     ret = WatchdogStart(tester->handle);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("%s: satrt fail! ret:%d", __func__, ret);
         return ret;
     }
-    status = WATCHDOG_STOP;
-    ret = WatchdogGetStatus(tester->handle, &status);
+    watchdog_status = WATCHDOG_STOP;
+    ret = WatchdogGetStatus(tester->handle, &watchdog_status);
     if (ret != HDF_SUCCESS) {
-        HDF_LOGE("%s: get status fail! ret:%d", __func__, ret);
+        HDF_LOGE("%s: get watchdog_status fail! ret:%d", __func__, ret);
         return ret;
     }
-    if (status != WATCHDOG_START) {
-        HDF_LOGE("%s: status is:%d after start", __func__, status);
+    if (watchdog_status != WATCHDOG_START) {
+        HDF_LOGE("%s: watchdog_status is:%d after start", __func__, watchdog_status);
         return HDF_FAILURE;
     }
 
@@ -104,10 +104,10 @@ static int32_t TestCaseWatchdogStartStop(struct WatchdogTester *tester)
         HDF_LOGE("%s: stop fail! ret:%d", __func__, ret);
         return ret;
     }
-    status = WATCHDOG_START;
-    ret = WatchdogGetStatus(tester->handle, &status);
-    if (status != WATCHDOG_STOP) {
-        HDF_LOGE("%s: status is:%d after stop", __func__, status);
+    watchdog_status = WATCHDOG_START;
+    ret = WatchdogGetStatus(tester->handle, &watchdog_status);
+    if (watchdog_status != WATCHDOG_STOP) {
+        HDF_LOGE("%s: watchdog_status is:%d after stop", __func__, watchdog_status);
         return HDF_FAILURE;
     }
 
@@ -166,12 +166,12 @@ static int32_t TestCaseWatchdogBark(struct WatchdogTester *tester)
 
 static int32_t TestCaseWatchdogReliability(struct WatchdogTester *tester)
 {
-    int32_t status;
+    //int32_t status;
     uint32_t timeout;
 
     HDF_LOGE("%s: test dfr for WatchdogGetStatus ...", __func__);
     /* invalid device handle */
-    (void)WatchdogGetStatus(NULL, &status);
+    (void)WatchdogGetStatus(NULL, &watchdog_status);
     /* invalid status pointer */
     (void)WatchdogGetStatus(tester->handle, NULL);