touch: goodix: v1.2.4

1. add LICENSE

Change-Id: Ic6175bc334599d135cb85caa9066971dbb089be2
Signed-off-by: xulinkun <[email protected]>
Git-commit: 428deaecc357693de40f8bbce5cddb5b236232f6
Git-repo: https://github.com/goodix/goodix_ts_berlin
Signed-off-by: Fei Mao <[email protected]>

LICENSE

@@ -0,0 +1,16 @@
+  Copyright (c) 2003-2006, Goodix Technology Co, Ltd.
+  All Rights Reserved
+
+  This program is free software; you can redistribute it and/or modify it
+  under the terms of version 2 of the GNU General Public License as
+  published by the Free Software Foundation.
+
+  This program is distributed in the hope that it will be useful, but WITHOUT
+  ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+  FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+  more details.
+
+  You should have received a copy of the GNU General Public License along with
+  this program; if not, write to the Free Software Foundation, Inc., 59
+  Temple Place - Suite 330, Boston, MA  02111-1307, USA.
+

driver/Kconfig

@@ -0,0 +1,20 @@
+#
+# Goodix touchscreen driver configuration
+#
+menuconfig TOUCHSCREEN_GOODIX_BRL
+	tristate "Goodix berlin touchscreen"
+	help
+	  Say Y here if you have a Goodix berlin series touch controller
+	  to your system.
+	  
+	  If build module, say M.
+	  If unsure, say N.
+
+if TOUCHSCREEN_GOODIX_BRL
+
+config TOUCHSCREEN_GOODIX_BRL_SPI
+	bool "support SPI bus connection" 
+	help
+		Say Y here if the touchscreen is connected via SPI bus.
+
+endif

driver/Makefile

@@ -0,0 +1,12 @@
+obj-$(CONFIG_TOUCHSCREEN_GOODIX_BRL) += goodix_core.o
+goodix_core-y := \
+				goodix_brl_i2c.o \
+				goodix_brl_spi.o \
+				goodix_ts_core.o \
+				goodix_brl_hw.o \
+				goodix_cfg_bin.o \
+				goodix_ts_utils.o \
+				goodix_brl_fwupdate.o \
+				goodix_ts_gesture.o \
+				goodix_ts_inspect.o \
+				goodix_ts_tools.o

goodix_brl_fwupdate.c → driver/goodix_brl_fwupdate.c

@@ -1,19 +1,19 @@
- /*
-  * Goodix Touchscreen Driver
-  * Copyright (C) 2020 - 2021 Goodix, Inc.
-  *
-  * This program is free software; you can redistribute it and/or modify
-  * it under the terms of the GNU General Public License as published by
-  * the Free Software Foundation; either version 2 of the License, or
-  * (at your option) any later version.
-  *
-  * This program is distributed in the hope that it will be a reference
-  * to you, when you are integrating the GOODiX's CTP IC into your system,
-  * but WITHOUT ANY WARRANTY; without even the implied warranty of
-  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-  * General Public License for more details.
-  *
-  */
+/*
+ * Goodix Touchscreen Driver
+ * Copyright (C) 2020 - 2021 Goodix, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be a reference
+ * to you, when you are integrating the GOODiX's CTP IC into your system,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ */
 #include "goodix_ts_core.h"
 
 #define BUS_TYPE_SPI					1
@@ -191,8 +191,9 @@ struct  firmware_summary {
  * @firmware: firmware data structure
  */
 struct firmware_data {
-	struct  firmware_summary fw_summary;
+	struct firmware_summary fw_summary;
 	const struct firmware *firmware;
+	struct firmware *fw_sysfs;
 };
 
 struct config_data {
@@ -330,7 +331,11 @@ static int goodix_parse_firmware(struct firmware_data *fw_data)
 	fw_summary = &fw_data->fw_summary;
 
 	/* copy firmware head info */
-	firmware = fw_data->firmware;
+	if (goodix_fw_update_ctrl.mode & UPDATE_MODE_SRC_SYSFS)
+		firmware = fw_data->fw_sysfs;
+	else
+		firmware = fw_data->firmware;
+
 	if (firmware->size < subsys_info_offset) {
 		ts_err("Invalid firmware size:%zu", firmware->size);
 		r = -EINVAL;
@@ -342,7 +347,8 @@ static int goodix_parse_firmware(struct firmware_data *fw_data)
 	fw_summary->size = le32_to_cpu(fw_summary->size);
 	if (firmware->size != fw_summary->size + FW_FILE_CHECKSUM_OFFSET) {
 		ts_err("Bad firmware, size not match, %zu != %d",
-			firmware->size, fw_summary->size + 6);
+				firmware->size,
+				fw_summary->size + FW_FILE_CHECKSUM_OFFSET);
 		r = -EINVAL;
 		goto err_size;
 	}
@@ -709,7 +715,7 @@ static int goodix_send_flash_cmd(struct goodix_flash_cmd *flash_cmd)
 	}
 	ts_info("flash cmd ack check pass");
 
-	msleep(80);
+	msleep(50);
 	retry = 20;
 	for (i = 0; i < retry; i++) {
 		ret = goodix_reg_read(flash_cmd_reg,
@@ -721,8 +727,8 @@ static int goodix_send_flash_cmd(struct goodix_flash_cmd *flash_cmd)
 		}
 
 		ts_info("flash cmd status not ready, retry %d, ack 0x%x, status 0x%x, ret %d",
-			i, tmp_cmd.ack, tmp_cmd.status, ret);
-		msleep(20);
+				i, tmp_cmd.ack, tmp_cmd.status, ret);
+		usleep_range(10000, 11000);
 	}
 
 	ts_err("flash cmd status error %d, ack 0x%x, status 0x%x, ret %d",
@@ -944,10 +950,10 @@ int goodix_fw_update_proc(struct fw_update_ctrl *fwu_ctrl)
 	if (!(fwu_ctrl->mode & UPDATE_MODE_FORCE)) {
 		ret = goodix_fw_version_compare(fwu_ctrl);
 		if (!ret) {
-			ts_info("firmware upgraded");
+			ts_info("no need to upgrade");
 			return 0;
-		} else
-			ts_info("need to upgrade");
+		}
+		ts_info("need to upgrade");
 	}
 
 start_update:
@@ -1036,75 +1042,29 @@ static ssize_t goodix_sysfs_update_en_store(
 	return -EINVAL;
 }
 
-static ssize_t goodix_sysfs_fwsize_show(
-		struct device *dev, struct device_attribute *attr,
-		char *buf)
-{
-	struct fw_update_ctrl *fw_ctrl = &goodix_fw_update_ctrl;
-	int r = -EINVAL;
-
-	if (fw_ctrl && fw_ctrl->fw_data.firmware)
-		r = snprintf(buf, PAGE_SIZE, "%zu\n",
-				fw_ctrl->fw_data.firmware->size);
-	return r;
-}
-
-static ssize_t goodix_sysfs_fwsize_store(
-		struct device *dev, struct device_attribute *attr,
-		const char *buf, size_t count)
-{
-	struct fw_update_ctrl *fw_ctrl = &goodix_fw_update_ctrl;
-	struct firmware *fw;
-	u8 **data;
-	size_t size = 0;
-
-	if (!fw_ctrl)
-		return -EINVAL;
-
-	if (sscanf(buf, "%zu", &size) < 0 || !size) {
-		ts_err("Failed to get fwsize");
-		return -EFAULT;
-	}
-
-	/* use vmalloc to alloc huge memory */
-	fw = vmalloc(sizeof(*fw) + size);
-	if (!fw)
-		return -ENOMEM;
-	mutex_lock(&fw_ctrl->mutex);
-	memset(fw, 0x00, sizeof(*fw) + size);
-	data = (u8 **)&fw->data;
-	*data = (u8 *)fw + sizeof(struct firmware);
-	fw->size = size;
-	fw_ctrl->fw_data.firmware = fw;
-	fw_ctrl->mode = UPDATE_MODE_SRC_SYSFS;
-	mutex_unlock(&fw_ctrl->mutex);
-	return count;
-}
-
 static ssize_t goodix_sysfs_fwimage_store(struct file *file,
 		struct kobject *kobj, struct bin_attribute *attr,
 		char *buf, loff_t pos, size_t count)
 {
-	struct fw_update_ctrl *fw_ctrl = &goodix_fw_update_ctrl;
-	struct firmware_data *fw_data;
+	struct firmware **fw = &goodix_fw_update_ctrl.fw_data.fw_sysfs;
 
-	fw_data = &fw_ctrl->fw_data;
-
-	if (!fw_data->firmware) {
-		ts_err("Need set fw image size first");
-		return -ENOMEM;
-	}
-
-	if (fw_data->firmware->size == 0) {
-		ts_err("Invalid firmware size");
-		return -EINVAL;
+	if (*fw == NULL) {
+		*fw = kzalloc(sizeof(**fw), GFP_KERNEL);
+		if (*fw == NULL)
+			return -ENOMEM;
+		(*fw)->data = vmalloc(GOODIX_FW_MAX_SIEZE);
+		if ((*fw)->data == NULL) {
+			kfree(*fw);
+			*fw = NULL;
+			return -ENOMEM;
+		}
 	}
 
-	if (pos + count > fw_data->firmware->size)
+	if (pos + count > GOODIX_FW_MAX_SIEZE)
 		return -EFAULT;
-	mutex_lock(&fw_ctrl->mutex);
-	memcpy((u8 *)&fw_data->firmware->data[pos], buf, count);
-	mutex_unlock(&fw_ctrl->mutex);
+	memcpy((u8 *)&(*fw)->data[pos], buf, count);
+	(*fw)->size = pos + count;
+
 	return count;
 }
 
@@ -1146,13 +1106,10 @@ static ssize_t goodix_sysfs_result_show(
 }
 
 static DEVICE_ATTR(update_en, 0220, NULL, goodix_sysfs_update_en_store);
-static DEVICE_ATTR(fwsize, 0664, goodix_sysfs_fwsize_show,
-		goodix_sysfs_fwsize_store);
 static DEVICE_ATTR(result, 0664, goodix_sysfs_result_show, NULL);
 
 static struct attribute *goodix_fwu_attrs[] = {
 	&dev_attr_update_en.attr,
-	&dev_attr_fwsize.attr,
 	&dev_attr_result.attr
 };
 
@@ -1181,7 +1138,7 @@ static int goodix_fw_sysfs_init(struct goodix_ts_core *core_data,
 	}
 
 	fw_ctrl->attr_fwimage.attr.name = "fwimage";
-	fw_ctrl->attr_fwimage.attr.mode = 0666;
+	fw_ctrl->attr_fwimage.attr.mode = 0664;
 	fw_ctrl->attr_fwimage.size = 0;
 	fw_ctrl->attr_fwimage.write = goodix_sysfs_fwimage_store;
 	ret = sysfs_create_bin_file(fw_ctrl->kobj, &fw_ctrl->attr_fwimage);
@@ -1259,7 +1216,6 @@ static inline void goodix_release_firmware(struct firmware_data *fw_data)
 static int goodix_fw_update_thread(void *data)
 {
 	struct fw_update_ctrl *fwu_ctrl = data;
-	struct firmware *temp_firmware = NULL;
 	ktime_t start, end;
 	int r = -EINVAL;
 
@@ -1268,37 +1224,45 @@ static int goodix_fw_update_thread(void *data)
 	fwu_ctrl->status = UPSTA_NOTWORK;
 	mutex_lock(&fwu_ctrl->mutex);
 
+	ts_debug("notify update start");
+	goodix_ts_blocking_notify(NOTIFY_FWUPDATE_START, NULL);
+
 	if (fwu_ctrl->mode & UPDATE_MODE_SRC_REQUEST) {
 		ts_info("Firmware request update starts");
 		r = goodix_request_firmware(&fwu_ctrl->fw_data,
 						fwu_ctrl->fw_name);
 		if (r < 0)
 			goto out;
-
 	} else if (fwu_ctrl->mode & UPDATE_MODE_SRC_SYSFS) {
-		if (!fwu_ctrl->fw_data.firmware) {
+		if (!fwu_ctrl->fw_data.fw_sysfs) {
 			ts_err("Invalid firmware from sysfs");
 			r = -EINVAL;
 			goto out;
 		}
+		if (fwu_ctrl->fw_data.fw_sysfs->size < 4096) {
+			ts_err("Invalid firmware size[%ld] from sysfs",
+					fwu_ctrl->fw_data.fw_sysfs->size);
+			vfree(fwu_ctrl->fw_data.fw_sysfs->data);
+			kfree(fwu_ctrl->fw_data.fw_sysfs);
+			fwu_ctrl->fw_data.fw_sysfs = NULL;
+			r = -EINVAL;
+			goto out;
+		}
 	} else {
 		ts_err("unknown update mode 0x%x", fwu_ctrl->mode);
 		r = -EINVAL;
 		goto out;
 	}
 
-	ts_debug("notify update start");
-	goodix_ts_blocking_notify(NOTIFY_FWUPDATE_START, NULL);
-
 	/* ready to update */
 	ts_debug("start update proc");
 	r = goodix_fw_update_proc(fwu_ctrl);
 
 	/* clean */
-	if (fwu_ctrl->mode & UPDATE_MODE_SRC_HEAD) {
-		kfree(fwu_ctrl->fw_data.firmware);
-		fwu_ctrl->fw_data.firmware = NULL;
-		temp_firmware = NULL;
+	if (fwu_ctrl->mode & UPDATE_MODE_SRC_SYSFS) {
+		vfree(fwu_ctrl->fw_data.fw_sysfs->data);
+		kfree(fwu_ctrl->fw_data.fw_sysfs);
+		fwu_ctrl->fw_data.fw_sysfs = NULL;
 	} else if (fwu_ctrl->mode & UPDATE_MODE_SRC_REQUEST) {
 		goodix_release_firmware(&fwu_ctrl->fw_data);
 	}

goodix_brl_hw.c → driver/goodix_brl_hw.c

@@ -68,7 +68,7 @@ static int brl_select_spi_mode(struct goodix_ts_core *cd)
 		if (!ret && r_value == w_value)
 			return 0;
 	}
-	ts_err("failed switch SPI mode after reset, ret:%d r_value:%02x", ret, r_value);
+	ts_err("failed switch SPI mode, ret:%d r_value:%02x", ret, r_value);
 	return -EINVAL;
 }
 
@@ -151,7 +151,8 @@ static int brl_reset_after(struct goodix_ts_core *cd)
 			break;
 	}
 	if (retry < 0) {
-		ts_err("failed to enable group0 clock, ret:%d status:%02x", ret, temp_buf[0]);
+		ts_err("failed to enable group0 clock, ret:%d status:%02x",
+				ret, temp_buf[0]);
 		return -EINVAL;
 	}
 
@@ -165,7 +166,8 @@ static int brl_reset_after(struct goodix_ts_core *cd)
 			break;
 	}
 	if (retry < 0) {
-		ts_err("failed to enable group1 clock, ret:%d status:%02x", ret, temp_buf[0]);
+		ts_err("failed to enable group1 clock, ret:%d status:%02x",
+				ret, temp_buf[0]);
 		return -EINVAL;
 	}
 
@@ -179,7 +181,8 @@ static int brl_reset_after(struct goodix_ts_core *cd)
 			break;
 	}
 	if (retry < 0) {
-		ts_err("failed to set D12, ret:%d status:%02x", ret, temp_buf[0]);
+		ts_err("failed to set D12, ret:%d status:%02x",
+				ret, temp_buf[0]);
 		return -EINVAL;
 	}
 
@@ -272,12 +275,16 @@ int brl_resume(struct goodix_ts_core *cd)
 	return cd->hw_ops->reset(cd, GOODIX_NORMAL_RESET_DELAY_MS);
 }
 
-#define GOODIX_GESTURE_CMD	0x12
+#define GOODIX_GESTURE_CMD_BA	0x12
+#define GOODIX_GESTURE_CMD		0xA6
 int brl_gesture(struct goodix_ts_core *cd, int gesture_type)
 {
 	struct goodix_ts_cmd cmd;
 
-	cmd.cmd = GOODIX_GESTURE_CMD;
+	if (cd->bus->ic_type == IC_TYPE_BERLIN_A)
+		cmd.cmd = GOODIX_GESTURE_CMD_BA;
+	else
+		cmd.cmd = GOODIX_GESTURE_CMD;
 	cmd.len = 5;
 	cmd.data[0] = gesture_type;
 	if (cd->hw_ops->send_cmd(cd, &cmd))
@@ -375,7 +382,7 @@ static int brl_send_cmd(struct goodix_ts_core *cd,
 			ts_debug("cmd ack data %*ph",
 				 (int)sizeof(cmd_ack), cmd_ack.buf);
 			if (cmd_ack.ack == CMD_ACK_OK) {
-				usleep_range(2000, 2100);
+				msleep(40);		// wait for cmd response
 				return 0;
 			}
 			if (cmd_ack.ack == CMD_ACK_BUSY ||
@@ -1083,12 +1090,16 @@ static int goodix_touch_handler(struct goodix_ts_core *cd,
 		}
 	}
 
+	/* read done */
+	hw_ops->after_event_handler(cd);
+
 	if (touch_num > 0) {
 		point_type = buffer[IRQ_EVENT_HEAD_LEN] & 0x0F;
 		if (point_type == POINT_TYPE_STYLUS ||
 				point_type == POINT_TYPE_STYLUS_HOVER) {
 			ret = checksum_cmp(&buffer[IRQ_EVENT_HEAD_LEN],
-					BYTES_PER_POINT * 2 + 2, CHECKSUM_MODE_U8_LE);
+					BYTES_PER_POINT * 2 + 2,
+					CHECKSUM_MODE_U8_LE);
 			if (ret) {
 				ts_debug("touch data checksum error");
 				ts_debug("data:%*ph", BYTES_PER_POINT * 2 + 2,
@@ -1097,10 +1108,12 @@ static int goodix_touch_handler(struct goodix_ts_core *cd,
 			}
 		} else {
 			ret = checksum_cmp(&buffer[IRQ_EVENT_HEAD_LEN],
-					touch_num * BYTES_PER_POINT + 2, CHECKSUM_MODE_U8_LE);
+					touch_num * BYTES_PER_POINT + 2,
+					CHECKSUM_MODE_U8_LE);
 			if (ret) {
 				ts_debug("touch data checksum error");
-				ts_debug("data:%*ph", touch_num * BYTES_PER_POINT + 2,
+				ts_debug("data:%*ph",
+						touch_num * BYTES_PER_POINT + 2,
 						&buffer[IRQ_EVENT_HEAD_LEN]);
 				return -EINVAL;
 			}
@@ -1159,10 +1172,14 @@ static int brl_event_handler(struct goodix_ts_core *cd,
 		return ret;
 	}
 
+	if (pre_buf[0] == 0x00) {
+		ts_debug("invalid touch head");
+		return -EINVAL;
+	}
+
 	if (checksum_cmp(pre_buf, IRQ_EVENT_HEAD_LEN, CHECKSUM_MODE_U8_LE)) {
-		ts_debug("touch head checksum err");
-		ts_debug("touch_head %*ph", IRQ_EVENT_HEAD_LEN, pre_buf);
-		ts_event->retry = 1;
+		ts_debug("touch head checksum err[%*ph]",
+				IRQ_EVENT_HEAD_LEN, pre_buf);
 		return -EINVAL;
 	}
 
@@ -1180,10 +1197,16 @@ static int brl_event_handler(struct goodix_ts_core *cd,
 		else
 			ts_debug("unsupported request code 0x%x", pre_buf[2]);
 	}
+
 	if (event_status & GOODIX_GESTURE_EVENT) {
 		ts_event->event_type = EVENT_GESTURE;
 		ts_event->gesture_type = pre_buf[4];
+		memcpy(ts_event->gesture_data, &pre_buf[8],
+				GOODIX_GESTURE_DATA_LEN);
 	}
+	/* read done */
+	hw_ops->after_event_handler(cd);
+
 	return 0;
 }
 
@@ -1193,6 +1216,8 @@ static int brl_after_event_handler(struct goodix_ts_core *cd)
 	struct goodix_ic_info_misc *misc = &cd->ic_info.misc;
 	u8 sync_clean = 0;
 
+	if (cd->tools_ctrl_sync)
+		return 0;
 	return hw_ops->write(cd, misc->touch_data_addr,
 		&sync_clean, 1);
 }
@@ -1233,13 +1258,15 @@ static int brld_get_framedata(struct goodix_ts_core *cd,
 		return ret;
 	}
 
-	if (checksum_cmp(frame_buf, cd->ic_info.misc.frame_data_head_len, CHECKSUM_MODE_U8_LE)) {
+	if (checksum_cmp(frame_buf, cd->ic_info.misc.frame_data_head_len,
+			CHECKSUM_MODE_U8_LE)) {
 		ts_err("frame head checksum error");
 		return -EINVAL;
 	}
 
 	frame_head = (struct frame_head *)frame_buf;
-	if (checksum_cmp(frame_buf, frame_head->cur_frame_len, CHECKSUM_MODE_U16_LE)) {
+	if (checksum_cmp(frame_buf, frame_head->cur_frame_len,
+			CHECKSUM_MODE_U16_LE)) {
 		ts_err("frame body checksum error");
 		return -EINVAL;
 	}

goodix_brl_spi.c → driver/goodix_brl_spi.c

@@ -24,7 +24,8 @@
 #define SPI_TRANS_PREFIX_LEN    1
 #define REGISTER_WIDTH          4
 #define SPI_READ_DUMMY_LEN      4
-#define SPI_READ_PREFIX_LEN  (SPI_TRANS_PREFIX_LEN + REGISTER_WIDTH + SPI_READ_DUMMY_LEN)
+#define SPI_READ_PREFIX_LEN  \
+		(SPI_TRANS_PREFIX_LEN + REGISTER_WIDTH + SPI_READ_DUMMY_LEN)
 #define SPI_WRITE_PREFIX_LEN (SPI_TRANS_PREFIX_LEN + REGISTER_WIDTH)
 
 #define SPI_WRITE_FLAG  0xF0
@@ -80,7 +81,7 @@ static int goodix_spi_read_bra(struct device *dev, unsigned int addr,
 	spi_message_add_tail(&xfers, &spi_msg);
 	ret = spi_sync(spi, &spi_msg);
 	if (ret < 0) {
-		ts_err("spi transfer error:%d",ret);
+		ts_err("spi transfer error:%d", ret);
 		goto exit;
 	}
 	memcpy(data, &rx_buf[SPI_READ_PREFIX_LEN], len);
@@ -129,7 +130,7 @@ static int goodix_spi_read(struct device *dev, unsigned int addr,
 	spi_message_add_tail(&xfers, &spi_msg);
 	ret = spi_sync(spi, &spi_msg);
 	if (ret < 0) {
-		ts_err("spi transfer error:%d",ret);
+		ts_err("spi transfer error:%d", ret);
 		goto exit;
 	}
 	memcpy(data, &rx_buf[SPI_READ_PREFIX_LEN - 1], len);
@@ -158,11 +159,8 @@ static int goodix_spi_write(struct device *dev, unsigned int addr,
 	int ret = 0;
 
 	tx_buf = kzalloc(SPI_WRITE_PREFIX_LEN + len, GFP_KERNEL);
-	if (!tx_buf) {
-		ts_err("alloc tx_buf failed, size:%d",
-			SPI_WRITE_PREFIX_LEN + len);
+	if (!tx_buf)
 		return -ENOMEM;
-	}
 
 	spi_message_init(&spi_msg);
 	memset(&xfers, 0, sizeof(xfers));
@@ -179,7 +177,7 @@ static int goodix_spi_write(struct device *dev, unsigned int addr,
 	spi_message_add_tail(&xfers, &spi_msg);
 	ret = spi_sync(spi, &spi_msg);
 	if (ret < 0)
-		ts_err("spi transfer error:%d",ret);
+		ts_err("spi transfer error:%d", ret);
 
 	kfree(tx_buf);
 	return ret;

goodix_cfg_bin.c → driver/goodix_cfg_bin.c

@@ -21,11 +21,15 @@
 #define TS_CFG_BIN_HEAD_RESERVED_LEN	6
 #define TS_CFG_OFFSET_LEN				2
 #define TS_IC_TYPE_NAME_MAX_LEN			15
-#define TS_CFG_BIN_HEAD_LEN		(sizeof(struct goodix_cfg_bin_head) + \
-					TS_CFG_BIN_HEAD_RESERVED_LEN)
-#define TS_PKG_CONST_INFO_LEN	(sizeof(struct goodix_cfg_pkg_const_info))
-#define TS_PKG_REG_INFO_LEN		(sizeof(struct goodix_cfg_pkg_reg_info))
-#define TS_PKG_HEAD_LEN			(TS_PKG_CONST_INFO_LEN + TS_PKG_REG_INFO_LEN)
+#define TS_CFG_BIN_HEAD_LEN \
+		(sizeof(struct goodix_cfg_bin_head) + \
+		TS_CFG_BIN_HEAD_RESERVED_LEN)
+#define TS_PKG_CONST_INFO_LEN \
+		(sizeof(struct goodix_cfg_pkg_const_info))
+#define TS_PKG_REG_INFO_LEN	\
+		(sizeof(struct goodix_cfg_pkg_reg_info))
+#define TS_PKG_HEAD_LEN \
+		(TS_PKG_CONST_INFO_LEN + TS_PKG_REG_INFO_LEN)
 
 /*cfg block definitin*/
 #define TS_CFG_BLOCK_PID_LEN		8
@@ -34,9 +38,9 @@
 #define TS_CFG_BLOCK_FW_PATCH_LEN	4
 #define TS_CFG_BLOCK_RESERVED_LEN	9
 
-#define TS_NORMAL_CFG 				0x01
-#define TS_HIGH_SENSE_CFG 			0x03
-#define TS_RQST_FW_RETRY_TIMES 		2
+#define TS_NORMAL_CFG				0x01
+#define TS_HIGH_SENSE_CFG			0x03
+#define TS_RQST_FW_RETRY_TIMES		2
 
 #pragma pack(1)
 struct goodix_cfg_pkg_reg {
@@ -100,7 +104,7 @@ struct goodix_cfg_bin {
 	struct goodix_cfg_package *cfg_pkgs;
 };
 
-static int goodix_read_cfg_bin(struct device *dev, const char *cfg_name, 
+static int goodix_read_cfg_bin(struct device *dev, const char *cfg_name,
 			struct goodix_cfg_bin *cfg_bin)
 {
 	const struct firmware *firmware = NULL;
@@ -167,9 +171,9 @@ static int goodix_parse_cfg_bin(struct goodix_cfg_bin *cfg_bin)
 
 	/*check cfg_bin valid*/
 	checksum = 0;
-	for (i = TS_BIN_VERSION_START_INDEX; i < cfg_bin->bin_data_len; i++) {
+	for (i = TS_BIN_VERSION_START_INDEX; i < cfg_bin->bin_data_len; i++)
 		checksum += cfg_bin->bin_data[i];
-	}
+
 	if (checksum != cfg_bin->head.checksum) {
 		ts_err("cfg_bin checksum check filed 0x%02x != 0x%02x",
 		       cfg_bin->head.checksum, checksum);
@@ -179,28 +183,34 @@ static int goodix_parse_cfg_bin(struct goodix_cfg_bin *cfg_bin)
 	/*allocate memory for cfg packages*/
 	cfg_bin->cfg_pkgs = kzalloc(sizeof(struct goodix_cfg_package) *
 				    cfg_bin->head.pkg_num, GFP_KERNEL);
-	if (!cfg_bin->cfg_pkgs) {
-		ts_err("cfg_pkgs, allocate memory ERROR");
+	if (!cfg_bin->cfg_pkgs)
 		return -ENOMEM;
-	}
 
 	/*get cfg_pkg's info*/
 	for (i = 0; i < cfg_bin->head.pkg_num; i++) {
 		/*get cfg pkg length*/
 		if (i == cfg_bin->head.pkg_num - 1) {
-			offset1 = cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN + i * TS_CFG_OFFSET_LEN] +
-				(cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN + i * TS_CFG_OFFSET_LEN + 1] << 8);
+			offset1 = cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN +
+					i * TS_CFG_OFFSET_LEN] +
+					(cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN +
+					i * TS_CFG_OFFSET_LEN + 1] << 8);
 
-			cfg_bin->cfg_pkgs[i].pkg_len = cfg_bin->bin_data_len - offset1;
+			cfg_bin->cfg_pkgs[i].pkg_len =
+					cfg_bin->bin_data_len - offset1;
 		} else {
-			offset1 = cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN + i * TS_CFG_OFFSET_LEN] +
-				(cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN + i * TS_CFG_OFFSET_LEN + 1] << 8);
+			offset1 = cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN +
+					i * TS_CFG_OFFSET_LEN] +
+					(cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN +
+					i * TS_CFG_OFFSET_LEN + 1] << 8);
 
-			offset2 = cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN + i * TS_CFG_OFFSET_LEN + 2] +
-				(cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN + i * TS_CFG_OFFSET_LEN + 3] << 8);
+			offset2 = cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN +
+					i * TS_CFG_OFFSET_LEN + 2] +
+					(cfg_bin->bin_data[TS_CFG_BIN_HEAD_LEN +
+					i * TS_CFG_OFFSET_LEN + 3] << 8);
 
 			if (offset2 <= offset1) {
-				ts_err("offset error,pkg:%d, offset1:%d, offset2:%d", i, offset1, offset2);
+				ts_err("offset error,pkg:%d, offset1:%d, offset2:%d",
+						i, offset1, offset2);
 				goto exit;
 			}
 
@@ -214,12 +224,15 @@ static int goodix_parse_cfg_bin(struct goodix_cfg_bin *cfg_bin)
 		       TS_PKG_REG_INFO_LEN);
 
 		/*get configuration data*/
-		cfg_bin->cfg_pkgs[i].cfg = &cfg_bin->bin_data[offset1 + TS_PKG_HEAD_LEN];
+		cfg_bin->cfg_pkgs[i].cfg =
+				&cfg_bin->bin_data[offset1 + TS_PKG_HEAD_LEN];
 	}
 
 	/*debug, print pkg information*/
-	ts_info("Driver bin info: ver %s, len %d, pkgs %d", cfg_bin->head.bin_version,
-		cfg_bin->head.bin_len, cfg_bin->head.pkg_num);
+	ts_info("Driver bin info: ver %s, len %d, pkgs %d",
+			cfg_bin->head.bin_version,
+			cfg_bin->head.bin_len,
+			cfg_bin->head.pkg_num);
 
 	return 0;
 exit:
@@ -268,7 +281,9 @@ static int goodix_get_reg_and_cfg(struct goodix_ts_core *cd, u8 sensor_id,
 				sensor_id);
 			continue;
 		}
-		cd->ic_configs[cfg_type] = kzalloc(sizeof(struct goodix_ic_config), GFP_KERNEL);
+		cd->ic_configs[cfg_type] =
+				kzalloc(sizeof(struct goodix_ic_config),
+				GFP_KERNEL);
 		if (!cd->ic_configs[cfg_type])
 			goto err_out;
 		cd->ic_configs[cfg_type]->len = cfg_len;
@@ -281,8 +296,7 @@ static int goodix_get_reg_and_cfg(struct goodix_ts_core *cd, u8 sensor_id,
 err_out:
 	/* parse config enter error, release memory alloced */
 	for (i = 0; i < GOODIX_MAX_CONFIG_GROUP; i++) {
-		if (cd->ic_configs[i])
-			kfree(cd->ic_configs[i]);
+		kfree(cd->ic_configs[i]);
 		cd->ic_configs[i] = NULL;
 	}
 	return -EINVAL;

goodix_ts_core.c → driver/goodix_ts_core.c

@@ -27,7 +27,7 @@
 
 #include "goodix_ts_core.h"
 
-#define GOODIX_DEFAULT_CFG_NAME 	"goodix_cfg_group.cfg"
+#define GOODIX_DEFAULT_CFG_NAME		"goodix_cfg_group.cfg"
 #define GOOIDX_INPUT_PHYS			"goodix_ts/input0"
 
 struct goodix_module goodix_modules;
@@ -91,7 +91,8 @@ static int __do_register_ext_module(struct goodix_ext_module *module)
 	return 0;
 }
 
-static void goodix_register_ext_module_work(struct work_struct *work) {
+static void goodix_register_ext_module_work(struct work_struct *work)
+{
 	struct goodix_ext_module *module =
 			container_of(work, struct goodix_ext_module, work);
 
@@ -132,13 +133,13 @@ int goodix_register_ext_module(struct goodix_ext_module *module)
 	if (!module)
 		return -EINVAL;
 
-	ts_info("goodix_register_ext_module IN");
+	ts_info("IN");
 
 	goodix_core_module_init();
 	INIT_WORK(&module->work, goodix_register_ext_module_work);
 	schedule_work(&module->work);
 
-	ts_info("goodix_register_ext_module OUT");
+	ts_info("OUT");
 	return 0;
 }
 
@@ -150,7 +151,8 @@ int goodix_register_ext_module_no_wait(struct goodix_ext_module *module)
 {
 	if (!module)
 		return -EINVAL;
-	ts_info("goodix_register_ext_module_no_wait IN");
+
+	ts_info("IN");
 	goodix_core_module_init();
 	/* driver probe failed */
 	if (core_module_prob_sate != CORE_MODULE_PROB_SUCCESS) {
@@ -273,7 +275,7 @@ struct kobject *goodix_get_default_kobj(void)
 }
 
 /* show driver infomation */
-static ssize_t goodix_ts_driver_info_show(struct device *dev,
+static ssize_t driver_info_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	return snprintf(buf, PAGE_SIZE, "DriverVersion:%s\n",
@@ -281,20 +283,22 @@ static ssize_t goodix_ts_driver_info_show(struct device *dev,
 }
 
 /* show chip infoamtion */
-static ssize_t goodix_ts_chip_info_show(struct device  *dev,
+static ssize_t chip_info_show(struct device  *dev,
 		struct device_attribute *attr, char *buf)
 {
-	struct goodix_ts_core *core_data = dev_get_drvdata(dev);
-	struct goodix_ts_hw_ops *hw_ops = core_data->hw_ops;
+	struct goodix_ts_core *cd = dev_get_drvdata(dev);
+	struct goodix_ts_hw_ops *hw_ops = cd->hw_ops;
 	struct goodix_fw_version chip_ver;
+	struct goodix_ic_info ic_info;
 	u8 temp_pid[8] = {0};
 	int ret;
 	int cnt = -EINVAL;
 
 	if (hw_ops->read_version) {
-		ret = hw_ops->read_version(core_data, &chip_ver);
+		ret = hw_ops->read_version(cd, &chip_ver);
 		if (!ret) {
-			memcpy(temp_pid, chip_ver.rom_pid, sizeof(chip_ver.rom_pid));
+			memcpy(temp_pid, chip_ver.rom_pid,
+					sizeof(chip_ver.rom_pid));
 			cnt = snprintf(&buf[0], PAGE_SIZE,
 				"rom_pid:%s\nrom_vid:%02x%02x%02x\n",
 				temp_pid, chip_ver.rom_vid[0],
@@ -310,12 +314,14 @@ static ssize_t goodix_ts_chip_info_show(struct device  *dev,
 	}
 
 	if (hw_ops->get_ic_info) {
-		ret = hw_ops->get_ic_info(core_data, &core_data->ic_info);
+		ret = hw_ops->get_ic_info(cd, &ic_info);
 		if (!ret) {
 			cnt += snprintf(&buf[cnt], PAGE_SIZE,
-				"config_id:%x\n", core_data->ic_info.version.config_id);
+					"config_id:%x\n",
+					ic_info.version.config_id);
 			cnt += snprintf(&buf[cnt], PAGE_SIZE,
-				"config_version:%x\n", core_data->ic_info.version.config_version);
+					"config_version:%x\n",
+					ic_info.version.config_version);
 		}
 	}
 
@@ -339,7 +345,7 @@ static ssize_t goodix_ts_reset_store(struct device *dev,
 }
 
 /* read config */
-static ssize_t goodix_ts_read_cfg_show(struct device *dev,
+static ssize_t read_cfg_show(struct device *dev,
 					struct device_attribute *attr,
 					char *buf)
 {
@@ -415,9 +421,8 @@ static int goodix_ts_convert_0x_data(const u8 *buf, int buf_size,
 			continue;
 
 		if (temp_index >= m_size) {
-			ts_err("exchange cfg data error, overflow,"
-			       "temp_index:%d,m_size:%d",
-			       temp_index, m_size);
+			ts_err("exchange cfg data error, overflow, temp_index:%d,m_size:%d",
+					temp_index, m_size);
 			return -EINVAL;
 		}
 		high = ascii2hex(buf[i + 1]);
@@ -441,13 +446,9 @@ static ssize_t goodix_ts_send_cfg_store(struct device *dev,
 	struct goodix_ts_hw_ops *hw_ops = core_data->hw_ops;
 	struct goodix_ic_config *config = NULL;
 	const struct firmware *cfg_img = NULL;
-	int en;
 	int ret;
 
-	if (sscanf(buf, "%d", &en) != 1)
-		return -EINVAL;
-
-	if (en != 1)
+	if (buf[0] != '1')
 		return -EINVAL;
 
 	hw_ops->irq_enable(core_data, false);
@@ -476,7 +477,7 @@ static ssize_t goodix_ts_send_cfg_store(struct device *dev,
 		if (ret < 0)
 			ts_err("send config failed");
 	}
-		
+
 exit:
 	hw_ops->irq_enable(core_data, true);
 	kfree(config);
@@ -513,7 +514,8 @@ static ssize_t goodix_ts_reg_rw_show(struct device *dev,
 	ret = hw_ops->read(core_data, rw_addr, show_buf, rw_len);
 	if (ret < 0) {
 		ts_err("failed read addr(%x) length(%d)", rw_addr, rw_len);
-		return snprintf(buf, PAGE_SIZE, "failed read addr(%x), len(%d)\n",
+		return snprintf(buf, PAGE_SIZE,
+			"failed read addr(%x), len(%d)\n",
 			rw_addr, rw_len);
 	}
 
@@ -692,7 +694,7 @@ static ssize_t goodix_ts_esd_info_show(struct device *dev,
 		     "enabled" : "disabled");
 
 	return r;
-}					   
+}
 
 /* enable/disable esd */
 static ssize_t goodix_ts_esd_info_store(struct device *dev,
@@ -736,17 +738,26 @@ static ssize_t goodix_ts_debug_log_store(struct device *dev,
 	else
 		debug_log_flag = false;
 	return count;
-}					
-
-static DEVICE_ATTR(driver_info, 0444, goodix_ts_driver_info_show, NULL);
-static DEVICE_ATTR(chip_info, 0444, goodix_ts_chip_info_show, NULL);
-static DEVICE_ATTR(reset, 0220, NULL, goodix_ts_reset_store);
-static DEVICE_ATTR(send_cfg, 0220, NULL, goodix_ts_send_cfg_store);
-static DEVICE_ATTR(read_cfg, 0444, goodix_ts_read_cfg_show, NULL);
-static DEVICE_ATTR(reg_rw, 0664, goodix_ts_reg_rw_show, goodix_ts_reg_rw_store);
-static DEVICE_ATTR(irq_info, 0664, goodix_ts_irq_info_show, goodix_ts_irq_info_store);
-static DEVICE_ATTR(esd_info, 0664, goodix_ts_esd_info_show, goodix_ts_esd_info_store);
-static DEVICE_ATTR(debug_log, 0664, goodix_ts_debug_log_show, goodix_ts_debug_log_store);
+}
+
+static DEVICE_ATTR(driver_info, 0440,
+		driver_info_show, NULL);
+static DEVICE_ATTR(chip_info, 0440,
+		chip_info_show, NULL);
+static DEVICE_ATTR(reset, 0220,
+		NULL, goodix_ts_reset_store);
+static DEVICE_ATTR(send_cfg, 0220,
+		NULL, goodix_ts_send_cfg_store);
+static DEVICE_ATTR(read_cfg, 0440,
+		read_cfg_show, NULL);
+static DEVICE_ATTR(reg_rw, 0664,
+		goodix_ts_reg_rw_show, goodix_ts_reg_rw_store);
+static DEVICE_ATTR(irq_info, 0664,
+		goodix_ts_irq_info_show, goodix_ts_irq_info_store);
+static DEVICE_ATTR(esd_info, 0664,
+		goodix_ts_esd_info_show, goodix_ts_esd_info_store);
+static DEVICE_ATTR(debug_log, 0664,
+		goodix_ts_debug_log_show, goodix_ts_debug_log_store);
 
 static struct attribute *sysfs_attrs[] = {
 	&dev_attr_driver_info.attr,
@@ -794,16 +805,12 @@ static int rawdata_proc_show(struct seq_file *m, void *v)
 	int i;
 	int index;
 
-	if (!m || !v || !cd) {
-		ts_err("rawdata_proc_show, input null ptr");
+	if (!m || !v || !cd)
 		return -EIO;
-	}
 
 	info = kzalloc(sizeof(*info), GFP_KERNEL);
-	if (!info) {
-		ts_err("Failed to alloc rawdata info memory");
+	if (!info)
 		return -ENOMEM;
-	}
 
 	ret = cd->hw_ops->get_capacitance_data(cd, info);
 	if (ret < 0) {
@@ -814,19 +821,19 @@ static int rawdata_proc_show(struct seq_file *m, void *v)
 	rx = info->buff[0];
 	tx = info->buff[1];
 	seq_printf(m, "TX:%d  RX:%d\n", tx, rx);
-	seq_printf(m, "mutual_rawdata:\n");
+	seq_puts(m, "mutual_rawdata:\n");
 	index = 2;
 	for (i = 0; i < tx * rx; i++) {
 		seq_printf(m, "%5d,", info->buff[index + i]);
 		if ((i + 1) % tx == 0)
-			seq_printf(m, "\n");
+			seq_puts(m, "\n");
 	}
-	seq_printf(m, "mutual_diffdata:\n");
+	seq_puts(m, "mutual_diffdata:\n");
 	index += tx * rx;
 	for (i = 0; i < tx * rx; i++) {
 		seq_printf(m, "%3d,", info->buff[index + i]);
 		if ((i + 1) % tx == 0)
-			seq_printf(m, "\n");
+			seq_puts(m, "\n");
 	}
 
 exit:
@@ -836,22 +843,36 @@ exit:
 
 static int rawdata_proc_open(struct inode *inode, struct file *file)
 {
-	return single_open_size(file, rawdata_proc_show, PDE_DATA(inode), PAGE_SIZE * 10);
+	return single_open_size(file, rawdata_proc_show,
+			PDE_DATA(inode), PAGE_SIZE * 10);
 }
 
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 6, 0))
+static const struct proc_ops rawdata_proc_fops = {
+	.proc_open = rawdata_proc_open,
+	.proc_read = seq_read,
+	.proc_lseek = seq_lseek,
+	.proc_release = single_release,
+};
+#else
 static const struct file_operations rawdata_proc_fops = {
 	.open = rawdata_proc_open,
 	.read = seq_read,
 	.llseek = seq_lseek,
 	.release = single_release,
 };
+#endif
 
 static void goodix_ts_procfs_init(struct goodix_ts_core *core_data)
 {
+	struct proc_dir_entry *proc_entry;
+
 	if (!proc_mkdir("goodix_ts", NULL))
 		return;
-	proc_create_data("goodix_ts/tp_capacitance_data",
-			0666, NULL, &rawdata_proc_fops, core_data);
+	proc_entry = proc_create_data("goodix_ts/tp_capacitance_data",
+			0664, NULL, &rawdata_proc_fops, core_data);
+	if (!proc_entry)
+		ts_err("failed to create proc entry");
 }
 
 static void goodix_ts_procfs_exit(struct goodix_ts_core *core_data)
@@ -895,7 +916,7 @@ int goodix_ts_blocking_notify(enum ts_notify_event evt, void *v)
 	return ret;
 }
 
-#ifdef CONFIG_OF
+#if IS_ENABLED(CONFIG_OF)
 /**
  * goodix_parse_dt_resolution - parse resolution from dt
  * @node: devicetree node
@@ -1026,20 +1047,28 @@ static int goodix_parse_dt(struct device_node *node,
 	r = of_property_read_string(node, "goodix,firmware-name", &name_tmp);
 	if (!r) {
 		ts_info("firmware name from dt: %s", name_tmp);
-		strncpy(board_data->fw_name, name_tmp, sizeof(board_data->fw_name));
+		strncpy(board_data->fw_name,
+				name_tmp, sizeof(board_data->fw_name));
 	} else {
-		ts_info("can't find firmware name, use default: %s", TS_DEFAULT_FIRMWARE);
-		strncpy(board_data->fw_name, TS_DEFAULT_FIRMWARE, sizeof(board_data->fw_name));
+		ts_info("can't find firmware name, use default: %s",
+				TS_DEFAULT_FIRMWARE);
+		strncpy(board_data->fw_name,
+				TS_DEFAULT_FIRMWARE,
+				sizeof(board_data->fw_name));
 	}
 
 	/* get config file name */
 	r = of_property_read_string(node, "goodix,config-name", &name_tmp);
 	if (!r) {
 		ts_info("config name from dt: %s", name_tmp);
-		strncpy(board_data->cfg_bin_name, name_tmp, sizeof(board_data->cfg_bin_name));
+		strncpy(board_data->cfg_bin_name, name_tmp,
+				sizeof(board_data->cfg_bin_name));
 	} else {
-		ts_info("can't find config name, use default: %s", TS_DEFAULT_CFG_BIN);
-		strncpy(board_data->cfg_bin_name, TS_DEFAULT_CFG_BIN, sizeof(board_data->cfg_bin_name));
+		ts_info("can't find config name, use default: %s",
+				TS_DEFAULT_CFG_BIN);
+		strncpy(board_data->cfg_bin_name,
+				TS_DEFAULT_CFG_BIN,
+				sizeof(board_data->cfg_bin_name));
 	}
 
 	/* get xyz resolutions */
@@ -1081,7 +1110,8 @@ static void goodix_ts_report_pen(struct input_dev *dev,
 		ts_debug("pen_data:x %d, y %d, p %d, tilt_x %d tilt_y %d key[%d %d]",
 				pen_data->coords.x, pen_data->coords.y,
 				pen_data->coords.p, pen_data->coords.tilt_x,
-				pen_data->coords.tilt_y, pen_data->keys[0].status == TS_TOUCH ? 1 : 0,
+				pen_data->coords.tilt_y,
+				pen_data->keys[0].status == TS_TOUCH ? 1 : 0,
 				pen_data->keys[1].status == TS_TOUCH ? 1 : 0);
 	} else {
 		input_report_key(dev, BTN_TOUCH, 0);
@@ -1109,8 +1139,9 @@ static void goodix_ts_report_finger(struct input_dev *dev,
 
 	for (i = 0; i < GOODIX_MAX_TOUCH; i++) {
 		if (touch_data->coords[i].status == TS_TOUCH) {
-			ts_debug("report: id %d, x %d, y %d, w %d", i,
-				touch_data->coords[i].x, touch_data->coords[i].y,
+			ts_debug("report: id[%d], x %d, y %d, w %d", i,
+				touch_data->coords[i].x,
+				touch_data->coords[i].y,
 				touch_data->coords[i].w);
 			input_mt_slot(dev, i);
 			input_mt_report_slot_state(dev, MT_TOOL_FINGER, true);
@@ -1200,15 +1231,10 @@ static irqreturn_t goodix_ts_threadirq_func(int irq, void *data)
 			goodix_ts_report_pen(core_data->pen_dev,
 					&ts_event->pen_data);
 		}
-		if (ts_event->event_type == EVENT_REQUEST) {
+		if (ts_event->event_type == EVENT_REQUEST)
 			goodix_ts_request_handle(core_data, ts_event);
-		}
 	}
 
-	if (!core_data->tools_ctrl_sync && !ts_event->retry)
-		hw_ops->after_event_handler(core_data);
-	ts_event->retry = 0;
-
 	return IRQ_HANDLED;
 }
 
@@ -1343,22 +1369,25 @@ static int goodix_ts_gpio_setup(struct goodix_ts_core *core_data)
 	 * after kenerl3.13, gpio_ api is deprecated, new
 	 * driver should use gpiod_ api.
 	 */
-	r = devm_gpio_request_one(&core_data->pdev->dev, ts_bdata->reset_gpio,
-				  GPIOF_OUT_INIT_LOW, "ts_reset_gpio");
+	r = devm_gpio_request_one(&core_data->pdev->dev,
+			ts_bdata->reset_gpio,
+			GPIOF_OUT_INIT_LOW, "ts_reset_gpio");
 	if (r < 0) {
 		ts_err("Failed to request reset gpio, r:%d", r);
 		return r;
 	}
 
-	r = devm_gpio_request_one(&core_data->pdev->dev, ts_bdata->irq_gpio,
-				  GPIOF_IN, "ts_irq_gpio");
+	r = devm_gpio_request_one(&core_data->pdev->dev,
+			ts_bdata->irq_gpio,
+			GPIOF_IN, "ts_irq_gpio");
 	if (r < 0) {
 		ts_err("Failed to request irq gpio, r:%d", r);
 		return r;
 	}
 
 	if (ts_bdata->avdd_gpio > 0) {
-		r = devm_gpio_request_one(&core_data->pdev->dev, ts_bdata->avdd_gpio,
+		r = devm_gpio_request_one(&core_data->pdev->dev,
+				ts_bdata->avdd_gpio,
 				GPIOF_OUT_INIT_LOW, "ts_avdd_gpio");
 		if (r < 0) {
 			ts_err("Failed to request avdd-gpio, r:%d", r);
@@ -1367,7 +1396,8 @@ static int goodix_ts_gpio_setup(struct goodix_ts_core *core_data)
 	}
 
 	if (ts_bdata->iovdd_gpio > 0) {
-		r = devm_gpio_request_one(&core_data->pdev->dev, ts_bdata->iovdd_gpio,
+		r = devm_gpio_request_one(&core_data->pdev->dev,
+				ts_bdata->iovdd_gpio,
 				GPIOF_OUT_INIT_LOW, "ts_iovdd_gpio");
 		if (r < 0) {
 			ts_err("Failed to request iovdd-gpio, r:%d", r);
@@ -1405,15 +1435,12 @@ static int goodix_ts_input_dev_config(struct goodix_ts_core *core_data)
 	input_dev->id.vendor = 0xBEEF;
 	input_dev->id.version = 10427;
 
-	__set_bit(EV_SYN, input_dev->evbit);
-	__set_bit(EV_KEY, input_dev->evbit);
-	__set_bit(EV_ABS, input_dev->evbit);
-	__set_bit(BTN_TOUCH, input_dev->keybit);
-	__set_bit(BTN_TOOL_FINGER, input_dev->keybit);
-
-#ifdef INPUT_PROP_DIRECT
-	__set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
-#endif
+	set_bit(EV_SYN, input_dev->evbit);
+	set_bit(EV_KEY, input_dev->evbit);
+	set_bit(EV_ABS, input_dev->evbit);
+	set_bit(BTN_TOUCH, input_dev->keybit);
+	set_bit(BTN_TOOL_FINGER, input_dev->keybit);
+	set_bit(INPUT_PROP_DIRECT, input_dev->propbit);
 
 	/* set input parameters */
 	input_set_abs_params(input_dev, ABS_MT_POSITION_X,
@@ -1432,6 +1459,8 @@ static int goodix_ts_input_dev_config(struct goodix_ts_core *core_data)
 #endif
 
 	input_set_capability(input_dev, EV_KEY, KEY_POWER);
+	input_set_capability(input_dev, EV_KEY, KEY_WAKEUP);
+	input_set_capability(input_dev, EV_KEY, KEY_GOTO);
 
 	r = input_register_device(input_dev);
 	if (r < 0) {
@@ -1464,15 +1493,15 @@ static int goodix_ts_pen_dev_config(struct goodix_ts_core *core_data)
 	pen_dev->id.version = 10427;
 
 	pen_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
-	__set_bit(ABS_X, pen_dev->absbit);
-	__set_bit(ABS_Y, pen_dev->absbit);
-	__set_bit(ABS_TILT_X, pen_dev->absbit);
-	__set_bit(ABS_TILT_Y, pen_dev->absbit);	
-	__set_bit(BTN_STYLUS, pen_dev->keybit);
-	__set_bit(BTN_STYLUS2, pen_dev->keybit);
-	__set_bit(BTN_TOUCH, pen_dev->keybit);
-	__set_bit(BTN_TOOL_PEN, pen_dev->keybit);
-	__set_bit(INPUT_PROP_DIRECT, pen_dev->propbit);
+	set_bit(ABS_X, pen_dev->absbit);
+	set_bit(ABS_Y, pen_dev->absbit);
+	set_bit(ABS_TILT_X, pen_dev->absbit);
+	set_bit(ABS_TILT_Y, pen_dev->absbit);
+	set_bit(BTN_STYLUS, pen_dev->keybit);
+	set_bit(BTN_STYLUS2, pen_dev->keybit);
+	set_bit(BTN_TOUCH, pen_dev->keybit);
+	set_bit(BTN_TOOL_PEN, pen_dev->keybit);
+	set_bit(INPUT_PROP_DIRECT, pen_dev->propbit);
 	input_set_abs_params(pen_dev, ABS_X, 0, ts_bdata->panel_max_x, 0, 0);
 	input_set_abs_params(pen_dev, ABS_Y, 0, ts_bdata->panel_max_y, 0, 0);
 	input_set_abs_params(pen_dev, ABS_PRESSURE, 0,
@@ -1480,7 +1509,7 @@ static int goodix_ts_pen_dev_config(struct goodix_ts_core *core_data)
 	input_set_abs_params(pen_dev, ABS_TILT_X,
 			-GOODIX_PEN_MAX_TILT, GOODIX_PEN_MAX_TILT, 0, 0);
 	input_set_abs_params(pen_dev, ABS_TILT_Y,
-			-GOODIX_PEN_MAX_TILT, GOODIX_PEN_MAX_TILT, 0, 0);				 
+			-GOODIX_PEN_MAX_TILT, GOODIX_PEN_MAX_TILT, 0, 0);
 
 	r = input_register_device(pen_dev);
 	if (r < 0) {
@@ -1562,9 +1591,9 @@ static void goodix_ts_esd_on(struct goodix_ts_core *cd)
 		return;
 
 	atomic_set(&ts_esd->esd_on, 1);
-	if (!schedule_delayed_work(&ts_esd->esd_work, 2 * HZ)) {
+	if (!schedule_delayed_work(&ts_esd->esd_work, 2 * HZ))
 		ts_info("esd work already in workqueue");
-	}
+
 	ts_info("esd on");
 }
 
@@ -1752,6 +1781,7 @@ static int goodix_ts_resume(struct goodix_ts_core *core_data)
 
 	ts_info("Resume start");
 	atomic_set(&core_data->suspended, 0);
+	hw_ops->irq_enable(core_data, false);
 
 	mutex_lock(&goodix_modules.mutex);
 	if (!list_empty(&goodix_modules.head)) {
@@ -1804,7 +1834,25 @@ out:
 	return 0;
 }
 
-#ifdef CONFIG_FB
+/* goodix FB test */
+/*
+void goodix_fb_ext_ctrl(int suspend)
+{
+	struct goodix_ts_core *cd = goodix_modules.core_data;
+
+	if (!cd)
+		return;
+
+	if (suspend)
+		goodix_ts_suspend(cd);
+	else
+		goodix_ts_resume(cd);
+}
+EXPORT_SYMBOL(goodix_fb_ext_ctrl);
+*/
+
+
+#if IS_ENABLED(CONFIG_FB)
 /**
  * goodix_ts_fb_notifier_callback - Framebuffer notifier callback
  * Called by kernel during framebuffer blanck/unblank phrase
@@ -1821,6 +1869,7 @@ int goodix_ts_fb_notifier_callback(struct notifier_block *self,
 			/* before fb blank */
 		} else if (event == FB_EVENT_BLANK) {
 			int *blank = fb_event->data;
+
 			if (*blank == FB_BLANK_UNBLANK)
 				goodix_ts_resume(core_data);
 			else if (*blank == FB_BLANK_POWERDOWN)
@@ -1832,9 +1881,8 @@ int goodix_ts_fb_notifier_callback(struct notifier_block *self,
 }
 #endif
 
-
-#ifdef CONFIG_PM
-#if !defined(CONFIG_FB) && !defined(CONFIG_HAS_EARLYSUSPEND)
+#if IS_ENABLED(CONFIG_PM)
+#if !IS_ENABLED(CONFIG_FB) && !IS_ENABLED(CONFIG_HAS_EARLYSUSPEND)
 /**
  * goodix_ts_pm_suspend - PM suspend function
  * Called by kernel during system suspend phrase
@@ -1917,7 +1965,7 @@ int goodix_ts_stage2_init(struct goodix_ts_core *cd)
 	}
 	ts_info("success register irq");
 
-#ifdef CONFIG_FB
+#if IS_ENABLED(CONFIG_FB)
 	cd->fb_notifier.notifier_call = goodix_ts_fb_notifier_callback;
 	if (fb_register_client(&cd->fb_notifier))
 		ts_err("Failed to register fb notifier client:%d", ret);
@@ -2010,7 +2058,8 @@ upgrade:
 	}
 
 	ts_info("update flag: 0x%X", update_flag);
-	ret = goodix_do_fw_update(cd->ic_configs[CONFIG_TYPE_NORMAL], update_flag);
+	ret = goodix_do_fw_update(cd->ic_configs[CONFIG_TYPE_NORMAL],
+			update_flag);
 	if (ret)
 		ts_err("failed do fw update");
 
@@ -2051,8 +2100,7 @@ err_out:
 	ts_err("stage2 init failed");
 	cd->init_stage = CORE_INIT_FAIL;
 	for (i = 0; i < GOODIX_MAX_CONFIG_GROUP; i++) {
-		if (cd->ic_configs[i])
-			kfree(cd->ic_configs[i]);
+		kfree(cd->ic_configs[i]);
 		cd->ic_configs[i] = NULL;
 	}
 	return ret;
@@ -2082,7 +2130,7 @@ static int goodix_ts_probe(struct platform_device *pdev)
 	struct goodix_bus_interface *bus_interface;
 	int ret;
 
-	ts_info("goodix_ts_probe IN");
+	ts_info("IN");
 
 	bus_interface = pdev->dev.platform_data;
 	if (!bus_interface) {
@@ -2094,7 +2142,6 @@ static int goodix_ts_probe(struct platform_device *pdev)
 	core_data = devm_kzalloc(&pdev->dev,
 			sizeof(struct goodix_ts_core), GFP_KERNEL);
 	if (!core_data) {
-		ts_err("Failed to allocate memory for core data");
 		core_module_prob_sate = CORE_MODULE_PROB_FAILED;
 		return -ENOMEM;
 	}
@@ -2180,7 +2227,7 @@ static int goodix_ts_remove(struct platform_device *pdev)
 		gesture_module_exit();
 		inspect_module_exit();
 		hw_ops->irq_enable(core_data, false);
-	#ifdef CONFIG_FB
+	#if IS_ENABLED(CONFIG_FB)
 		fb_unregister_client(&core_data->fb_notifier);
 	#endif
 		core_module_prob_sate = CORE_MODULE_REMOVED;
@@ -2199,9 +2246,9 @@ static int goodix_ts_remove(struct platform_device *pdev)
 	return 0;
 }
 
-#ifdef CONFIG_PM
+#if IS_ENABLED(CONFIG_PM)
 static const struct dev_pm_ops dev_pm_ops = {
-#if !defined(CONFIG_FB) && !defined(CONFIG_HAS_EARLYSUSPEND)
+#if !IS_ENABLED(CONFIG_FB) && !IS_ENABLED(CONFIG_HAS_EARLYSUSPEND)
 	.suspend = goodix_ts_pm_suspend,
 	.resume = goodix_ts_pm_resume,
 #endif
@@ -2218,7 +2265,7 @@ static struct platform_driver goodix_ts_driver = {
 	.driver = {
 		.name = GOODIX_CORE_DRIVER_NAME,
 		.owner = THIS_MODULE,
-#ifdef CONFIG_PM
+#if IS_ENABLED(CONFIG_PM)
 		.pm = &dev_pm_ops,
 #endif
 	},

goodix_ts_core.h → driver/goodix_ts_core.h

@@ -1,3 +1,19 @@
+/*
+ * Goodix Touchscreen Driver
+ * Copyright (C) 2020 - 2021 Goodix, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be a reference
+ * to you, when you are integrating the GOODiX's CTP IC into your system,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ */
 #ifndef _GOODIX_TS_CORE_H_
 #define _GOODIX_TS_CORE_H_
 #include <linux/module.h>
@@ -15,25 +31,27 @@
 #include <linux/interrupt.h>
 #include <linux/completion.h>
 #include <linux/of_irq.h>
-#ifdef CONFIG_OF
+#if IS_ENABLED(CONFIG_OF)
 #include <linux/of_gpio.h>
 #include <linux/regulator/consumer.h>
 #endif
-#ifdef CONFIG_FB
+#if IS_ENABLED(CONFIG_FB)
 #include <linux/notifier.h>
 #include <linux/fb.h>
 #endif
 
 #define GOODIX_CORE_DRIVER_NAME			"goodix_ts"
 #define GOODIX_PEN_DRIVER_NAME			"goodix_ts,pen"
-#define GOODIX_DRIVER_VERSION			"v1.2.3"
+#define GOODIX_DRIVER_VERSION			"v1.2.4"
 #define GOODIX_MAX_TOUCH				10
 #define GOODIX_PEN_MAX_PRESSURE			4096
-#define GOODIX_MAX_PEN_KEY 				2
+#define GOODIX_MAX_PEN_KEY				2
 #define GOODIX_PEN_MAX_TILT				90
 #define GOODIX_CFG_MAX_SIZE				4096
+#define GOODIX_FW_MAX_SIEZE				(300 * 1024)
 #define GOODIX_MAX_STR_LABLE_LEN		32
 #define GOODIX_MAX_FRAMEDATA_LEN		1700
+#define GOODIX_GESTURE_DATA_LEN			16
 
 #define GOODIX_NORMAL_RESET_DELAY_MS	100
 #define GOODIX_HOLD_CPU_RESET_DELAY_MS  5
@@ -43,7 +61,13 @@
 #define GOODIX_RETRY_10					10
 
 #define TS_DEFAULT_FIRMWARE				"goodix_firmware.bin"
-#define TS_DEFAULT_CFG_BIN 				"goodix_cfg_group.bin"
+#define TS_DEFAULT_CFG_BIN				"goodix_cfg_group.bin"
+
+enum GOODIX_GESTURE_TYP {
+	GESTURE_SINGLE_TAP = (1 << 0),
+	GESTURE_DOUBLE_TAP = (1 << 1),
+	GESTURE_FOD_PRESS  = (1 << 2)
+};
 
 enum CORD_PROB_STA {
 	CORE_MODULE_UNPROBED = 0,
@@ -90,8 +114,8 @@ enum CHECKSUM_MODE {
 	CHECKSUM_MODE_U16_LE,
 };
 
-#define MAX_SCAN_FREQ_NUM            5
-#define MAX_SCAN_RATE_NUM            5
+#define MAX_SCAN_FREQ_NUM            8
+#define MAX_SCAN_RATE_NUM            8
 #define MAX_FREQ_NUM_STYLUS          8
 #define MAX_STYLUS_SCAN_FREQ_NUM     6
 #pragma pack(1)
@@ -366,10 +390,10 @@ struct goodix_pen_data {
  * @event_data: event data
  */
 struct goodix_ts_event {
-	int retry;
 	enum ts_event_type event_type;
 	u8 request_code; /* represent the request type */
 	u8 gesture_type;
+	u8 gesture_data[GOODIX_GESTURE_DATA_LEN];
 	struct goodix_touch_data touch_data;
 	struct goodix_pen_data pen_data;
 };
@@ -387,7 +411,7 @@ struct goodix_bus_interface {
 	int (*read)(struct device *dev, unsigned int addr,
 			 unsigned char *data, unsigned int len);
 	int (*write)(struct device *dev, unsigned int addr,
-			unsigned char *data, unsigned int len);	
+			unsigned char *data, unsigned int len);
 };
 
 struct goodix_ts_hw_ops {
@@ -401,15 +425,22 @@ struct goodix_ts_hw_ops {
 		    unsigned char *data, unsigned int len);
 	int (*write)(struct goodix_ts_core *cd, unsigned int addr,
 		     unsigned char *data, unsigned int len);
-	int (*send_cmd)(struct goodix_ts_core *cd, struct goodix_ts_cmd *cmd);
-	int (*send_config)(struct goodix_ts_core *cd, u8 *config, int len);
-	int (*read_config)(struct goodix_ts_core *cd, u8 *config_data, int size);
-	int (*read_version)(struct goodix_ts_core *cd, struct goodix_fw_version *version);
-	int (*get_ic_info)(struct goodix_ts_core *cd, struct goodix_ic_info *ic_info);
+	int (*send_cmd)(struct goodix_ts_core *cd,
+			struct goodix_ts_cmd *cmd);
+	int (*send_config)(struct goodix_ts_core *cd,
+			u8 *config, int len);
+	int (*read_config)(struct goodix_ts_core *cd,
+			u8 *config_data, int size);
+	int (*read_version)(struct goodix_ts_core *cd,
+			struct goodix_fw_version *version);
+	int (*get_ic_info)(struct goodix_ts_core *cd,
+			struct goodix_ic_info *ic_info);
 	int (*esd_check)(struct goodix_ts_core *cd);
-	int (*event_handler)(struct goodix_ts_core *cd, struct goodix_ts_event *ts_event);
-	int (*after_event_handler)(struct goodix_ts_core *cd); /* clean sync flag */
-	int (*get_capacitance_data)(struct goodix_ts_core *cd, struct ts_rawdata_info *info);
+	int (*event_handler)(struct goodix_ts_core *cd,
+			struct goodix_ts_event *ts_event);
+	int (*after_event_handler)(struct goodix_ts_core *cd);
+	int (*get_capacitance_data)(struct goodix_ts_core *cd,
+			struct ts_rawdata_info *info);
 };
 
 /*
@@ -448,13 +479,14 @@ struct goodix_ts_core {
 	struct goodix_ts_hw_ops *hw_ops;
 	struct input_dev *input_dev;
 	struct input_dev *pen_dev;
- 	/* TODO counld we remove this from core data? */
+	/* TODO counld we remove this from core data? */
 	struct goodix_ts_event ts_event;
 
 	/* every pointer of this array represent a kind of config */
 	struct goodix_ic_config *ic_configs[GOODIX_MAX_CONFIG_GROUP];
 	struct regulator *avdd;
 	struct regulator *iovdd;
+	unsigned char gesture_type;
 
 	int power_on;
 	int irq;
@@ -468,7 +500,7 @@ struct goodix_ts_core {
 	struct notifier_block ts_notifier;
 	struct goodix_ts_esd ts_esd;
 
-#ifdef CONFIG_FB
+#if IS_ENABLED(CONFIG_FB)
 	struct notifier_block fb_notifier;
 #endif
 };
@@ -542,8 +574,9 @@ struct goodix_ext_module {
  */
 struct goodix_ext_attribute {
 	struct attribute attr;
-	ssize_t (*show)(struct goodix_ext_module *, char *);
-	ssize_t (*store)(struct goodix_ext_module *, const char *, size_t);
+	ssize_t (*show)(struct goodix_ext_module *module, char *buf);
+	ssize_t (*store)(struct goodix_ext_module *module,
+			const char *buf, size_t len);
 };
 
 /* external attrs helper macro */
@@ -556,13 +589,17 @@ struct goodix_ext_attribute {
 /* external attrs helper macro, used to define external attrs */
 #define DEFINE_EXTMOD_ATTR(_name, _mode, _show, _store)	\
 static struct goodix_ext_attribute ext_attr_##_name = \
-	__EXTMOD_ATTR(_name, _mode, _show, _store);
+	__EXTMOD_ATTR(_name, _mode, _show, _store)
 
 /* log macro */
 extern bool debug_log_flag;
-#define ts_info(fmt, arg...)	pr_info("[GTP-INF][%s:%d] "fmt"\n", __func__, __LINE__, ##arg)
-#define	ts_err(fmt, arg...)		pr_err("[GTP-ERR][%s:%d] "fmt"\n", __func__, __LINE__, ##arg)
-#define ts_debug(fmt, arg...)	{if (debug_log_flag) pr_info("[GTP-DBG][%s:%d] "fmt"\n", __func__, __LINE__, ##arg);}
+#define ts_info(fmt, arg...) \
+		pr_info("[GTP-INF][%s:%d] "fmt"\n", __func__, __LINE__, ##arg)
+#define	ts_err(fmt, arg...) \
+		pr_err("[GTP-ERR][%s:%d] "fmt"\n", __func__, __LINE__, ##arg)
+#define ts_debug(fmt, arg...) \
+		{if (debug_log_flag) \
+		pr_info("[GTP-DBG][%s:%d] "fmt"\n", __func__, __LINE__, ##arg);}
 
 /*
  * get board data pointer
@@ -613,7 +650,6 @@ int checksum_cmp(const u8 *data, int size, int mode);
 int is_risk_data(const u8 *data, int size);
 u32 goodix_get_file_config_id(u8 *ic_config);
 void goodix_rotate_abcd2cbad(int tx, int rx, s16 *data);
-int goodix_gesture_enable(int enable);
 
 int goodix_fw_update_init(struct goodix_ts_core *core_data);
 void goodix_fw_update_uninit(void);
@@ -627,4 +663,9 @@ void inspect_module_exit(void);
 int goodix_tools_init(void);
 void goodix_tools_exit(void);
 
+/* goodix FB test */
+/*
+void goodix_fb_ext_ctrl(int suspend);
+*/
+
 #endif

driver/goodix_ts_gesture.c

@@ -0,0 +1,446 @@
+/*
+ * Goodix Gesture Module
+ *
+ * Copyright (C) 2019 - 2020 Goodix, Inc.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be a reference
+ * to you, when you are integrating the GOODiX's CTP IC into your system,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ */
+#include <linux/spinlock.h>
+#include <linux/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/string.h>
+#include <linux/input.h>
+#include <linux/platform_device.h>
+#include <linux/version.h>
+#include <linux/delay.h>
+#include <linux/atomic.h>
+#include <linux/input/mt.h>
+#include "goodix_ts_core.h"
+
+
+#define GOODIX_GESTURE_DOUBLE_TAP		0xCC
+#define GOODIX_GESTURE_SINGLE_TAP		0x4C
+#define GOODIX_GESTURE_FOD_DOWN			0x46
+#define GOODIX_GESTURE_FOD_UP			0x55
+
+/*
+ * struct gesture_module - gesture module data
+ * @registered: module register state
+ * @sysfs_node_created: sysfs node state
+ * @gesture_type: valid gesture type, each bit represent one gesture type
+ * @gesture_data: store latest gesture code get from irq event
+ * @gesture_ts_cmd: gesture command data
+ */
+struct gesture_module {
+	atomic_t registered;
+	struct goodix_ts_core *ts_core;
+	struct goodix_ext_module module;
+};
+
+static struct gesture_module *gsx_gesture; /*allocated in gesture init module*/
+static bool module_initialized;
+
+static ssize_t gsx_double_type_show(struct goodix_ext_module *module,
+		char *buf)
+{
+	struct gesture_module *gsx = module->priv_data;
+	unsigned char type = gsx->ts_core->gesture_type;
+
+	if (!gsx)
+		return -EIO;
+
+	if (atomic_read(&gsx->registered) == 0) {
+		ts_err("gesture module is not registered");
+		return 0;
+	}
+
+	return sprintf(buf, "%s\n",
+			(type & GESTURE_DOUBLE_TAP) ? "enable" : "disable");
+}
+
+static ssize_t gsx_double_type_store(struct goodix_ext_module *module,
+		const char *buf, size_t count)
+{
+	struct gesture_module *gsx = module->priv_data;
+
+	if (!gsx)
+		return -EIO;
+
+	if (atomic_read(&gsx->registered) == 0) {
+		ts_err("gesture module is not registered");
+		return 0;
+	}
+
+	if (buf[0] == '1') {
+		ts_info("enable double tap");
+		gsx->ts_core->gesture_type |= GESTURE_DOUBLE_TAP;
+	} else if (buf[0] == '0') {
+		ts_info("disable double tap");
+		gsx->ts_core->gesture_type &= ~GESTURE_DOUBLE_TAP;
+	} else
+		ts_err("invalid cmd[%d]", buf[0]);
+
+	return count;
+}
+
+static ssize_t gsx_single_type_show(struct goodix_ext_module *module,
+		char *buf)
+{
+	struct gesture_module *gsx = module->priv_data;
+	unsigned char type = gsx->ts_core->gesture_type;
+
+	if (!gsx)
+		return -EIO;
+
+	if (atomic_read(&gsx->registered) == 0) {
+		ts_err("gesture module is not registered");
+		return 0;
+	}
+
+	return sprintf(buf, "%s\n",
+			(type & GESTURE_SINGLE_TAP) ? "enable" : "disable");
+}
+
+static ssize_t gsx_single_type_store(struct goodix_ext_module *module,
+		const char *buf, size_t count)
+{
+	struct gesture_module *gsx = module->priv_data;
+
+	if (!gsx)
+		return -EIO;
+
+	if (atomic_read(&gsx->registered) == 0) {
+		ts_err("gesture module is not registered");
+		return 0;
+	}
+
+	if (buf[0] == '1') {
+		ts_info("enable single tap");
+		gsx->ts_core->gesture_type |= GESTURE_SINGLE_TAP;
+	} else if (buf[0] == '0') {
+		ts_info("disable single tap");
+		gsx->ts_core->gesture_type &= ~GESTURE_SINGLE_TAP;
+	} else
+		ts_err("invalid cmd[%d]", buf[0]);
+
+	return count;
+}
+
+static ssize_t gsx_fod_type_show(struct goodix_ext_module *module,
+		char *buf)
+{
+	struct gesture_module *gsx = module->priv_data;
+	unsigned char type = gsx->ts_core->gesture_type;
+
+	if (!gsx)
+		return -EIO;
+
+	if (atomic_read(&gsx->registered) == 0) {
+		ts_err("gesture module is not registered");
+		return 0;
+	}
+
+	return sprintf(buf, "%s\n",
+			(type & GESTURE_FOD_PRESS) ? "enable" : "disable");
+}
+
+static ssize_t gsx_fod_type_store(struct goodix_ext_module *module,
+		const char *buf, size_t count)
+{
+	struct gesture_module *gsx = module->priv_data;
+
+	if (!gsx)
+		return -EIO;
+
+	if (atomic_read(&gsx->registered) == 0) {
+		ts_err("gesture module is not registered");
+		return 0;
+	}
+
+	if (buf[0] == '1') {
+		ts_info("enable fod");
+		gsx->ts_core->gesture_type |= GESTURE_FOD_PRESS;
+	} else if (buf[0] == '0') {
+		ts_info("disable fod");
+		gsx->ts_core->gesture_type &= ~GESTURE_FOD_PRESS;
+	} else
+		ts_err("invalid cmd[%d]", buf[0]);
+
+	return count;
+}
+
+
+const struct goodix_ext_attribute gesture_attrs[] = {
+	__EXTMOD_ATTR(double_en, 0664,
+			gsx_double_type_show, gsx_double_type_store),
+	__EXTMOD_ATTR(single_en, 0664,
+			gsx_single_type_show, gsx_single_type_store),
+	__EXTMOD_ATTR(fod_en, 0664,
+			gsx_fod_type_show, gsx_fod_type_store),
+};
+
+static int gsx_gesture_init(struct goodix_ts_core *cd,
+		struct goodix_ext_module *module)
+{
+	struct gesture_module *gsx = module->priv_data;
+
+	if (!cd || !cd->hw_ops->gesture) {
+		ts_err("gesture unsupported");
+		return -EINVAL;
+	}
+
+	gsx->ts_core = cd;
+	gsx->ts_core->gesture_type = 0;
+	atomic_set(&gsx->registered, 1);
+
+	return 0;
+}
+
+static int gsx_gesture_exit(struct goodix_ts_core *cd,
+		struct goodix_ext_module *module)
+{
+	struct gesture_module *gsx = module->priv_data;
+
+	if (!cd || !cd->hw_ops->gesture) {
+		ts_err("gesture unsupported");
+		return -EINVAL;
+	}
+
+	atomic_set(&gsx->registered, 0);
+
+	return 0;
+}
+
+/**
+ * gsx_gesture_ist - Gesture Irq handle
+ * This functions is excuted when interrupt happended and
+ * ic in doze mode.
+ *
+ * @cd: pointer to touch core data
+ * @module: pointer to goodix_ext_module struct
+ * return: 0 goon execute, EVT_CANCEL_IRQEVT  stop execute
+ */
+static int gsx_gesture_ist(struct goodix_ts_core *cd,
+	struct goodix_ext_module *module)
+{
+	struct goodix_ts_hw_ops *hw_ops = cd->hw_ops;
+	struct goodix_ts_event gs_event = {0};
+	int fodx, fody, overlay_area;
+	int ret;
+
+	if (atomic_read(&cd->suspended) == 0 || cd->gesture_type == 0)
+		return EVT_CONTINUE;
+
+	ret = hw_ops->event_handler(cd, &gs_event);
+	if (ret) {
+		ts_err("failed get gesture data");
+		goto re_send_ges_cmd;
+	}
+
+	if (!(gs_event.event_type & EVENT_GESTURE)) {
+		ts_err("invalid event type: 0x%x",
+			cd->ts_event.event_type);
+		goto re_send_ges_cmd;
+	}
+
+	switch (gs_event.gesture_type) {
+	case GOODIX_GESTURE_SINGLE_TAP:
+		if (cd->gesture_type & GESTURE_SINGLE_TAP) {
+			ts_info("get SINGLE-TAP gesture");
+			input_report_key(cd->input_dev, KEY_WAKEUP, 1);
+			// input_report_key(cd->input_dev, KEY_GOTO, 1);
+			input_sync(cd->input_dev);
+			input_report_key(cd->input_dev, KEY_WAKEUP, 0);
+			// input_report_key(cd->input_dev, KEY_GOTO, 0);
+			input_sync(cd->input_dev);
+		} else {
+			ts_debug("not enable SINGLE-TAP");
+		}
+		break;
+	case GOODIX_GESTURE_DOUBLE_TAP:
+		if (cd->gesture_type & GESTURE_DOUBLE_TAP) {
+			ts_info("get DOUBLE-TAP gesture");
+			input_report_key(cd->input_dev, KEY_WAKEUP, 1);
+			input_sync(cd->input_dev);
+			input_report_key(cd->input_dev, KEY_WAKEUP, 0);
+			input_sync(cd->input_dev);
+		} else {
+			ts_debug("not enable DOUBLE-TAP");
+		}
+		break;
+	case GOODIX_GESTURE_FOD_DOWN:
+		if (cd->gesture_type & GESTURE_FOD_PRESS) {
+			ts_info("get FOD-DOWN gesture");
+			fodx = le16_to_cpup((__le16 *)gs_event.gesture_data);
+			fody = le16_to_cpup((__le16 *)(gs_event.gesture_data + 2));
+			overlay_area = gs_event.gesture_data[4];
+			ts_debug("fodx:%d fody:%d overlay_area:%d", fodx, fody, overlay_area);
+			input_report_key(cd->input_dev, BTN_TOUCH, 1);
+			input_mt_slot(cd->input_dev, 0);
+			input_mt_report_slot_state(cd->input_dev, MT_TOOL_FINGER, 1);
+			input_report_abs(cd->input_dev, ABS_MT_POSITION_X, fodx);
+			input_report_abs(cd->input_dev, ABS_MT_POSITION_Y, fody);
+			input_report_abs(cd->input_dev, ABS_MT_WIDTH_MAJOR, overlay_area);
+			input_sync(cd->input_dev);
+		} else {
+			ts_debug("not enable FOD-DOWN");
+		}
+		break;
+	case GOODIX_GESTURE_FOD_UP:
+		if (cd->gesture_type & GESTURE_FOD_PRESS) {
+			ts_info("get FOD-UP gesture");
+			fodx = le16_to_cpup((__le16 *)gs_event.gesture_data);
+			fody = le16_to_cpup((__le16 *)(gs_event.gesture_data + 2));
+			overlay_area = gs_event.gesture_data[4];
+			input_report_key(cd->input_dev, BTN_TOUCH, 0);
+			input_mt_slot(cd->input_dev, 0);
+			input_mt_report_slot_state(cd->input_dev,
+					MT_TOOL_FINGER, 0);
+			input_sync(cd->input_dev);
+		} else {
+			ts_debug("not enable FOD-UP");
+		}
+		break;
+	default:
+		ts_err("not support gesture type[%02X]", gs_event.gesture_type);
+		break;
+	}
+
+re_send_ges_cmd:
+	if (hw_ops->gesture(cd, 0))
+		ts_info("warning: failed re_send gesture cmd");
+	return EVT_CANCEL_IRQEVT;
+}
+
+/**
+ * gsx_gesture_before_suspend - execute gesture suspend routine
+ * This functions is excuted to set ic into doze mode
+ *
+ * @cd: pointer to touch core data
+ * @module: pointer to goodix_ext_module struct
+ * return: 0 goon execute, EVT_IRQCANCLED  stop execute
+ */
+static int gsx_gesture_before_suspend(struct goodix_ts_core *cd,
+	struct goodix_ext_module *module)
+{
+	int ret;
+	const struct goodix_ts_hw_ops *hw_ops = cd->hw_ops;
+
+	if (cd->gesture_type == 0)
+		return EVT_CONTINUE;
+
+	ret = hw_ops->gesture(cd, 0);
+	if (ret)
+		ts_err("failed enter gesture mode");
+	else
+		ts_info("enter gesture mode, type[0x%02X]", cd->gesture_type);
+
+	hw_ops->irq_enable(cd, true);
+	enable_irq_wake(cd->irq);
+
+	return EVT_CANCEL_SUSPEND;
+}
+
+static int gsx_gesture_before_resume(struct goodix_ts_core *cd,
+	struct goodix_ext_module *module)
+{
+	const struct goodix_ts_hw_ops *hw_ops = cd->hw_ops;
+
+	if (cd->gesture_type == 0)
+		return EVT_CONTINUE;
+
+	disable_irq_wake(cd->irq);
+	hw_ops->reset(cd, GOODIX_NORMAL_RESET_DELAY_MS);
+
+	return EVT_CANCEL_RESUME;
+}
+
+static struct goodix_ext_module_funcs gsx_gesture_funcs = {
+	.irq_event = gsx_gesture_ist,
+	.init = gsx_gesture_init,
+	.exit = gsx_gesture_exit,
+	.before_suspend = gsx_gesture_before_suspend,
+	.before_resume = gsx_gesture_before_resume,
+};
+
+int gesture_module_init(void)
+{
+	int ret;
+	int i;
+	struct kobject *def_kobj = goodix_get_default_kobj();
+	struct kobj_type *def_kobj_type = goodix_get_default_ktype();
+
+	gsx_gesture = kzalloc(sizeof(struct gesture_module), GFP_KERNEL);
+	if (!gsx_gesture)
+		return -ENOMEM;
+
+	gsx_gesture->module.funcs = &gsx_gesture_funcs;
+	gsx_gesture->module.priority = EXTMOD_PRIO_GESTURE;
+	gsx_gesture->module.name = "Goodix_gsx_gesture";
+	gsx_gesture->module.priv_data = gsx_gesture;
+
+	atomic_set(&gsx_gesture->registered, 0);
+
+	/* gesture sysfs init */
+	ret = kobject_init_and_add(&gsx_gesture->module.kobj,
+			def_kobj_type, def_kobj, "gesture");
+	if (ret) {
+		ts_err("failed create gesture sysfs node!");
+		goto err_out;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(gesture_attrs) && !ret; i++)
+		ret = sysfs_create_file(&gsx_gesture->module.kobj,
+				&gesture_attrs[i].attr);
+	if (ret) {
+		ts_err("failed create gst sysfs files");
+		while (--i >= 0)
+			sysfs_remove_file(&gsx_gesture->module.kobj,
+					&gesture_attrs[i].attr);
+
+		kobject_put(&gsx_gesture->module.kobj);
+		goto err_out;
+	}
+
+	module_initialized = true;
+	goodix_register_ext_module_no_wait(&gsx_gesture->module);
+	ts_info("gesture module init success");
+
+	return 0;
+
+err_out:
+	ts_err("gesture module init failed!");
+	kfree(gsx_gesture);
+	return ret;
+}
+
+void gesture_module_exit(void)
+{
+	int i;
+
+	ts_info("gesture module exit");
+	if (!module_initialized)
+		return;
+
+	goodix_unregister_ext_module(&gsx_gesture->module);
+
+	/* deinit sysfs */
+	for (i = 0; i < ARRAY_SIZE(gesture_attrs); i++)
+		sysfs_remove_file(&gsx_gesture->module.kobj,
+					&gesture_attrs[i].attr);
+
+	kobject_put(&gsx_gesture->module.kobj);
+	kfree(gsx_gesture);
+	module_initialized = false;
+}

goodix_ts_inspect.c → driver/goodix_ts_inspect.c

@@ -26,7 +26,7 @@
 /* test config */
 #define TOTAL_FRAME_NUM 					1 /* rawdata test frames */
 #define NOISEDATA_TEST_TIMES				1  /* noise test frames */
-#define SAVE_IN_CSV
+// #define SAVE_IN_CSV
 
 #define GOODIX_RESULT_SAVE_PATH				"/vendor/etc/Test_Data.csv"
 #define GOODIX_TEST_FILE_NAME				"goodix"
@@ -329,11 +329,11 @@ static int cal_cha_to_cha_res(struct goodix_ts_test *ts_test, int v1, int v2)
 static int cal_cha_to_avdd_res(struct goodix_ts_test *ts_test, int v1, int v2)
 {
 	if (ts_test->ts->bus->ic_type == IC_TYPE_BERLIN_A)
-		return 125 * 1024 * (100 * v2 - 125) * 40 / (10000 * v1) - 40;
+		return 64 * (2 * v2 - 25) * 40 / v1 - 40;
 	else if (ts_test->ts->bus->ic_type == IC_TYPE_BERLIN_B)
-		return 125 * 1024 * (100 * v2 - 125) * 99 / (10000 * v1) - 60;
+		return 64 * (2 * v2 - 25) * 99 / v1 - 60;
 	else
-		return 125 * 1024 * (100 * v2 - 125) * 93 / (10000 * v1) - 20;
+		return 64 * (2 * v2 - 25) * 93 / v1 - 20;
 }
 
 static int cal_cha_to_gnd_res(struct goodix_ts_test *ts_test, int v)
@@ -614,7 +614,7 @@ static int goodix_init_testlimits(struct goodix_ts_test *ts_test)
 			ts_test->test_config.data[i] = (u8)test_params->cfg_buf[i];
 		ts_test->test_config.len = ret;
 	}
-	
+
     /* obtain mutual_raw min */
     ret = parse_csvfile(temp_buf, firmware->size, CSV_TP_SPECIAL_RAW_MIN,
         test_params->min_limits, rx, tx);
@@ -770,7 +770,8 @@ static int goodix_short_test_prepare(struct goodix_ts_test *ts_test)
     struct goodix_ts_cmd tmp_cmd;
     struct goodix_fw_version fw_ver;
     int ret;
-    int retry = 3;
+    int retry;
+	int resend = 3;
 	u8 status;
 
 	ts_info("short test prepare IN");
@@ -778,12 +779,14 @@ static int goodix_short_test_prepare(struct goodix_ts_test *ts_test)
     tmp_cmd.len = 4;
     tmp_cmd.cmd = INSPECT_FW_SWITCH_CMD;
 
+resend_cmd:
     ret = ts_test_send_cmd(ts_test, &tmp_cmd);
     if (ret < 0) {
         ts_err("send test mode failed");
         return ret;
     }
 
+	retry = 3;
     while (retry--) {
         msleep(40);
 		if (ts_test->ts->bus->ic_type == IC_TYPE_BERLIN_A) {
@@ -805,6 +808,11 @@ static int goodix_short_test_prepare(struct goodix_ts_test *ts_test)
 		}
     }
 
+	if (resend--) {
+		ts_test_reset(ts_test, 100);
+		goto resend_cmd;
+	}
+
     return -EINVAL;
 }
 
@@ -1140,21 +1148,24 @@ static int gdix_check_resistance_to_gnd(struct ts_test_params *test_params,
 	u16 r_th = 0, avdd_value = 0;
 	u16 chn_id_tmp = 0;
 	u8 pin_num = 0;
+	unsigned short short_type;
 	struct goodix_ts_test *ts_test = container_of(test_params,
 		struct goodix_ts_test, test_params);
 	int max_drv_num = test_params->params_info->max_drv_num;
 	int max_sen_num = test_params->params_info->max_sen_num;
 
 	avdd_value = test_params->avdd_value;
-	if (adc_signal == 0 || adc_signal == 0x8000)
-		adc_signal |= 1;
+	short_type = adc_signal & 0x8000;
+	adc_signal &= ~0x8000;
+	if (adc_signal == 0)
+		adc_signal = 1;
 
-	if ((adc_signal & 0x8000) == 0) {
+	if (short_type == 0) {
 		/* short to GND */
 		r = cal_cha_to_gnd_res(ts_test, adc_signal);
 	} else {
 		/* short to VDD */
-		r = cal_cha_to_avdd_res(ts_test, adc_signal & ~0x8000, avdd_value);
+		r = cal_cha_to_avdd_res(ts_test, adc_signal, avdd_value);
 	}
 
 	if (pos < max_drv_num)
@@ -1171,11 +1182,11 @@ static int gdix_check_resistance_to_gnd(struct ts_test_params *test_params,
 	if (r < r_th) {
 		pin_num = map_die2pin(test_params, chn_id_tmp);
 		goodix_save_short_res(test_params, pin_num,
-			(adc_signal & 0x8000)? CHN_VDD : CHN_GND, r);
+				short_type ? CHN_VDD : CHN_GND, r);
 		ts_err("%s%d shortcircut to %s,R=%ldK,R_Threshold=%dK",
 				(pin_num & DRV_CHANNEL_FLAG) ? "DRV" : "SEN",
 				(pin_num & ~DRV_CHANNEL_FLAG),
-				(adc_signal & 0x8000) ? "VDD" : "GND",
+				short_type ? "VDD" : "GND",
 				r, r_th);
 
 		return -EINVAL;
@@ -1253,7 +1264,7 @@ static int goodix_shortcircut_analysis(struct goodix_ts_test *ts_test)
 	if (!(test_result.result & 0x0F)) {
 		ts_info(">>>>> No shortcircut");
 		return 0;
-	}     
+	}
 	ts_info("short flag 0x%02x, drv&drv:%d, sen&sen:%d, drv&sen:%d, drv/GNDVDD:%d, sen/GNDVDD:%d",
 		test_result.result, test_result.drv_drv_num, test_result.sen_sen_num,
 		test_result.drv_sen_num, test_result.drv_gnd_avdd_num, test_result.sen_gnd_avdd_num);
@@ -2051,10 +2062,10 @@ static int goodix_save_test_config(struct goodix_ts_test *ts_test,
 		ts_err("test config write failed");
 		goto save_end;
 	}
-	
+
 save_end:
 	kfree(data);
-	return ret;	
+	return ret;
 }
 
 static int goodix_save_header(struct goodix_ts_test *ts_test,
@@ -2066,7 +2077,7 @@ static int goodix_save_header(struct goodix_ts_test *ts_test,
 	bool result = false;
 	char *data = NULL;
 	struct goodix_ts_core *ts = ts_test->ts;
-	
+
 	data = kzalloc(MAX_DATA_BUFFER, GFP_KERNEL);
 	if (!data) {
 		ts_err("alloc memory failed");
@@ -2117,10 +2128,10 @@ static int goodix_save_header(struct goodix_ts_test *ts_test,
 	bytes += sprintf(&data[bytes], "<ItemList>\n");
 	if (ts_test->test_result[GTP_CAP_TEST]) {
 		if (GTP_TEST_PASS == ts_test->test_result[GTP_CAP_TEST])
-			bytes += sprintf(&data[bytes], 
+			bytes += sprintf(&data[bytes],
 					"<Item name=\"Rawdata MAX/MIN Test\" result=\"OK\"/>\n");
 		else
-			bytes += sprintf(&data[bytes], 
+			bytes += sprintf(&data[bytes],
 					"<Item name=\"Rawdata MAX/MIN Test\" result=\"NG\"/>\n");
 	}
 
@@ -2135,37 +2146,37 @@ static int goodix_save_header(struct goodix_ts_test *ts_test,
 
 	if (ts_test->test_result[GTP_NOISE_TEST]) {
 		if (GTP_TEST_PASS == ts_test->test_result[GTP_NOISE_TEST])
-			bytes += sprintf(&data[bytes], 
+			bytes += sprintf(&data[bytes],
 					"<Item name=\"Diffdata Jitter Test\" result=\"OK\"/>\n");
 		else
-			bytes += sprintf(&data[bytes], 
+			bytes += sprintf(&data[bytes],
 					"<Item name=\"Diffdata Jitter Test\" result=\"NG\"/>\n");
 	}
 
 	if (ts_test->test_result[GTP_SELFNOISE_TEST]) {
 		if (GTP_TEST_PASS == ts_test->test_result[GTP_SELFNOISE_TEST])
-			bytes += sprintf(&data[bytes], 
+			bytes += sprintf(&data[bytes],
 					"<Item name=\"Self Diffdata Jitter Limit Test\" result=\"OK\"/>\n");
 		else
-			bytes += sprintf(&data[bytes], 
+			bytes += sprintf(&data[bytes],
 					"<Item name=\"Self Diffdata Jitter Limit Test\" result=\"NG\"/>\n");
 	}
 
 	if (ts_test->test_result[GTP_SELFCAP_TEST]) {
 		if (GTP_TEST_PASS == ts_test->test_result[GTP_SELFCAP_TEST])
-			bytes += sprintf(&data[bytes], 
+			bytes += sprintf(&data[bytes],
 					"<Item name=\"Self Rawdata Upper Limit Test\" result=\"OK\"/>\n");
 		else
-			bytes += sprintf(&data[bytes], 
+			bytes += sprintf(&data[bytes],
 					"<Item name=\"Self Rawdata Upper Limit Test\" result=\"NG\"/>\n");
 	}
 
 	if (ts_test->test_result[GTP_SHORT_TEST]) {
 		if (GTP_TEST_PASS == ts_test->test_result[GTP_SHORT_TEST])
-			bytes += sprintf(&data[bytes], 
+			bytes += sprintf(&data[bytes],
 					"<Item name=\"Short Test\" result=\"OK\"/>\n");
 		else
-			bytes += sprintf(&data[bytes], 
+			bytes += sprintf(&data[bytes],
 					"<Item name=\"Short Test\" result=\"NG\"/>\n");
 	}
 
@@ -2178,7 +2189,7 @@ static int goodix_save_header(struct goodix_ts_test *ts_test,
 
 save_end:
 	kfree(data);
-	return ret;	
+	return ret;
 }
 
 static int goodix_save_limits(struct goodix_ts_test *ts_test,
@@ -2196,9 +2207,7 @@ static int goodix_save_limits(struct goodix_ts_test *ts_test,
 
 	data = kzalloc(MAX_DATA_BUFFER, GFP_KERNEL);
 	if (!data) {
-		ts_err("alloc memory failed for ");
 		return -ENOMEM;
-	}
 
 	bytes += sprintf(&data[bytes], "<TestItems>\n");
 
@@ -2223,7 +2232,7 @@ static int goodix_save_limits(struct goodix_ts_test *ts_test,
 				bytes += sprintf(&data[bytes], "<ShortMess Chn1=\"Rx%d\" ",
 						chn1 & 0x7f);
 			if (chn2 == CHN_VDD)
-				bytes += sprintf(&data[bytes], 
+				bytes += sprintf(&data[bytes],
 						"Chn2=\"VDD\" ShortResistor= \"%dKom\"/>\n", r);
 			else if (chn2 == CHN_GND)
 				bytes += sprintf(&data[bytes],
@@ -2306,7 +2315,7 @@ static int goodix_save_limits(struct goodix_ts_test *ts_test,
 			ts_test->test_params.deviation_limits[i]);
 		if ((i + 1) % tx == 0)
 			bytes += sprintf(&data[bytes], "\n");
-	}	
+	}
 	bytes += sprintf(&data[bytes], "</MaxAccordLimit>\n");
 	/* BeyondAccordLimitCnt */
 	bytes += sprintf(&data[bytes], "<BeyondAccordLimitCnt>\n");
@@ -2327,10 +2336,13 @@ static int goodix_save_limits(struct goodix_ts_test *ts_test,
 
 	/* save noise limit */
 	if (ts_test->test_result[GTP_NOISE_TEST]) {
-		bytes += sprintf(&data[bytes], "<Item name=\"Diffdata Test Sets\">\n");
-		bytes += sprintf(&data[bytes], "<TotalFrameCnt>%d</TotalFrameCnt>\n",
+		bytes += sprintf(&data[bytes],
+				"<Item name=\"Diffdata Test Sets\">\n");
+		bytes += sprintf(&data[bytes],
+				"<TotalFrameCnt>%d</TotalFrameCnt>\n",
 				NOISEDATA_TEST_TIMES);
-		bytes += sprintf(&data[bytes], "<MaxJitterLimit>%d</MaxJitterLimit>\n",
+		bytes += sprintf(&data[bytes],
+				"<MaxJitterLimit>%d</MaxJitterLimit>\n",
 				ts_test->test_params.noise_threshold);
 		bytes += sprintf(&data[bytes], "</Item>\n");
 		ret = fs_write(data, bytes, fp);
@@ -2343,12 +2355,15 @@ static int goodix_save_limits(struct goodix_ts_test *ts_test,
 
 	/* save self rawdata limit */
 	if (ts_test->test_result[GTP_SELFCAP_TEST]) {
-		bytes += sprintf(&data[bytes], "<Item name=\"Self Rawdata Test Sets\">\n");
-		bytes += sprintf(&data[bytes], "<TotalFrameCnt>1</TotalFrameCnt>\n");
-		bytes += sprintf(&data[bytes], "<MaxRawLimit>\n");
+		bytes += sprintf(&data[bytes],
+				"<Item name=\"Self Rawdata Test Sets\">\n");
+		bytes += sprintf(&data[bytes],
+				"<TotalFrameCnt>1</TotalFrameCnt>\n");
+		bytes += sprintf(&data[bytes],
+				"<MaxRawLimit>\n");
 		for (i = 0; i < tx + rx; i++) {
 			bytes += sprintf(&data[bytes], "%d,",
-					ts_test->test_params.self_max_limits[i]);
+				ts_test->test_params.self_max_limits[i]);
 			if ((i + 1) % tx == 0)
 				bytes += sprintf(&data[bytes], "\n");
 		}
@@ -2358,7 +2373,7 @@ static int goodix_save_limits(struct goodix_ts_test *ts_test,
 		bytes += sprintf(&data[bytes], "<MinRawLimit>\n");
 		for (i = 0; i < tx + rx; i++) {
 			bytes += sprintf(&data[bytes], "%d,",
-					ts_test->test_params.self_min_limits[i]);
+				ts_test->test_params.self_min_limits[i]);
 			if ((i + 1) % tx == 0)
 				bytes += sprintf(&data[bytes], "\n");
 		}
@@ -2376,9 +2391,12 @@ static int goodix_save_limits(struct goodix_ts_test *ts_test,
 
 	/* save selfnoise limit */
 	if (ts_test->test_result[GTP_SELFNOISE_TEST]) {
-		bytes += sprintf(&data[bytes], "<Item name=\"Self Diffdata Test Sets\">\n");
-		bytes += sprintf(&data[bytes], "<TotalFrameCnt>1</TotalFrameCnt>\n");
-		bytes += sprintf(&data[bytes], "<MaxJitterLimit>%d</MaxJitterLimit>\n",
+		bytes += sprintf(&data[bytes],
+				"<Item name=\"Self Diffdata Test Sets\">\n");
+		bytes += sprintf(&data[bytes],
+				"<TotalFrameCnt>1</TotalFrameCnt>\n");
+		bytes += sprintf(&data[bytes],
+				"<MaxJitterLimit>%d</MaxJitterLimit>\n",
 				ts_test->test_params.self_noise_threshold);
 		bytes += sprintf(&data[bytes], "</Item>\n");
 		ret = fs_write(data, bytes, fp);
@@ -2413,10 +2431,8 @@ static int goodix_save_rawdata(struct goodix_ts_test *ts_test,
 	int len = tx * rx;
 
 	data = kzalloc(MAX_DATA_BUFFER, GFP_KERNEL);
-	if (!data) {
-		ts_err("alloc memory failed for ");
+	if (!data)
 		return -ENOMEM;
-	}
 
 	bytes += sprintf(&data[bytes], "<RawDataRecord>\n");
 	for (i = 0; i < TOTAL_FRAME_NUM; i++) {
@@ -2425,7 +2441,8 @@ static int goodix_save_rawdata(struct goodix_ts_test *ts_test,
 			"<DataContent No.=\"%d\" DataCount=\"%d\" Maximum=\"%d\" Minimum=\"%d\" Average=\"%d\">\n",
 			i, len, stat_result[1], stat_result[2], stat_result[0]);
 		for (j = 0; j < len; j++) {
-			bytes += sprintf(&data[bytes], "%d,", ts_test->rawdata[i].data[j]);
+			bytes += sprintf(&data[bytes], "%d,",
+					ts_test->rawdata[i].data[j]);
 			if ((j + 1) % tx == 0)
 				bytes += sprintf(&data[bytes], "\n");
 		}
@@ -2435,7 +2452,8 @@ static int goodix_save_rawdata(struct goodix_ts_test *ts_test,
 			"<RawAccord No.=\"%d\" DataCount=\"%d\" Maximum=\"%d\" Minimum=\"%d\" Average=\"%d\">\n",
 			i, len, stat_result[1], stat_result[2], stat_result[0]);
 		for (j = 0; j < len; j++) {
-			bytes += sprintf(&data[bytes], "%d,", ts_test->accord_arr[i].data[j]);
+			bytes += sprintf(&data[bytes], "%d,",
+					ts_test->accord_arr[i].data[j]);
 			if ((j + 1) % tx == 0)
 				bytes += sprintf(&data[bytes], "\n");
 		}
@@ -2458,7 +2476,8 @@ save_end:
 	return ret;
 }
 
-static int goodix_save_noise_data(struct goodix_ts_test *ts_test, struct file *fp)
+static int goodix_save_noise_data(struct goodix_ts_test *ts_test,
+		struct file *fp)
 {
 	int i;
 	int j;
@@ -2471,10 +2490,8 @@ static int goodix_save_noise_data(struct goodix_ts_test *ts_test, struct file *f
 	int len = tx * rx;
 
 	data = kzalloc(MAX_DATA_BUFFER, GFP_KERNEL);
-	if (!data) {
-		ts_err("alloc memory failed for ");
+	if (!data)
 		return -ENOMEM;
-	}
 
 	bytes += sprintf(&data[bytes], "<DiffDataRecord>\n");
 	for (i = 0; i < NOISEDATA_TEST_TIMES; i++) {
@@ -2483,7 +2500,8 @@ static int goodix_save_noise_data(struct goodix_ts_test *ts_test, struct file *f
 			"<DataContent No.=\"%d\" DataCount=\"%d\" Maximum=\"%d\" Minimum=\"%d\" Average=\"%d\">\n",
 			i, len, stat_result[1], stat_result[2], stat_result[0]);
 		for (j = 0; j < len; j++) {
-			bytes += sprintf(&data[bytes], "%d,", ts_test->noisedata[i].data[j]);
+			bytes += sprintf(&data[bytes], "%d,",
+					ts_test->noisedata[i].data[j]);
 			if ((j + 1) % tx == 0)
 				bytes += sprintf(&data[bytes], "\n");
 		}
@@ -2503,7 +2521,7 @@ static int goodix_save_noise_data(struct goodix_ts_test *ts_test, struct file *f
 
 save_end:
 	kfree(data);
-	return ret;	
+	return ret;
 }
 
 static int goodix_save_self_data(struct goodix_ts_test *ts_test,
@@ -2517,12 +2535,10 @@ static int goodix_save_self_data(struct goodix_ts_test *ts_test,
 	int tx = ts_test->test_params.drv_num;
 
 	data = kzalloc(MAX_DATA_BUFFER, GFP_KERNEL);
-	if (!data) {
-		ts_err("alloc memory failed for ");
+	if (!data)
 		return -ENOMEM;
-	}
 
-	bytes += sprintf(&data[bytes], "<%s>\n",title);
+	bytes += sprintf(&data[bytes], "<%s>\n", title);
 	ret = fs_write(data, bytes, fp);
 	if (ret < 0) {
 		ts_err("rawdata write fail.");
@@ -2542,7 +2558,7 @@ static int goodix_save_self_data(struct goodix_ts_test *ts_test,
 	if (len % tx != 0)
 		bytes += sprintf(&data[bytes], "\n");
 	bytes += sprintf(&data[bytes], "</DataContent>\n");
-	bytes += sprintf(&data[bytes], "</%s>\n",title);
+	bytes += sprintf(&data[bytes], "</%s>\n", title);
 	ret = fs_write(data, bytes, fp);
 	if (ret < 0)
 		ts_err("rawdata write fail.");
@@ -2560,10 +2576,8 @@ static int goodix_save_data(struct goodix_ts_test *ts_test,
 	char *data = NULL;
 
 	data = kzalloc(MAX_DATA_BUFFER, GFP_KERNEL);
-	if (!data) {
-		ts_err("alloc memory failed for ");
+	if (!data)
 		return -ENOMEM;
-	}
 
 	bytes += sprintf(&data[bytes], "<DataRecord>\n");
 	ret = fs_write(data, bytes, fp);
@@ -2584,15 +2598,19 @@ static int goodix_save_data(struct goodix_ts_test *ts_test,
 	}
 
 	if (ts_test->test_result[GTP_SELFCAP_TEST]) {
-		ret = goodix_save_self_data(ts_test, fp, ts_test->self_rawdata.data,
-				"selfDataRecord", ts_test->self_rawdata.size);
+		ret = goodix_save_self_data(ts_test, fp,
+				ts_test->self_rawdata.data,
+				"selfDataRecord",
+				ts_test->self_rawdata.size);
 		if (ret < 0)
-			goto save_end;		
+			goto save_end;
 	}
 
 	if (ts_test->test_result[GTP_SELFNOISE_TEST]) {
-		ret = goodix_save_self_data(ts_test, fp, ts_test->self_noisedata.data,
-				"selfDiffDataRecord", ts_test->self_noisedata.size);
+		ret = goodix_save_self_data(ts_test, fp,
+				ts_test->self_noisedata.data,
+				"selfDiffDataRecord",
+				ts_test->self_noisedata.size);
 		if (ret < 0)
 			goto save_end;
 	}
@@ -2616,10 +2634,8 @@ static int goodix_save_tail(struct goodix_ts_test *ts_test,
 	char *data = NULL;
 
 	data = kzalloc(MAX_DATA_BUFFER, GFP_KERNEL);
-	if (!data) {
-		ts_err("alloc memory failed for ");
+	if (!data)
 		return -ENOMEM;
-	}
 
 	bytes += sprintf(&data[bytes], "</TESTLOG>\n");
 	ret = fs_write(data, bytes, fp);
@@ -2689,28 +2705,32 @@ static void goodix_put_test_result(struct goodix_ts_test *ts_test,
 	/* save rawdata to info->buff, only one frame */
 	if (ts_test->rawdata[0].size) {
 		for (i = 0; i < ts_test->rawdata[0].size; i++)
-			info->buff[info->used_size + i] = ts_test->rawdata[0].data[i];
+			info->buff[info->used_size + i] =
+					ts_test->rawdata[0].data[i];
 		info->used_size += ts_test->rawdata[0].size;
 	}
 
 	/* save noisedata to info->buff */
 	if (ts_test->noisedata[0].size) {
 		for (i = 0; i < ts_test->noisedata[0].size; i++)
-			info->buff[info->used_size + i] = ts_test->noisedata[0].data[i];
+			info->buff[info->used_size + i] =
+					ts_test->noisedata[0].data[i];
 		info->used_size += ts_test->noisedata[0].size;
 	}
 
 	/* save self_noisedata to info->buff */
 	if (ts_test->self_noisedata.size) {
 		for (i = 0; i < ts_test->self_noisedata.size; i++)
-			info->buff[info->used_size + i] = ts_test->self_noisedata.data[i];
+			info->buff[info->used_size + i] =
+					ts_test->self_noisedata.data[i];
 		info->used_size += ts_test->self_noisedata.size;
 	}
 
 	/* save self_rawdata to info->buff */
 	if (ts_test->self_rawdata.size) {
 		for (i = 0; i < ts_test->self_rawdata.size; i++)
-			info->buff[info->used_size + i] = ts_test->self_rawdata.data[i];
+			info->buff[info->used_size + i] =
+					ts_test->self_rawdata.data[i];
 		info->used_size += ts_test->self_rawdata.size;
 	}
 
@@ -2723,19 +2743,23 @@ static void goodix_put_test_result(struct goodix_ts_test *ts_test,
 	}
 	ts_info("Have bus error:%d", have_bus_error);
 	if (have_bus_error || have_panel_error)
-		goodix_strncat(ts_test->test_info, "[FAIL]-", TS_RAWDATA_RESULT_MAX);
+		goodix_strncat(ts_test->test_info, "[FAIL]-",
+				TS_RAWDATA_RESULT_MAX);
 	else
-		goodix_strncat(ts_test->test_info, "[PASS]-", TS_RAWDATA_RESULT_MAX);
+		goodix_strncat(ts_test->test_info, "[PASS]-",
+				TS_RAWDATA_RESULT_MAX);
 
 	if (have_bus_error)
-		goodix_strncat(ts_test->test_info, "0F-", TS_RAWDATA_RESULT_MAX);
+		goodix_strncat(ts_test->test_info, "0F-",
+				TS_RAWDATA_RESULT_MAX);
 	else
-		goodix_strncat(ts_test->test_info, "0P-", TS_RAWDATA_RESULT_MAX);
+		goodix_strncat(ts_test->test_info, "0P-",
+				TS_RAWDATA_RESULT_MAX);
 
 	for (i = 0; i < MAX_TEST_ITEMS; i++) {
 		/* if have tested, show result */
 		if (ts_test->test_result[i]) {
-			if (GTP_TEST_PASS == ts_test->test_result[i])
+			if (ts_test->test_result[i] == GTP_TEST_PASS)
 				goodix_strncatint(ts_test->test_info, i, "%dP-",
 					TS_RAWDATA_RESULT_MAX);
 			else
@@ -2821,48 +2845,47 @@ static void goodix_put_test_result(struct goodix_ts_test *ts_test,
 #ifdef SAVE_IN_CSV
 	/* save result to file */
 	goodix_save_result_data(ts_test);
-#endif	
+#endif
 }
 
-static int goodix_do_inspect(struct goodix_ts_core *cd, struct ts_rawdata_info *info)
+static int goodix_do_inspect(struct goodix_ts_core *cd,
+		struct ts_rawdata_info *info)
 {
-    int ret;
-    struct goodix_ts_test *ts_test = NULL;
+	int ret;
+	struct goodix_ts_test *ts_test = NULL;
 
-    if (!cd || !info) {
-        ts_err("core_data or info is NULL");
-        return -ENODEV;
-    }
+	if (!cd || !info) {
+		ts_err("core_data or info is NULL");
+		return -ENODEV;
+	}
 
 	ts_test = kzalloc(sizeof(*ts_test), GFP_KERNEL);
-	if (!ts_test) {
-		ts_err("Failed to alloc mem");
+	if (!ts_test)
 		return -ENOMEM;
-	}
 
-    ts_test->ts = cd;
-    ret = goodix_tptest_prepare(ts_test);
-    if (ret < 0) {
-        ts_err("Failed to prepare TP test, exit");
-        strncpy(info->result, "[FAIL]-0F-software reason\n",
-			TS_RAWDATA_RESULT_MAX - 1);
-        goto exit_finish;
-    }
-    ts_info("TP test prepare OK");
+	ts_test->ts = cd;
+	ret = goodix_tptest_prepare(ts_test);
+	if (ret < 0) {
+		ts_err("Failed to prepare TP test, exit");
+		strncpy(info->result, "[FAIL]-0F-software reason\n",
+				TS_RAWDATA_RESULT_MAX - 1);
+		goto exit_finish;
+	}
+	ts_info("TP test prepare OK");
 
-    goodix_capacitance_test(ts_test); /* 1F 3F 6F 7F test */
+	goodix_capacitance_test(ts_test); /* 1F 3F 6F 7F test */
 	if (ts_test->test_params.test_items[GTP_SHORT_TEST])
-    	goodix_shortcircut_test(ts_test); /* 5F test */
-    goodix_put_test_result(ts_test, info);
-    goodix_tptest_finish(ts_test);
+		goodix_shortcircut_test(ts_test); /* 5F test */
+	goodix_put_test_result(ts_test, info);
+	goodix_tptest_finish(ts_test);
 
 exit_finish:
 	kfree(ts_test);
-    return ret;
+	return ret;
 }
 
 /* show rawdata */
-static ssize_t goodix_ts_get_rawdata_show(struct device *dev,
+static ssize_t get_rawdata_show(struct device *dev,
 		struct device_attribute *attr, char *buf)
 {
 	int ret = 0;
@@ -2870,10 +2893,8 @@ static ssize_t goodix_ts_get_rawdata_show(struct device *dev,
 	struct goodix_ts_core *cd = dev_get_drvdata(dev);
 
 	info = kzalloc(sizeof(*info), GFP_KERNEL);
-	if (!info) {
-		ts_err("Failed to alloc rawdata info memory");
+	if (!info)
 		return -ENOMEM;
-	}
 
 	goodix_do_inspect(cd, info);
 
@@ -2883,7 +2904,7 @@ static ssize_t goodix_ts_get_rawdata_show(struct device *dev,
 	return ret;
 }
 
-static DEVICE_ATTR(get_rawdata, S_IRUGO, goodix_ts_get_rawdata_show, NULL);
+static DEVICE_ATTR(get_rawdata, 0444, get_rawdata_show, NULL);
 
 int inspect_module_init(void)
 {
@@ -2903,7 +2924,7 @@ int inspect_module_init(void)
 
 err_out:
 	ts_err("inspect module init failed!");
-	return ret;	
+	return ret;
 }
 
 void inspect_module_exit(void)

goodix_ts_gesture.c

@@ -1,384 +0,0 @@
-/*
- * Goodix Gesture Module
- *
- * Copyright (C) 2019 - 2020 Goodix, Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be a reference
- * to you, when you are integrating the GOODiX's CTP IC into your system,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- */
-#include <linux/spinlock.h>
-#include <linux/module.h>
-#include <linux/kernel.h>
-#include <linux/init.h>
-#include <linux/slab.h>
-#include <linux/string.h>
-#include <linux/input.h>
-#include <linux/platform_device.h>
-#include <linux/version.h>
-#include <linux/delay.h>
-#include <linux/atomic.h>
-#include "goodix_ts_core.h"
-
-#define QUERYBIT(longlong, bit) (!!(longlong[bit/8] & (1 << bit%8)))
-
-#define GSX_GESTURE_TYPE_LEN	32
-
-/*
- * struct gesture_module - gesture module data
- * @registered: module register state
- * @sysfs_node_created: sysfs node state
- * @gesture_type: valid gesture type, each bit represent one gesture type
- * @gesture_data: store latest gesture code get from irq event
- * @gesture_ts_cmd: gesture command data
- */
-struct gesture_module {
-	atomic_t registered;
-	rwlock_t rwlock;
-	u8 gesture_type[GSX_GESTURE_TYPE_LEN];
-	u8 gesture_data;
-	struct goodix_ext_module module;
-};
-
-static struct gesture_module *gsx_gesture; /*allocated in gesture init module*/
-static bool module_initialized;
-
-
-int goodix_gesture_enable(int enable)
-{
-	int ret = 0;
-
-	if (!module_initialized)
-		return 0;		
-
-	if (enable) {
-		if (atomic_read(&gsx_gesture->registered))
-			ts_info("gesture module has been already registered");
-		else
-			ret = goodix_register_ext_module_no_wait(&gsx_gesture->module);
-	} else {
-		if (!atomic_read(&gsx_gesture->registered))
-			ts_info("gesture module has been already unregistered");
-		else
-			ret = goodix_unregister_ext_module(&gsx_gesture->module);
-	}
-
-	return ret;
-}
-
-/**
- * gsx_gesture_type_show - show valid gesture type
- *
- * @module: pointer to goodix_ext_module struct
- * @buf: pointer to output buffer
- * Returns >=0 - succeed,< 0 - failed
- */
-static ssize_t gsx_gesture_type_show(struct goodix_ext_module *module,
-				char *buf)
-{
-	int count = 0, i, ret = 0;
-	unsigned char *type;
-
-	type = kzalloc(PAGE_SIZE, GFP_KERNEL);
-	if (!type)
-		return -ENOMEM;
-	read_lock(&gsx_gesture->rwlock);
-	for (i = 0; i < 256; i++) {
-		if (QUERYBIT(gsx_gesture->gesture_type, i)) {
-			count += scnprintf(type + count,
-					   PAGE_SIZE, "%02x,", i);
-		}
-	}
-	if (count > 0)
-		ret = scnprintf(buf, PAGE_SIZE, "%s\n", type);
-	read_unlock(&gsx_gesture->rwlock);
-
-	kfree(type);
-	return ret;
-}
-
-/**
- * gsx_gesture_type_store - set vailed gesture
- *
- * @module: pointer to goodix_ext_module struct
- * @buf: pointer to valid gesture type
- * @count: length of buf
- * Returns >0 - valid gestures, < 0 - failed
- */
-static ssize_t gsx_gesture_type_store(struct goodix_ext_module *module,
-		const char *buf, size_t count)
-{
-	int i;
-
-	if (count <= 0 || count > 256 || buf == NULL) {
-		ts_err("Parameter error");
-		return -EINVAL;
-	}
-
-	write_lock(&gsx_gesture->rwlock);
-	memset(gsx_gesture->gesture_type, 0, GSX_GESTURE_TYPE_LEN);
-	for (i = 0; i < count; i++)
-		gsx_gesture->gesture_type[buf[i]/8] |= (0x1 << buf[i]%8);
-	write_unlock(&gsx_gesture->rwlock);
-
-	return count;
-}
-
-static ssize_t gsx_gesture_enable_show(struct goodix_ext_module *module,
-		char *buf)
-{
-	return scnprintf(buf, PAGE_SIZE, "%d\n",
-			 atomic_read(&gsx_gesture->registered));
-}
-
-static ssize_t gsx_gesture_enable_store(struct goodix_ext_module *module,
-		const char *buf, size_t count)
-{
-	bool val;
-	int ret;
-
-	ret = strtobool(buf, &val);
-	if (ret < 0)
-		return ret;
-
-	if (val) {
-		ret = goodix_gesture_enable(1);
-		return ret ? ret : count;
-	} else {
-		ret = goodix_gesture_enable(0);
-		return ret ? ret : count;
-	}
-}
-
-static ssize_t gsx_gesture_data_show(struct goodix_ext_module *module,
-				char *buf)
-{
-	ssize_t count;
-
-	read_lock(&gsx_gesture->rwlock);
-	count = scnprintf(buf, PAGE_SIZE, "gesture type code:0x%x\n",
-			  gsx_gesture->gesture_data);
-	read_unlock(&gsx_gesture->rwlock);
-
-	return count;
-}
-
-const struct goodix_ext_attribute gesture_attrs[] = {
-	__EXTMOD_ATTR(type, 0666, gsx_gesture_type_show,
-		gsx_gesture_type_store),
-	__EXTMOD_ATTR(enable, 0666, gsx_gesture_enable_show,
-		gsx_gesture_enable_store),
-	__EXTMOD_ATTR(data, 0444, gsx_gesture_data_show, NULL)
-};
-
-static int gsx_gesture_init(struct goodix_ts_core *cd,
-		struct goodix_ext_module *module)
-{
-	if (!cd || !cd->hw_ops->gesture) {
-		ts_err("gesture unsupported");
-		return -EINVAL;
-	}
-
-	ts_info("gesture switch: ON");
-	ts_debug("enable all gesture type");
-	/* set all bit to 1 to enable all gesture wakeup */
-	memset(gsx_gesture->gesture_type, 0xff, GSX_GESTURE_TYPE_LEN);
-	atomic_set(&gsx_gesture->registered, 1);
-
-	return 0;
-}
-
-static int gsx_gesture_exit(struct goodix_ts_core *cd,
-		struct goodix_ext_module *module)
-{
-	if (!cd || !cd->hw_ops->gesture) {
-		ts_err("gesture unsupported");
-		return -EINVAL;
-	}
-
-	ts_info("gesture switch: OFF");
-	ts_debug("disable all gesture type");
-	memset(gsx_gesture->gesture_type, 0x00, GSX_GESTURE_TYPE_LEN);
-	atomic_set(&gsx_gesture->registered, 0);
-	
-	return 0;
-}
-
-/**
- * gsx_gesture_ist - Gesture Irq handle
- * This functions is excuted when interrupt happended and
- * ic in doze mode.
- *
- * @cd: pointer to touch core data
- * @module: pointer to goodix_ext_module struct
- * return: 0 goon execute, EVT_CANCEL_IRQEVT  stop execute
- */
-static int gsx_gesture_ist(struct goodix_ts_core *cd,
-	struct goodix_ext_module *module)
-{
-	struct goodix_ts_hw_ops *hw_ops = cd->hw_ops;
-	struct goodix_ts_event gs_event = {0};
-	int ret;
-
-	if (atomic_read(&cd->suspended) == 0)
-		return EVT_CONTINUE;
-
-	ret = hw_ops->event_handler(cd, &gs_event);
-	if (ret) {
-		ts_err("failed get gesture data");
-		goto re_send_ges_cmd;
-	}
-	
-	if (!(gs_event.event_type & EVENT_GESTURE)) {
-		ts_err("invalid event type: 0x%x",
-			cd->ts_event.event_type);
-		goto re_send_ges_cmd;
-	}
-
-	if (QUERYBIT(gsx_gesture->gesture_type,
-		     gs_event.gesture_type)) {
-		gsx_gesture->gesture_data = gs_event.gesture_type;
-		/* do resume routine */
-		ts_info("got valid gesture type 0x%x",
-			gs_event.gesture_type);
-		input_report_key(cd->input_dev, KEY_POWER, 1);
-		input_sync(cd->input_dev);
-		input_report_key(cd->input_dev, KEY_POWER, 0);
-		input_sync(cd->input_dev);
-		goto gesture_ist_exit;
-	} else {
-		ts_info("unsupported gesture:%x", gs_event.gesture_type);
-	}
-
-re_send_ges_cmd:
-	if (hw_ops->gesture(cd, 0))
-		ts_info("warning: failed re_send gesture cmd");
-gesture_ist_exit:
-	if (!cd->tools_ctrl_sync)
-		hw_ops->after_event_handler(cd);
-	return EVT_CANCEL_IRQEVT;
-}
-
-/**
- * gsx_gesture_before_suspend - execute gesture suspend routine
- * This functions is excuted to set ic into doze mode
- *
- * @cd: pointer to touch core data
- * @module: pointer to goodix_ext_module struct
- * return: 0 goon execute, EVT_IRQCANCLED  stop execute
- */
-static int gsx_gesture_before_suspend(struct goodix_ts_core *cd,
-	struct goodix_ext_module *module)
-{
-	int ret;
-	const struct goodix_ts_hw_ops *hw_ops = cd->hw_ops;
-
-	ret = hw_ops->gesture(cd, 0);
-	if (ret)
-		ts_err("failed enter gesture mode");
-	else
-		ts_info("enter gesture mode");
-
-	hw_ops->irq_enable(cd, true);
-	enable_irq_wake(cd->irq);
-
-	return EVT_CANCEL_SUSPEND;
-}
-
-static int gsx_gesture_before_resume(struct goodix_ts_core *cd,
-	struct goodix_ext_module *module)
-{
-	const struct goodix_ts_hw_ops *hw_ops = cd->hw_ops;
-
-	hw_ops->irq_enable(cd, false);
-	disable_irq_wake(cd->irq);
-	hw_ops->reset(cd, GOODIX_NORMAL_RESET_DELAY_MS);
-
-	return EVT_CANCEL_RESUME;
-}
-
-static struct goodix_ext_module_funcs gsx_gesture_funcs = {
-	.irq_event = gsx_gesture_ist,
-	.init = gsx_gesture_init,
-	.exit = gsx_gesture_exit,
-	.before_suspend = gsx_gesture_before_suspend,
-	.before_resume = gsx_gesture_before_resume,
-};
-
-int gesture_module_init(void)
-{
-	int ret;
-	int i;
-	struct kobject *def_kobj = goodix_get_default_kobj();
-	struct kobj_type *def_kobj_type = goodix_get_default_ktype();
-
-	gsx_gesture = kzalloc(sizeof(struct gesture_module), GFP_KERNEL);
-	if (!gsx_gesture)
-		return -ENOMEM;
-
-	gsx_gesture->module.funcs = &gsx_gesture_funcs;
-	gsx_gesture->module.priority = EXTMOD_PRIO_GESTURE;
-	gsx_gesture->module.name = "Goodix_gsx_gesture";
-	gsx_gesture->module.priv_data = gsx_gesture;
-
-	atomic_set(&gsx_gesture->registered, 0);
-	rwlock_init(&gsx_gesture->rwlock);
-
-	/* gesture sysfs init */
-	ret = kobject_init_and_add(&gsx_gesture->module.kobj,
-			def_kobj_type, def_kobj, "gesture");
-	if (ret) {
-		ts_err("failed create gesture sysfs node!");
-		goto err_out;
-	}
-
-	for (i = 0; i < ARRAY_SIZE(gesture_attrs) && !ret; i++)
-		ret = sysfs_create_file(&gsx_gesture->module.kobj,
-				&gesture_attrs[i].attr);
-	if (ret) {
-		ts_err("failed create gst sysfs files");
-		while (--i >= 0)
-			sysfs_remove_file(&gsx_gesture->module.kobj,
-					&gesture_attrs[i].attr);
-
-		kobject_put(&gsx_gesture->module.kobj);
-		goto err_out;
-	}
-
-	module_initialized = true;
-	ts_info("gesture module init success");
-
-	return 0;
-
-err_out:
-	ts_err("gesture module init failed!");
-	kfree(gsx_gesture);
-	return ret;
-}
-
-void gesture_module_exit(void)
-{
-	int i;
-
-	ts_info("gesture module exit");
-	if (!module_initialized)
-		return;
-
-	goodix_gesture_enable(0);
-
-	/* deinit sysfs */
-	for (i = 0; i < ARRAY_SIZE(gesture_attrs); i++)
-		sysfs_remove_file(&gsx_gesture->module.kobj,
-					&gesture_attrs[i].attr);
-
-	kobject_put(&gsx_gesture->module.kobj);
-	kfree(gsx_gesture);
-	module_initialized = false;
-}