1 /*
2 * Copyright (c) 2020-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_touch.h"
10 #include "gpio_if.h"
11 #include "hdf_device_desc.h"
12 #include "hdf_log.h"
13 #include "hdf_pm.h"
14 #include "osal_mem.h"
15 #include "osal_io.h"
16 #include "event_hub.h"
17 #include "input_i2c_ops.h"
18
19 #if defined(CONFIG_ARCH_ROCKCHIP)
20 #include <linux/hrtimer.h>
21 #include <linux/string.h>
22 #include <linux/jiffies.h>
23 #include <linux/time.h>
24 #include <linux/sched.h>
25 #include <linux/kthread.h>
26 #endif
27
28 #define I2C_TYPE 0
29 #define SPI_TYPE 1
30 #define MAX_TOUCH_DEVICE 5
31 #define REGISTER_BYTE_SIZE 4
32 #define TOUCH_CHIP_NAME_LEN 10
33
34 #if defined(CONFIG_ARCH_ROCKCHIP)
35 #define GTP_ESD_PROTECT 1
36 #define GTP_REG_CMD 0x8040
37 #define GTP_REG_CMD_1 0x8041
38 unsigned long g_timeout;
39 static int32_t ChipCheckResetRetry(ChipDevice *chipDev);
40 #endif
41
42 static TouchDriver *g_touchDriverList[MAX_TOUCH_DEVICE];
43 static void InputFrameReport(TouchDriver *driver);
44 static int SuspendFlag = 0;
45
SetGpioDirAndLevel(int gpio,int dir,int level)46 static int32_t SetGpioDirAndLevel(int gpio, int dir, int level)
47 {
48 int32_t ret;
49 if ((dir == GPIO_DIR_IN) || (dir == GPIO_DIR_OUT)) {
50 ret = GpioSetDir(gpio, dir);
51 if (ret != HDF_SUCCESS) {
52 HDF_LOGE("%s: set gpio%d to %d dir failed, ret %d", __func__, gpio, dir, ret);
53 return HDF_FAILURE;
54 }
55 }
56
57 if ((level == GPIO_VAL_LOW) || (level == GPIO_VAL_HIGH)) {
58 ret = GpioWrite(gpio, level);
59 if (ret != HDF_SUCCESS) {
60 HDF_LOGE("%s: pull gpio%d to %d level failed, ret %d", __func__, gpio, level, ret);
61 return HDF_FAILURE;
62 }
63 }
64 return HDF_SUCCESS;
65 }
66
SetVccPower(uint32_t status)67 static int32_t SetVccPower(uint32_t status)
68 {
69 (void)status;
70 return HDF_SUCCESS;
71 }
72
SetVciPower(uint32_t status)73 static int32_t SetVciPower(uint32_t status)
74 {
75 (void)status;
76 return HDF_SUCCESS;
77 }
78
SetGpio(uint16_t gpio,uint32_t dir,uint32_t status)79 static int32_t SetGpio(uint16_t gpio, uint32_t dir, uint32_t status)
80 {
81 int32_t ret = SetGpioDirAndLevel(gpio, dir, status);
82 CHECK_RETURN_VALUE(ret);
83 return HDF_SUCCESS;
84 }
85
HandleResetEvent(ChipDevice * chipDev,uint32_t * timing,uint32_t length)86 static int32_t HandleResetEvent(ChipDevice *chipDev, uint32_t *timing, uint32_t length)
87 {
88 int32_t ret = 0;
89 uint16_t gpio;
90
91 if (length <= PWR_DELAY_INDEX) {
92 HDF_LOGE("%s: invalid param", __func__);
93 return HDF_FAILURE;
94 }
95 uint32_t type = timing[PWR_TYPE_INDEX];
96 uint32_t status = timing[PWR_STATUS_INDEX];
97 uint32_t dir = timing[PWR_DIR_INDEX];
98 uint32_t delay = timing[PWR_DELAY_INDEX];
99 HDF_LOGD("%s: type = %u, status = %u, dir = %u, delay = %u", __func__, type, status, dir, delay);
100
101 switch (type) {
102 case TYPE_VCC:
103 case TYPE_VCI:
104 break;
105 case TYPE_INT:
106 gpio = chipDev->boardCfg->pins.intGpio;
107 ret = SetGpio(gpio, dir, status);
108 break;
109 case TYPE_RESET:
110 gpio = chipDev->boardCfg->pins.rstGpio;
111 ret = SetGpio(gpio, dir, status);
112 break;
113 default:
114 HDF_LOGE("%s: unknown power type", __func__);
115 break;
116 }
117 if (delay > 0) {
118 OsalMSleep(delay);
119 }
120 return ret;
121 }
122
HandlePowerEvent(ChipDevice * chipDev,uint32_t * timing,uint32_t length)123 static int32_t HandlePowerEvent(ChipDevice *chipDev, uint32_t *timing, uint32_t length)
124 {
125 int32_t ret = 0;
126 uint16_t gpio;
127
128 if (length <= PWR_DELAY_INDEX) {
129 HDF_LOGE("%s: invalid param", __func__);
130 return HDF_FAILURE;
131 }
132 uint32_t type = timing[PWR_TYPE_INDEX];
133 uint32_t status = timing[PWR_STATUS_INDEX];
134 uint32_t dir = timing[PWR_DIR_INDEX];
135 uint32_t delay = timing[PWR_DELAY_INDEX];
136 HDF_LOGD("%s: type = %u, status = %u, dir = %u, delay = %u", __func__, type, status, dir, delay);
137
138 switch (type) {
139 case TYPE_VCC:
140 ret = SetVccPower(status);
141 break;
142 case TYPE_VCI:
143 ret = SetVciPower(status);
144 break;
145 case TYPE_RESET:
146 gpio = chipDev->boardCfg->pins.rstGpio;
147 ret = SetGpio(gpio, dir, status);
148 break;
149 case TYPE_INT:
150 gpio = chipDev->boardCfg->pins.intGpio;
151 ret = SetGpio(gpio, dir, status);
152 break;
153 default:
154 HDF_LOGE("%s: unknown power type", __func__);
155 break;
156 }
157 if (delay > 0) {
158 OsalMSleep(delay);
159 }
160 return ret;
161 }
162
InputPinMuxCfg(uint32_t regAddr,int32_t regSize,uint32_t regValue)163 static int32_t InputPinMuxCfg(uint32_t regAddr, int32_t regSize, uint32_t regValue)
164 {
165 #if defined(CONFIG_ARCH_SPRD) || defined(CONFIG_ARCH_ROCKCHIP) || defined(LOSCFG_PLATFORM_STM32MP157) || \
166 defined(CONFIG_ARCH_MESON) || defined(CONFIG_ARCH_NXP_TOUCH)
167 return HDF_SUCCESS;
168 #endif
169 uint8_t *base = NULL;
170 if (regAddr == 0) {
171 HDF_LOGE("%s: regAddr invalid", __func__);
172 return HDF_FAILURE;
173 }
174
175 base = OsalIoRemap(regAddr, regSize);
176 if (base == NULL) {
177 HDF_LOGE("%s: ioremap failed", __func__);
178 return HDF_FAILURE;
179 }
180
181 OSAL_WRITEL(regValue, base);
182 OsalIoUnmap((void *)base);
183 return HDF_SUCCESS;
184 }
185
186 #if defined(CONFIG_ARCH_ROCKCHIP)
SetResetStatus(TouchDriver * driver)187 static int32_t SetResetStatus(TouchDriver *driver)
188 {
189 int32_t ret;
190 uint8_t writeBuf[5]; // 5: buffer size
191
192 writeBuf[0] = (GTP_REG_CMD_1 >> 8) & 0xFF; // 8:high byte 0xffmask
193 writeBuf[1] = GTP_REG_CMD_1 & 0xFF;
194 writeBuf[2] = 0x00; // 2:index 0x00: reg value
195 writeBuf[3] = 0x56; // 3:index 0x56: reg value
196 writeBuf[4] = 0xAA; // 4:index 0xAA: reg value
197 ret = InputI2cWrite(&driver->i2cClient, writeBuf, 5); // 5: buffer size
198 if (ret != HDF_SUCCESS) {
199 HDF_LOGE("%s: InputI2cWrite failed, ret = %d", __func__, ret);
200 return ret;
201 }
202
203 writeBuf[0] = (GTP_REG_CMD >> 8) & 0xFF; // 8:high byte 0xffmask
204 writeBuf[1] = GTP_REG_CMD & 0xFF;
205 writeBuf[2] = 0xAA; // 2:index 0xAA: reg value
206
207 ret = InputI2cWrite(&driver->i2cClient, writeBuf, 3); // 3: buffer size
208 if (ret != HDF_SUCCESS) {
209 HDF_LOGE("%s: InputI2cWrite failed, ret = %d", __func__, ret);
210 return ret;
211 }
212
213 return HDF_SUCCESS;
214 }
215
Gt1xRequestIo(ChipDevice * chipDev)216 static int32_t Gt1xRequestIo(ChipDevice *chipDev)
217 {
218 int32_t ret;
219 ret = SetGpio(chipDev->boardCfg->pins.rstGpio, 1, 0);
220 if (ret != HDF_SUCCESS) {
221 HDF_LOGE("%s: set rstGpio to output failed, ret %d", __func__, ret);
222 return HDF_FAILURE;
223 }
224 ret = SetGpio(chipDev->boardCfg->pins.intGpio, 1, 0);
225 if (ret != HDF_SUCCESS) {
226 HDF_LOGE("%s: set intGpio to output failed, ret %d", __func__, ret);
227 return HDF_FAILURE;
228 }
229 OsalMSleep(100); // 100 : delay time
230 ret = SetGpio(chipDev->boardCfg->pins.rstGpio, 1, 1);
231 if (ret != HDF_SUCCESS) {
232 HDF_LOGE("%s: set intGpio to output failed, ret %d", __func__, ret);
233 return HDF_FAILURE;
234 }
235 OsalMSleep(20); // 20 : delay time
236 return HDF_SUCCESS;
237 }
238 #endif
239
SetTiming(ChipDevice * chipDev,bool enable)240 static int32_t SetTiming(ChipDevice *chipDev, bool enable)
241 {
242 #if defined(CONFIG_ARCH_MESON)
243 return HDF_SUCCESS;
244 #endif
245 int32_t i;
246 int32_t ret;
247 uint32_t rstPinAddr;
248 uint32_t rstPinValue;
249 uint32_t intPinAddr;
250 uint32_t intPinValue;
251 SeqArray pwrOnTiming = {0};
252 SeqArray pwroffTiming = {0};
253 TouchDriver *driver = chipDev->driver;
254
255 rstPinAddr = driver->boardCfg->pins.rstPinReg[0];
256 rstPinValue = driver->boardCfg->pins.rstPinReg[1];
257 intPinAddr = driver->boardCfg->pins.intPinReg[0];
258 intPinValue = driver->boardCfg->pins.intPinReg[1];
259
260 if (InputPinMuxCfg(rstPinAddr, REGISTER_BYTE_SIZE, rstPinValue) != HDF_SUCCESS) {
261 return HDF_FAILURE;
262 }
263
264 if (InputPinMuxCfg(intPinAddr, REGISTER_BYTE_SIZE, intPinValue) != HDF_SUCCESS) {
265 return HDF_FAILURE;
266 }
267 HDF_LOGD("%s: rstPinAddr = 0x%x, rstPinValue = 0x%x, intPinAddr = 0x%x, intPinValue = 0x%x",
268 __func__, rstPinAddr, rstPinValue, intPinAddr, intPinValue);
269
270 HDF_LOGE("%s: enable = %d", __func__, enable);
271 if (enable) {
272 ret = memcpy_s(&pwrOnTiming, sizeof(SeqArray), &chipDev->chipCfg->pwrSeq.pwrOn, sizeof(SeqArray));
273 if (ret != EOK) {
274 HDF_LOGE("%s: memcpy_s failed", __func__);
275 return HDF_FAILURE;
276 }
277 if ((pwrOnTiming.buf == NULL) || (pwrOnTiming.count == 0)) {
278 HDF_LOGE("%s: pwrOnTiming config is invalid", __func__);
279 return HDF_FAILURE;
280 }
281 for (i = 0; i < pwrOnTiming.count / PWR_CELL_LEN; i++) {
282 ret = HandleResetEvent(chipDev, pwrOnTiming.buf, PWR_CELL_LEN);
283 CHECK_RETURN_VALUE(ret);
284 pwrOnTiming.buf = pwrOnTiming.buf + PWR_CELL_LEN;
285 }
286 } else {
287 ret = memcpy_s(&pwroffTiming, sizeof(SeqArray), &chipDev->chipCfg->pwrSeq.pwrOff, sizeof(SeqArray));
288 if (ret != EOK) {
289 HDF_LOGE("%s: memcpy_s failed", __func__);
290 return HDF_FAILURE;
291 }
292 if ((pwroffTiming.buf == NULL) || (pwroffTiming.count == 0)) {
293 HDF_LOGE("%s: pwroffTiming config is invalid", __func__);
294 return HDF_FAILURE;
295 }
296 for (i = 0; i < pwroffTiming.count / PWR_CELL_LEN; i++) {
297 ret = HandlePowerEvent(chipDev, pwroffTiming.buf, PWR_CELL_LEN);
298 CHECK_RETURN_VALUE(ret);
299 pwroffTiming.buf = pwroffTiming.buf + PWR_CELL_LEN;
300 }
301 }
302
303 #if defined(CONFIG_ARCH_ROCKCHIP)
304 ret = SetResetStatus(driver);
305 if (ret != HDF_SUCCESS) {
306 HDF_LOGE("%s: SetResetStatus failed", __func__);
307 }
308 #endif
309 return HDF_SUCCESS;
310 }
311
EventHandle(TouchDriver * driver,ChipDevice * chipDev)312 static void EventHandle(TouchDriver *driver, ChipDevice *chipDev)
313 {
314 int32_t ret;
315 if ((chipDev->ops == NULL) || (chipDev->ops->DataHandle == NULL)) {
316 return;
317 }
318
319 ret = chipDev->ops->DataHandle(chipDev);
320 if (ret == HDF_SUCCESS) {
321 InputFrameReport(driver);
322 }
323 }
324
IrqHandle(uint16_t intGpioNum,void * data)325 static int32_t IrqHandle(uint16_t intGpioNum, void *data)
326 {
327 TouchDriver *driver = (TouchDriver *)data;
328 int ret = GpioDisableIrq(intGpioNum);
329 if (ret != HDF_SUCCESS) {
330 HDF_LOGE("%s: disable irq failed, ret %d", __func__, ret);
331 return HDF_FAILURE;
332 }
333
334 EventHandle(driver, driver->device);
335
336 ret = GpioEnableIrq(intGpioNum);
337 if (ret != HDF_SUCCESS) {
338 HDF_LOGE("%s: enable irq failed, ret %d", __func__, ret);
339 return HDF_FAILURE;
340 }
341 return HDF_SUCCESS;
342 }
343
InputFrameReport(TouchDriver * driver)344 static void InputFrameReport(TouchDriver *driver)
345 {
346 InputDevice *dev = driver->inputDev;
347 FrameData *frame = &driver->frameData;
348 int32_t i;
349
350 OsalMutexLock(&driver->mutex);
351 for (i = 0; i < MAX_FINGERS_NUM; i++) {
352 if (frame->fingers[i].valid) {
353 input_report_abs(dev, ABS_MT_POSITION_X, frame->fingers[i].x);
354 input_report_abs(dev, ABS_MT_POSITION_Y, frame->fingers[i].y);
355 input_report_abs(dev, ABS_MT_TRACKING_ID, frame->fingers[i].trackId);
356 input_mt_sync(dev);
357 }
358 }
359
360 if ((frame->definedEvent == TOUCH_DOWN) || (frame->definedEvent == TOUCH_CONTACT)) {
361 input_report_key(dev, BTN_TOUCH, 1); // BTN_TOUCH DOWN
362 } else {
363 input_report_key(dev, BTN_TOUCH, 0); // BTN_TOUCH UP
364 }
365 OsalMutexUnlock(&driver->mutex);
366 input_sync(dev);
367 }
368
SetupChipIrq(ChipDevice * chipDev)369 static int32_t SetupChipIrq(ChipDevice *chipDev)
370 {
371 #if defined(CONFIG_ARCH_MESON)
372 return HDF_SUCCESS;
373 #endif
374 int32_t ret;
375 uint16_t intGpioNum = chipDev->boardCfg->pins.intGpio;
376 uint16_t irqFlag = chipDev->chipCfg->bus.chipI2c.irqFlag;
377
378 if (chipDev->driver == NULL) {
379 HDF_LOGE("%s: invalid param", __func__);
380 return HDF_FAILURE;
381 }
382 irqFlag |= GPIO_IRQ_USING_THREAD;
383 HDF_LOGD("%s: gpioNum = %u, irqFlag = %u", __func__, intGpioNum, irqFlag);
384 ret = GpioSetIrq(intGpioNum, irqFlag, IrqHandle, chipDev->driver);
385 if (ret != 0) {
386 HDF_LOGE("%s: register irq failed, ret %d", __func__, ret);
387 return ret;
388 }
389
390 ret = GpioEnableIrq(intGpioNum);
391 if (ret != HDF_SUCCESS) {
392 HDF_LOGE("%s: enable irq failed, ret %d", __func__, ret);
393 return HDF_FAILURE;
394 }
395 return HDF_SUCCESS;
396 }
397
ChipReset(ChipDevice * chipDev)398 static void ChipReset(ChipDevice *chipDev)
399 {
400 if (chipDev == NULL) {
401 HDF_LOGE("%s: invalid param", __func__);
402 return;
403 }
404 if (!SuspendFlag) {
405 (void)SetTiming(chipDev, true);
406 } else {
407 (void)SetTiming(chipDev, false);
408 }
409 }
410
411 #if GTP_ESD_PROTECT
412 static TouchDriver *g_touchDriver;
413 static struct workqueue_struct *gt1x_workqueue = NULL;
414 static int esd_work_cycle = 200;
415 static struct delayed_work esd_check_work;
416 static int esd_running;
417 static void Gt1xEsdCheckFunc(struct work_struct *);
418
Gt1xSedFeedWatchdog(TouchDriver * driver,uint8_t cmd,uint8_t data)419 int32_t Gt1xSedFeedWatchdog(TouchDriver *driver, uint8_t cmd, uint8_t data)
420 {
421 (void)driver;
422 int32_t ret;
423
424 uint8_t writeBuf[4]; // 4: buffer len
425 writeBuf[0] = 0x80; // 0x80: reg address high bit
426 writeBuf[1] = 0x41; // 0x41: reg address low bit
427 writeBuf[2] = 0; // 2: bit nu 0: reg value
428 writeBuf[3] = (uint8_t) ((0 - cmd - data) & 0xFF); // 3: bit nu 0xFF: mask
429
430 ret = InputI2cWrite(&g_touchDriver->i2cClient, writeBuf, 4); // 4: len
431 CHIP_CHECK_RETURN(ret);
432
433 writeBuf[0] = 0x80; // 0x80: reg address high bit
434 writeBuf[1] = 0x40; // 0x40: reg address low bit
435 writeBuf[2] = 0xAA; // 2:bit nu 0xAA: reg value
436
437 ret = InputI2cWrite(&g_touchDriver->i2cClient, writeBuf, 3); // 3: len
438 CHIP_CHECK_RETURN(ret);
439 OsalMSleep(50); // 50: ms
440
441 return ret;
442 }
443
Gt1xSedReadStatus(TouchDriver * driver)444 static int32_t Gt1xSedReadStatus(TouchDriver *driver)
445 {
446 int32_t ret = -1;
447 uint8_t buf[4] = {0};
448 uint8_t reg[2] = {0};
449 reg[0] = 0x80; // 0x80: reg address high bit
450 reg[1] = 0x40; // 0x40: reg address low bit
451 ret = InputI2cRead(&g_touchDriver->i2cClient, reg, 2, buf, 4); // 2: len 4: len
452
453 return (!ret && buf[0] != 0xAA && buf[3] == 0xAA); // 0xAA: reg value 3: bit nu
454 }
455
Gt1xSedResetStatus(TouchDriver * driver)456 static int32_t Gt1xSedResetStatus(TouchDriver *driver)
457 {
458 int32_t ret = -1;
459 uint8_t writeBuf[6]; // 6: buffer size
460
461 writeBuf[0] = 0x42; // 0x42: reg address high bit
462 writeBuf[1] = 0x26; // 0x26: reg address low bit
463 writeBuf[2] = 0x01; // 0x01: reg value
464 writeBuf[3] = 0x01; // 3: bit nu 0x01: reg value
465 writeBuf[4] = 0x01; // 4: bit nu 0x01: reg value
466 writeBuf[5] = 0x01; // 5: bit nu 0x01: reg value
467 ret = InputI2cWrite(&g_touchDriver->i2cClient, writeBuf, 6); // 6: len
468
469 return ret;
470 }
471
Gt1xInitEsdProtect(void)472 void Gt1xInitEsdProtect(void)
473 {
474 esd_work_cycle = 2 * HZ; // 2:nu HZ: clock ticks in 1 second generated by system
475 HDF_LOGI("Clock ticks for an esd cycle: %d", esd_work_cycle);
476 g_timeout = jiffies + HZ * 600; // 600: second
477 INIT_DELAYED_WORK(&esd_check_work, Gt1xEsdCheckFunc);
478 }
479
Gt1xEsdSwitch(int32_t on)480 void Gt1xEsdSwitch(int32_t on)
481 {
482 if (on) { // switch on esd check
483 HDF_LOGI("Esd protector started!");
484 queue_delayed_work(gt1x_workqueue, &esd_check_work, 1);
485 } else { // switch off esd check
486 HDF_LOGI("Esd protector stoped!");
487 cancel_delayed_work(&esd_check_work);
488 }
489 }
490
Gt1xDeinitEsdProtect(void)491 static void Gt1xDeinitEsdProtect(void)
492 {
493 Gt1xEsdSwitch(0);
494 }
495
ChipEsdResetRetry(TouchDriver * driver)496 static int32_t ChipEsdResetRetry(TouchDriver *driver)
497 {
498 int32_t ret;
499 ChipDevice *chipDev = driver->device;
500 uint16_t intGpioNum = driver->device->boardCfg->pins.intGpio;
501
502 ret = GpioDisableIrq(intGpioNum);
503 if (ret != HDF_SUCCESS) {
504 HDF_LOGE("%s: disable irq failed, ret %d", __func__, ret);
505 return HDF_FAILURE;
506 }
507 HDF_LOGE("start ChipEsdResetRetry");
508 ret = ChipCheckResetRetry(chipDev);
509 if (ret != HDF_SUCCESS) {
510 HDF_LOGE("%s: ChipCheckResetRetry failed, ret %d", __func__, ret);
511 ret = GpioEnableIrq(intGpioNum);
512 if (ret != HDF_SUCCESS) {
513 HDF_LOGE("%s: enable irq failed, ret %d", __func__, ret);
514 }
515 return HDF_FAILURE;
516 }
517 HDF_LOGE("end ChipEsdResetRetry");
518
519 ret = GpioEnableIrq(intGpioNum);
520 if (ret != HDF_SUCCESS) {
521 HDF_LOGE("%s: enable irq failed, ret %d", __func__, ret);
522 return HDF_FAILURE;
523 }
524 return HDF_SUCCESS;
525 }
526
Gt1xEsdCheckFunc(struct work_struct * work)527 static void Gt1xEsdCheckFunc(struct work_struct *work)
528 {
529 int32_t i = 0;
530 int32_t ret = -1;
531 if (time_after(jiffies, g_timeout)) {
532 HDF_LOGE("ESD check runing...");
533 g_timeout = jiffies + HZ * 600; // 600: second
534 }
535 for (i = 0; i < 3; i++) { // 3:nu
536 ret = Gt1xSedReadStatus(g_touchDriver);
537 if (ret) {
538 break;
539 }
540 OsalMSleep(50); // 50: sleep time
541 }
542
543 if (likely(i < 3)) { // 3:nu
544 Gt1xSedFeedWatchdog(g_touchDriver, 0xaa, 0); // 0xaa: reg value
545 queue_delayed_work(gt1x_workqueue, &esd_check_work, esd_work_cycle);
546 } else {
547 HDF_LOGE("IC works abnormally! Process reset guitar");
548 Gt1xSedResetStatus(g_touchDriver);
549 OsalMSleep(50); // 50: sleep time
550 ret = ChipEsdResetRetry(g_touchDriver);
551 if (ret == HDF_SUCCESS) {
552 queue_delayed_work(gt1x_workqueue, &esd_check_work, esd_work_cycle);
553 } else {
554 HDF_LOGE("ESD failed, exit esd check work thread");
555 }
556 }
557 }
558
ChipCheckResetRetry(ChipDevice * chipDev)559 static int32_t ChipCheckResetRetry(ChipDevice *chipDev)
560 {
561 int32_t count = 20; // 20 : reset time
562 int32_t ret;
563
564 if ((chipDev->ops == NULL) || (chipDev->ops->Detect == NULL)) {
565 return HDF_FAILURE;
566 }
567
568 while (count --) {
569 ChipReset(chipDev);
570 OsalMSleep(100); // 100 : wait 100msthen try one time
571 ret = chipDev->ops->Detect(chipDev);
572 if (ret == HDF_SUCCESS) {
573 return HDF_SUCCESS;
574 }
575 HDF_LOGE("%s: reset chip %d time", __func__, count);
576 }
577 return HDF_FAILURE;
578 }
579 #endif
580
ChipDriverInit(ChipDevice * chipDev)581 static int32_t ChipDriverInit(ChipDevice *chipDev)
582 {
583 int32_t count = 20; // 20: reset time
584 int32_t ret;
585 #if defined(CONFIG_ARCH_ROCKCHIP)
586 #if GTP_ESD_PROTECT
587 g_touchDriver = chipDev->driver;
588 #endif
589 ret = Gt1xRequestIo(chipDev);
590 CHECK_RETURN_VALUE(ret);
591 #endif
592 ret = SetTiming(chipDev, false);
593 CHECK_RETURN_VALUE(ret);
594
595 if ((chipDev->ops == NULL) || (chipDev->ops->Detect == NULL)) {
596 return HDF_FAILURE;
597 }
598
599 while (count --) {
600 OsalMSleep(100); // 100 : wait 100msthen try one time
601 ret = chipDev->ops->Detect(chipDev);
602 if (ret == HDF_SUCCESS) {
603 break;
604 }
605 HDF_LOGI("%s: reset chip %d time", __func__, count);
606 ChipReset(chipDev);
607 }
608 CHECK_RETURN_VALUE(ret);
609
610 #if GTP_ESD_PROTECT
611 gt1x_workqueue = create_singlethread_workqueue("gt1x_workthread");
612 if (gt1x_workqueue == NULL) {
613 HDF_LOGE("Create workqueue failed!");
614 }
615 Gt1xInitEsdProtect();
616 Gt1xEsdSwitch(1);
617 #endif
618
619 HDF_LOGI("%s: chipDetect succ, ret = %d ", __func__, ret);
620
621 #if defined(CONFIG_ARCH_SPRD) || defined(CONFIG_ARCH_ROCKCHIP) || defined(LOSCFG_PLATFORM_STM32MP157)
622 HDF_LOGI("%s: do not update firmware", __func__);
623 #elif defined(CONFIG_ARCH_NXP_TOUCH)
624 HDF_LOGI("%s: NXP TOUCH do not update firmware", __func__);
625 #else
626 ret = chipDev->ops->UpdateFirmware(chipDev);
627 CHECK_RETURN_VALUE(ret);
628 HDF_LOGI("%s: update firmware success", __func__);
629 #endif
630
631 ret = SetupChipIrq(chipDev);
632 CHECK_RETURN_VALUE(ret);
633 return HDF_SUCCESS;
634 }
635
InputDeviceInstance(ChipDevice * chipDev)636 static InputDevice *InputDeviceInstance(ChipDevice *chipDev)
637 {
638 InputDevice *inputDev = (InputDevice *)OsalMemAlloc(sizeof(InputDevice));
639 if (inputDev == NULL) {
640 HDF_LOGE("%s: instance input device failed", __func__);
641 return NULL;
642 }
643 (void)memset_s(inputDev, sizeof(InputDevice), 0, sizeof(InputDevice));
644
645 inputDev->hdfDevObj = chipDev->driver->hdfTouchDev;
646 inputDev->pvtData = (void *)chipDev;
647 inputDev->devType = chipDev->driver->boardCfg->attr.devType;
648 inputDev->devName = chipDev->driver->devName;
649
650 return inputDev;
651 }
652
ChipMatchCheck(const ChipDevice * chipDev,const TouchDriver * driver)653 static int32_t ChipMatchCheck(const ChipDevice *chipDev, const TouchDriver *driver)
654 {
655 const struct DeviceResourceNode *boardNode = driver->boardCfg->boardNode;
656 const struct DeviceResourceNode *chipNode = chipDev->chipCfg->chipNode;
657
658 if ((boardNode == NULL) || (boardNode->parent == NULL)) {
659 HDF_LOGE("%s: board node or upper node is null", __func__);
660 return HDF_FAILURE;
661 }
662
663 if ((chipNode == NULL) || (chipNode->parent == NULL) || (chipNode->parent->parent == NULL)) {
664 HDF_LOGE("%s: chip node or upper node is null ", __func__);
665 return HDF_FAILURE;
666 }
667
668 if (boardNode->parent == chipNode->parent->parent) {
669 HDF_LOGI("%s: boardNode's father name = %s, chipNode's grandpa name = %s", __func__,
670 boardNode->parent->name, chipNode->parent->parent->name);
671 return HDF_SUCCESS;
672 }
673 return HDF_FAILURE;
674 }
675
DeviceBindDriver(ChipDevice * chipDev)676 static int32_t DeviceBindDriver(ChipDevice *chipDev)
677 {
678 TouchDriver *driver = NULL;
679 int32_t ret = HDF_FAILURE;
680 int32_t i;
681 for (i = 0; i < MAX_TOUCH_DEVICE; i++) {
682 if ((g_touchDriverList[i] != NULL) && g_touchDriverList[i]->initedFlag) {
683 ret = ChipMatchCheck(chipDev, g_touchDriverList[i]);
684 if (ret == HDF_SUCCESS) {
685 driver = g_touchDriverList[i];
686 break;
687 }
688 }
689 }
690
691 if ((ret == HDF_FAILURE) || (driver == NULL)) {
692 return HDF_FAILURE;
693 }
694
695 driver->i2cClient.i2cCfg.addr = chipDev->chipCfg->bus.chipI2c.commAddr;
696 driver->device = chipDev;
697 chipDev->driver = driver;
698 chipDev->boardCfg = driver->boardCfg;
699 return HDF_SUCCESS;
700 }
701
RegisterTouchChipDevice(ChipDevice * chipDev)702 int32_t RegisterTouchChipDevice(ChipDevice *chipDev)
703 {
704 int32_t ret;
705 InputDevice *inputDev = NULL;
706 if ((chipDev == NULL) || (chipDev->chipCfg == NULL)) {
707 return HDF_ERR_INVALID_PARAM;
708 }
709
710 ret = DeviceBindDriver(chipDev);
711 if (ret != HDF_SUCCESS) {
712 HDF_LOGE("%s: chip device match driver failed", __func__);
713 return HDF_FAILURE;
714 }
715
716 ret = ChipDriverInit(chipDev);
717 if (ret != HDF_SUCCESS) {
718 goto EXIT;
719 }
720
721 inputDev = InputDeviceInstance(chipDev);
722 if (inputDev == NULL) {
723 return HDF_ERR_MALLOC_FAIL;
724 }
725
726 ret = RegisterInputDevice(inputDev);
727 if (ret != HDF_SUCCESS) {
728 goto EXIT1;
729 }
730 chipDev->driver->inputDev = inputDev;
731 chipDev->ops->SetAbility(chipDev);
732 return HDF_SUCCESS;
733
734 EXIT1:
735 OsalMemFree(inputDev);
736 EXIT:
737 chipDev->driver->device = NULL;
738 return HDF_FAILURE;
739 }
740
TouchGetDevType(TouchDriver * driver,struct HdfSBuf * reply)741 static int32_t TouchGetDevType(TouchDriver *driver, struct HdfSBuf *reply)
742 {
743 uint32_t devType = driver->devType;
744 HDF_LOGI("%s: enter, devType is %u", __func__, devType);
745 bool ret = HdfSbufWriteUint32(reply, devType);
746 if (!ret) {
747 HDF_LOGE("%s: HdfSbufWriteUint32 failed", __func__);
748 return HDF_FAILURE;
749 }
750 return HDF_SUCCESS;
751 }
752
TouchSetPowerStatus(TouchDriver * driver,struct HdfSBuf * data)753 static int32_t TouchSetPowerStatus(TouchDriver *driver, struct HdfSBuf *data)
754 {
755 uint32_t pwrStatus = 0;
756 bool ret = HdfSbufReadUint32(data, &pwrStatus);
757 if (!ret) {
758 HDF_LOGE("%s: HdfSbufWriteUint32 failed", __func__);
759 return HDF_FAILURE;
760 }
761 driver->pwrStatus = pwrStatus;
762 HDF_LOGI("%s: set power status is %u", __func__, pwrStatus);
763 return HDF_SUCCESS;
764 }
765
TouchGetPowerStatus(TouchDriver * driver,struct HdfSBuf * reply)766 static int32_t TouchGetPowerStatus(TouchDriver *driver, struct HdfSBuf *reply)
767 {
768 uint32_t pwrStatus = driver->pwrStatus;
769 bool ret = HdfSbufWriteUint32(reply, pwrStatus);
770 if (!ret) {
771 HDF_LOGE("%s: HdfSbufWriteUint32 failed", __func__);
772 return HDF_FAILURE;
773 }
774 HDF_LOGI("%s: get power status is %u", __func__, pwrStatus);
775 return HDF_SUCCESS;
776 }
777
TouchGetDeviceStrInfo(TouchDriver * driver,int32_t cmd,struct HdfSBuf * reply)778 static int32_t TouchGetDeviceStrInfo(TouchDriver *driver, int32_t cmd, struct HdfSBuf *reply)
779 {
780 const char *info = NULL;
781 if ((driver->device == NULL) || (driver->device->chipCfg == NULL)) {
782 HDF_LOGE("%s: parameter invalid", __func__);
783 return HDF_ERR_INVALID_PARAM;
784 }
785
786 switch (cmd) {
787 case GET_CHIP_NAME:
788 info = driver->device->chipName;
789 break;
790 case GET_VENDOR_NAME:
791 info = driver->device->vendorName;
792 break;
793 case GET_CHIP_INFO:
794 info = driver->device->chipCfg->chipInfo;
795 break;
796 default:
797 info = NULL;
798 break;
799 }
800
801 bool ret = HdfSbufWriteString(reply, info);
802 if (!ret) {
803 HDF_LOGE("%s: HdfSbufWriteUint32 failed", __func__);
804 return HDF_FAILURE;
805 }
806 HDF_LOGI("%s: cmd is %d, the info is %s", __func__, cmd, info);
807 return HDF_SUCCESS;
808 }
809
TouchGetDeviceAttr(TouchDriver * driver,struct HdfSBuf * reply)810 static int32_t TouchGetDeviceAttr(TouchDriver *driver, struct HdfSBuf *reply)
811 {
812 char *tempStr = "main_touch";
813 int32_t ret;
814 if (driver->inputDev == NULL) {
815 return HDF_FAILURE;
816 }
817
818 HDF_LOGE("%s: enter", __func__);
819 ret = strncpy_s(driver->inputDev->attrSet.devName, DEV_NAME_LEN, tempStr, strlen(tempStr));
820 if (ret != 0) {
821 HDF_LOGE("%s: strncpy dev attr failed", __func__);
822 return HDF_FAILURE;
823 }
824
825 if (!HdfSbufWriteBuffer(reply, &driver->inputDev->attrSet, sizeof(DevAttr))) {
826 HDF_LOGE("%s: sbuf write dev attr failed", __func__);
827 }
828
829 HDF_LOGI("%s: get dev attr succ", __func__);
830 return HDF_SUCCESS;
831 }
832
TouchGetDeviceAbility(TouchDriver * driver,struct HdfSBuf * reply)833 static int32_t TouchGetDeviceAbility(TouchDriver *driver, struct HdfSBuf *reply)
834 {
835 if (driver->inputDev == NULL) {
836 return HDF_FAILURE;
837 }
838 HDF_LOGE("%s: enter", __func__);
839
840 if (!HdfSbufWriteBuffer(reply, &driver->inputDev->abilitySet, sizeof(DevAbility))) {
841 HDF_LOGE("%s: sbuf write dev ability failed", __func__);
842 }
843
844 HDF_LOGI("%s: get dev ability succ", __func__);
845 return HDF_SUCCESS;
846 }
847
TouchSetGestureMode(TouchDriver * driver,struct HdfSBuf * data)848 static int32_t TouchSetGestureMode(TouchDriver *driver, struct HdfSBuf *data)
849 {
850 uint32_t gestureMode = 0;
851 bool ret = HdfSbufReadUint32(data, &gestureMode);
852 if (!ret) {
853 HDF_LOGE("%s: HdfSbufWriteUint32 failed", __func__);
854 return HDF_FAILURE;
855 }
856 driver->gestureMode = gestureMode;
857 HDF_LOGD("%s: set gesture mode is %u", __func__, gestureMode);
858 return HDF_SUCCESS;
859 }
860
TouchSelfCapacitance(TouchDriver * driver,struct HdfSBuf * data,struct HdfSBuf * reply)861 static int32_t TouchSelfCapacitance(TouchDriver *driver, struct HdfSBuf *data, struct HdfSBuf *reply)
862 {
863 CapacitanceTestInfo capacTest = {0};
864 bool ret = HdfSbufReadUint32(data, &capacTest.testType);
865 if (!ret) {
866 HDF_LOGE("%s: HdfSbufWriteUint32 failed", __func__);
867 return HDF_FAILURE;
868 }
869
870 if (strncpy_s(capacTest.testResult, SELF_TEST_RESULT_LEN, "SUCCESS", sizeof("SUCCESS")) != EOK) {
871 HDF_LOGE("%s: strncpy_s fail", __func__);
872 return HDF_FAILURE;
873 }
874
875 ret = HdfSbufWriteString(reply, (const char *)capacTest.testResult);
876 if (!ret) {
877 HDF_LOGE("%s: HdfSbufWriteString failed", __func__);
878 return HDF_FAILURE;
879 }
880 HDF_LOGD("%s: capac test type is %u, test result is %s", __func__, capacTest.testType, capacTest.testResult);
881 return HDF_SUCCESS;
882 }
883
TouchRunExtraCmd(TouchDriver * driver,struct HdfSBuf * data)884 static int32_t TouchRunExtraCmd(TouchDriver *driver, struct HdfSBuf *data)
885 {
886 InputExtraCmd cmd = {0};
887 cmd.cmdCode = HdfSbufReadString(data);
888 if (cmd.cmdCode == NULL) {
889 HDF_LOGE("%s: HdfSbufReadString failed", __func__);
890 return HDF_FAILURE;
891 }
892
893 cmd.cmdValue = HdfSbufReadString(data);
894 if (cmd.cmdValue == NULL) {
895 HDF_LOGE("%s: HdfSbufReadString failed", __func__);
896 return HDF_FAILURE;
897 }
898 HDF_LOGD("%s: extra cmd code is %s, cmd value is %s", __func__, cmd.cmdCode, cmd.cmdValue);
899 return HDF_SUCCESS;
900 }
901
HdfTouchDispatch(struct HdfDeviceIoClient * client,int32_t cmd,struct HdfSBuf * data,struct HdfSBuf * reply)902 static int32_t HdfTouchDispatch(struct HdfDeviceIoClient *client, int32_t cmd,
903 struct HdfSBuf *data, struct HdfSBuf *reply)
904 {
905 int32_t ret;
906 TouchDriver *touchDriver = NULL;
907 if ((client == NULL) || (client->device == NULL) || (data == NULL) || (reply == NULL)) {
908 HDF_LOGE("%s: param is null", __func__);
909 return HDF_FAILURE;
910 }
911
912 touchDriver = (TouchDriver *)client->device->priv;
913 if (touchDriver == NULL) {
914 HDF_LOGE("%s: touchDriver is null", __func__);
915 return HDF_FAILURE;
916 }
917
918 HDF_LOGI("%s: cmd = %d", __func__, cmd);
919 switch (cmd) {
920 case GET_DEV_TYPE:
921 ret = TouchGetDevType(touchDriver, reply);
922 break;
923 case SET_PWR_STATUS:
924 ret = TouchSetPowerStatus(touchDriver, data);
925 break;
926 case GET_PWR_STATUS:
927 ret = TouchGetPowerStatus(touchDriver, reply);
928 break;
929 case GET_CHIP_NAME:
930 case GET_VENDOR_NAME:
931 case GET_CHIP_INFO:
932 ret = TouchGetDeviceStrInfo(touchDriver, cmd, reply);
933 break;
934 case GET_DEV_ATTR:
935 ret = TouchGetDeviceAttr(touchDriver, reply);
936 break;
937 case GET_DEV_ABILITY:
938 ret = TouchGetDeviceAbility(touchDriver, reply);
939 break;
940 case SET_GESTURE_MODE:
941 ret = TouchSetGestureMode(touchDriver, data);
942 break;
943 case RUN_CAPAC_TEST:
944 ret = TouchSelfCapacitance(touchDriver, data, reply);
945 break;
946 case RUN_EXTRA_CMD:
947 ret = TouchRunExtraCmd(touchDriver, data);
948 break;
949 default:
950 ret = HDF_SUCCESS;
951 HDF_LOGE("%s: cmd unknown, cmd = 0x%x", __func__, cmd);
952 break;
953 }
954 return ret;
955 }
956
TouchSetupBus(TouchDriver * driver,TouchBoardCfg * config)957 static int32_t TouchSetupBus(TouchDriver *driver, TouchBoardCfg *config)
958 {
959 uint8_t busType = config->bus.busType;
960 uint8_t busNum = config->bus.i2c.busNum;
961 if (busType == I2C_TYPE) {
962 uint32_t i2cClkAddr = config->bus.i2c.i2cClkReg[0];
963 uint32_t i2cClkValue = config->bus.i2c.i2cClkReg[1];
964 uint32_t i2cDataAddr = config->bus.i2c.i2cDataReg[0];
965 uint32_t i2cDataValue = config->bus.i2c.i2cDataReg[1];
966
967 if (InputPinMuxCfg(i2cClkAddr, REGISTER_BYTE_SIZE, i2cClkValue) != HDF_SUCCESS) {
968 return HDF_FAILURE;
969 }
970 if (InputPinMuxCfg(i2cDataAddr, REGISTER_BYTE_SIZE, i2cDataValue) != HDF_SUCCESS) {
971 return HDF_FAILURE;
972 }
973
974 /* get i2c handle */
975 driver->i2cClient.i2cHandle = I2cOpen(busNum);
976 if (driver->i2cClient.i2cHandle == NULL) {
977 HDF_LOGE("%s: open i2c%u failed", __func__, busNum);
978 return HDF_FAILURE;
979 }
980 return HDF_SUCCESS;
981 }
982
983 if (busType == SPI_TYPE) {
984 HDF_LOGI("%s: setup spi bus succ", __func__);
985 return HDF_SUCCESS;
986 }
987
988 return HDF_FAILURE;
989 }
990
TouchInitData(TouchDriver * driver,TouchBoardCfg * config)991 static int32_t TouchInitData(TouchDriver *driver, TouchBoardCfg *config)
992 {
993 driver->devType = config->attr.devType;
994 driver->devName = config->attr.devName;
995 driver->i2cClient.i2cCfg.busNum = config->bus.i2c.busNum;
996 driver->irqStopFlag = false;
997
998 return HDF_SUCCESS;
999 }
1000
TouchDriverInit(TouchDriver * driver,TouchBoardCfg * config)1001 static int32_t TouchDriverInit(TouchDriver *driver, TouchBoardCfg *config)
1002 {
1003 int32_t ret = TouchInitData(driver, config);
1004 CHECK_RETURN_VALUE(ret);
1005
1006 ret = TouchSetupBus(driver, config);
1007 CHECK_RETURN_VALUE(ret);
1008
1009 ret = OsalMutexInit(&driver->mutex);
1010 CHECK_RETURN_VALUE(ret);
1011
1012 driver->initedFlag = true;
1013 return HDF_SUCCESS;
1014 }
1015
BoardConfigInstance(struct HdfDeviceObject * device)1016 static TouchBoardCfg *BoardConfigInstance(struct HdfDeviceObject *device)
1017 {
1018 TouchBoardCfg *boardCfg = (TouchBoardCfg *)OsalMemAlloc(sizeof(TouchBoardCfg));
1019 if (boardCfg == NULL) {
1020 HDF_LOGE("%s: instance board config failed", __func__);
1021 return NULL;
1022 }
1023 (void)memset_s(boardCfg, sizeof(TouchBoardCfg), 0, sizeof(TouchBoardCfg));
1024
1025 if (ParseTouchBoardConfig(device->property, boardCfg) != HDF_SUCCESS) {
1026 HDF_LOGE("%s: parse board config failed", __func__);
1027 OsalMemFree(boardCfg);
1028 boardCfg = NULL;
1029 }
1030 return boardCfg;
1031 }
1032
TouchDriverInstance(void)1033 static TouchDriver *TouchDriverInstance(void)
1034 {
1035 TouchDriver *touchDrv = (TouchDriver *)OsalMemAlloc(sizeof(TouchDriver));
1036 if (touchDrv == NULL) {
1037 HDF_LOGE("%s: instance touch driver failed", __func__);
1038 return NULL;
1039 }
1040 (void)memset_s(touchDrv, sizeof(TouchDriver), 0, sizeof(TouchDriver));
1041 return touchDrv;
1042 }
1043
AddTouchDriver(TouchDriver * driver)1044 static void AddTouchDriver(TouchDriver *driver)
1045 {
1046 int32_t i;
1047 for (i = 0; i < MAX_TOUCH_DEVICE; i++) {
1048 if (g_touchDriverList[i] == NULL) {
1049 g_touchDriverList[i] = driver;
1050 return;
1051 }
1052 }
1053 }
1054
HdfTouchDriverBind(struct HdfDeviceObject * device)1055 static int32_t HdfTouchDriverBind(struct HdfDeviceObject *device)
1056 {
1057 if (device == NULL) {
1058 HDF_LOGE("%s: param is null", __func__);
1059 return HDF_ERR_INVALID_PARAM;
1060 }
1061
1062 static struct IDeviceIoService touchService = {
1063 .Dispatch = HdfTouchDispatch,
1064 };
1065
1066 device->service = &touchService;
1067 return HDF_SUCCESS;
1068 }
1069 #if defined(CONFIG_ARCH_ROCKCHIP)
HdfTouchDriverDozeResume(struct HdfDeviceObject * device)1070 static int HdfTouchDriverDozeResume(struct HdfDeviceObject *device)
1071 {
1072 if (device == NULL) {
1073 HDF_LOGE("%s: param is null", __func__);
1074 return HDF_ERR_INVALID_PARAM;
1075 }
1076 HDF_LOGI("%s:called", __func__);
1077 #if GTP_ESD_PROTECT
1078 Gt1xEsdSwitch(1);
1079 #endif
1080 SuspendFlag = 0;
1081 static int32_t isFirstResume = 1;
1082 if (isFirstResume == 1) {
1083 isFirstResume = 0;
1084 return HDF_SUCCESS;
1085 }
1086 TouchDriver *touchDriver = (TouchDriver *)device->priv;
1087 ChipReset(touchDriver->device);
1088
1089 return HDF_SUCCESS;
1090 }
1091
HdfTouchDriverDozeSuspend(struct HdfDeviceObject * device)1092 static int HdfTouchDriverDozeSuspend(struct HdfDeviceObject *device)
1093 {
1094 if (device == NULL) {
1095 HDF_LOGE("%s: param is null", __func__);
1096 return HDF_ERR_INVALID_PARAM;
1097 }
1098 HDF_LOGI("%s:called", __func__);
1099 #if GTP_ESD_PROTECT
1100 Gt1xDeinitEsdProtect();
1101 #endif
1102 SuspendFlag = 1;
1103 int32_t ret = -1;
1104 uint8_t writeBuf[3]; // 3: buffer size
1105 uint16_t intGpioNum;
1106 TouchDriver *touchDriver = (TouchDriver *)device->priv;
1107 if (touchDriver == NULL || touchDriver->device == NULL || touchDriver->device->boardCfg == NULL) {
1108 HDF_LOGE("%s: invalid parameter.", __func__);
1109 return HDF_ERR_INVALID_PARAM;
1110 }
1111 intGpioNum = touchDriver->device->boardCfg->pins.intGpio;
1112
1113 GpioSetDir(intGpioNum, 1);
1114 GpioWrite(intGpioNum, 0);
1115
1116 writeBuf[0] = 0x80; // 0x42: reg address high bit
1117 writeBuf[1] = 0x40; // 0x26: reg address low bit
1118 writeBuf[2] = 0x05; // 0x01: reg value
1119 ret = InputI2cWrite(&touchDriver->i2cClient, writeBuf, 3); // 3: len
1120 HDF_LOGI("%s:ret = %d", __func__, ret);
1121
1122 return HDF_SUCCESS;
1123 }
1124
HdfTouchDriverRegisterPowerListener(struct HdfDeviceObject * device)1125 static void HdfTouchDriverRegisterPowerListener(struct HdfDeviceObject *device)
1126 {
1127 int ret;
1128 static struct IPowerEventListener powerListener = {0};
1129 HDF_LOGI("%s::enter!", __func__);
1130 powerListener.DozeResume = HdfTouchDriverDozeResume;
1131 powerListener.DozeSuspend = HdfTouchDriverDozeSuspend;
1132 powerListener.Resume = NULL;
1133 powerListener.Suspend = NULL;
1134
1135 ret = HdfPmRegisterPowerListener(device, &powerListener);
1136 HDF_LOGI("%s:register power listener, ret = %d", __func__, ret);
1137 }
1138
HdfTouchDriverUnregisterPowerListener(struct HdfDeviceObject * device)1139 static void HdfTouchDriverUnregisterPowerListener(struct HdfDeviceObject *device)
1140 {
1141 static struct IPowerEventListener powerListener = {0};
1142 HDF_LOGI("%s::enter!", __func__);
1143 powerListener.DozeResume = NULL;
1144 powerListener.DozeSuspend = NULL;
1145 powerListener.Resume = NULL;
1146 powerListener.Suspend = NULL;
1147
1148 HdfPmUnregisterPowerListener(device, &powerListener);
1149 }
1150 #endif
1151
HdfTouchDriverProbe(struct HdfDeviceObject * device)1152 static int32_t HdfTouchDriverProbe(struct HdfDeviceObject *device)
1153 {
1154 int32_t ret;
1155 TouchBoardCfg *boardCfg = NULL;
1156 TouchDriver *touchDriver = NULL;
1157
1158 HDF_LOGI("%s: enter", __func__);
1159 if (device == NULL) {
1160 HDF_LOGE("%s: param is null", __func__);
1161 return HDF_ERR_INVALID_PARAM;
1162 }
1163
1164 boardCfg = BoardConfigInstance(device);
1165 if (boardCfg == NULL) {
1166 return HDF_ERR_MALLOC_FAIL;
1167 }
1168 touchDriver = TouchDriverInstance();
1169 if (touchDriver == NULL) {
1170 goto EXIT;
1171 }
1172
1173 ret = TouchDriverInit(touchDriver, boardCfg);
1174 if (ret == HDF_SUCCESS) {
1175 touchDriver->hdfTouchDev = device;
1176 touchDriver->boardCfg = boardCfg;
1177 AddTouchDriver(touchDriver);
1178 device->priv = (void *)touchDriver;
1179 #if defined(CONFIG_ARCH_ROCKCHIP)
1180 HdfTouchDriverRegisterPowerListener(device);
1181 #endif
1182 HDF_LOGI("%s: %s exit succ", __func__, boardCfg->attr.devName);
1183 return HDF_SUCCESS;
1184 }
1185
1186 EXIT:
1187 OsalMemFree(boardCfg);
1188 if (touchDriver != NULL) {
1189 touchDriver->boardCfg = NULL;
1190 OsalMemFree(touchDriver);
1191 }
1192 return HDF_FAILURE;
1193 }
1194
HdfTouchDriverRelease(struct HdfDeviceObject * device)1195 static void HdfTouchDriverRelease(struct HdfDeviceObject *device)
1196 {
1197 TouchDriver *driver = NULL;
1198 InputDevice *inputDev = NULL;
1199 int32_t i;
1200
1201 if (device == NULL || device->priv == NULL) {
1202 HDF_LOGE("%s: param is null", __func__);
1203 return;
1204 }
1205 driver = device->priv;
1206
1207 for (i = 0; i < MAX_TOUCH_DEVICE; i++) {
1208 if (g_touchDriverList[i] == driver) {
1209 inputDev = driver->inputDev;
1210 break;
1211 }
1212 }
1213
1214 if (inputDev != NULL) {
1215 UnregisterInputDevice(inputDev);
1216 driver->inputDev = NULL;
1217 }
1218
1219 #if defined(CONFIG_ARCH_ROCKCHIP)
1220 HdfTouchDriverUnregisterPowerListener(device);
1221 #endif
1222
1223 OsalMutexDestroy(&driver->mutex);
1224 OsalMemFree(driver);
1225 if (i < MAX_TOUCH_DEVICE) {
1226 g_touchDriverList[i] = NULL;
1227 }
1228 }
1229
1230 struct HdfDriverEntry g_hdfTouchEntry = {
1231 .moduleVersion = 1,
1232 .moduleName = "HDF_TOUCH",
1233 .Bind = HdfTouchDriverBind,
1234 .Init = HdfTouchDriverProbe,
1235 .Release = HdfTouchDriverRelease,
1236 };
1237
1238 HDF_INIT(g_hdfTouchEntry);
1239