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 <securec.h>
10 #include "osal_mem.h"
11 #include "hdf_device_desc.h"
12 #include "hdf_log.h"
13 #include "hdf_touch.h"
14 #include "input_i2c_ops.h"
15 #include "touch_gt911.h"
16
17 #define MAX_POINT 5
18 #if defined(CONFIG_ARCH_ROCKCHIP)
19 #define GT5688_FIRMWARE_VERSION 256
20 #define GT911_FIRMWARE_VERSION 4192
21 #endif
22
ChipInit(ChipDevice * device)23 static int32_t ChipInit(ChipDevice *device)
24 {
25 return HDF_SUCCESS;
26 }
27
ChipResume(ChipDevice * device)28 static int32_t ChipResume(ChipDevice *device)
29 {
30 return HDF_SUCCESS;
31 }
32
ChipSuspend(ChipDevice * device)33 static int32_t ChipSuspend(ChipDevice *device)
34 {
35 return HDF_SUCCESS;
36 }
37
ChipDetect(ChipDevice * device)38 static int32_t ChipDetect(ChipDevice *device)
39 {
40 int32_t ret;
41 int32_t version;
42 int32_t xSolution;
43 int32_t ySolution;
44 InputI2cClient *i2cClient = &device->driver->i2cClient;
45 uint8_t buf[GT_CFG_INFO_LEN] = {0};
46 uint8_t reg[GT_ADDR_LEN] = {0};
47 reg[0] = (GT_CFG_INFO_ADDR >> ONE_BYTE_OFFSET) & ONE_BYTE_MASK;
48 reg[1] = GT_CFG_INFO_ADDR & ONE_BYTE_MASK;
49
50 ret = InputI2cRead(i2cClient, reg, GT_ADDR_LEN, buf, GT_CFG_INFO_LEN);
51 if (ret < 0) {
52 HDF_LOGE("%s: read chip version failed", __func__);
53 return HDF_FAILURE;
54 }
55
56 version = (buf[GT_FW_VER_HIGH] << ONE_BYTE_OFFSET) | buf[GT_FW_VER_LOW];
57 xSolution = (buf[GT_SOLU_X_HIGH] << ONE_BYTE_OFFSET) | buf[GT_SOLU_X_LOW];
58 ySolution = (buf[GT_SOLU_Y_HIGH] << ONE_BYTE_OFFSET) | buf[GT_SOLU_Y_LOW];
59 #if defined(CONFIG_ARCH_ROCKCHIP)
60 HDF_LOGI("%s:IC FW version is %d", __func__, version);
61 switch (version) {
62 case GT5688_FIRMWARE_VERSION:
63 HDF_LOGI("%s:TOUCH IC is GT5688", __func__);
64 break;
65 case GT911_FIRMWARE_VERSION:
66 HDF_LOGI("%s:TOUCH IC is GT911", __func__);
67 break;
68 default:
69 HDF_LOGE("%s: ID wrong,IC FW version is %d", __func__, version);
70 return HDF_FAILURE;
71 }
72 #endif
73 if (buf[GT_FW_VER_HIGH] == 0x0) {
74 HDF_LOGI("Product ID : %c%c%c_%02x%02x, xSol = %d, ySol = %d", buf[GT_PROD_ID_1ST], buf[GT_PROD_ID_2ND],
75 buf[GT_PROD_ID_3RD], buf[GT_FW_VER_HIGH], buf[GT_FW_VER_LOW], xSolution, ySolution);
76 } else {
77 HDF_LOGI("Product_ID: %c%c%c%c_%02x%02x, x_sol = %d, y_sol = %d", buf[GT_PROD_ID_1ST], buf[GT_PROD_ID_2ND],
78 buf[GT_PROD_ID_3RD], buf[GT_PROD_ID_4TH], buf[GT_FW_VER_HIGH], buf[GT_FW_VER_LOW], xSolution, ySolution);
79 }
80
81 (void)ChipInit(device);
82 (void)ChipResume(device);
83 (void)ChipSuspend(device);
84 return HDF_SUCCESS;
85 }
86
ChipCleanBuffer(InputI2cClient * i2cClient)87 static int ChipCleanBuffer(InputI2cClient *i2cClient)
88 {
89 int32_t ret;
90 uint8_t writeBuf[GT_CLEAN_DATA_LEN];
91 writeBuf[GT_REG_HIGH_POS] = (GT_BUF_STATE_ADDR >> ONE_BYTE_OFFSET) & ONE_BYTE_MASK;
92 writeBuf[GT_REG_LOW_POS] = GT_BUF_STATE_ADDR & ONE_BYTE_MASK;
93 writeBuf[GT_CLEAN_POS] = GT_CLEAN_FLAG;
94 ret = InputI2cWrite(i2cClient, writeBuf, GT_CLEAN_DATA_LEN);
95 if (ret != HDF_SUCCESS) {
96 HDF_LOGE("%s: InputI2cWrite failed, ret = %d", __func__, ret);
97 }
98 return ret;
99 }
100
101 #define X_OFFSET 1
102
ParsePointData(ChipDevice * device,FrameData * frame,uint8_t * buf,uint8_t pointNum)103 static void ParsePointData(ChipDevice *device, FrameData *frame, uint8_t *buf, uint8_t pointNum)
104 {
105 int32_t chipVer = device->chipCfg->chipVersion;
106 int32_t resX = device->driver->boardCfg->attr.resolutionX;
107 int32_t resY = device->driver->boardCfg->attr.resolutionY;
108 int32_t i;
109
110 for (i = 0; i < pointNum; i++) {
111 if (chipVer == 0) { // chipversion A:gt911_zsj5p5
112 frame->fingers[i].trackId = buf[GT_POINT_SIZE * i + GT_TRACK_ID];
113 #if defined(CONFIG_ARCH_SPRD)
114 frame->fingers[i].y = (resX - 1 - ((buf[GT_POINT_SIZE * i + GT_X_LOW] & ONE_BYTE_MASK) |
115 ((buf[GT_POINT_SIZE * i + GT_X_HIGH] & ONE_BYTE_MASK) <<
116 ONE_BYTE_OFFSET))) * resY / resX;
117 frame->fingers[i].x = ((buf[GT_POINT_SIZE * i + GT_Y_LOW] & ONE_BYTE_MASK) |
118 ((buf[GT_POINT_SIZE * i + GT_Y_HIGH] & ONE_BYTE_MASK) <<
119 ONE_BYTE_OFFSET)) * resX / resY;
120 #elif defined(CONFIG_ARCH_ROCKCHIP)
121 frame->fingers[i].x = resX - ((buf[GT_POINT_SIZE * i + GT_X_LOW] & ONE_BYTE_MASK) |
122 ((buf[GT_POINT_SIZE * i + GT_X_HIGH] & ONE_BYTE_MASK) << ONE_BYTE_OFFSET));
123 frame->fingers[i].y = resY - ((buf[GT_POINT_SIZE * i + GT_Y_LOW] & ONE_BYTE_MASK) |
124 ((buf[GT_POINT_SIZE * i + GT_Y_HIGH] & ONE_BYTE_MASK) << ONE_BYTE_OFFSET));
125 if (frame->fingers[i].y < GT_Y_OFFSET_A)
126 frame->fingers[i].y += CORRECTION_VALUE_A;
127 else if (frame->fingers[i].y < GT_Y_OFFSET_B)
128 frame->fingers[i].y += CORRECTION_VALUE_B;
129 else if (frame->fingers[i].y < GT_Y_OFFSET_C)
130 frame->fingers[i].y += CORRECTION_VALUE_C;
131 #elif defined(LOSCFG_PLATFORM_STM32MP157)
132 frame->fingers[i].x = (buf[GT_POINT_SIZE * i + GT_X_LOW] & ONE_BYTE_MASK) |
133 ((buf[GT_POINT_SIZE * i + GT_X_HIGH] & ONE_BYTE_MASK) << ONE_BYTE_OFFSET);
134 frame->fingers[i].y = (buf[GT_POINT_SIZE * i + GT_Y_LOW] & ONE_BYTE_MASK) |
135 ((buf[GT_POINT_SIZE * i + GT_Y_HIGH] & ONE_BYTE_MASK) << ONE_BYTE_OFFSET);
136 #else
137 frame->fingers[i].y = (buf[GT_POINT_SIZE * i + GT_X_LOW] & ONE_BYTE_MASK) |
138 ((buf[GT_POINT_SIZE * i + GT_X_HIGH] & ONE_BYTE_MASK) << ONE_BYTE_OFFSET);
139 frame->fingers[i].x = (buf[GT_POINT_SIZE * i + GT_Y_LOW] & ONE_BYTE_MASK) |
140 ((buf[GT_POINT_SIZE * i + GT_Y_HIGH] & ONE_BYTE_MASK) << ONE_BYTE_OFFSET);
141 #endif
142 if (frame->fingers[i].x == 0) {
143 frame->fingers[i].x = X_OFFSET;
144 }
145 } else if (chipVer == 1) { // chipversion B:gt911_zsj4p0
146 frame->fingers[i].x = resX - 1 - ((buf[GT_POINT_SIZE * i + GT_X_LOW] & ONE_BYTE_MASK) |
147 ((buf[GT_POINT_SIZE * i + GT_X_HIGH] & ONE_BYTE_MASK) << ONE_BYTE_OFFSET));
148 frame->fingers[i].y = resY - 1 - ((buf[GT_POINT_SIZE * i + GT_Y_LOW] & ONE_BYTE_MASK) |
149 ((buf[GT_POINT_SIZE * i + GT_Y_HIGH] & ONE_BYTE_MASK) << ONE_BYTE_OFFSET));
150 } else { // chipversion C:gt911_tg7p0
151 frame->fingers[i].x = resX - 1 - ((buf[GT_POINT_SIZE * i + GT_Y_LOW] & ONE_BYTE_MASK) |
152 ((buf[GT_POINT_SIZE * i + GT_Y_HIGH] & ONE_BYTE_MASK) << ONE_BYTE_OFFSET));
153 frame->fingers[i].y = resY - 1 - ((buf[GT_POINT_SIZE * i + GT_X_LOW] & ONE_BYTE_MASK) |
154 ((buf[GT_POINT_SIZE * i + GT_X_HIGH] & ONE_BYTE_MASK) << ONE_BYTE_OFFSET));
155 }
156 frame->fingers[i].valid = true;
157 }
158 }
159
ChipDataHandle(ChipDevice * device)160 static int32_t ChipDataHandle(ChipDevice *device)
161 {
162 int32_t ret;
163 uint8_t touchStatus = 0;
164 uint8_t pointNum;
165 uint8_t buf[GT_POINT_SIZE * MAX_SUPPORT_POINT] = {0};
166 InputI2cClient *i2cClient = &device->driver->i2cClient;
167 uint8_t reg[GT_ADDR_LEN] = {0};
168 FrameData *frame = &device->driver->frameData;
169
170 reg[0] = (GT_BUF_STATE_ADDR >> ONE_BYTE_OFFSET) & ONE_BYTE_MASK;
171 reg[1] = GT_BUF_STATE_ADDR & ONE_BYTE_MASK;
172 ret = InputI2cRead(i2cClient, reg, GT_ADDR_LEN, &touchStatus, 1);
173 if (ret < 0 || touchStatus == GT_EVENT_INVALID) {
174 return HDF_FAILURE;
175 }
176
177 OsalMutexLock(&device->driver->mutex);
178 (void)memset_s(frame, sizeof(FrameData), 0, sizeof(FrameData));
179 if (touchStatus == GT_EVENT_UP) {
180 frame->realPointNum = 0;
181 frame->definedEvent = TOUCH_UP;
182 goto EXIT;
183 }
184
185 reg[0] = (GT_X_LOW_BYTE_BASE >> ONE_BYTE_OFFSET) & ONE_BYTE_MASK;
186 reg[1] = GT_X_LOW_BYTE_BASE & ONE_BYTE_MASK;
187 pointNum = touchStatus & GT_FINGER_NUM_MASK;
188 if (pointNum == 0 || pointNum > MAX_SUPPORT_POINT) {
189 HDF_LOGE("%s: pointNum is invalid, %u", __func__, pointNum);
190 (void)ChipCleanBuffer(i2cClient);
191 OsalMutexUnlock(&device->driver->mutex);
192 return HDF_FAILURE;
193 }
194 frame->realPointNum = pointNum;
195 frame->definedEvent = TOUCH_DOWN;
196 (void)InputI2cRead(i2cClient, reg, GT_ADDR_LEN, buf, GT_POINT_SIZE * pointNum);
197 ParsePointData(device, frame, buf, pointNum);
198
199 EXIT:
200 OsalMutexUnlock(&device->driver->mutex);
201 if (ChipCleanBuffer(i2cClient) != HDF_SUCCESS) {
202 return HDF_FAILURE;
203 }
204 return HDF_SUCCESS;
205 }
206
UpdateFirmware(ChipDevice * device)207 static int32_t UpdateFirmware(ChipDevice *device)
208 {
209 int32_t ret;
210 InputI2cClient *i2cClient = &device->driver->i2cClient;
211 #if defined(CONFIG_ARCH_ROCKCHIP)
212 uint8_t buf[1] = {0};
213 uint8_t reg[GT_ADDR_LEN] = {0};
214
215 reg[0] = (GTP_REG_CONFIG_DATA >> ONE_BYTE_OFFSET) & ONE_BYTE_MASK;
216 reg[1] = GTP_REG_CONFIG_DATA & ONE_BYTE_MASK;
217 ret = InputI2cRead(i2cClient, reg, GT_ADDR_LEN, buf, 1);
218 if (ret < 0) {
219 HDF_LOGE("%s: read fw version failed", __func__);
220 return HDF_FAILURE;
221 }
222
223 HDF_LOGI("%s: buf[0]=0x%x", __func__, buf[0]);
224 if (buf[0] == firmWareParm[FIRMWARE_3RD]) {
225 HDF_LOGI("%s: needn't update fw version", __func__);
226 return HDF_SUCCESS;
227 }
228 #endif
229 ret = InputI2cWrite(i2cClient, firmWareParm, FIRMWARE_LEN);
230 if (ret < 0) {
231 return HDF_FAILURE;
232 }
233 HDF_LOGI("%s: update firmware success\n", __func__);
234 return HDF_SUCCESS;
235 }
236
SetAbility(ChipDevice * device)237 static void SetAbility(ChipDevice *device)
238 {
239 device->driver->inputDev->abilitySet.devProp[0] = SET_BIT(INPUT_PROP_DIRECT);
240 device->driver->inputDev->abilitySet.eventType[0] = SET_BIT(EV_SYN) |
241 SET_BIT(EV_KEY) | SET_BIT(EV_ABS);
242 device->driver->inputDev->abilitySet.absCode[0] = SET_BIT(ABS_X) | SET_BIT(ABS_Y);
243 device->driver->inputDev->abilitySet.absCode[1] = SET_BIT(ABS_MT_POSITION_X) |
244 SET_BIT(ABS_MT_POSITION_Y) | SET_BIT(ABS_MT_TRACKING_ID);
245 device->driver->inputDev->abilitySet.keyCode[KEY_CODE_4TH] = SET_BIT(KEY_UP) | SET_BIT(KEY_DOWN);
246 device->driver->inputDev->attrSet.axisInfo[ABS_X].min = 0;
247 device->driver->inputDev->attrSet.axisInfo[ABS_X].max = device->boardCfg->attr.resolutionX - 1;
248 device->driver->inputDev->attrSet.axisInfo[ABS_X].range = 0;
249 device->driver->inputDev->attrSet.axisInfo[ABS_Y].min = 0;
250 device->driver->inputDev->attrSet.axisInfo[ABS_Y].max = device->boardCfg->attr.resolutionY - 1;
251 device->driver->inputDev->attrSet.axisInfo[ABS_Y].range = 0;
252 device->driver->inputDev->attrSet.axisInfo[ABS_MT_POSITION_X].min = 0;
253 device->driver->inputDev->attrSet.axisInfo[ABS_MT_POSITION_X].max = device->boardCfg->attr.resolutionX - 1;
254 device->driver->inputDev->attrSet.axisInfo[ABS_MT_POSITION_X].range = 0;
255 device->driver->inputDev->attrSet.axisInfo[ABS_MT_POSITION_Y].min = 0;
256 device->driver->inputDev->attrSet.axisInfo[ABS_MT_POSITION_Y].max = device->boardCfg->attr.resolutionY - 1;
257 device->driver->inputDev->attrSet.axisInfo[ABS_MT_POSITION_Y].range = 0;
258 device->driver->inputDev->attrSet.axisInfo[ABS_MT_TRACKING_ID].max = MAX_POINT;
259 }
260
261 static struct TouchChipOps g_gt911ChipOps = {
262 .Init = ChipInit,
263 .Detect = ChipDetect,
264 .Resume = ChipResume,
265 .Suspend = ChipSuspend,
266 .DataHandle = ChipDataHandle,
267 .UpdateFirmware = UpdateFirmware,
268 .SetAbility = SetAbility,
269 };
270
ChipConfigInstance(struct HdfDeviceObject * device)271 static TouchChipCfg *ChipConfigInstance(struct HdfDeviceObject *device)
272 {
273 TouchChipCfg *chipCfg = (TouchChipCfg *)OsalMemAlloc(sizeof(TouchChipCfg));
274 if (chipCfg == NULL) {
275 HDF_LOGE("%s: instance chip config failed", __func__);
276 return NULL;
277 }
278 (void)memset_s(chipCfg, sizeof(TouchChipCfg), 0, sizeof(TouchChipCfg));
279
280 if (ParseTouchChipConfig(device->property, chipCfg) != HDF_SUCCESS) {
281 HDF_LOGE("%s: parse chip config failed", __func__);
282 OsalMemFree(chipCfg);
283 chipCfg = NULL;
284 }
285 return chipCfg;
286 }
287
ChipDeviceInstance(void)288 static ChipDevice *ChipDeviceInstance(void)
289 {
290 ChipDevice *chipDev = (ChipDevice *)OsalMemAlloc(sizeof(ChipDevice));
291 if (chipDev == NULL) {
292 HDF_LOGE("%s: instance chip device failed", __func__);
293 return NULL;
294 }
295 (void)memset_s(chipDev, sizeof(ChipDevice), 0, sizeof(ChipDevice));
296 return chipDev;
297 }
298
FreeChipConfig(TouchChipCfg * config)299 static void FreeChipConfig(TouchChipCfg *config)
300 {
301 if (config == NULL) {
302 HDF_LOGE("%s: param is null", __func__);
303 return;
304 }
305 if (config->pwrSeq.pwrOn.buf != NULL) {
306 OsalMemFree(config->pwrSeq.pwrOn.buf);
307 }
308
309 if (config->pwrSeq.pwrOff.buf != NULL) {
310 OsalMemFree(config->pwrSeq.pwrOff.buf);
311 }
312
313 if (config->pwrSeq.resume.buf != NULL) {
314 OsalMemFree(config->pwrSeq.resume.buf);
315 }
316
317 if (config->pwrSeq.suspend.buf != NULL) {
318 OsalMemFree(config->pwrSeq.suspend.buf);
319 }
320
321 OsalMemFree(config);
322 }
323
HdfGoodixChipInit(struct HdfDeviceObject * device)324 static int32_t HdfGoodixChipInit(struct HdfDeviceObject *device)
325 {
326 TouchChipCfg *chipCfg = NULL;
327 ChipDevice *chipDev = NULL;
328
329 HDF_LOGI("%s: enter", __func__);
330 if (device == NULL) {
331 return HDF_ERR_INVALID_PARAM;
332 }
333
334 chipCfg = ChipConfigInstance(device);
335 if (chipCfg == NULL) {
336 return HDF_ERR_MALLOC_FAIL;
337 }
338
339 chipDev = ChipDeviceInstance();
340 if (chipDev == NULL) {
341 goto EXIT;
342 }
343
344 chipDev->chipCfg = chipCfg;
345 chipDev->ops = &g_gt911ChipOps;
346 chipDev->chipName = chipCfg->chipName;
347 chipDev->vendorName = chipCfg->vendorName;
348 device->priv = (void *)chipDev;
349
350 if (RegisterTouchChipDevice(chipDev) != HDF_SUCCESS) {
351 goto EXIT1;
352 }
353 HDF_LOGI("%s: exit succ, chipName = %s", __func__, chipCfg->chipName);
354 return HDF_SUCCESS;
355
356 EXIT1:
357 OsalMemFree(chipDev);
358 EXIT:
359 FreeChipConfig(chipCfg);
360 return HDF_FAILURE;
361 }
362
HdfGoodixChipRelease(struct HdfDeviceObject * device)363 static void HdfGoodixChipRelease(struct HdfDeviceObject *device)
364 {
365 if (device == NULL || device->priv == NULL) {
366 HDF_LOGE("%s: param is null", __func__);
367 return;
368 }
369 HDF_LOGI("%s: goodix chip is release", __func__);
370 }
371
372 struct HdfDriverEntry g_touchGoodixChipEntry = {
373 .moduleVersion = 1,
374 .moduleName = "HDF_TOUCH_GT911",
375 .Init = HdfGoodixChipInit,
376 .Release = HdfGoodixChipRelease,
377 };
378
379 HDF_INIT(g_touchGoodixChipEntry);
380