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