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