From 8445ac455ec3cfab0a733a7824833f89c31bb9bf Mon Sep 17 00:00:00 2001
From: YOUR_NAME <huangkai71@huawei.com>
Date: Tue, 7 Sep 2021 12:54:10 +0000
Subject: [PATCH 01/11] add ec11

Signed-off-by: YOUR_NAME <huangkai71@huawei.com>
---
 model/input/driver/hdf_encoder.c         | 248 +++++++++++++++++++++++
 model/input/driver/hdf_encoder.h         |  30 +++
 model/input/driver/input_config.h        |   9 +
 model/input/driver/input_config_parser.c |  29 ++-
 4 files changed, 315 insertions(+), 1 deletion(-)
 create mode 100644 model/input/driver/hdf_encoder.c
 create mode 100644 model/input/driver/hdf_encoder.h

diff --git a/model/input/driver/hdf_encoder.c b/model/input/driver/hdf_encoder.c
new file mode 100644
index 000000000..180c7d749
--- /dev/null
+++ b/model/input/driver/hdf_encoder.c
@@ -0,0 +1,248 @@
+/*
+ * 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_encoder.h"
+#include "hdf_device_desc.h"
+#include "osal_mem.h"
+#include "osal_timer.h"
+#include "gpio_if.h"
+#include "hdf_log.h"
+#include "event_hub.h"
+
+
+static void EncoderTimerFunc(uintptr_t arg)
+{
+    EncoderDriver *encoderDrv = (EncoderDriver *)arg;
+    uint16_t gpioClk = encoderDrv->encoderCfg->gpioClk;
+    uint16_t gpioData = encoderDrv->encoderCfg->gpioData;
+    uint16_t gpioSW = encoderDrv->encoderCfg->gpioSW;
+
+    int32_t ret = GpioRead(gpioClk, &encoderDrv->encoderClkNowSta);
+    if (ret != HDF_SUCCESS) {
+         HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
+         return;
+    }
+    ret = GpioRead(gpioData, &encoderDrv->encoderDataNowSta);
+    if (ret != HDF_SUCCESS) {
+         HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
+         return;
+    }
+
+    if (encoderDrv->encoderClkNowSta != encoderDrv->encoderClkPreSta) {
+        if (encoderDrv->encoderClkNowSta == 0) {
+            if (encoderDrv->encoderDataNowSta == 1) {
+                input_report_rel(encoderDrv->inputDev,REL_WHEEL, 1);
+            } else {
+                input_report_rel(encoderDrv->inputDev,REL_WHEEL, -1);
+            }
+            input_sync(encoderDrv->inputDev);
+        }
+        encoderDrv->encoderClkPreSta = encoderDrv->encoderClkNowSta;
+        encoderDrv->encoderDataPreSta  = encoderDrv->encoderDataNowSta;
+    }
+}
+
+static EncoderCfg *EncoderConfigInstance(struct HdfDeviceObject *device)
+{
+    EncoderCfg *encoderCfg = (EncoderCfg *)OsalMemAlloc(sizeof(EncoderCfg));
+    if (encoderCfg == NULL) {
+        HDF_LOGE("%s: malloc encoder config failed", __func__);
+        return NULL;
+    }
+    int32_t ret = memset_s(encoderCfg, sizeof(EncoderCfg), 0, sizeof(EncoderCfg));
+    if (ret != 0) {
+        HDF_LOGE("%s: memset_s encoder config failed", __func__);
+        OsalMemFree(encoderCfg);
+        return NULL;
+    }
+    encoderCfg->hdfEncoderDev = device;
+
+    if (ParseEncoderConfig(device->property, encoderCfg) != HDF_SUCCESS) {
+        HDF_LOGE("%s: parse encoder config failed", __func__);
+        OsalMemFree(encoderCfg);
+        return NULL;
+    }
+    return encoderCfg;
+}
+
+static EncoderDriver *EncoderDriverInstance(EncoderCfg *encoderCfg)
+{
+    EncoderDriver *encoderDrv = (EncoderDriver *)OsalMemAlloc(sizeof(EncoderDriver));
+    if (encoderDrv == NULL) {
+        HDF_LOGE("%s: malloc key driver failed", __func__);
+        return NULL;
+    }
+    int32_t ret = memset_s(encoderDrv, sizeof(EncoderDriver), 0, sizeof(EncoderDriver));
+    if (ret != 0) {
+        HDF_LOGE("%s: memset encoder driver failed", __func__);
+        OsalMemFree(encoderDrv);
+        return NULL;
+    }
+
+    encoderDrv->devType = encoderCfg->devType;
+    encoderDrv->encoderCfg = encoderCfg;
+
+    return encoderDrv;
+}
+
+static int32_t EncoderInit(EncoderDriver *EncoderDrv)
+{
+    uint16_t gpioClk = EncoderDrv->encoderCfg->gpioClk;
+    uint16_t gpioData = EncoderDrv->encoderCfg->gpioData;
+    uint16_t gpioSW = EncoderDrv->encoderCfg->gpioSW;
+    GpioSetDir(gpioClk, GPIO_DIR_IN);
+    GpioSetDir(gpioData, GPIO_DIR_IN);
+    GpioSetDir(gpioSW, GPIO_DIR_IN);
+
+    int32_t ret = OsalTimerCreate(&EncoderDrv->timer, 10, EncoderTimerFunc, EncoderDrv);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: create timer failed, ret = %d\n", __func__, ret);
+        return HDF_FAILURE;
+    }
+    ret = OsalTimerStartLoop(&EncoderDrv->timer);
+    if (ret != HDF_SUCCESS) {
+         HDF_LOGE("%s: start timer failed, ret = %d\n", __func__, ret);
+         return HDF_FAILURE;
+    }
+
+    ret = GpioRead(gpioClk, &EncoderDrv->encoderClkNowSta);
+    if (ret != HDF_SUCCESS) {
+         HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
+         return HDF_FAILURE;
+    }
+    ret = GpioRead(gpioData, &EncoderDrv->encoderDataNowSta);
+    if (ret != HDF_SUCCESS) {
+         HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
+         return HDF_FAILURE;
+    }
+
+    EncoderDrv->encoderClkPreSta = EncoderDrv->encoderClkNowSta;
+    EncoderDrv->encoderDataPreSta = EncoderDrv->encoderDataNowSta;
+
+    return HDF_SUCCESS;
+}
+
+static InputDevice *InputDeviceInstance(EncoderDriver *encoderDrv)
+{
+    InputDevice *inputDev = (InputDevice *)OsalMemAlloc(sizeof(InputDevice));
+    if (inputDev == NULL) {
+        HDF_LOGE("%s: malloc input device failed", __func__);
+        return NULL;
+    }
+    int32_t ret = memset_s(inputDev, sizeof(InputDevice), 0, sizeof(InputDevice));
+    if (ret != 0) {
+        HDF_LOGE("%s: memset encoder driver failed", __func__);
+        OsalMemFree(inputDev);
+        return NULL;
+    }
+
+    inputDev->pvtData = (void *)encoderDrv;
+    inputDev->devType = encoderDrv->devType;
+    inputDev->hdfDevObj = encoderDrv->encoderCfg->hdfEncoderDev;
+    encoderDrv->inputdev = inputDev;
+
+    return inputDev;
+}
+
+static int32_t RegisterEncoderDevice(EncoderCfg *encoderCfg)
+{
+    EncoderDriver *EncoderDrv = EncoderDriverInstance(encoderCfg);
+    if (EncoderDrv == NULL) {
+        HDF_LOGE("%s: instance encoder driver failed", __func__);
+        return HDF_ERR_MALLOC_FAIL;
+    }
+
+    int32_t ret = EncoderInit(EncoderDrv);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: key driver init failed, ret %d", __func__, ret);
+        goto EXIT;
+    }
+
+    InputDevice *inputDev = InputDeviceInstance(EncoderDrv);
+    if (inputDev == NULL) {
+        HDF_LOGE("%s: instance input device failed", __func__);
+        goto EXIT;
+    }
+
+    ret = RegisterInputDevice(inputDev);
+    if (ret != HDF_SUCCESS) {
+        goto EXIT1;
+    }
+    return HDF_SUCCESS;
+
+EXIT1:
+    OsalMemFree(inputDev->pkgBuf);
+    OsalMemFree(inputDev);
+EXIT:
+    OsalMemFree(EncoderDrv);
+    return HDF_FAILURE;
+}
+
+static int32_t HdfEnCoderDriverInit(struct HdfDeviceObject *device)
+{
+    if (device == NULL) {
+        HDF_LOGE("%s: param is null", __func__);
+        return HDF_ERR_INVALID_PARAM;
+    }
+
+    EncoderCfg *encoderCfg = EncoderConfigInstance(device);
+    if (encoderCfg == NULL) {
+        HDF_LOGE("%s: instance encoder config failed", __func__);
+        return HDF_ERR_MALLOC_FAIL;
+    }
+
+    int32_t ret = RegisterEncoderDevice(encoderCfg);
+    if (ret != HDF_SUCCESS) {
+        goto EXIT;
+    }
+
+    HDF_LOGI("%s: exit succ!", __func__);
+    return HDF_SUCCESS;
+
+EXIT:
+    OsalMemFree(encoderCfg);
+    return HDF_FAILURE;
+}
+
+static int32_t HdfEnCoderDispatch(struct HdfDeviceIoClient *client, int cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
+{
+    (void)cmd;
+    if (client == NULL || data == NULL || reply == NULL) {
+        HDF_LOGE("%s: param is null", __func__);
+        return HDF_FAILURE;
+    }
+    return HDF_SUCCESS;
+}
+
+static void HdfEncoderDriverRelease(struct HdfDeviceObject *device)
+{
+    (void)device;
+}
+
+static int32_t HdfEnCoderDriverBind(struct HdfDeviceObject *device)
+{
+    if (device == NULL) {
+        return HDF_ERR_INVALID_PARAM;
+    }
+    static struct IDeviceIoService enCoderService = {
+        .object.objectId = 1,
+        .Dispatch = HdfEnCoderDispatch,
+    };
+    device->service = &enCoderService;
+    return HDF_SUCCESS;
+}
+
+struct HdfDriverEntry g_hdfEnCoderEntry = {
+    .moduleVersion = 1,
+    .moduleName = "HDF_ENCODER",
+    .Bind = HdfEnCoderDriverBind,
+    .Init = HdfEnCoderDriverInit,
+    .Release = HdfEncoderDriverRelease,
+};
+
+HDF_INIT(g_hdfEnCoderEntry);
diff --git a/model/input/driver/hdf_encoder.h b/model/input/driver/hdf_encoder.h
new file mode 100644
index 000000000..3233f8dea
--- /dev/null
+++ b/model/input/driver/hdf_encoder.h
@@ -0,0 +1,30 @@
+/*
+ * 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_ENCODER_H
+#define HDF_ENCODER_H
+
+#include <securec.h>
+#include "osal_time.h"
+#include "osal_timer.h"
+#include "input_config.h"
+#include "hdf_input_device_manager.h"
+
+
+typedef struct EncoderDriverInfo {
+    struct HdfDeviceObject *hdfEncoderDev;
+    uint8_t devType;
+    EncoderCfg *encoderCfg;
+    InputDevice *inputdev;
+    OsalTimer timer;
+    uint16_t encoderClkPreSta;
+    uint16_t encoderClkNowSta;
+    uint16_t encoderDataPreSta;
+    uint16_t encoderDataNowSta;
+} EncoderDriver;
+
+#endif
\ No newline at end of file
diff --git a/model/input/driver/input_config.h b/model/input/driver/input_config.h
index e44d400cc..ee25b9f2c 100644
--- a/model/input/driver/input_config.h
+++ b/model/input/driver/input_config.h
@@ -140,8 +140,17 @@ typedef struct {
     uint32_t debounceTime;
 } KeyChipCfg;
 
+typedef struct {
+    struct HdfDeviceObject *hdfEncoderDev;
+    uint8_t devType;
+    uint16_t gpioClk;
+    uint16_t gpioData;
+    uint16_t gpioSW;
+} EncoderCfg;
+
 int32_t ParseTouchBoardConfig(const struct DeviceResourceNode *node, TouchBoardCfg *config);
 int32_t ParseTouchChipConfig(const struct DeviceResourceNode *node, TouchChipCfg *config);
 int32_t ParseKeyConfig(const struct DeviceResourceNode *node, KeyChipCfg *config);
+int32_t ParseEncoderConfig(const struct DeviceResourceNode *node, EncoderCfg *config);
 
 #endif
\ No newline at end of file
diff --git a/model/input/driver/input_config_parser.c b/model/input/driver/input_config_parser.c
index f6c49ebab..01bc6524e 100644
--- a/model/input/driver/input_config_parser.c
+++ b/model/input/driver/input_config_parser.c
@@ -43,7 +43,7 @@ int32_t ParseKeyConfig(const struct DeviceResourceNode *node, KeyChipCfg *config
     ret = parser->GetUint8(keyNode, "inputType", &config->devType, 0);
     CHECK_PARSER_RET(ret, "GetUint8");
     ret = parser->GetUint16(keyNode, "gpioNum", &config->gpioNum, 0);
-    CHECK_PARSER_RET(ret, "GetUint32");
+    CHECK_PARSER_RET(ret, "GetUint16");
     ret = parser->GetUint16(keyNode, "irqFlag", &config->irqFlag, 0);
     CHECK_PARSER_RET(ret, "GetUint8");
     ret = parser->GetUint32(keyNode, "debounceTime", &config->debounceTime, 0);
@@ -52,6 +52,33 @@ int32_t ParseKeyConfig(const struct DeviceResourceNode *node, KeyChipCfg *config
     return HDF_SUCCESS;
 }
 
+int32_t ParseEncoderConfig(const struct DeviceResourceNode *node, EncoderCfg *config)
+{
+    if (node == NULL || config == NULL) {
+        HDF_LOGE("%s: param is null", __func__);
+        return HDF_FAILURE;
+    }
+
+    struct DeviceResourceIface *parser = NULL;
+    parser = DeviceResourceGetIfaceInstance(HDF_CONFIG_SOURCE);
+    if (parser == NULL) {
+        HDF_LOGE("%s: instance parser failed", __func__);
+        return HDF_FAILURE;
+    }
+
+    const struct DeviceResourceNode *encoderNode = node;
+    int32_t ret = parser->GetUint8(encoderNode, "inputType", &config->devType, 0);
+    CHECK_PARSER_RET(ret, "GetUint8");
+    ret = parser->GetUint16(encoderNode, "gpioClk", &config->gpioClk, 0);
+    CHECK_PARSER_RET(ret, "GetUint16");
+    ret = parser->GetUint16(encoderNode, "gpioDT", &config->gpioData, 0);
+    CHECK_PARSER_RET(ret, "GetUint16");
+    ret = parser->GetUint16(encoderNode, "gpioSW", &config->gpioSW, 0);
+    CHECK_PARSER_RET(ret, "GetUint16");
+
+    return HDF_SUCCESS;
+}
+
 static int32_t ParseAttr(struct DeviceResourceIface *parser, const struct DeviceResourceNode *attrNode,
     BoardAttrCfg *attr)
 {
-- 
Gitee


From e4e005aa12999037ef903a1b486cea3f25a56bfc Mon Sep 17 00:00:00 2001
From: YOUR_NAME <huangkai71@huawei.com>
Date: Tue, 7 Sep 2021 13:02:52 +0000
Subject: [PATCH 02/11] add ec11

Signed-off-by: YOUR_NAME <huangkai71@huawei.com>
---
 model/input/driver/hdf_encoder.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/model/input/driver/hdf_encoder.c b/model/input/driver/hdf_encoder.c
index 180c7d749..e2e8cc8e9 100644
--- a/model/input/driver/hdf_encoder.c
+++ b/model/input/driver/hdf_encoder.c
@@ -14,6 +14,8 @@
 #include "hdf_log.h"
 #include "event_hub.h"
 
+#define TIMER_INTERVAL_ENCODER  10
+
 
 static void EncoderTimerFunc(uintptr_t arg)
 {
@@ -99,7 +101,7 @@ static int32_t EncoderInit(EncoderDriver *EncoderDrv)
     GpioSetDir(gpioData, GPIO_DIR_IN);
     GpioSetDir(gpioSW, GPIO_DIR_IN);
 
-    int32_t ret = OsalTimerCreate(&EncoderDrv->timer, 10, EncoderTimerFunc, EncoderDrv);
+    int32_t ret = OsalTimerCreate(&EncoderDrv->timer, TIMER_INTERVAL_ENCODER, EncoderTimerFunc, EncoderDrv);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("%s: create timer failed, ret = %d\n", __func__, ret);
         return HDF_FAILURE;
-- 
Gitee


From 5ce5568ebcdcf1a50fd3b653be3b3b7e5b8771ac Mon Sep 17 00:00:00 2001
From: YOUR_NAME <huangkai71@huawei.com>
Date: Tue, 7 Sep 2021 13:13:50 +0000
Subject: [PATCH 03/11] add ec11

Signed-off-by: YOUR_NAME <huangkai71@huawei.com>
---
 model/input/driver/hdf_encoder.c | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/model/input/driver/hdf_encoder.c b/model/input/driver/hdf_encoder.c
index e2e8cc8e9..df6c8cb9d 100644
--- a/model/input/driver/hdf_encoder.c
+++ b/model/input/driver/hdf_encoder.c
@@ -16,7 +16,6 @@
 
 #define TIMER_INTERVAL_ENCODER  10
 
-
 static void EncoderTimerFunc(uintptr_t arg)
 {
     EncoderDriver *encoderDrv = (EncoderDriver *)arg;
@@ -26,21 +25,21 @@ static void EncoderTimerFunc(uintptr_t arg)
 
     int32_t ret = GpioRead(gpioClk, &encoderDrv->encoderClkNowSta);
     if (ret != HDF_SUCCESS) {
-         HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
-         return;
+        HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
+        return;
     }
     ret = GpioRead(gpioData, &encoderDrv->encoderDataNowSta);
     if (ret != HDF_SUCCESS) {
-         HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
-         return;
+        HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
+        return;
     }
 
     if (encoderDrv->encoderClkNowSta != encoderDrv->encoderClkPreSta) {
         if (encoderDrv->encoderClkNowSta == 0) {
             if (encoderDrv->encoderDataNowSta == 1) {
-                input_report_rel(encoderDrv->inputDev,REL_WHEEL, 1);
+                input_report_rel(encoderDrv->inputDev, REL_WHEEL, 1);
             } else {
-                input_report_rel(encoderDrv->inputDev,REL_WHEEL, -1);
+                input_report_rel(encoderDrv->inputDev, REL_WHEEL, -1);
             }
             input_sync(encoderDrv->inputDev);
         }
@@ -108,19 +107,19 @@ static int32_t EncoderInit(EncoderDriver *EncoderDrv)
     }
     ret = OsalTimerStartLoop(&EncoderDrv->timer);
     if (ret != HDF_SUCCESS) {
-         HDF_LOGE("%s: start timer failed, ret = %d\n", __func__, ret);
-         return HDF_FAILURE;
+        HDF_LOGE("%s: start timer failed, ret = %d\n", __func__, ret);
+        return HDF_FAILURE;
     }
 
     ret = GpioRead(gpioClk, &EncoderDrv->encoderClkNowSta);
     if (ret != HDF_SUCCESS) {
-         HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
-         return HDF_FAILURE;
+        HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
+        return HDF_FAILURE;
     }
     ret = GpioRead(gpioData, &EncoderDrv->encoderDataNowSta);
     if (ret != HDF_SUCCESS) {
-         HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
-         return HDF_FAILURE;
+        HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
+        return HDF_FAILURE;
     }
 
     EncoderDrv->encoderClkPreSta = EncoderDrv->encoderClkNowSta;
@@ -211,7 +210,8 @@ EXIT:
     return HDF_FAILURE;
 }
 
-static int32_t HdfEnCoderDispatch(struct HdfDeviceIoClient *client, int cmd, struct HdfSBuf *data, struct HdfSBuf *reply)
+static int32_t HdfEnCoderDispatch(struct HdfDeviceIoClient *client, int cmd,
+                                  struct HdfSBuf *data, struct HdfSBuf *reply)
 {
     (void)cmd;
     if (client == NULL || data == NULL || reply == NULL) {
-- 
Gitee


From f9d167e55156ff357a486b1fe0d511496d83e84d Mon Sep 17 00:00:00 2001
From: YOUR_NAME <huangkai71@huawei.com>
Date: Tue, 7 Sep 2021 13:16:16 +0000
Subject: [PATCH 04/11] add ec11

Signed-off-by: YOUR_NAME <huangkai71@huawei.com>
---
 model/input/driver/hdf_encoder.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/model/input/driver/hdf_encoder.h b/model/input/driver/hdf_encoder.h
index 3233f8dea..b7ce9272a 100644
--- a/model/input/driver/hdf_encoder.h
+++ b/model/input/driver/hdf_encoder.h
@@ -19,7 +19,7 @@ typedef struct EncoderDriverInfo {
     struct HdfDeviceObject *hdfEncoderDev;
     uint8_t devType;
     EncoderCfg *encoderCfg;
-    InputDevice *inputdev;
+    InputDevice *inputDev;
     OsalTimer timer;
     uint16_t encoderClkPreSta;
     uint16_t encoderClkNowSta;
-- 
Gitee


From caec0358858be96f452662bfc1459fb5aad4baef Mon Sep 17 00:00:00 2001
From: YOUR_NAME <huangkai71@huawei.com>
Date: Tue, 7 Sep 2021 13:18:54 +0000
Subject: [PATCH 05/11] add ec11

Signed-off-by: YOUR_NAME <huangkai71@huawei.com>
---
 model/input/driver/hdf_encoder.c | 7 ++++---
 model/input/driver/hdf_encoder.h | 6 +++---
 2 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/model/input/driver/hdf_encoder.c b/model/input/driver/hdf_encoder.c
index df6c8cb9d..5c09d646b 100644
--- a/model/input/driver/hdf_encoder.c
+++ b/model/input/driver/hdf_encoder.c
@@ -7,12 +7,13 @@
  */
 
 #include "hdf_encoder.h"
-#include "hdf_device_desc.h"
+#include "event_hub.h"
+#include "gpio_if.h"
 #include "osal_mem.h"
 #include "osal_timer.h"
-#include "gpio_if.h"
 #include "hdf_log.h"
-#include "event_hub.h"
+#include "hdf_device_desc.h"
+
 
 #define TIMER_INTERVAL_ENCODER  10
 
diff --git a/model/input/driver/hdf_encoder.h b/model/input/driver/hdf_encoder.h
index b7ce9272a..158cc73c6 100644
--- a/model/input/driver/hdf_encoder.h
+++ b/model/input/driver/hdf_encoder.h
@@ -8,11 +8,11 @@
 #ifndef HDF_ENCODER_H
 #define HDF_ENCODER_H
 
-#include <securec.h>
-#include "osal_time.h"
-#include "osal_timer.h"
 #include "input_config.h"
 #include "hdf_input_device_manager.h"
+#include "osal_time.h"
+#include "osal_timer.h"
+#include <securec.h>
 
 
 typedef struct EncoderDriverInfo {
-- 
Gitee


From 651e9956c802b7a6f3aa4b16f60916edc5f8b3d1 Mon Sep 17 00:00:00 2001
From: YOUR_NAME <huangkai71@huawei.com>
Date: Tue, 7 Sep 2021 13:30:43 +0000
Subject: [PATCH 06/11] add ec11

Signed-off-by: YOUR_NAME <huangkai71@huawei.com>
---
 model/input/driver/hdf_encoder.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/model/input/driver/hdf_encoder.c b/model/input/driver/hdf_encoder.c
index 5c09d646b..dd117544f 100644
--- a/model/input/driver/hdf_encoder.c
+++ b/model/input/driver/hdf_encoder.c
@@ -146,7 +146,7 @@ static InputDevice *InputDeviceInstance(EncoderDriver *encoderDrv)
     inputDev->pvtData = (void *)encoderDrv;
     inputDev->devType = encoderDrv->devType;
     inputDev->hdfDevObj = encoderDrv->encoderCfg->hdfEncoderDev;
-    encoderDrv->inputdev = inputDev;
+    encoderDrv->inputDev = inputDev;
 
     return inputDev;
 }
-- 
Gitee


From 6b6de0db53191c7406accca2741afb3abdbd37f9 Mon Sep 17 00:00:00 2001
From: YOUR_NAME <huangkai71@huawei.com>
Date: Tue, 7 Sep 2021 13:49:54 +0000
Subject: [PATCH 07/11] add ec11

Signed-off-by: YOUR_NAME <huangkai71@huawei.com>
---
 model/input/driver/hdf_encoder.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/model/input/driver/hdf_encoder.c b/model/input/driver/hdf_encoder.c
index dd117544f..46b79053c 100644
--- a/model/input/driver/hdf_encoder.c
+++ b/model/input/driver/hdf_encoder.c
@@ -143,6 +143,13 @@ static InputDevice *InputDeviceInstance(EncoderDriver *encoderDrv)
         return NULL;
     }
 
+    ret = OsalMutexInit(&inputDev->mutex);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: Init mutex error", __func__);
+        OsalMemFree(inputDev);
+        return NULL;
+    }
+
     inputDev->pvtData = (void *)encoderDrv;
     inputDev->devType = encoderDrv->devType;
     inputDev->hdfDevObj = encoderDrv->encoderCfg->hdfEncoderDev;
-- 
Gitee


From 765dc7abe0f894e8912d0278183aaa86a177bc5c Mon Sep 17 00:00:00 2001
From: YOUR_NAME <huangkai71@huawei.com>
Date: Wed, 8 Sep 2021 01:31:38 +0000
Subject: [PATCH 08/11] add ec11

Signed-off-by: YOUR_NAME <huangkai71@huawei.com>
---
 model/input/driver/hdf_encoder.c | 20 +++++++++++++++++---
 model/input/driver/hdf_encoder.h |  2 +-
 2 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/model/input/driver/hdf_encoder.c b/model/input/driver/hdf_encoder.c
index 46b79053c..445d62c92 100644
--- a/model/input/driver/hdf_encoder.c
+++ b/model/input/driver/hdf_encoder.c
@@ -158,13 +158,14 @@ static InputDevice *InputDeviceInstance(EncoderDriver *encoderDrv)
     return inputDev;
 }
 
-static int32_t RegisterEncoderDevice(EncoderCfg *encoderCfg)
+static int32_t RegisterEncoderDevice(EncoderCfg *encoderCfg, struct HdfDeviceObject *device)
 {
     EncoderDriver *EncoderDrv = EncoderDriverInstance(encoderCfg);
     if (EncoderDrv == NULL) {
         HDF_LOGE("%s: instance encoder driver failed", __func__);
         return HDF_ERR_MALLOC_FAIL;
     }
+    device->priv = (void *)EncoderDrv;
 
     int32_t ret = EncoderInit(EncoderDrv);
     if (ret != HDF_SUCCESS) {
@@ -205,7 +206,7 @@ static int32_t HdfEnCoderDriverInit(struct HdfDeviceObject *device)
         return HDF_ERR_MALLOC_FAIL;
     }
 
-    int32_t ret = RegisterEncoderDevice(encoderCfg);
+    int32_t ret = RegisterEncoderDevice(encoderCfg, device);
     if (ret != HDF_SUCCESS) {
         goto EXIT;
     }
@@ -231,7 +232,20 @@ static int32_t HdfEnCoderDispatch(struct HdfDeviceIoClient *client, int cmd,
 
 static void HdfEncoderDriverRelease(struct HdfDeviceObject *device)
 {
-    (void)device;
+    EncoderDriver *driver = NULL;
+    InputDevice *inputDev = NULL;
+
+    if (device == NULL || device->priv == NULL) {
+        HDF_LOGE("%s: param is null", __func__);
+        return;
+    }
+    driver = (EncoderDriver *)device->priv;
+    inputDev = driver->inputDev;
+    if (inputDev != NULL) {
+        UnregisterInputDevice(inputDev);
+        driver->inputDev = NULL;
+    }
+    OsalMemFree(driver);
 }
 
 static int32_t HdfEnCoderDriverBind(struct HdfDeviceObject *device)
diff --git a/model/input/driver/hdf_encoder.h b/model/input/driver/hdf_encoder.h
index 158cc73c6..37e92db21 100644
--- a/model/input/driver/hdf_encoder.h
+++ b/model/input/driver/hdf_encoder.h
@@ -8,8 +8,8 @@
 #ifndef HDF_ENCODER_H
 #define HDF_ENCODER_H
 
-#include "input_config.h"
 #include "hdf_input_device_manager.h"
+#include "input_config.h"
 #include "osal_time.h"
 #include "osal_timer.h"
 #include <securec.h>
-- 
Gitee


From 8cd7187e831d6ee7750092e3ccfa292718fb61be Mon Sep 17 00:00:00 2001
From: YOUR_NAME <huangkai71@huawei.com>
Date: Wed, 8 Sep 2021 02:54:38 +0000
Subject: [PATCH 09/11] add ec11

Signed-off-by: YOUR_NAME <huangkai71@huawei.com>
---
 model/input/driver/hdf_encoder.c | 11 ++++++++++-
 model/input/driver/hdf_encoder.h |  1 +
 2 files changed, 11 insertions(+), 1 deletion(-)

diff --git a/model/input/driver/hdf_encoder.c b/model/input/driver/hdf_encoder.c
index 445d62c92..eaab0f338 100644
--- a/model/input/driver/hdf_encoder.c
+++ b/model/input/driver/hdf_encoder.c
@@ -15,7 +15,7 @@
 #include "hdf_device_desc.h"
 
 
-#define TIMER_INTERVAL_ENCODER  10
+#define TIMER_INTERVAL_ENCODER  5
 
 static void EncoderTimerFunc(uintptr_t arg)
 {
@@ -34,6 +34,11 @@ static void EncoderTimerFunc(uintptr_t arg)
         HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
         return;
     }
+    ret = GpioRead(gpioSW, &encoderDrv->encoderSW);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
+        return;
+    }
 
     if (encoderDrv->encoderClkNowSta != encoderDrv->encoderClkPreSta) {
         if (encoderDrv->encoderClkNowSta == 0) {
@@ -47,6 +52,10 @@ static void EncoderTimerFunc(uintptr_t arg)
         encoderDrv->encoderClkPreSta = encoderDrv->encoderClkNowSta;
         encoderDrv->encoderDataPreSta  = encoderDrv->encoderDataNowSta;
     }
+    if (encoderDrv->encoderSW == 0) {
+        input_report_key(encoderDrv->inputDev, KEY_OK, 0);
+        input_sync(encoderDrv->inputDev);
+    }
 }
 
 static EncoderCfg *EncoderConfigInstance(struct HdfDeviceObject *device)
diff --git a/model/input/driver/hdf_encoder.h b/model/input/driver/hdf_encoder.h
index 37e92db21..c9574d3f7 100644
--- a/model/input/driver/hdf_encoder.h
+++ b/model/input/driver/hdf_encoder.h
@@ -25,6 +25,7 @@ typedef struct EncoderDriverInfo {
     uint16_t encoderClkNowSta;
     uint16_t encoderDataPreSta;
     uint16_t encoderDataNowSta;
+    uint16_t encoderSW;
 } EncoderDriver;
 
 #endif
\ No newline at end of file
-- 
Gitee


From a6d2b3abac4e3a6d0c92f15aa620bd0001a53c46 Mon Sep 17 00:00:00 2001
From: YOUR_NAME <huangkai71@huawei.com>
Date: Wed, 8 Sep 2021 03:04:54 +0000
Subject: [PATCH 10/11] add ec11

Signed-off-by: YOUR_NAME <huangkai71@huawei.com>
---
 model/input/driver/hdf_encoder.c | 3 +--
 model/input/driver/hdf_encoder.h | 5 ++---
 2 files changed, 3 insertions(+), 5 deletions(-)

diff --git a/model/input/driver/hdf_encoder.c b/model/input/driver/hdf_encoder.c
index eaab0f338..56b513bff 100644
--- a/model/input/driver/hdf_encoder.c
+++ b/model/input/driver/hdf_encoder.c
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
+ * Copyright (c) 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.
@@ -14,7 +14,6 @@
 #include "hdf_log.h"
 #include "hdf_device_desc.h"
 
-
 #define TIMER_INTERVAL_ENCODER  5
 
 static void EncoderTimerFunc(uintptr_t arg)
diff --git a/model/input/driver/hdf_encoder.h b/model/input/driver/hdf_encoder.h
index c9574d3f7..d5d431615 100644
--- a/model/input/driver/hdf_encoder.h
+++ b/model/input/driver/hdf_encoder.h
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2020-2021 Huawei Device Co., Ltd.
+ * Copyright (c) 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.
@@ -8,12 +8,11 @@
 #ifndef HDF_ENCODER_H
 #define HDF_ENCODER_H
 
+#include <securec.h>
 #include "hdf_input_device_manager.h"
 #include "input_config.h"
 #include "osal_time.h"
 #include "osal_timer.h"
-#include <securec.h>
-
 
 typedef struct EncoderDriverInfo {
     struct HdfDeviceObject *hdfEncoderDev;
-- 
Gitee


From b818a571b63b9a9b10ac6ff00ed0872f188dde6f Mon Sep 17 00:00:00 2001
From: YOUR_NAME <huangkai71@huawei.com>
Date: Wed, 8 Sep 2021 04:04:43 +0000
Subject: [PATCH 11/11] add ec11

Signed-off-by: YOUR_NAME <huangkai71@huawei.com>
---
 model/input/driver/hdf_encoder.c | 16 +++++++++++++---
 model/input/driver/hdf_encoder.h |  3 ++-
 2 files changed, 15 insertions(+), 4 deletions(-)

diff --git a/model/input/driver/hdf_encoder.c b/model/input/driver/hdf_encoder.c
index 56b513bff..134b8f610 100644
--- a/model/input/driver/hdf_encoder.c
+++ b/model/input/driver/hdf_encoder.c
@@ -33,7 +33,7 @@ static void EncoderTimerFunc(uintptr_t arg)
         HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
         return;
     }
-    ret = GpioRead(gpioSW, &encoderDrv->encoderSW);
+    ret = GpioRead(gpioSW, &encoderDrv->encoderSWNowSta);
     if (ret != HDF_SUCCESS) {
         HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
         return;
@@ -51,8 +51,13 @@ static void EncoderTimerFunc(uintptr_t arg)
         encoderDrv->encoderClkPreSta = encoderDrv->encoderClkNowSta;
         encoderDrv->encoderDataPreSta  = encoderDrv->encoderDataNowSta;
     }
-    if (encoderDrv->encoderSW == 0) {
-        input_report_key(encoderDrv->inputDev, KEY_OK, 0);
+    if (encoderDrv->encoderSWPreSta != encoderDrv->encoderSWNowSta) {
+        if (encoderDrv->encoderSWNowSta == 0) {
+            input_report_key(encoderDrv->inputDev, KEY_OK, 0);
+        } else {
+            input_report_key(encoderDrv->inputDev, KEY_OK, 1);
+        }
+        encoderDrv->encoderSWPreSta = encoderDrv->encoderSWNowSta;
         input_sync(encoderDrv->inputDev);
     }
 }
@@ -130,6 +135,11 @@ static int32_t EncoderInit(EncoderDriver *EncoderDrv)
         HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
         return HDF_FAILURE;
     }
+    ret = GpioRead(gpioSW, &EncoderDrv->encoderSWNowSta);
+    if (ret != HDF_SUCCESS) {
+        HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
+        return HDF_FAILURE;
+    }
 
     EncoderDrv->encoderClkPreSta = EncoderDrv->encoderClkNowSta;
     EncoderDrv->encoderDataPreSta = EncoderDrv->encoderDataNowSta;
diff --git a/model/input/driver/hdf_encoder.h b/model/input/driver/hdf_encoder.h
index d5d431615..0456fcfc4 100644
--- a/model/input/driver/hdf_encoder.h
+++ b/model/input/driver/hdf_encoder.h
@@ -24,7 +24,8 @@ typedef struct EncoderDriverInfo {
     uint16_t encoderClkNowSta;
     uint16_t encoderDataPreSta;
     uint16_t encoderDataNowSta;
-    uint16_t encoderSW;
+    uint16_t encoderSWPreSta;
+    uint16_t encoderSWNowSta
 } EncoderDriver;
 
 #endif
\ No newline at end of file
-- 
Gitee