1 /*
2 * Copyright (c) 2021 Huawei Device Co., Ltd.
3 *
4 * HDF is dual licensed: you can use it either under the terms of
5 * the GPL, or the BSD license, at your option.
6 * See the LICENSE file in the root of this repository for complete details.
7 */
8
9 #include "hdf_encoder.h"
10 #include "event_hub.h"
11 #include "gpio_if.h"
12 #include "hdf_device_desc.h"
13 #include "hdf_log.h"
14 #include "osal_mem.h"
15 #include "osal_timer.h"
16
17 #define TIMER_INTERVAL_ENCODER 5
18
EncoderTimerFunc(uintptr_t arg)19 static void EncoderTimerFunc(uintptr_t arg)
20 {
21 int32_t ret;
22 EncoderDriver *encoderDrv = (EncoderDriver *)arg;
23 uint16_t gpioClk = encoderDrv->encoderCfg->gpioClk;
24 uint16_t gpioData = encoderDrv->encoderCfg->gpioData;
25 uint16_t gpioSW = encoderDrv->encoderCfg->gpioSW;
26
27 ret = GpioRead(gpioClk, &encoderDrv->encoderClkNowSta);
28 if (ret != HDF_SUCCESS) {
29 HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
30 return;
31 }
32 ret = GpioRead(gpioData, &encoderDrv->encoderDataNowSta);
33 if (ret != HDF_SUCCESS) {
34 HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
35 return;
36 }
37 ret = GpioRead(gpioSW, &encoderDrv->encoderSWNowSta);
38 if (ret != HDF_SUCCESS) {
39 HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
40 return;
41 }
42
43 if (encoderDrv->encoderClkNowSta != encoderDrv->encoderClkPreSta) {
44 if (encoderDrv->encoderClkNowSta == 0) {
45 if (encoderDrv->encoderDataNowSta == 1) {
46 input_report_rel(encoderDrv->inputDev, REL_WHEEL, 1);
47 } else {
48 input_report_rel(encoderDrv->inputDev, REL_WHEEL, -1);
49 }
50 input_sync(encoderDrv->inputDev);
51 }
52 encoderDrv->encoderClkPreSta = encoderDrv->encoderClkNowSta;
53 encoderDrv->encoderDataPreSta = encoderDrv->encoderDataNowSta;
54 }
55 if (encoderDrv->encoderSWPreSta != encoderDrv->encoderSWNowSta) {
56 if (encoderDrv->encoderSWNowSta == 0) {
57 input_report_key(encoderDrv->inputDev, KEY_OK, 0);
58 } else {
59 input_report_key(encoderDrv->inputDev, KEY_OK, 1);
60 }
61 encoderDrv->encoderSWPreSta = encoderDrv->encoderSWNowSta;
62 input_sync(encoderDrv->inputDev);
63 }
64 }
65
EncoderConfigInstance(struct HdfDeviceObject * device)66 static EncoderCfg *EncoderConfigInstance(struct HdfDeviceObject *device)
67 {
68 int32_t ret;
69 EncoderCfg *encoderCfg = (EncoderCfg *)OsalMemAlloc(sizeof(EncoderCfg));
70 if (encoderCfg == NULL) {
71 HDF_LOGE("%s: malloc encoder config failed", __func__);
72 return NULL;
73 }
74 ret = memset_s(encoderCfg, sizeof(EncoderCfg), 0, sizeof(EncoderCfg));
75 if (ret != 0) {
76 HDF_LOGE("%s: memset_s encoder config failed", __func__);
77 OsalMemFree(encoderCfg);
78 return NULL;
79 }
80 encoderCfg->hdfEncoderDev = device;
81
82 if (ParseEncoderConfig(device->property, encoderCfg) != HDF_SUCCESS) {
83 HDF_LOGE("%s: parse encoder config failed", __func__);
84 OsalMemFree(encoderCfg);
85 return NULL;
86 }
87 return encoderCfg;
88 }
89
EncoderDriverInstance(EncoderCfg * encoderCfg)90 static EncoderDriver *EncoderDriverInstance(EncoderCfg *encoderCfg)
91 {
92 int32_t ret;
93 EncoderDriver *encoderDrv = (EncoderDriver *)OsalMemAlloc(sizeof(EncoderDriver));
94 if (encoderDrv == NULL) {
95 HDF_LOGE("%s: malloc key driver failed", __func__);
96 return NULL;
97 }
98 ret = memset_s(encoderDrv, sizeof(EncoderDriver), 0, sizeof(EncoderDriver));
99 if (ret != 0) {
100 HDF_LOGE("%s: memset encoder driver failed", __func__);
101 OsalMemFree(encoderDrv);
102 return NULL;
103 }
104
105 encoderDrv->devType = encoderCfg->devType;
106 encoderDrv->encoderCfg = encoderCfg;
107
108 return encoderDrv;
109 }
110
EncoderInit(EncoderDriver * EncoderDrv)111 static int32_t EncoderInit(EncoderDriver *EncoderDrv)
112 {
113 int32_t ret;
114 uint16_t gpioClk = EncoderDrv->encoderCfg->gpioClk;
115 uint16_t gpioData = EncoderDrv->encoderCfg->gpioData;
116 uint16_t gpioSW = EncoderDrv->encoderCfg->gpioSW;
117 GpioSetDir(gpioClk, GPIO_DIR_IN);
118 GpioSetDir(gpioData, GPIO_DIR_IN);
119 GpioSetDir(gpioSW, GPIO_DIR_IN);
120
121 ret = OsalTimerCreate(&EncoderDrv->timer, TIMER_INTERVAL_ENCODER, EncoderTimerFunc, EncoderDrv);
122 if (ret != HDF_SUCCESS) {
123 HDF_LOGE("%s: create timer failed, ret = %d\n", __func__, ret);
124 return HDF_FAILURE;
125 }
126 ret = OsalTimerStartLoop(&EncoderDrv->timer);
127 if (ret != HDF_SUCCESS) {
128 HDF_LOGE("%s: start timer failed, ret = %d\n", __func__, ret);
129 return HDF_FAILURE;
130 }
131
132 ret = GpioRead(gpioClk, &EncoderDrv->encoderClkNowSta);
133 if (ret != HDF_SUCCESS) {
134 HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
135 return HDF_FAILURE;
136 }
137 ret = GpioRead(gpioData, &EncoderDrv->encoderDataNowSta);
138 if (ret != HDF_SUCCESS) {
139 HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
140 return HDF_FAILURE;
141 }
142 ret = GpioRead(gpioSW, &EncoderDrv->encoderSWNowSta);
143 if (ret != HDF_SUCCESS) {
144 HDF_LOGE("%s: gpio read failed, ret %d", __func__, ret);
145 return HDF_FAILURE;
146 }
147
148 EncoderDrv->encoderClkPreSta = EncoderDrv->encoderClkNowSta;
149 EncoderDrv->encoderDataPreSta = EncoderDrv->encoderDataNowSta;
150
151 return HDF_SUCCESS;
152 }
153
InputDeviceInstance(EncoderDriver * encoderDrv)154 static InputDevice *InputDeviceInstance(EncoderDriver *encoderDrv)
155 {
156 int32_t ret;
157 InputDevice *inputDev = (InputDevice *)OsalMemAlloc(sizeof(InputDevice));
158 if (inputDev == NULL) {
159 HDF_LOGE("%s: malloc input device failed", __func__);
160 return NULL;
161 }
162 ret = memset_s(inputDev, sizeof(InputDevice), 0, sizeof(InputDevice));
163 if (ret != 0) {
164 HDF_LOGE("%s: memset encoder driver failed", __func__);
165 OsalMemFree(inputDev);
166 return NULL;
167 }
168
169 ret = OsalMutexInit(&inputDev->mutex);
170 if (ret != HDF_SUCCESS) {
171 HDF_LOGE("%s: Init mutex error", __func__);
172 OsalMemFree(inputDev);
173 return NULL;
174 }
175
176 inputDev->pvtData = (void *)encoderDrv;
177 inputDev->devType = encoderDrv->devType;
178 inputDev->hdfDevObj = encoderDrv->encoderCfg->hdfEncoderDev;
179 encoderDrv->inputDev = inputDev;
180
181 return inputDev;
182 }
183
RegisterEncoderDevice(EncoderCfg * encoderCfg,struct HdfDeviceObject * device)184 static int32_t RegisterEncoderDevice(EncoderCfg *encoderCfg, struct HdfDeviceObject *device)
185 {
186 int32_t ret;
187 EncoderDriver *encoderDrv = EncoderDriverInstance(encoderCfg);
188 if (encoderDrv == NULL) {
189 HDF_LOGE("%s: instance encoder driver failed", __func__);
190 return HDF_ERR_MALLOC_FAIL;
191 }
192 device->priv = (void *)encoderDrv;
193
194 ret = EncoderInit(encoderDrv);
195 if (ret != HDF_SUCCESS) {
196 HDF_LOGE("%s: key driver init failed, ret %d", __func__, ret);
197 goto EXIT;
198 }
199
200 InputDevice *inputDev = InputDeviceInstance(encoderDrv);
201 if (inputDev == NULL) {
202 HDF_LOGE("%s: instance input device failed", __func__);
203 goto EXIT;
204 }
205
206 ret = RegisterInputDevice(inputDev);
207 if (ret != HDF_SUCCESS) {
208 goto EXIT1;
209 }
210 return HDF_SUCCESS;
211
212 EXIT1:
213 OsalMemFree(inputDev->pkgBuf);
214 OsalMemFree(inputDev);
215 EXIT:
216 OsalMemFree(encoderDrv);
217 return HDF_FAILURE;
218 }
219
HdfEnCoderDriverInit(struct HdfDeviceObject * device)220 static int32_t HdfEnCoderDriverInit(struct HdfDeviceObject *device)
221 {
222 int32_t ret;
223 if (device == NULL) {
224 HDF_LOGE("%s: param is null", __func__);
225 return HDF_ERR_INVALID_PARAM;
226 }
227
228 EncoderCfg *encoderCfg = EncoderConfigInstance(device);
229 if (encoderCfg == NULL) {
230 HDF_LOGE("%s: instance encoder config failed", __func__);
231 return HDF_ERR_MALLOC_FAIL;
232 }
233
234 ret = RegisterEncoderDevice(encoderCfg, device);
235 if (ret != HDF_SUCCESS) {
236 goto EXIT;
237 }
238
239 HDF_LOGI("%s: exit succ!", __func__);
240 return HDF_SUCCESS;
241
242 EXIT:
243 OsalMemFree(encoderCfg);
244 return HDF_FAILURE;
245 }
246
HdfEnCoderDispatch(struct HdfDeviceIoClient * client,int cmd,struct HdfSBuf * data,struct HdfSBuf * reply)247 static int32_t HdfEnCoderDispatch(struct HdfDeviceIoClient *client, int cmd,
248 struct HdfSBuf *data, struct HdfSBuf *reply)
249 {
250 (void)cmd;
251 if (client == NULL || data == NULL || reply == NULL) {
252 HDF_LOGE("%s: param is null", __func__);
253 return HDF_FAILURE;
254 }
255 return HDF_SUCCESS;
256 }
257
HdfEncoderDriverRelease(struct HdfDeviceObject * device)258 static void HdfEncoderDriverRelease(struct HdfDeviceObject *device)
259 {
260 EncoderDriver *driver = NULL;
261 InputDevice *inputDev = NULL;
262
263 if (device == NULL || device->priv == NULL) {
264 HDF_LOGE("%s: param is null", __func__);
265 return;
266 }
267 driver = (EncoderDriver *)device->priv;
268 inputDev = driver->inputDev;
269 if (inputDev != NULL) {
270 UnregisterInputDevice(inputDev);
271 driver->inputDev = NULL;
272 }
273 OsalMemFree(driver);
274 }
275
HdfEnCoderDriverBind(struct HdfDeviceObject * device)276 static int32_t HdfEnCoderDriverBind(struct HdfDeviceObject *device)
277 {
278 if (device == NULL) {
279 return HDF_ERR_INVALID_PARAM;
280 }
281 static struct IDeviceIoService enCoderService = {
282 .object.objectId = 1,
283 .Dispatch = HdfEnCoderDispatch,
284 };
285 device->service = &enCoderService;
286 return HDF_SUCCESS;
287 }
288
289 struct HdfDriverEntry g_hdfEnCoderEntry = {
290 .moduleVersion = 1,
291 .moduleName = "HDF_ENCODER",
292 .Bind = HdfEnCoderDriverBind,
293 .Init = HdfEnCoderDriverInit,
294 .Release = HdfEncoderDriverRelease,
295 };
296
297 HDF_INIT(g_hdfEnCoderEntry);
298