[PATCH v4 0/2] Input: Add Cypress Gen5 Touchscreen driver

[PATCH v4 0/2] Input: Add Cypress Gen5 Touchscreen driver

[Mylène Josserand]

Hi everyone,

Here is a V4 series to add the driver of the touchscreen Cypress,
TrueTouch Generation 5.
Based on last master branch of "input" kernel's tree, last commit c1b433e04ef9.

This touchscreen is similar to Cypress generation 4 but the
registers are different.

This driver uses regmap as it is possible to use I2C or SPI
busses. Currently, only the I2C support are available in the driver.
This touchscreen can handle some multitouch events as buttons using
some defined zones. That is why the driver handles buttons and
multitouch events.

Changes since v3:
   - Rebased on last input's branch
   - Changed the CRC table to use crc_itu_t_table instead of
   crc_ccitt_false_table which is not merged.
   - Added selection of CRC_ITU_T on KConfig
Changes since v2:
   - Removed pinctrl in dt-binding example which is uncessecary.
   - Added Acked-by and Reviewed-by received.
Changes since v1:
   - Updated the driver according to reviews. Most important modifications:
   removed unnecessary mutex, updated dev_err output, handled return cases
   in a better way, created a HID_ENUM, removed magic value, used an
   existing CRC table and used "linux-keycodes" instead of sub-nodes.
   - Updated the dt-bindings to use linux-keycodes and removed properties'
   description that comes from touchscreen's binding.

Patch 01: Add the basis of the driver for Cypress Gen5 Touchscreen.
Patch 02: Add the binding documentation for this driver.

If you have any remarks, let me know.

Thank you in advance,
Mylène

Mylène Josserand (2):
  Input: Add driver for Cypress Generation 5 touchscreen
  dt-bindings: input: Add documentation for cyttsp5

 .../bindings/input/touchscreen/cypress,cyttsp5.txt |   39 +
 drivers/input/touchscreen/Kconfig                  |   16 +
 drivers/input/touchscreen/Makefile                 |    1 +
 drivers/input/touchscreen/cyttsp5.c                | 1110 ++++++++++++++++++++
 4 files changed, 1166 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/input/touchscreen/cypress,cyttsp5.txt
 create mode 100644 drivers/input/touchscreen/cyttsp5.c

-- 
2.11.0

--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

[PATCH v4 1/2] Input: Add driver for Cypress Generation 5 touchscreen

[Mylène Josserand]

This is the basic driver for the Cypress TrueTouch Gen5 touchscreen
controllers. This driver supports only the I2C bus but it uses regmap
so SPI support could be added later.
The touchscreen can retrieve some defined zone that are handled as
buttons (according to the hardware). That is why it handles
button and multitouch events.

Reviewed-by: Maxime Ripard <maxime.ripard@free-electrons.com>
Signed-off-by: Mylène Josserand <mylene.josserand@free-electrons.com>
---
 drivers/input/touchscreen/Kconfig   |   16 +
 drivers/input/touchscreen/Makefile  |    1 +
 drivers/input/touchscreen/cyttsp5.c | 1110 +++++++++++++++++++++++++++++++++++
 3 files changed, 1127 insertions(+)
 create mode 100644 drivers/input/touchscreen/cyttsp5.c

diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index 0cfdb7cb610e..28eea6d5f1bb 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -238,6 +238,22 @@ config TOUCHSCREEN_CYTTSP4_SPI
 	  To compile this driver as a module, choose M here: the
 	  module will be called cyttsp4_spi.
 
+config TOUCHSCREEN_CYTTSP5
+	tristate "Cypress TrueTouch Gen5 Touchscreen Driver"
+	depends on OF
+	select REGMAP_I2C
+	select CRC_ITU_T
+	help
+	  Driver for Parade TrueTouch Standard Product
+	  Generation 5 touchscreen controllers.
+	  I2C bus interface support only.
+
+	  Say Y here if you have a Cypress Gen5 touchscreen.
+	  If unsure, say N.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called cyttsp5.
+
 config TOUCHSCREEN_DA9034
 	tristate "Touchscreen support for Dialog Semiconductor DA9034"
 	depends on PMIC_DA903X
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index d2a2b3b7af27..e7d124901dd9 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -26,6 +26,7 @@ obj-$(CONFIG_TOUCHSCREEN_CYTTSP_SPI)	+= cyttsp_spi.o
 obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_CORE)	+= cyttsp4_core.o
 obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_I2C)	+= cyttsp4_i2c.o cyttsp_i2c_common.o
 obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_SPI)	+= cyttsp4_spi.o
+obj-$(CONFIG_TOUCHSCREEN_CYTTSP5)	+= cyttsp5.o
 obj-$(CONFIG_TOUCHSCREEN_DA9034)	+= da9034-ts.o
 obj-$(CONFIG_TOUCHSCREEN_DA9052)	+= da9052_tsi.o
 obj-$(CONFIG_TOUCHSCREEN_DYNAPRO)	+= dynapro.o
diff --git a/drivers/input/touchscreen/cyttsp5.c b/drivers/input/touchscreen/cyttsp5.c
new file mode 100644
index 000000000000..a41feea2cd5a
--- /dev/null
+++ b/drivers/input/touchscreen/cyttsp5.c
@@ -0,0 +1,1110 @@
+/*
+ * Parade TrueTouch(TM) Standard Product V5 Module.
+ * For use with Parade touchscreen controllers.
+ *
+ * Copyright (C) 2015 Parade Technologies
+ * Copyright (C) 2012-2015 Cypress Semiconductor
+ * Copyright (C) 2017 Free Electrons
+ *
+ * Author: Mylène Josserand <mylene.josserand@free-electrons.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2, and only version 2, 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.
+ *
+ */
+
+#include <asm/unaligned.h>
+#include <linux/crc-itu-t.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/gpio.h>
+#include <linux/input/mt.h>
+#include <linux/input/touchscreen.h>
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/of_device.h>
+#include <linux/regmap.h>
+
+#define CYTTSP5_NAME				"cyttsp5"
+#define CY_I2C_DATA_SIZE			(2 * 256)
+#define HID_VERSION				0x0100
+#define CY_MAX_INPUT				512
+#define CYTTSP5_PREALLOCATED_CMD_BUFFER	32
+#define CY_BITS_PER_BTN			1
+#define CY_NUM_BTN_EVENT_ID			((1 << CY_BITS_PER_BTN) - 1)
+
+#define MAX_AREA				255
+#define HID_OUTPUT_BL_SOP			0x1
+#define HID_OUTPUT_BL_EOP			0x17
+#define HID_OUTPUT_BL_LAUNCH_APP		0x3B
+#define HID_OUTPUT_BL_LAUNCH_APP_SIZE		11
+#define HID_OUTPUT_GET_SYSINFO			0x2
+#define HID_OUTPUT_GET_SYSINFO_SIZE		5
+
+#define HID_DESC_REG				0x1
+#define HID_INPUT_REG				0x3
+#define HID_OUTPUT_REG				0x4
+
+#define REPORT_ID_TOUCH			0x1
+#define REPORT_ID_BTN				0x3
+#define REPORT_SIZE_5				5
+#define REPORT_SIZE_8				8
+#define REPORT_SIZE_16				16
+
+/* Touch reports offsets */
+/* Header offsets */
+#define TOUCH_REPORT_DESC_HDR_CONTACTCOUNT	16
+/* Record offsets */
+#define TOUCH_REPORT_DESC_CONTACTID		8
+#define TOUCH_REPORT_DESC_X			16
+#define TOUCH_REPORT_DESC_Y			32
+#define TOUCH_REPORT_DESC_P			48
+#define TOUCH_REPORT_DESC_MAJ			56
+#define TOUCH_REPORT_DESC_MIN			64
+
+/* HID */
+#define HID_TOUCH_REPORT_ID			0x1
+#define HID_BTN_REPORT_ID			0x3
+#define HID_APP_RESPONSE_REPORT_ID		0x1F
+#define HID_APP_OUTPUT_REPORT_ID		0x2F
+#define HID_BL_RESPONSE_REPORT_ID		0x30
+#define HID_BL_OUTPUT_REPORT_ID		0x40
+
+#define HID_OUTPUT_RESPONSE_REPORT_OFFSET	2
+#define HID_OUTPUT_RESPONSE_CMD_OFFSET		4
+#define HID_OUTPUT_RESPONSE_CMD_MASK		0x7F
+
+#define HID_SYSINFO_SENSING_OFFSET		33
+#define HID_SYSINFO_BTN_OFFSET			48
+#define HID_SYSINFO_BTN_MASK			0xFF
+#define HID_SYSINFO_MAX_BTN			8
+
+/*  Timeout in ms */
+#define CY_HID_OUTPUT_TIMEOUT			200
+#define CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT	3000
+#define CY_HID_GET_HID_DESCRIPTOR_TIMEOUT	4000
+
+/* maximum number of concurrent tracks */
+#define TOUCH_REPORT_SIZE			10
+#define TOUCH_INPUT_HEADER_SIZE		7
+#define BTN_REPORT_SIZE			9
+#define BTN_INPUT_HEADER_SIZE			5
+
+/* All usage pages for Touch Report */
+#define TOUCH_REPORT_USAGE_PG_X		0x00010030
+#define TOUCH_REPORT_USAGE_PG_Y		0x00010031
+#define TOUCH_REPORT_USAGE_PG_P		0x000D0030
+#define TOUCH_REPORT_USAGE_PG_CONTACTID	0x000D0051
+#define TOUCH_REPORT_USAGE_PG_CONTACTCOUNT	0x000D0054
+#define TOUCH_REPORT_USAGE_PG_MAJ		0xFF010062
+#define TOUCH_REPORT_USAGE_PG_MIN		0xFF010063
+#define TOUCH_COL_USAGE_PG			0x000D0022
+
+/* helpers */
+#define HI_BYTE(x)				(u8)(((x) >> 8) & 0xFF)
+#define LOW_BYTE(x)				(u8)((x) & 0xFF)
+
+/* System Information interface definitions */
+struct cyttsp5_sensing_conf_data_dev {
+	u8 electrodes_x;
+	u8 electrodes_y;
+	__le16 len_x;
+	__le16 len_y;
+	__le16 res_x;
+	__le16 res_y;
+	__le16 max_z;
+	u8 origin_x;
+	u8 origin_y;
+	u8 btn;
+	u8 scan_mode;
+	u8 max_num_of_tch_per_refresh_cycle;
+} __packed;
+
+struct cyttsp5_sensing_conf_data {
+	u16 res_x;
+	u16 res_y;
+	u16 max_z;
+	u16 len_x;
+	u16 len_y;
+	u8 origin_x;
+	u8 origin_y;
+	u8 max_tch;
+};
+
+enum { HID_CMD_DONE, HID_CMD_BUSY } hid_cmd_state;
+
+enum cyttsp5_tch_abs {	/* for ordering within the extracted touch data array */
+	CY_TCH_X,	/* X */
+	CY_TCH_Y,	/* Y */
+	CY_TCH_P,	/* P (Z) */
+	CY_TCH_T,	/* TOUCH ID */
+	CY_TCH_MAJ,	/* TOUCH_MAJOR */
+	CY_TCH_MIN,	/* TOUCH_MINOR */
+	CY_TCH_NUM_ABS,
+};
+
+struct cyttsp5_tch_abs_params {
+	size_t ofs;	/* abs byte offset */
+	size_t size;	/* size in bits */
+	size_t min;	/* min value */
+	size_t max;	/* max value */
+	size_t bofs;	/* bit offset */
+};
+
+struct cyttsp5_touch {
+	int hdr;
+	int abs[CY_TCH_NUM_ABS];
+};
+
+struct cyttsp5_sysinfo {
+	struct cyttsp5_sensing_conf_data sensing_conf_data;
+	int num_btns;
+	struct cyttsp5_tch_abs_params tch_hdr;
+	struct cyttsp5_tch_abs_params tch_abs[CY_TCH_NUM_ABS];
+	u32 key_code[HID_SYSINFO_MAX_BTN];
+	u8 *xy_mode;
+	u8 *xy_data;
+};
+
+struct cyttsp5_hid_desc {
+	__le16 hid_desc_len;
+	u8 packet_id;
+	u8 reserved_byte;
+	__le16 bcd_version;
+	__le16 report_desc_len;
+	__le16 report_desc_register;
+	__le16 input_register;
+	__le16 max_input_len;
+	__le16 output_register;
+	__le16 max_output_len;
+	__le16 command_register;
+	__le16 data_register;
+	__le16 vendor_id;
+	__le16 product_id;
+	__le16 version_id;
+	u8 reserved[4];
+} __packed;
+
+struct cyttsp5 {
+	struct device *dev;
+	struct mutex system_lock;
+	wait_queue_head_t wait_q;
+	struct cyttsp5_sysinfo sysinfo;
+	int hid_cmd_state;
+	struct cyttsp5_hid_desc hid_desc;
+	u8 cmd_buf[CYTTSP5_PREALLOCATED_CMD_BUFFER];
+	u8 input_buf[CY_MAX_INPUT];
+	u8 response_buf[CY_MAX_INPUT];
+	struct gpio_desc *reset_gpio;
+	struct input_dev *input;
+	char phys[NAME_MAX];
+	int num_prv_rec;
+	struct regmap *regmap;
+};
+
+/*
+ * For what understood in the datasheet, the register does not
+ * matter. For consistency, used the Input Register address
+ * but it does mean anything to the device. The important data
+ * to send is the I2C address
+ */
+static int cyttsp5_read(struct cyttsp5 *ts, u8 *buf, u32 max)
+{
+	int rc;
+	u32 size;
+	u8 temp[2];
+
+	if (!buf)
+		return -EINVAL;
+
+	/* Read the frame to retrieve the size */
+	rc = regmap_bulk_read(ts->regmap, HID_INPUT_REG, temp, 2);
+	if (rc < 0)
+		return rc;
+
+	size = get_unaligned_le16(temp);
+	if (!size || size == 2)
+		return 0;
+
+	if (size > max)
+		return -EINVAL;
+
+	/* Get the real value */
+	return regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, size);
+}
+
+static int cyttsp5_write(struct cyttsp5 *ts, unsigned int reg, u8 *data,
+			 size_t size)
+{
+	u8 cmd[size + 1];
+
+	/* High bytes of register address needed as first byte of cmd */
+	cmd[0] = HI_BYTE(reg);
+
+	/* Copy the rest of the data */
+	if (data)
+		memcpy(&cmd[1], data, size);
+
+	/* The hardware wants to receive a frame with the address register
+	 * contains in the first two bytes. As the regmap_write function
+	 * add the register adresse in the frame, we use the LOW_BYTE as
+	 * first frame byte for the address register and the first
+	 * data byte is the high register + left of the cmd to send
+	 */
+	return regmap_bulk_write(ts->regmap, LOW_BYTE(reg), cmd, size + 1);
+}
+
+static void cyttsp5_final_sync(struct input_dev *input, int max_slots,
+			       unsigned long *ids)
+{
+	int t;
+
+	for (t = 0; t < max_slots; t++) {
+		if (test_bit(t, ids))
+			continue;
+		input_mt_slot(input, t);
+		input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
+	}
+
+	input_sync(input);
+}
+
+static void cyttsp5_report_slot_liftoff(struct cyttsp5 *ts, int max_slots)
+{
+	int t;
+
+	if (ts->num_prv_rec == 0)
+		return;
+
+	for (t = 0; t < max_slots; t++) {
+		input_mt_slot(ts->input, t);
+		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, false);
+	}
+}
+
+static void cyttsp5_mt_lift_all(struct cyttsp5 *ts)
+{
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int max = si->tch_abs[CY_TCH_T].max;
+
+	if (ts->num_prv_rec != 0) {
+		cyttsp5_report_slot_liftoff(ts, max);
+		input_sync(ts->input);
+		ts->num_prv_rec = 0;
+	}
+}
+
+static void cyttsp5_get_touch_axis(int *axis, int size, int max, u8 *xy_data,
+				   int bofs)
+{
+	int nbyte;
+	int next;
+
+	for (nbyte = 0, *axis = 0, next = 0; nbyte < size; nbyte++)
+		*axis = *axis + ((xy_data[nbyte] >> bofs) << (nbyte * 8));
+
+	*axis &= max - 1;
+}
+
+static void cyttsp5_get_touch_record(struct cyttsp5 *ts,
+				     struct cyttsp5_touch *touch, u8 *xy_data)
+{
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	enum cyttsp5_tch_abs abs;
+
+	for (abs = CY_TCH_X; abs < CY_TCH_NUM_ABS; abs++) {
+		cyttsp5_get_touch_axis(&touch->abs[abs],
+				       si->tch_abs[abs].size,
+				       si->tch_abs[abs].max,
+				       xy_data + si->tch_abs[abs].ofs,
+				       si->tch_abs[abs].bofs);
+	}
+}
+
+static void cyttsp5_get_mt_touches(struct cyttsp5 *ts,
+				   struct cyttsp5_touch *tch, int num_cur_tch)
+{
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int i, t = 0;
+	DECLARE_BITMAP(ids, si->tch_abs[CY_TCH_T].max);
+	u8 *tch_addr;
+	int tmp;
+
+	bitmap_zero(ids, si->tch_abs[CY_TCH_T].max);
+	memset(tch->abs, 0, sizeof(tch->abs));
+
+	for (i = 0; i < num_cur_tch; i++) {
+		tch_addr = si->xy_data + (i * TOUCH_REPORT_SIZE);
+		cyttsp5_get_touch_record(ts, tch, tch_addr);
+
+		/* Convert MAJOR/MINOR from mm to resolution */
+		tmp = tch->abs[CY_TCH_MAJ] * 100 * si->sensing_conf_data.res_x;
+		tch->abs[CY_TCH_MAJ] = tmp / si->sensing_conf_data.len_x;
+		tmp = tch->abs[CY_TCH_MIN] * 100 * si->sensing_conf_data.res_x;
+		tch->abs[CY_TCH_MIN] = tmp / si->sensing_conf_data.len_x;
+
+		t = tch->abs[CY_TCH_T];
+		input_mt_slot(ts->input, t);
+		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
+		__set_bit(t, ids);
+
+		/* position and pressure fields */
+		input_report_abs(ts->input, ABS_MT_POSITION_X,
+				 tch->abs[CY_TCH_X]);
+		input_report_abs(ts->input, ABS_MT_POSITION_Y,
+				 tch->abs[CY_TCH_Y]);
+		input_report_abs(ts->input, ABS_MT_PRESSURE,
+				 tch->abs[CY_TCH_P]);
+
+		/* Get the extended touch fields */
+		input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR,
+				 tch->abs[CY_TCH_MAJ]);
+		input_report_abs(ts->input, ABS_MT_TOUCH_MINOR,
+				 tch->abs[CY_TCH_MIN]);
+	}
+
+	cyttsp5_final_sync(ts->input, si->tch_abs[CY_TCH_T].max, ids);
+
+	ts->num_prv_rec = num_cur_tch;
+}
+
+/* read xy_data for all current touches */
+static int cyttsp5_xy_worker(struct cyttsp5 *ts)
+{
+	struct device *dev = ts->dev;
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int max_tch = si->sensing_conf_data.max_tch;
+	struct cyttsp5_touch tch;
+	u8 num_cur_tch;
+
+	cyttsp5_get_touch_axis(&tch.hdr, si->tch_hdr.size,
+			       si->tch_hdr.max,
+			       si->xy_mode + 3 + si->tch_hdr.ofs,
+			       si->tch_hdr.bofs);
+
+	num_cur_tch = tch.hdr;
+	if (num_cur_tch > max_tch) {
+		dev_err(dev, "Num touch err detected (n=%d)\n", num_cur_tch);
+		num_cur_tch = max_tch;
+	}
+
+	if (num_cur_tch == 0 && ts->num_prv_rec == 0)
+		return 0;
+
+	/* extract xy_data for all currently reported touches */
+	if (num_cur_tch)
+		cyttsp5_get_mt_touches(ts, &tch, num_cur_tch);
+	else
+		cyttsp5_mt_lift_all(ts);
+
+	return 0;
+}
+
+static int cyttsp5_mt_attention(struct device *dev)
+{
+	struct cyttsp5 *ts = dev_get_drvdata(dev);
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int rc;
+
+	if (si->xy_mode[2] != HID_TOUCH_REPORT_ID)
+		return 0;
+
+	/* core handles handshake */
+	rc = cyttsp5_xy_worker(ts);
+	if (rc < 0)
+		dev_err(dev, "xy_worker error r=%d\n", rc);
+
+	return rc;
+}
+
+static int cyttsp5_setup_input_device(struct device *dev)
+{
+	struct cyttsp5 *ts = dev_get_drvdata(dev);
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int max_x, max_y, max_p;
+	int max_x_tmp, max_y_tmp;
+	int rc;
+
+	__set_bit(EV_ABS, ts->input->evbit);
+	__set_bit(EV_REL, ts->input->evbit);
+	__set_bit(EV_KEY, ts->input->evbit);
+
+	max_x_tmp = si->sensing_conf_data.res_x;
+	max_y_tmp = si->sensing_conf_data.res_y;
+	max_x = max_y_tmp - 1;
+	max_y = max_x_tmp - 1;
+	max_p = si->sensing_conf_data.max_z;
+
+	input_mt_init_slots(ts->input, si->tch_abs[CY_TCH_T].max, 0);
+
+	__set_bit(ABS_MT_POSITION_X, ts->input->absbit);
+	__set_bit(ABS_MT_POSITION_Y, ts->input->absbit);
+	__set_bit(ABS_MT_PRESSURE, ts->input->absbit);
+
+	input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
+	input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
+	input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, max_p, 0, 0);
+
+	input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);
+	input_set_abs_params(ts->input, ABS_MT_TOUCH_MINOR, 0, MAX_AREA, 0, 0);
+
+	rc = input_register_device(ts->input);
+	if (rc < 0)
+		dev_err(dev, "Error, failed register input device r=%d\n", rc);
+
+	return rc;
+}
+
+#ifdef CONFIG_OF
+static int cyttsp5_parse_dt_key_code(struct device *dev)
+{
+	struct cyttsp5 *ts = dev_get_drvdata(dev);
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	struct device_node *np;
+	int i;
+
+	np = dev->of_node;
+	if (!np)
+		return -EINVAL;
+
+	if (!si->num_btns)
+		return 0;
+
+	/* Initialize the button to RESERVED */
+	for (i = 0; i < si->num_btns; i++)
+		si->key_code[i] = KEY_RESERVED;
+
+	return of_property_read_u32_array(np, "linux,keycodes",
+				   si->key_code, si->num_btns);
+}
+#else
+static int cyttsp5_parse_dt_key_code(struct device *dev)
+{
+	struct cyttsp5 *ts = dev_get_drvdata(dev);
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int i;
+
+	if (!si->num_btns)
+		return 0;
+
+	/* Initialize the button to RESERVED */
+	for (i = 0; i < si->num_btns; i++)
+		si->key_code[i] = KEY_RESERVED;
+
+	return 0;
+}
+#endif
+
+static int cyttsp5_btn_attention(struct device *dev)
+{
+	struct cyttsp5 *ts = dev_get_drvdata(dev);
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int cur_btn;
+	int cur_btn_state;
+
+	if (si->xy_mode[2] != HID_BTN_REPORT_ID || !si->num_btns)
+		return 0;
+
+	/* extract button press/release touch information */
+	for (cur_btn = 0; cur_btn < si->num_btns; cur_btn++) {
+		/* Get current button state */
+		cur_btn_state = (si->xy_data[0] >> (cur_btn * CY_BITS_PER_BTN))
+			& CY_NUM_BTN_EVENT_ID;
+
+		input_report_key(ts->input, si->key_code[cur_btn],
+				 cur_btn_state);
+		input_sync(ts->input);
+	}
+
+	return 0;
+}
+
+static u16 cyttsp5_compute_crc(u8 *buf, u32 size)
+{
+	u16 remainder = 0xFFFF;
+	u16 xor_mask = 0x0000;
+	u32 index;
+	u32 byte_value;
+	u32 table_index;
+	u32 crc_bit_width = sizeof(u16) * 8;
+
+	/* Divide the message by polynomial, via the table. */
+	for (index = 0; index < size; index++) {
+		byte_value = buf[index];
+		table_index = ((byte_value >> 4) & 0x0F)
+			^ (remainder >> (crc_bit_width - 4));
+		remainder = crc_itu_t_table[table_index]
+			^ (remainder << 4);
+		table_index = (byte_value & 0x0F)
+			^ (remainder >> (crc_bit_width - 4));
+		remainder = crc_itu_t_table[table_index]
+			^ (remainder << 4);
+	}
+
+	/* Perform the final remainder CRC. */
+	return remainder ^ xor_mask;
+}
+
+static int cyttsp5_validate_cmd_response(struct cyttsp5 *ts, u8 code)
+{
+	u16 size, crc;
+	u8 status, offset;
+	int command_code;
+
+	size = get_unaligned_le16(&ts->response_buf[0]);
+
+	if (!size)
+		return 0;
+
+	offset = ts->response_buf[HID_OUTPUT_RESPONSE_REPORT_OFFSET];
+
+	if (offset == HID_BL_RESPONSE_REPORT_ID) {
+		if (ts->response_buf[4] != HID_OUTPUT_BL_SOP) {
+			dev_err(ts->dev, "HID output response, wrong SOP\n");
+			return -EPROTO;
+		}
+
+		if (ts->response_buf[size - 1] != HID_OUTPUT_BL_EOP) {
+			dev_err(ts->dev, "HID output response, wrong EOP\n");
+			return -EPROTO;
+		}
+
+		crc = cyttsp5_compute_crc(&ts->response_buf[4], size - 7);
+		if (ts->response_buf[size - 3] != LOW_BYTE(crc) ||
+		    ts->response_buf[size - 2] != HI_BYTE(crc)) {
+			dev_err(ts->dev, "HID output response, wrong CRC 0x%X\n",
+				crc);
+			return -EPROTO;
+		}
+
+		status = ts->response_buf[5];
+		if (status) {
+			dev_err(ts->dev, "HID output response, ERROR:%d\n",
+				status);
+			return -EPROTO;
+		}
+	}
+
+	if (offset == HID_APP_RESPONSE_REPORT_ID) {
+		command_code = ts->response_buf[HID_OUTPUT_RESPONSE_CMD_OFFSET]
+			& HID_OUTPUT_RESPONSE_CMD_MASK;
+		if (command_code != code) {
+			dev_err(ts->dev,
+				"HID output response, wrong command_code:%X\n",
+				command_code);
+			return -EPROTO;
+		}
+	}
+
+	return 0;
+}
+
+static void cyttsp5_si_get_btn_data(struct cyttsp5 *ts)
+{
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int i;
+	unsigned int btns = ts->response_buf[HID_SYSINFO_BTN_OFFSET]
+		& HID_SYSINFO_BTN_MASK;
+
+	si->num_btns = 0;
+	for (i = 0; i < HID_SYSINFO_MAX_BTN; i++) {
+		if (btns & BIT(i))
+			si->num_btns++;
+	}
+}
+
+static int cyttsp5_get_sysinfo_regs(struct cyttsp5 *ts)
+{
+	struct cyttsp5_sensing_conf_data *scd = &ts->sysinfo.sensing_conf_data;
+	struct cyttsp5_sensing_conf_data_dev *scd_dev =
+		(struct cyttsp5_sensing_conf_data_dev *)
+		&ts->response_buf[HID_SYSINFO_SENSING_OFFSET];
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+
+	cyttsp5_si_get_btn_data(ts);
+
+	scd->max_tch = scd_dev->max_num_of_tch_per_refresh_cycle;
+	scd->res_x = get_unaligned_le16(&scd_dev->res_x);
+	scd->res_y = get_unaligned_le16(&scd_dev->res_y);
+	scd->max_z = get_unaligned_le16(&scd_dev->max_z);
+	scd->len_x = get_unaligned_le16(&scd_dev->len_x);
+	scd->len_y = get_unaligned_le16(&scd_dev->len_y);
+
+	si->xy_data = devm_kzalloc(ts->dev, scd->max_tch * TOUCH_REPORT_SIZE,
+				   GFP_KERNEL);
+	if (!si->xy_data)
+		return -ENOMEM;
+
+	si->xy_mode = devm_kzalloc(ts->dev, TOUCH_INPUT_HEADER_SIZE,
+				   GFP_KERNEL);
+	if (!si->xy_mode)
+		return -ENOMEM;
+
+	return 0;
+}
+
+static int cyttsp5_hid_output_get_sysinfo(struct cyttsp5 *ts)
+{
+	int rc;
+	u8 cmd[HID_OUTPUT_GET_SYSINFO_SIZE];
+
+	ts->hid_cmd_state = HID_CMD_BUSY;
+
+	/* HI bytes of Output register address */
+	cmd[0] = LOW_BYTE(HID_OUTPUT_GET_SYSINFO_SIZE);
+	cmd[1] = HI_BYTE(HID_OUTPUT_GET_SYSINFO_SIZE);
+	cmd[2] = HID_APP_OUTPUT_REPORT_ID;
+	cmd[3] = 0x0; /* Reserved */
+	cmd[4] = HID_OUTPUT_GET_SYSINFO;
+
+	rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
+			   HID_OUTPUT_GET_SYSINFO_SIZE);
+	if (rc) {
+		dev_err(ts->dev, "Failed to write command %d", rc);
+		goto error;
+	}
+
+	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
+				msecs_to_jiffies(CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT));
+	if (!rc) {
+		dev_err(ts->dev, "HID output cmd execution timed out\n");
+		rc = -ETIME;
+		goto error;
+	}
+
+	rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_GET_SYSINFO);
+	if (rc) {
+		dev_err(ts->dev, "Validation of the response failed\n");
+		goto error;
+	}
+
+	return cyttsp5_get_sysinfo_regs(ts);
+
+error:
+	mutex_lock(&ts->system_lock);
+	ts->hid_cmd_state = HID_CMD_DONE;
+	mutex_unlock(&ts->system_lock);
+	return rc;
+}
+
+static int cyttsp5_hid_output_bl_launch_app(struct cyttsp5 *ts)
+{
+	int rc;
+	u8 cmd[HID_OUTPUT_BL_LAUNCH_APP];
+	u16 crc;
+
+	mutex_lock(&ts->system_lock);
+	ts->hid_cmd_state = HID_CMD_BUSY;
+	mutex_unlock(&ts->system_lock);
+
+	cmd[0] = LOW_BYTE(HID_OUTPUT_BL_LAUNCH_APP_SIZE);
+	cmd[1] = HI_BYTE(HID_OUTPUT_BL_LAUNCH_APP_SIZE);
+	cmd[2] = HID_BL_OUTPUT_REPORT_ID;
+	cmd[3] = 0x0; /* Reserved */
+	cmd[4] = HID_OUTPUT_BL_SOP;
+	cmd[5] = HID_OUTPUT_BL_LAUNCH_APP;
+	cmd[6] = 0x0; /* Low bytes of data */
+	cmd[7] = 0x0; /* Hi bytes of data */
+	crc = cyttsp5_compute_crc(&cmd[4], 4);
+	cmd[8] = LOW_BYTE(crc);
+	cmd[9] = HI_BYTE(crc);
+	cmd[10] = HID_OUTPUT_BL_EOP;
+
+	rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
+			   HID_OUTPUT_BL_LAUNCH_APP_SIZE);
+	if (rc) {
+		dev_err(ts->dev, "Failed to write command %d", rc);
+		goto error;
+	}
+
+	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
+				msecs_to_jiffies(CY_HID_OUTPUT_TIMEOUT));
+	if (!rc) {
+		dev_err(ts->dev, "HID output cmd execution timed out\n");
+		rc = -ETIME;
+		goto error;
+	}
+
+	rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_BL_LAUNCH_APP);
+	if (rc) {
+		dev_err(ts->dev, "Validation of the response failed\n");
+		goto error;
+	}
+
+	return rc;
+
+error:
+	mutex_lock(&ts->system_lock);
+	ts->hid_cmd_state = HID_CMD_DONE;
+	mutex_unlock(&ts->system_lock);
+
+	return rc;
+}
+
+static int cyttsp5_get_hid_descriptor(struct cyttsp5 *ts,
+				      struct cyttsp5_hid_desc *desc)
+{
+	struct device *dev = ts->dev;
+	__le16 hid_desc_register = HID_DESC_REG;
+	int rc;
+	u8 cmd[2];
+
+	/* Read HID descriptor length and version */
+	mutex_lock(&ts->system_lock);
+	ts->hid_cmd_state = HID_CMD_BUSY;
+	mutex_unlock(&ts->system_lock);
+
+	/* Set HID descriptor register */
+	memcpy(cmd, &hid_desc_register, sizeof(hid_desc_register));
+
+	rc = cyttsp5_write(ts, HID_DESC_REG, NULL, 0);
+	if (rc < 0) {
+		dev_err(dev, "Failed to get HID descriptor, rc=%d\n", rc);
+		goto error;
+	}
+
+	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
+				msecs_to_jiffies(CY_HID_GET_HID_DESCRIPTOR_TIMEOUT));
+	if (!rc) {
+		dev_err(ts->dev, "HID get descriptor timed out\n");
+		rc = -ETIME;
+		goto error;
+	}
+
+	memcpy(desc, ts->response_buf, sizeof(struct cyttsp5_hid_desc));
+
+	/* Check HID descriptor length and version */
+	if (le16_to_cpu(desc->hid_desc_len) != sizeof(*desc) ||
+	    le16_to_cpu(desc->bcd_version) != HID_VERSION) {
+		dev_err(dev, "Unsupported HID version\n");
+		return -ENODEV;
+	}
+
+	goto exit;
+
+error:
+	mutex_lock(&ts->system_lock);
+	ts->hid_cmd_state = HID_CMD_DONE;
+	mutex_unlock(&ts->system_lock);
+exit:
+	return rc;
+}
+
+static int fill_tch_abs(struct cyttsp5_tch_abs_params *tch_abs, int report_size,
+			int offset)
+{
+	tch_abs->ofs = offset / 8;
+	tch_abs->size = report_size / 8;
+	if (report_size % 8)
+		tch_abs->size += 1;
+	tch_abs->min = 0;
+	tch_abs->max = 1 << report_size;
+	tch_abs->bofs = offset - (tch_abs->ofs << 3);
+
+	return 0;
+}
+
+static int move_button_data(struct cyttsp5 *ts, struct cyttsp5_sysinfo *si)
+{
+	memcpy(si->xy_mode, ts->input_buf, BTN_INPUT_HEADER_SIZE);
+	memcpy(si->xy_data, &ts->input_buf[BTN_INPUT_HEADER_SIZE],
+	       BTN_REPORT_SIZE);
+
+	return 0;
+}
+
+static int move_touch_data(struct cyttsp5 *ts, struct cyttsp5_sysinfo *si)
+{
+	int max_tch = si->sensing_conf_data.max_tch;
+	int num_cur_tch;
+	int length;
+	struct cyttsp5_tch_abs_params *tch = &si->tch_hdr;
+
+	memcpy(si->xy_mode, ts->input_buf, TOUCH_INPUT_HEADER_SIZE);
+
+	cyttsp5_get_touch_axis(&num_cur_tch, tch->size,
+			       tch->max, si->xy_mode + 3 + tch->ofs, tch->bofs);
+	if (unlikely(num_cur_tch > max_tch))
+		num_cur_tch = max_tch;
+
+	length = num_cur_tch * TOUCH_REPORT_SIZE;
+
+	memcpy(si->xy_data, &ts->input_buf[TOUCH_INPUT_HEADER_SIZE], length);
+
+	return 0;
+}
+
+static irqreturn_t cyttsp5_handle_irq(int irq, void *handle)
+{
+	struct cyttsp5 *ts = handle;
+	int report_id;
+	int size;
+	int rc;
+
+	rc = cyttsp5_read(ts, ts->input_buf, CY_MAX_INPUT);
+	if (rc)
+		return IRQ_HANDLED;
+
+	size = get_unaligned_le16(&ts->input_buf[0]);
+
+	/* check reset */
+	if (size == 0) {
+		memcpy(ts->response_buf, ts->input_buf, 2);
+
+		mutex_lock(&ts->system_lock);
+		ts->hid_cmd_state = HID_CMD_DONE;
+		mutex_unlock(&ts->system_lock);
+		wake_up(&ts->wait_q);
+		return IRQ_HANDLED;
+	}
+
+	report_id = ts->input_buf[2];
+
+	if (report_id == HID_TOUCH_REPORT_ID) {
+		move_touch_data(ts, &ts->sysinfo);
+		cyttsp5_mt_attention(ts->dev);
+	} else if (report_id == HID_BTN_REPORT_ID) {
+		move_button_data(ts, &ts->sysinfo);
+		cyttsp5_btn_attention(ts->dev);
+	} else {
+		/* It is not an input but a command response */
+		memcpy(ts->response_buf, ts->input_buf, size);
+
+		mutex_lock(&ts->system_lock);
+		ts->hid_cmd_state = HID_CMD_DONE;
+		mutex_unlock(&ts->system_lock);
+		wake_up(&ts->wait_q);
+	}
+
+	return IRQ_HANDLED;
+}
+
+static int cyttsp5_deassert_int(struct cyttsp5 *ts)
+{
+	u16 size;
+	u8 buf[2];
+	int rc;
+
+	rc = regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, 2);
+	if (rc < 0)
+		return rc;
+
+	size = get_unaligned_le16(&buf[0]);
+	if (size == 2 || size == 0)
+		return 0;
+
+	return -EINVAL;
+}
+
+static int cyttsp5_fill_all_touch(struct cyttsp5 *ts)
+{
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+
+	fill_tch_abs(&si->tch_abs[CY_TCH_X], REPORT_SIZE_16,
+		     TOUCH_REPORT_DESC_X);
+	fill_tch_abs(&si->tch_abs[CY_TCH_Y], REPORT_SIZE_16,
+		     TOUCH_REPORT_DESC_Y);
+	fill_tch_abs(&si->tch_abs[CY_TCH_P], REPORT_SIZE_8,
+		     TOUCH_REPORT_DESC_P);
+	fill_tch_abs(&si->tch_abs[CY_TCH_T], REPORT_SIZE_5,
+		     TOUCH_REPORT_DESC_CONTACTID);
+	fill_tch_abs(&si->tch_hdr, REPORT_SIZE_5,
+		     TOUCH_REPORT_DESC_HDR_CONTACTCOUNT);
+	fill_tch_abs(&si->tch_abs[CY_TCH_MAJ], REPORT_SIZE_8,
+		     TOUCH_REPORT_DESC_MAJ);
+	fill_tch_abs(&si->tch_abs[CY_TCH_MIN], REPORT_SIZE_8,
+		     TOUCH_REPORT_DESC_MIN);
+
+	return 0;
+}
+
+static int cyttsp5_startup(struct cyttsp5 *ts)
+{
+	int rc;
+
+	rc = cyttsp5_deassert_int(ts);
+	if (rc) {
+		dev_err(ts->dev, "Error on deassert int r=%d\n", rc);
+		return -ENODEV;
+	}
+
+	/*
+	 * Launch the application as the device starts in bootloader mode
+	 * because of a power-on-reset
+	 */
+	rc = cyttsp5_hid_output_bl_launch_app(ts);
+	if (rc < 0) {
+		dev_err(ts->dev, "Error on launch app r=%d\n", rc);
+		return rc;
+	}
+
+	rc = cyttsp5_get_hid_descriptor(ts, &ts->hid_desc);
+	if (rc < 0) {
+		dev_err(ts->dev, "Error on getting HID descriptor r=%d\n", rc);
+		return rc;
+	}
+
+	rc = cyttsp5_fill_all_touch(ts);
+	if (rc < 0) {
+		dev_err(ts->dev, "Error on report descriptor r=%d\n", rc);
+		return rc;
+	}
+
+	rc = cyttsp5_hid_output_get_sysinfo(ts);
+	if (rc) {
+		dev_err(ts->dev, "Error on getting sysinfo r=%d\n", rc);
+		return rc;
+	}
+
+	return rc;
+}
+
+#ifdef CONFIG_OF
+static const struct of_device_id cyttsp5_of_match[] = {
+	{ .compatible = "cypress,cyttsp5", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, cyttsp5_of_match);
+#endif
+
+static const struct i2c_device_id cyttsp5_i2c_id[] = {
+	{ CYTTSP5_NAME, 0, },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, cyttsp5_i2c_id);
+
+static int cyttsp5_probe(struct device *dev, struct regmap *regmap, int irq,
+			 const char *name)
+{
+	struct cyttsp5 *ts;
+	struct cyttsp5_sysinfo *si;
+	int rc = 0, i;
+
+	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
+	if (!ts)
+		return -ENOMEM;
+
+	/* Initialize device info */
+	ts->regmap = regmap;
+	ts->dev = dev;
+	si = &ts->sysinfo;
+	dev_set_drvdata(dev, ts);
+
+	/* Initialize mutexes and spinlocks */
+	mutex_init(&ts->system_lock);
+
+	/* Initialize wait queue */
+	init_waitqueue_head(&ts->wait_q);
+
+	/* Reset the gpio to be in a reset state */
+	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
+	if (IS_ERR(ts->reset_gpio)) {
+		rc = PTR_ERR(ts->reset_gpio);
+		dev_err(dev, "Failed to request reset gpio, error %d\n", rc);
+		return rc;
+	}
+	gpiod_set_value(ts->reset_gpio, 1);
+
+	/* Need a delay to have device up */
+	msleep(20);
+
+	rc = devm_request_threaded_irq(dev, irq, NULL, cyttsp5_handle_irq,
+				       IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+				       name, ts);
+	if (rc) {
+		dev_err(dev, "unable to request IRQ\n");
+		return rc;
+	}
+
+	rc = cyttsp5_startup(ts);
+	if (rc) {
+		dev_err(ts->dev, "Fail initial startup r=%d\n", rc);
+		return rc;
+	}
+
+	rc = cyttsp5_parse_dt_key_code(dev);
+	if (rc < 0) {
+		dev_err(ts->dev, "Error while parsing dts %d\n", rc);
+		return rc;
+	}
+
+	ts->input = devm_input_allocate_device(dev);
+	if (!ts->input) {
+		dev_err(dev, "Error, failed to allocate input device\n");
+		return -ENODEV;
+	}
+
+	ts->input->name = "cyttsp5";
+	scnprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
+	ts->input->phys = ts->phys;
+	ts->input->dev.parent = ts->dev;
+	input_set_drvdata(ts->input, ts);
+
+	touchscreen_parse_properties(ts->input, true, NULL);
+
+	__set_bit(EV_KEY, ts->input->evbit);
+	for (i = 0; i < si->num_btns; i++)
+		__set_bit(si->key_code[i], ts->input->keybit);
+
+	return cyttsp5_setup_input_device(dev);
+}
+
+static int cyttsp5_i2c_probe(struct i2c_client *client,
+			     const struct i2c_device_id *id)
+{
+	struct regmap *regmap;
+	static const struct regmap_config config = {
+		.reg_bits = 8,
+		.val_bits = 8,
+	};
+
+	regmap = devm_regmap_init_i2c(client, &config);
+	if (IS_ERR(regmap)) {
+		dev_err(&client->dev, "regmap allocation failed: %ld\n",
+			PTR_ERR(regmap));
+		return PTR_ERR(regmap);
+	}
+
+	return cyttsp5_probe(&client->dev, regmap, client->irq, client->name);
+}
+
+static int cyttsp5_remove(struct device *dev)
+{
+	struct cyttsp5 *ts = dev_get_drvdata(dev);
+
+	input_unregister_device(ts->input);
+
+	return 0;
+}
+
+static int cyttsp5_i2c_remove(struct i2c_client *client)
+{
+	struct device *dev = &client->dev;
+
+	return cyttsp5_remove(dev);
+}
+
+static struct i2c_driver cyttsp5_i2c_driver = {
+	.driver = {
+		.name = CYTTSP5_NAME,
+		.owner = THIS_MODULE,
+		.of_match_table = of_match_ptr(cyttsp5_of_match),
+	},
+	.probe = cyttsp5_i2c_probe,
+	.remove = cyttsp5_i2c_remove,
+	.id_table = cyttsp5_i2c_id,
+};
+
+module_i2c_driver(cyttsp5_i2c_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Touchscreen driver for Cypress TrueTouch Gen 5 Product");
+MODULE_AUTHOR("Mylène Josserand <mylene.josserand@free-electrons.com>");
-- 
2.11.0

Re: [PATCH v4 1/2] Input: Add driver for Cypress Generation 5 touchscreen

[kbuild test robot]

Hi Mylène,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on input/next]
[also build test WARNING on v4.15-rc1 next-20171201]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Myl-ne-Josserand/Input-Add-driver-for-Cypress-Generation-5-touchscreen/20171203-203557
base:   https://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git next


coccinelle warnings: (new ones prefixed by >>)

>> drivers/input/touchscreen/cyttsp5.c:1098:3-8: No need to set .owner here. The core will do it.

Please review and possibly fold the followup patch.

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[PATCH] Input: fix platform_no_drv_owner.cocci warnings

[kbuild test robot]

drivers/input/touchscreen/cyttsp5.c:1098:3-8: No need to set .owner here. The core will do it.

 Remove .owner field if calls are used which set it automatically

Generated by: scripts/coccinelle/api/platform_no_drv_owner.cocci

Fixes: 68d0bd1e4815 ("Input: Add driver for Cypress Generation 5 touchscreen")
CC: Mylène Josserand <mylene.josserand@free-electrons.com>
Signed-off-by: Fengguang Wu <fengguang.wu@intel.com>
---

 cyttsp5.c |    1 -
 1 file changed, 1 deletion(-)

--- a/drivers/input/touchscreen/cyttsp5.c
+++ b/drivers/input/touchscreen/cyttsp5.c
@@ -1095,7 +1095,6 @@ static int cyttsp5_i2c_remove(struct i2c
 static struct i2c_driver cyttsp5_i2c_driver = {
 	.driver = {
 		.name = CYTTSP5_NAME,
-		.owner = THIS_MODULE,
 		.of_match_table = of_match_ptr(cyttsp5_of_match),
 	},
 	.probe = cyttsp5_i2c_probe,

Re: [PATCH v4 1/2] Input: Add driver for Cypress Generation 5 touchscreen

[kbuild test robot]

Hi Mylène,

Thank you for the patch! Perhaps something to improve:

[auto build test WARNING on input/next]
[also build test WARNING on v4.15-rc3 next-20171213]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Myl-ne-Josserand/Input-Add-driver-for-Cypress-Generation-5-touchscreen/20171203-203557
base:   https://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git next
reproduce:
        # apt-get install sparse
        make ARCH=x86_64 allmodconfig
        make C=1 CF=-D__CHECK_ENDIAN__


sparse warnings: (new ones prefixed by >>)


Please review and possibly fold the followup patch.

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[RFC PATCH] Input: hid_cmd_state can be static

[kbuild test robot]

Fixes: 68d0bd1e4815 ("Input: Add driver for Cypress Generation 5 touchscreen")
Signed-off-by: Fengguang Wu <fengguang.wu@intel.com>
---
 cyttsp5.c |    2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/drivers/input/touchscreen/cyttsp5.c b/drivers/input/touchscreen/cyttsp5.c
index a41feea..9694ae41 100644
--- a/drivers/input/touchscreen/cyttsp5.c
+++ b/drivers/input/touchscreen/cyttsp5.c
@@ -139,7 +139,7 @@ struct cyttsp5_sensing_conf_data {
 	u8 max_tch;
 };
 
-enum { HID_CMD_DONE, HID_CMD_BUSY } hid_cmd_state;
+static enum { HID_CMD_DONE, HID_CMD_BUSY } hid_cmd_state;
 
 enum cyttsp5_tch_abs {	/* for ordering within the extracted touch data array */
 	CY_TCH_X,	/* X */

Re: [PATCH v4 1/2] Input: Add driver for Cypress Generation 5 touchscreen

[Maxime Ripard]

[-- Attachment #1: Type: text/plain, Size: 885 bytes --]

Dmitry,

On Fri, Dec 01, 2017 at 04:39:56PM +0100, Mylène Josserand wrote:
> This is the basic driver for the Cypress TrueTouch Gen5 touchscreen
> controllers. This driver supports only the I2C bus but it uses regmap
> so SPI support could be added later.
> The touchscreen can retrieve some defined zone that are handled as
> buttons (according to the hardware). That is why it handles
> button and multitouch events.
> 
> Reviewed-by: Maxime Ripard <maxime.ripard@free-electrons.com>
> Signed-off-by: Mylène Josserand <mylene.josserand@free-electrons.com>

Can we have some review here? This is the fourth iteration, with the
first having been sent back in May, and as far as I know we never got
any review from you. Can we please move forward on this?

Maxime

-- 
Maxime Ripard, Free Electrons
Embedded Linux and Kernel engineering
http://free-electrons.com

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [PATCH v4 1/2] Input: Add driver for Cypress Generation 5 touchscreen

[Marcus Folkesson]

[-- Attachment #1: Type: text/plain, Size: 6537 bytes --]

Mylene,

On Fri, Dec 01, 2017 at 04:39:56PM +0100, Mylène Josserand wrote:
> +++ b/drivers/input/touchscreen/cyttsp5.c
> @@ -0,0 +1,1110 @@
> +/*
> + * Parade TrueTouch(TM) Standard Product V5 Module.
> + * For use with Parade touchscreen controllers.
> + *
> + * Copyright (C) 2015 Parade Technologies
> + * Copyright (C) 2012-2015 Cypress Semiconductor
> + * Copyright (C) 2017 Free Electrons
> + *
> + * Author: Mylène Josserand <mylene.josserand-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org>
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License
> + * version 2, and only version 2, as published by the
> + * Free Software Foundation.

Please use SPDX license Identifier to describe the license.

E.g.
SPDX-License-Identifier: GPL-2.0

Also, the MODULE_LICENSE means GPL 2.0 or later per module.h and this does
not match the license description.

Could you make sure they are in sync?


> + *
> + * 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.
> + *
> + */
> +
> +#include <asm/unaligned.h>
> +#include <linux/crc-itu-t.h>
> +#include <linux/delay.h>
> +#include <linux/device.h>
> +#include <linux/gpio.h>
> +#include <linux/input/mt.h>
> +#include <linux/input/touchscreen.h>
> +#include <linux/interrupt.h>
> +#include <linux/i2c.h>
> +#include <linux/module.h>
> +#include <linux/of_device.h>
> +#include <linux/regmap.h>

#include <linux/bitops.h>

since you are using BIT()


[snip]


> +static int cyttsp5_setup_input_device(struct device *dev)
> +{
> +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> +	int max_x, max_y, max_p;
> +	int max_x_tmp, max_y_tmp;
> +	int rc;
> +
> +	__set_bit(EV_ABS, ts->input->evbit);
> +	__set_bit(EV_REL, ts->input->evbit);
> +	__set_bit(EV_KEY, ts->input->evbit);
> +
> +	max_x_tmp = si->sensing_conf_data.res_x;
> +	max_y_tmp = si->sensing_conf_data.res_y;
> +	max_x = max_y_tmp - 1;
> +	max_y = max_x_tmp - 1;
> +	max_p = si->sensing_conf_data.max_z;
> +
> +	input_mt_init_slots(ts->input, si->tch_abs[CY_TCH_T].max, 0);
> +
> +	__set_bit(ABS_MT_POSITION_X, ts->input->absbit);
> +	__set_bit(ABS_MT_POSITION_Y, ts->input->absbit);
> +	__set_bit(ABS_MT_PRESSURE, ts->input->absbit);

Not needed, input_set_abs_params() will set the bits for you below.


> +
> +	input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
> +	input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
> +	input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, max_p, 0, 0);
> +
> +	input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);
> +	input_set_abs_params(ts->input, ABS_MT_TOUCH_MINOR, 0, MAX_AREA, 0, 0);
> +
> +	rc = input_register_device(ts->input);
> +	if (rc < 0)
> +		dev_err(dev, "Error, failed register input device r=%d\n", rc);
> +
> +	return rc;
> +}
> +
> +

[snip]

> +static int cyttsp5_get_hid_descriptor(struct cyttsp5 *ts,
> +				      struct cyttsp5_hid_desc *desc)
> +{
> +	struct device *dev = ts->dev;
> +	__le16 hid_desc_register = HID_DESC_REG;
> +	int rc;
> +	u8 cmd[2];
> +
> +	/* Read HID descriptor length and version */
> +	mutex_lock(&ts->system_lock);
> +	ts->hid_cmd_state = HID_CMD_BUSY;
> +	mutex_unlock(&ts->system_lock);
> +
> +	/* Set HID descriptor register */
> +	memcpy(cmd, &hid_desc_register, sizeof(hid_desc_register));
> +
> +	rc = cyttsp5_write(ts, HID_DESC_REG, NULL, 0);
> +	if (rc < 0) {
> +		dev_err(dev, "Failed to get HID descriptor, rc=%d\n", rc);
> +		goto error;
> +	}
> +
> +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
> +				msecs_to_jiffies(CY_HID_GET_HID_DESCRIPTOR_TIMEOUT));
> +	if (!rc) {
> +		dev_err(ts->dev, "HID get descriptor timed out\n");
> +		rc = -ETIME;
> +		goto error;
> +	}
> +
> +	memcpy(desc, ts->response_buf, sizeof(struct cyttsp5_hid_desc));
> +
> +	/* Check HID descriptor length and version */
> +	if (le16_to_cpu(desc->hid_desc_len) != sizeof(*desc) ||
> +	    le16_to_cpu(desc->bcd_version) != HID_VERSION) {
> +		dev_err(dev, "Unsupported HID version\n");
> +		return -ENODEV;

Maybe it is supposed to return here, but all other faults use "goto
error".

> +	}
> +
> +	goto exit;
> +
> +error:
> +	mutex_lock(&ts->system_lock);
> +	ts->hid_cmd_state = HID_CMD_DONE;
> +	mutex_unlock(&ts->system_lock);
> +exit:
> +	return rc;
> +}
> +

[snip]

> +static int cyttsp5_probe(struct device *dev, struct regmap *regmap, int irq,
> +			 const char *name)
> +{
> +	struct cyttsp5 *ts;
> +	struct cyttsp5_sysinfo *si;
> +	int rc = 0, i;
> +
> +	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
> +	if (!ts)
> +		return -ENOMEM;
> +
> +	/* Initialize device info */
> +	ts->regmap = regmap;
> +	ts->dev = dev;
> +	si = &ts->sysinfo;
> +	dev_set_drvdata(dev, ts);
> +
> +	/* Initialize mutexes and spinlocks */

No spinlocks here :-)

> +	mutex_init(&ts->system_lock);
> +
> +	/* Initialize wait queue */
> +	init_waitqueue_head(&ts->wait_q);
> +
> +	/* Reset the gpio to be in a reset state */
> +	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
> +	if (IS_ERR(ts->reset_gpio)) {
> +		rc = PTR_ERR(ts->reset_gpio);
> +		dev_err(dev, "Failed to request reset gpio, error %d\n", rc);
> +		return rc;
> +	}
> +	gpiod_set_value(ts->reset_gpio, 1);
> +

[snip]

> +static struct i2c_driver cyttsp5_i2c_driver = {
> +	.driver = {
> +		.name = CYTTSP5_NAME,
> +		.owner = THIS_MODULE,
> +		.of_match_table = of_match_ptr(cyttsp5_of_match),
> +	},
> +	.probe = cyttsp5_i2c_probe,
> +	.remove = cyttsp5_i2c_remove,
> +	.id_table = cyttsp5_i2c_id,
> +};
> +
> +module_i2c_driver(cyttsp5_i2c_driver);
> +
> +MODULE_LICENSE("GPL");

From linux/module.h:

/*
 * The following license idents are currently accepted as indicating free
 * software modules
 *
 *	"GPL"				[GNU Public License v2 or later]
 *	"GPL v2"			[GNU Public License v2]



> +MODULE_DESCRIPTION("Touchscreen driver for Cypress TrueTouch Gen 5 Product");
> +MODULE_AUTHOR("Mylène Josserand <mylene.josserand-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org>");
> -- 
> 2.11.0
> 

Best regards
Marcus Folkesson

[-- Attachment #2: signature.asc --]
[-- Type: application/pgp-signature, Size: 833 bytes --]

Re: [PATCH v4 1/2] Input: Add driver for Cypress Generation 5 touchscreen

[Mylene Josserand]

Hello Marcus,

Thank you for the review.

Le Mon, 22 Jan 2018 21:11:09 +0100,
Marcus Folkesson <marcus.folkesson@gmail.com> a écrit :

> Mylene,
> 
> On Fri, Dec 01, 2017 at 04:39:56PM +0100, Mylène Josserand wrote:
> > +++ b/drivers/input/touchscreen/cyttsp5.c
> > @@ -0,0 +1,1110 @@
> > +/*
> > + * Parade TrueTouch(TM) Standard Product V5 Module.
> > + * For use with Parade touchscreen controllers.
> > + *
> > + * Copyright (C) 2015 Parade Technologies
> > + * Copyright (C) 2012-2015 Cypress Semiconductor
> > + * Copyright (C) 2017 Free Electrons
> > + *
> > + * Author: Mylène Josserand <mylene.josserand@free-electrons.com>
> > + *
> > + * This program is free software; you can redistribute it and/or
> > + * modify it under the terms of the GNU General Public License
> > + * version 2, and only version 2, as published by the
> > + * Free Software Foundation.  
> 
> Please use SPDX license Identifier to describe the license.
> 
> E.g.
> SPDX-License-Identifier: GPL-2.0
> 
> Also, the MODULE_LICENSE means GPL 2.0 or later per module.h and this does
> not match the license description.
> 
> Could you make sure they are in sync?

You are right, I will check that, thanks.

> 
> 
> > + *
> > + * 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.
> > + *
> > + */
> > +
> > +#include <asm/unaligned.h>
> > +#include <linux/crc-itu-t.h>
> > +#include <linux/delay.h>
> > +#include <linux/device.h>
> > +#include <linux/gpio.h>
> > +#include <linux/input/mt.h>
> > +#include <linux/input/touchscreen.h>
> > +#include <linux/interrupt.h>
> > +#include <linux/i2c.h>
> > +#include <linux/module.h>
> > +#include <linux/of_device.h>
> > +#include <linux/regmap.h>  
> 
> #include <linux/bitops.h>
> 
> since you are using BIT()

okay

> 
> 
> [snip]
> 
> 
> > +static int cyttsp5_setup_input_device(struct device *dev)
> > +{
> > +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > +	int max_x, max_y, max_p;
> > +	int max_x_tmp, max_y_tmp;
> > +	int rc;
> > +
> > +	__set_bit(EV_ABS, ts->input->evbit);
> > +	__set_bit(EV_REL, ts->input->evbit);
> > +	__set_bit(EV_KEY, ts->input->evbit);
> > +
> > +	max_x_tmp = si->sensing_conf_data.res_x;
> > +	max_y_tmp = si->sensing_conf_data.res_y;
> > +	max_x = max_y_tmp - 1;
> > +	max_y = max_x_tmp - 1;
> > +	max_p = si->sensing_conf_data.max_z;
> > +
> > +	input_mt_init_slots(ts->input, si->tch_abs[CY_TCH_T].max, 0);
> > +
> > +	__set_bit(ABS_MT_POSITION_X, ts->input->absbit);
> > +	__set_bit(ABS_MT_POSITION_Y, ts->input->absbit);
> > +	__set_bit(ABS_MT_PRESSURE, ts->input->absbit);  
> 
> Not needed, input_set_abs_params() will set the bits for you below.

Yes, I will remove it.

> 
> 
> > +
> > +	input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
> > +	input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
> > +	input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, max_p, 0, 0);
> > +
> > +	input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);
> > +	input_set_abs_params(ts->input, ABS_MT_TOUCH_MINOR, 0, MAX_AREA, 0, 0);
> > +
> > +	rc = input_register_device(ts->input);
> > +	if (rc < 0)
> > +		dev_err(dev, "Error, failed register input device r=%d\n", rc);
> > +
> > +	return rc;
> > +}
> > +
> > +  
> 
> [snip]
> 
> > +static int cyttsp5_get_hid_descriptor(struct cyttsp5 *ts,
> > +				      struct cyttsp5_hid_desc *desc)
> > +{
> > +	struct device *dev = ts->dev;
> > +	__le16 hid_desc_register = HID_DESC_REG;
> > +	int rc;
> > +	u8 cmd[2];
> > +
> > +	/* Read HID descriptor length and version */
> > +	mutex_lock(&ts->system_lock);
> > +	ts->hid_cmd_state = HID_CMD_BUSY;
> > +	mutex_unlock(&ts->system_lock);
> > +
> > +	/* Set HID descriptor register */
> > +	memcpy(cmd, &hid_desc_register, sizeof(hid_desc_register));
> > +
> > +	rc = cyttsp5_write(ts, HID_DESC_REG, NULL, 0);
> > +	if (rc < 0) {
> > +		dev_err(dev, "Failed to get HID descriptor, rc=%d\n", rc);
> > +		goto error;
> > +	}
> > +
> > +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
> > +				msecs_to_jiffies(CY_HID_GET_HID_DESCRIPTOR_TIMEOUT));
> > +	if (!rc) {
> > +		dev_err(ts->dev, "HID get descriptor timed out\n");
> > +		rc = -ETIME;
> > +		goto error;
> > +	}
> > +
> > +	memcpy(desc, ts->response_buf, sizeof(struct cyttsp5_hid_desc));
> > +
> > +	/* Check HID descriptor length and version */
> > +	if (le16_to_cpu(desc->hid_desc_len) != sizeof(*desc) ||
> > +	    le16_to_cpu(desc->bcd_version) != HID_VERSION) {
> > +		dev_err(dev, "Unsupported HID version\n");
> > +		return -ENODEV;  
> 
> Maybe it is supposed to return here, but all other faults use "goto
> error".

Yep, I will use 'goto' instead of 'return' here.

> 
> > +	}
> > +
> > +	goto exit;
> > +
> > +error:
> > +	mutex_lock(&ts->system_lock);
> > +	ts->hid_cmd_state = HID_CMD_DONE;
> > +	mutex_unlock(&ts->system_lock);
> > +exit:
> > +	return rc;
> > +}
> > +  
> 
> [snip]
> 
> > +static int cyttsp5_probe(struct device *dev, struct regmap *regmap, int irq,
> > +			 const char *name)
> > +{
> > +	struct cyttsp5 *ts;
> > +	struct cyttsp5_sysinfo *si;
> > +	int rc = 0, i;
> > +
> > +	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
> > +	if (!ts)
> > +		return -ENOMEM;
> > +
> > +	/* Initialize device info */
> > +	ts->regmap = regmap;
> > +	ts->dev = dev;
> > +	si = &ts->sysinfo;
> > +	dev_set_drvdata(dev, ts);
> > +
> > +	/* Initialize mutexes and spinlocks */  
> 
> No spinlocks here :-)

I forgot to remove the comment from vendor's driver, thanks :)

> 
> > +	mutex_init(&ts->system_lock);
> > +
> > +	/* Initialize wait queue */
> > +	init_waitqueue_head(&ts->wait_q);
> > +
> > +	/* Reset the gpio to be in a reset state */
> > +	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
> > +	if (IS_ERR(ts->reset_gpio)) {
> > +		rc = PTR_ERR(ts->reset_gpio);
> > +		dev_err(dev, "Failed to request reset gpio, error %d\n", rc);
> > +		return rc;
> > +	}
> > +	gpiod_set_value(ts->reset_gpio, 1);
> > +  
> 
> [snip]
> 
> > +static struct i2c_driver cyttsp5_i2c_driver = {
> > +	.driver = {
> > +		.name = CYTTSP5_NAME,
> > +		.owner = THIS_MODULE,
> > +		.of_match_table = of_match_ptr(cyttsp5_of_match),
> > +	},
> > +	.probe = cyttsp5_i2c_probe,
> > +	.remove = cyttsp5_i2c_remove,
> > +	.id_table = cyttsp5_i2c_id,
> > +};
> > +
> > +module_i2c_driver(cyttsp5_i2c_driver);
> > +
> > +MODULE_LICENSE("GPL");  
> 
> From linux/module.h:
> 
> /*
>  * The following license idents are currently accepted as indicating free
>  * software modules
>  *
>  *	"GPL"				[GNU Public License v2 or later]
>  *	"GPL v2"			[GNU Public License v2]
> 

Okay, noted.

> 
> 
> > +MODULE_DESCRIPTION("Touchscreen driver for Cypress TrueTouch Gen 5 Product");
> > +MODULE_AUTHOR("Mylène Josserand <mylene.josserand@free-electrons.com>");
> > -- 
> > 2.11.0
> >   
> 
> Best regards
> Marcus Folkesson

Best regards,

-- 
Mylène Josserand, Free Electrons
Embedded Linux and Kernel engineering
http://free-electrons.com

Re: [PATCH v4 1/2] Input: Add driver for Cypress Generation 5 touchscreen

[Dmitry Torokhov]

Hi Mylène,

On Fri, Dec 01, 2017 at 04:39:56PM +0100, Mylène Josserand wrote:
> This is the basic driver for the Cypress TrueTouch Gen5 touchscreen
> controllers. This driver supports only the I2C bus but it uses regmap
> so SPI support could be added later.
> The touchscreen can retrieve some defined zone that are handled as
> buttons (according to the hardware). That is why it handles
> button and multitouch events.
> 
> Reviewed-by: Maxime Ripard <maxime.ripard-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org>
> Signed-off-by: Mylène Josserand <mylene.josserand-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org>
> ---
>  drivers/input/touchscreen/Kconfig   |   16 +
>  drivers/input/touchscreen/Makefile  |    1 +
>  drivers/input/touchscreen/cyttsp5.c | 1110 +++++++++++++++++++++++++++++++++++
>  3 files changed, 1127 insertions(+)
>  create mode 100644 drivers/input/touchscreen/cyttsp5.c
> 
> diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
> index 0cfdb7cb610e..28eea6d5f1bb 100644
> --- a/drivers/input/touchscreen/Kconfig
> +++ b/drivers/input/touchscreen/Kconfig
> @@ -238,6 +238,22 @@ config TOUCHSCREEN_CYTTSP4_SPI
>  	  To compile this driver as a module, choose M here: the
>  	  module will be called cyttsp4_spi.
>  
> +config TOUCHSCREEN_CYTTSP5
> +	tristate "Cypress TrueTouch Gen5 Touchscreen Driver"
> +	depends on OF

Does it have to be? Please use generic device properties
(device_property_* API) and it can be used with ACPI and static board
files, of needed.

> +	select REGMAP_I2C
> +	select CRC_ITU_T
> +	help
> +	  Driver for Parade TrueTouch Standard Product
> +	  Generation 5 touchscreen controllers.
> +	  I2C bus interface support only.
> +
> +	  Say Y here if you have a Cypress Gen5 touchscreen.
> +	  If unsure, say N.
> +
> +	  To compile this driver as a module, choose M here: the
> +	  module will be called cyttsp5.
> +
>  config TOUCHSCREEN_DA9034
>  	tristate "Touchscreen support for Dialog Semiconductor DA9034"
>  	depends on PMIC_DA903X
> diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
> index d2a2b3b7af27..e7d124901dd9 100644
> --- a/drivers/input/touchscreen/Makefile
> +++ b/drivers/input/touchscreen/Makefile
> @@ -26,6 +26,7 @@ obj-$(CONFIG_TOUCHSCREEN_CYTTSP_SPI)	+= cyttsp_spi.o
>  obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_CORE)	+= cyttsp4_core.o
>  obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_I2C)	+= cyttsp4_i2c.o cyttsp_i2c_common.o
>  obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_SPI)	+= cyttsp4_spi.o
> +obj-$(CONFIG_TOUCHSCREEN_CYTTSP5)	+= cyttsp5.o
>  obj-$(CONFIG_TOUCHSCREEN_DA9034)	+= da9034-ts.o
>  obj-$(CONFIG_TOUCHSCREEN_DA9052)	+= da9052_tsi.o
>  obj-$(CONFIG_TOUCHSCREEN_DYNAPRO)	+= dynapro.o
> diff --git a/drivers/input/touchscreen/cyttsp5.c b/drivers/input/touchscreen/cyttsp5.c
> new file mode 100644
> index 000000000000..a41feea2cd5a
> --- /dev/null
> +++ b/drivers/input/touchscreen/cyttsp5.c
> @@ -0,0 +1,1110 @@
> +/*
> + * Parade TrueTouch(TM) Standard Product V5 Module.
> + * For use with Parade touchscreen controllers.
> + *
> + * Copyright (C) 2015 Parade Technologies
> + * Copyright (C) 2012-2015 Cypress Semiconductor
> + * Copyright (C) 2017 Free Electrons
> + *
> + * Author: Mylène Josserand <mylene.josserand-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org>
> + *
> + * This program is free software; you can redistribute it and/or
> + * modify it under the terms of the GNU General Public License
> + * version 2, and only version 2, 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.
> + *
> + */
> +
> +#include <asm/unaligned.h>
> +#include <linux/crc-itu-t.h>
> +#include <linux/delay.h>
> +#include <linux/device.h>
> +#include <linux/gpio.h>
> +#include <linux/input/mt.h>
> +#include <linux/input/touchscreen.h>
> +#include <linux/interrupt.h>
> +#include <linux/i2c.h>
> +#include <linux/module.h>
> +#include <linux/of_device.h>
> +#include <linux/regmap.h>
> +
> +#define CYTTSP5_NAME				"cyttsp5"
> +#define CY_I2C_DATA_SIZE			(2 * 256)
> +#define HID_VERSION				0x0100
> +#define CY_MAX_INPUT				512
> +#define CYTTSP5_PREALLOCATED_CMD_BUFFER	32
> +#define CY_BITS_PER_BTN			1
> +#define CY_NUM_BTN_EVENT_ID			((1 << CY_BITS_PER_BTN) - 1)
> +
> +#define MAX_AREA				255
> +#define HID_OUTPUT_BL_SOP			0x1
> +#define HID_OUTPUT_BL_EOP			0x17
> +#define HID_OUTPUT_BL_LAUNCH_APP		0x3B
> +#define HID_OUTPUT_BL_LAUNCH_APP_SIZE		11
> +#define HID_OUTPUT_GET_SYSINFO			0x2
> +#define HID_OUTPUT_GET_SYSINFO_SIZE		5
> +
> +#define HID_DESC_REG				0x1
> +#define HID_INPUT_REG				0x3
> +#define HID_OUTPUT_REG				0x4
> +
> +#define REPORT_ID_TOUCH			0x1
> +#define REPORT_ID_BTN				0x3
> +#define REPORT_SIZE_5				5
> +#define REPORT_SIZE_8				8
> +#define REPORT_SIZE_16				16
> +
> +/* Touch reports offsets */
> +/* Header offsets */
> +#define TOUCH_REPORT_DESC_HDR_CONTACTCOUNT	16
> +/* Record offsets */
> +#define TOUCH_REPORT_DESC_CONTACTID		8
> +#define TOUCH_REPORT_DESC_X			16
> +#define TOUCH_REPORT_DESC_Y			32
> +#define TOUCH_REPORT_DESC_P			48
> +#define TOUCH_REPORT_DESC_MAJ			56
> +#define TOUCH_REPORT_DESC_MIN			64
> +
> +/* HID */
> +#define HID_TOUCH_REPORT_ID			0x1
> +#define HID_BTN_REPORT_ID			0x3
> +#define HID_APP_RESPONSE_REPORT_ID		0x1F
> +#define HID_APP_OUTPUT_REPORT_ID		0x2F
> +#define HID_BL_RESPONSE_REPORT_ID		0x30
> +#define HID_BL_OUTPUT_REPORT_ID		0x40
> +
> +#define HID_OUTPUT_RESPONSE_REPORT_OFFSET	2
> +#define HID_OUTPUT_RESPONSE_CMD_OFFSET		4
> +#define HID_OUTPUT_RESPONSE_CMD_MASK		0x7F
> +
> +#define HID_SYSINFO_SENSING_OFFSET		33
> +#define HID_SYSINFO_BTN_OFFSET			48
> +#define HID_SYSINFO_BTN_MASK			0xFF
> +#define HID_SYSINFO_MAX_BTN			8
> +
> +/*  Timeout in ms */
> +#define CY_HID_OUTPUT_TIMEOUT			200
> +#define CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT	3000
> +#define CY_HID_GET_HID_DESCRIPTOR_TIMEOUT	4000
> +
> +/* maximum number of concurrent tracks */
> +#define TOUCH_REPORT_SIZE			10
> +#define TOUCH_INPUT_HEADER_SIZE		7
> +#define BTN_REPORT_SIZE			9
> +#define BTN_INPUT_HEADER_SIZE			5
> +
> +/* All usage pages for Touch Report */
> +#define TOUCH_REPORT_USAGE_PG_X		0x00010030
> +#define TOUCH_REPORT_USAGE_PG_Y		0x00010031
> +#define TOUCH_REPORT_USAGE_PG_P		0x000D0030
> +#define TOUCH_REPORT_USAGE_PG_CONTACTID	0x000D0051
> +#define TOUCH_REPORT_USAGE_PG_CONTACTCOUNT	0x000D0054
> +#define TOUCH_REPORT_USAGE_PG_MAJ		0xFF010062
> +#define TOUCH_REPORT_USAGE_PG_MIN		0xFF010063
> +#define TOUCH_COL_USAGE_PG			0x000D0022
> +
> +/* helpers */
> +#define HI_BYTE(x)				(u8)(((x) >> 8) & 0xFF)
> +#define LOW_BYTE(x)				(u8)((x) & 0xFF)
> +
> +/* System Information interface definitions */
> +struct cyttsp5_sensing_conf_data_dev {
> +	u8 electrodes_x;
> +	u8 electrodes_y;
> +	__le16 len_x;
> +	__le16 len_y;
> +	__le16 res_x;
> +	__le16 res_y;
> +	__le16 max_z;
> +	u8 origin_x;
> +	u8 origin_y;
> +	u8 btn;
> +	u8 scan_mode;
> +	u8 max_num_of_tch_per_refresh_cycle;
> +} __packed;
> +
> +struct cyttsp5_sensing_conf_data {
> +	u16 res_x;
> +	u16 res_y;
> +	u16 max_z;
> +	u16 len_x;
> +	u16 len_y;
> +	u8 origin_x;
> +	u8 origin_y;
> +	u8 max_tch;
> +};
> +
> +enum { HID_CMD_DONE, HID_CMD_BUSY } hid_cmd_state;
> +
> +enum cyttsp5_tch_abs {	/* for ordering within the extracted touch data array */
> +	CY_TCH_X,	/* X */
> +	CY_TCH_Y,	/* Y */
> +	CY_TCH_P,	/* P (Z) */
> +	CY_TCH_T,	/* TOUCH ID */
> +	CY_TCH_MAJ,	/* TOUCH_MAJOR */
> +	CY_TCH_MIN,	/* TOUCH_MINOR */
> +	CY_TCH_NUM_ABS,
> +};
> +
> +struct cyttsp5_tch_abs_params {
> +	size_t ofs;	/* abs byte offset */
> +	size_t size;	/* size in bits */
> +	size_t min;	/* min value */
> +	size_t max;	/* max value */
> +	size_t bofs;	/* bit offset */
> +};
> +
> +struct cyttsp5_touch {
> +	int hdr;
> +	int abs[CY_TCH_NUM_ABS];
> +};
> +
> +struct cyttsp5_sysinfo {
> +	struct cyttsp5_sensing_conf_data sensing_conf_data;
> +	int num_btns;
> +	struct cyttsp5_tch_abs_params tch_hdr;
> +	struct cyttsp5_tch_abs_params tch_abs[CY_TCH_NUM_ABS];
> +	u32 key_code[HID_SYSINFO_MAX_BTN];
> +	u8 *xy_mode;
> +	u8 *xy_data;
> +};
> +
> +struct cyttsp5_hid_desc {
> +	__le16 hid_desc_len;
> +	u8 packet_id;
> +	u8 reserved_byte;
> +	__le16 bcd_version;
> +	__le16 report_desc_len;
> +	__le16 report_desc_register;
> +	__le16 input_register;
> +	__le16 max_input_len;
> +	__le16 output_register;
> +	__le16 max_output_len;
> +	__le16 command_register;
> +	__le16 data_register;
> +	__le16 vendor_id;
> +	__le16 product_id;
> +	__le16 version_id;
> +	u8 reserved[4];
> +} __packed;
> +
> +struct cyttsp5 {
> +	struct device *dev;
> +	struct mutex system_lock;
> +	wait_queue_head_t wait_q;
> +	struct cyttsp5_sysinfo sysinfo;
> +	int hid_cmd_state;
> +	struct cyttsp5_hid_desc hid_desc;
> +	u8 cmd_buf[CYTTSP5_PREALLOCATED_CMD_BUFFER];
> +	u8 input_buf[CY_MAX_INPUT];
> +	u8 response_buf[CY_MAX_INPUT];
> +	struct gpio_desc *reset_gpio;
> +	struct input_dev *input;
> +	char phys[NAME_MAX];
> +	int num_prv_rec;
> +	struct regmap *regmap;
> +};
> +
> +/*
> + * For what understood in the datasheet, the register does not
> + * matter. For consistency, used the Input Register address
> + * but it does mean anything to the device. The important data
> + * to send is the I2C address
> + */
> +static int cyttsp5_read(struct cyttsp5 *ts, u8 *buf, u32 max)
> +{
> +	int rc;
> +	u32 size;
> +	u8 temp[2];
> +
> +	if (!buf)
> +		return -EINVAL;

Is it really possible? This is not a publicly facing API but private
driver data, do you ever happen to call it with NULL?

> +
> +	/* Read the frame to retrieve the size */
> +	rc = regmap_bulk_read(ts->regmap, HID_INPUT_REG, temp, 2);
> +	if (rc < 0)
> +		return rc;

Can we call this kind of variables "error" pelase?

> +
> +	size = get_unaligned_le16(temp);
> +	if (!size || size == 2)
> +		return 0;
> +
> +	if (size > max)
> +		return -EINVAL;
> +
> +	/* Get the real value */
> +	return regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, size);
> +}
> +
> +static int cyttsp5_write(struct cyttsp5 *ts, unsigned int reg, u8 *data,
> +			 size_t size)
> +{
> +	u8 cmd[size + 1];
> +
> +	/* High bytes of register address needed as first byte of cmd */
> +	cmd[0] = HI_BYTE(reg);
> +
> +	/* Copy the rest of the data */
> +	if (data)
> +		memcpy(&cmd[1], data, size);
> +
> +	/* The hardware wants to receive a frame with the address register

The multiline comment block should start with "/*" on a separate line
please.

> +	 * contains in the first two bytes. As the regmap_write function
> +	 * add the register adresse in the frame, we use the LOW_BYTE as
> +	 * first frame byte for the address register and the first
> +	 * data byte is the high register + left of the cmd to send
> +	 */
> +	return regmap_bulk_write(ts->regmap, LOW_BYTE(reg), cmd, size + 1);
> +}
> +
> +static void cyttsp5_final_sync(struct input_dev *input, int max_slots,
> +			       unsigned long *ids)
> +{
> +	int t;
> +
> +	for (t = 0; t < max_slots; t++) {

	for_each_set_bit() {
	}

> +		if (test_bit(t, ids))
> +			continue;
> +		input_mt_slot(input, t);
> +		input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
> +	}
> +
> +	input_sync(input);
> +}
> +
> +static void cyttsp5_report_slot_liftoff(struct cyttsp5 *ts, int max_slots)
> +{
> +	int t;
> +
> +	if (ts->num_prv_rec == 0)
> +		return;

Do you need this check? The caller checks the same condition.

> +
> +	for (t = 0; t < max_slots; t++) {
> +		input_mt_slot(ts->input, t);
> +		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, false);
> +	}
> +}
> +
> +static void cyttsp5_mt_lift_all(struct cyttsp5 *ts)
> +{
> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> +	int max = si->tch_abs[CY_TCH_T].max;
> +
> +	if (ts->num_prv_rec != 0) {
> +		cyttsp5_report_slot_liftoff(ts, max);
> +		input_sync(ts->input);
> +		ts->num_prv_rec = 0;
> +	}
> +}
> +
> +static void cyttsp5_get_touch_axis(int *axis, int size, int max, u8 *xy_data,
> +				   int bofs)
> +{
> +	int nbyte;
> +	int next;
> +
> +	for (nbyte = 0, *axis = 0, next = 0; nbyte < size; nbyte++)
> +		*axis = *axis + ((xy_data[nbyte] >> bofs) << (nbyte * 8));
> +
> +	*axis &= max - 1;
> +}
> +
> +static void cyttsp5_get_touch_record(struct cyttsp5 *ts,
> +				     struct cyttsp5_touch *touch, u8 *xy_data)
> +{
> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> +	enum cyttsp5_tch_abs abs;
> +
> +	for (abs = CY_TCH_X; abs < CY_TCH_NUM_ABS; abs++) {
> +		cyttsp5_get_touch_axis(&touch->abs[abs],
> +				       si->tch_abs[abs].size,
> +				       si->tch_abs[abs].max,
> +				       xy_data + si->tch_abs[abs].ofs,
> +				       si->tch_abs[abs].bofs);
> +	}
> +}
> +
> +static void cyttsp5_get_mt_touches(struct cyttsp5 *ts,
> +				   struct cyttsp5_touch *tch, int num_cur_tch)
> +{
> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> +	int i, t = 0;
> +	DECLARE_BITMAP(ids, si->tch_abs[CY_TCH_T].max);
> +	u8 *tch_addr;
> +	int tmp;
> +
> +	bitmap_zero(ids, si->tch_abs[CY_TCH_T].max);
> +	memset(tch->abs, 0, sizeof(tch->abs));
> +
> +	for (i = 0; i < num_cur_tch; i++) {
> +		tch_addr = si->xy_data + (i * TOUCH_REPORT_SIZE);
> +		cyttsp5_get_touch_record(ts, tch, tch_addr);
> +
> +		/* Convert MAJOR/MINOR from mm to resolution */
> +		tmp = tch->abs[CY_TCH_MAJ] * 100 * si->sensing_conf_data.res_x;
> +		tch->abs[CY_TCH_MAJ] = tmp / si->sensing_conf_data.len_x;
> +		tmp = tch->abs[CY_TCH_MIN] * 100 * si->sensing_conf_data.res_x;
> +		tch->abs[CY_TCH_MIN] = tmp / si->sensing_conf_data.len_x;
> +
> +		t = tch->abs[CY_TCH_T];
> +		input_mt_slot(ts->input, t);
> +		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
> +		__set_bit(t, ids);
> +
> +		/* position and pressure fields */
> +		input_report_abs(ts->input, ABS_MT_POSITION_X,
> +				 tch->abs[CY_TCH_X]);
> +		input_report_abs(ts->input, ABS_MT_POSITION_Y,
> +				 tch->abs[CY_TCH_Y]);
> +		input_report_abs(ts->input, ABS_MT_PRESSURE,
> +				 tch->abs[CY_TCH_P]);
> +
> +		/* Get the extended touch fields */
> +		input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR,
> +				 tch->abs[CY_TCH_MAJ]);
> +		input_report_abs(ts->input, ABS_MT_TOUCH_MINOR,
> +				 tch->abs[CY_TCH_MIN]);
> +	}
> +
> +	cyttsp5_final_sync(ts->input, si->tch_abs[CY_TCH_T].max, ids);
> +
> +	ts->num_prv_rec = num_cur_tch;
> +}
> +
> +/* read xy_data for all current touches */
> +static int cyttsp5_xy_worker(struct cyttsp5 *ts)
> +{
> +	struct device *dev = ts->dev;
> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> +	int max_tch = si->sensing_conf_data.max_tch;
> +	struct cyttsp5_touch tch;
> +	u8 num_cur_tch;
> +
> +	cyttsp5_get_touch_axis(&tch.hdr, si->tch_hdr.size,
> +			       si->tch_hdr.max,
> +			       si->xy_mode + 3 + si->tch_hdr.ofs,
> +			       si->tch_hdr.bofs);
> +
> +	num_cur_tch = tch.hdr;
> +	if (num_cur_tch > max_tch) {
> +		dev_err(dev, "Num touch err detected (n=%d)\n", num_cur_tch);
> +		num_cur_tch = max_tch;
> +	}
> +
> +	if (num_cur_tch == 0 && ts->num_prv_rec == 0)
> +		return 0;
> +
> +	/* extract xy_data for all currently reported touches */
> +	if (num_cur_tch)
> +		cyttsp5_get_mt_touches(ts, &tch, num_cur_tch);
> +	else
> +		cyttsp5_mt_lift_all(ts);
> +
> +	return 0;
> +}
> +
> +static int cyttsp5_mt_attention(struct device *dev)
> +{
> +	struct cyttsp5 *ts = dev_get_drvdata(dev);

Why don't you pass ts into cyttsp5_mt_attention?

> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> +	int rc;
> +
> +	if (si->xy_mode[2] != HID_TOUCH_REPORT_ID)
> +		return 0;
> +
> +	/* core handles handshake */
> +	rc = cyttsp5_xy_worker(ts);
> +	if (rc < 0)
> +		dev_err(dev, "xy_worker error r=%d\n", rc);
> +
> +	return rc;
> +}
> +
> +static int cyttsp5_setup_input_device(struct device *dev)
> +{
> +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> +	int max_x, max_y, max_p;
> +	int max_x_tmp, max_y_tmp;
> +	int rc;
> +
> +	__set_bit(EV_ABS, ts->input->evbit);
> +	__set_bit(EV_REL, ts->input->evbit);
> +	__set_bit(EV_KEY, ts->input->evbit);
> +
> +	max_x_tmp = si->sensing_conf_data.res_x;
> +	max_y_tmp = si->sensing_conf_data.res_y;
> +	max_x = max_y_tmp - 1;
> +	max_y = max_x_tmp - 1;
> +	max_p = si->sensing_conf_data.max_z;
> +
> +	input_mt_init_slots(ts->input, si->tch_abs[CY_TCH_T].max, 0);

Error handling.

> +
> +	__set_bit(ABS_MT_POSITION_X, ts->input->absbit);
> +	__set_bit(ABS_MT_POSITION_Y, ts->input->absbit);
> +	__set_bit(ABS_MT_PRESSURE, ts->input->absbit);
> +
> +	input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
> +	input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
> +	input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, max_p, 0, 0);
> +
> +	input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);
> +	input_set_abs_params(ts->input, ABS_MT_TOUCH_MINOR, 0, MAX_AREA, 0, 0);

You might want to use the standard DT touchscreen properties and
reporting functions to support axis inversion and swapping of axes.

> +
> +	rc = input_register_device(ts->input);
> +	if (rc < 0)
> +		dev_err(dev, "Error, failed register input device r=%d\n", rc);
> +
> +	return rc;
> +}
> +
> +#ifdef CONFIG_OF
> +static int cyttsp5_parse_dt_key_code(struct device *dev)
> +{
> +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> +	struct device_node *np;
> +	int i;
> +
> +	np = dev->of_node;
> +	if (!np)
> +		return -EINVAL;
> +
> +	if (!si->num_btns)
> +		return 0;
> +
> +	/* Initialize the button to RESERVED */
> +	for (i = 0; i < si->num_btns; i++)
> +		si->key_code[i] = KEY_RESERVED;
> +
> +	return of_property_read_u32_array(np, "linux,keycodes",
> +				   si->key_code, si->num_btns);
> +}
> +#else
> +static int cyttsp5_parse_dt_key_code(struct device *dev)
> +{
> +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> +	int i;
> +
> +	if (!si->num_btns)
> +		return 0;
> +
> +	/* Initialize the button to RESERVED */
> +	for (i = 0; i < si->num_btns; i++)
> +		si->key_code[i] = KEY_RESERVED;
> +
> +	return 0;
> +}
> +#endif
> +
> +static int cyttsp5_btn_attention(struct device *dev)
> +{
> +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> +	int cur_btn;
> +	int cur_btn_state;
> +
> +	if (si->xy_mode[2] != HID_BTN_REPORT_ID || !si->num_btns)
> +		return 0;
> +
> +	/* extract button press/release touch information */
> +	for (cur_btn = 0; cur_btn < si->num_btns; cur_btn++) {
> +		/* Get current button state */
> +		cur_btn_state = (si->xy_data[0] >> (cur_btn * CY_BITS_PER_BTN))
> +			& CY_NUM_BTN_EVENT_ID;
> +
> +		input_report_key(ts->input, si->key_code[cur_btn],
> +				 cur_btn_state);
> +		input_sync(ts->input);

You do not need to sen sync after each button, send it once after all
buttons sent.

> +	}
> +
> +	return 0;
> +}
> +
> +static u16 cyttsp5_compute_crc(u8 *buf, u32 size)
> +{
> +	u16 remainder = 0xFFFF;
> +	u16 xor_mask = 0x0000;
> +	u32 index;
> +	u32 byte_value;
> +	u32 table_index;
> +	u32 crc_bit_width = sizeof(u16) * 8;
> +
> +	/* Divide the message by polynomial, via the table. */
> +	for (index = 0; index < size; index++) {
> +		byte_value = buf[index];
> +		table_index = ((byte_value >> 4) & 0x0F)
> +			^ (remainder >> (crc_bit_width - 4));
> +		remainder = crc_itu_t_table[table_index]
> +			^ (remainder << 4);
> +		table_index = (byte_value & 0x0F)
> +			^ (remainder >> (crc_bit_width - 4));
> +		remainder = crc_itu_t_table[table_index]
> +			^ (remainder << 4);
> +	}
> +
> +	/* Perform the final remainder CRC. */
> +	return remainder ^ xor_mask;
> +}
> +
> +static int cyttsp5_validate_cmd_response(struct cyttsp5 *ts, u8 code)
> +{
> +	u16 size, crc;
> +	u8 status, offset;
> +	int command_code;
> +
> +	size = get_unaligned_le16(&ts->response_buf[0]);
> +
> +	if (!size)
> +		return 0;
> +
> +	offset = ts->response_buf[HID_OUTPUT_RESPONSE_REPORT_OFFSET];
> +
> +	if (offset == HID_BL_RESPONSE_REPORT_ID) {
> +		if (ts->response_buf[4] != HID_OUTPUT_BL_SOP) {
> +			dev_err(ts->dev, "HID output response, wrong SOP\n");
> +			return -EPROTO;
> +		}
> +
> +		if (ts->response_buf[size - 1] != HID_OUTPUT_BL_EOP) {
> +			dev_err(ts->dev, "HID output response, wrong EOP\n");
> +			return -EPROTO;
> +		}
> +
> +		crc = cyttsp5_compute_crc(&ts->response_buf[4], size - 7);
> +		if (ts->response_buf[size - 3] != LOW_BYTE(crc) ||
> +		    ts->response_buf[size - 2] != HI_BYTE(crc)) {
> +			dev_err(ts->dev, "HID output response, wrong CRC 0x%X\n",
> +				crc);
> +			return -EPROTO;
> +		}
> +
> +		status = ts->response_buf[5];
> +		if (status) {
> +			dev_err(ts->dev, "HID output response, ERROR:%d\n",
> +				status);
> +			return -EPROTO;
> +		}
> +	}
> +
> +	if (offset == HID_APP_RESPONSE_REPORT_ID) {
> +		command_code = ts->response_buf[HID_OUTPUT_RESPONSE_CMD_OFFSET]
> +			& HID_OUTPUT_RESPONSE_CMD_MASK;
> +		if (command_code != code) {
> +			dev_err(ts->dev,
> +				"HID output response, wrong command_code:%X\n",
> +				command_code);
> +			return -EPROTO;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static void cyttsp5_si_get_btn_data(struct cyttsp5 *ts)
> +{
> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> +	int i;
> +	unsigned int btns = ts->response_buf[HID_SYSINFO_BTN_OFFSET]
> +		& HID_SYSINFO_BTN_MASK;
> +
> +	si->num_btns = 0;
> +	for (i = 0; i < HID_SYSINFO_MAX_BTN; i++) {
> +		if (btns & BIT(i))
> +			si->num_btns++;
> +	}

	si->num_btns = hweight8(ts->response_buf[HID_SYSINFO_BTN_OFFSET]);

> +}
> +
> +static int cyttsp5_get_sysinfo_regs(struct cyttsp5 *ts)
> +{
> +	struct cyttsp5_sensing_conf_data *scd = &ts->sysinfo.sensing_conf_data;
> +	struct cyttsp5_sensing_conf_data_dev *scd_dev =
> +		(struct cyttsp5_sensing_conf_data_dev *)
> +		&ts->response_buf[HID_SYSINFO_SENSING_OFFSET];
> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> +
> +	cyttsp5_si_get_btn_data(ts);
> +
> +	scd->max_tch = scd_dev->max_num_of_tch_per_refresh_cycle;
> +	scd->res_x = get_unaligned_le16(&scd_dev->res_x);
> +	scd->res_y = get_unaligned_le16(&scd_dev->res_y);
> +	scd->max_z = get_unaligned_le16(&scd_dev->max_z);
> +	scd->len_x = get_unaligned_le16(&scd_dev->len_x);
> +	scd->len_y = get_unaligned_le16(&scd_dev->len_y);
> +
> +	si->xy_data = devm_kzalloc(ts->dev, scd->max_tch * TOUCH_REPORT_SIZE,
> +				   GFP_KERNEL);
> +	if (!si->xy_data)
> +		return -ENOMEM;
> +
> +	si->xy_mode = devm_kzalloc(ts->dev, TOUCH_INPUT_HEADER_SIZE,
> +				   GFP_KERNEL);
> +	if (!si->xy_mode)
> +		return -ENOMEM;

Why do we need these 2 allocated separately form the driver data?

> +
> +	return 0;
> +}
> +
> +static int cyttsp5_hid_output_get_sysinfo(struct cyttsp5 *ts)
> +{
> +	int rc;
> +	u8 cmd[HID_OUTPUT_GET_SYSINFO_SIZE];
> +
> +	ts->hid_cmd_state = HID_CMD_BUSY;
> +
> +	/* HI bytes of Output register address */
> +	cmd[0] = LOW_BYTE(HID_OUTPUT_GET_SYSINFO_SIZE);
> +	cmd[1] = HI_BYTE(HID_OUTPUT_GET_SYSINFO_SIZE);
> +	cmd[2] = HID_APP_OUTPUT_REPORT_ID;
> +	cmd[3] = 0x0; /* Reserved */
> +	cmd[4] = HID_OUTPUT_GET_SYSINFO;
> +
> +	rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
> +			   HID_OUTPUT_GET_SYSINFO_SIZE);
> +	if (rc) {
> +		dev_err(ts->dev, "Failed to write command %d", rc);
> +		goto error;
> +	}
> +
> +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
> +				msecs_to_jiffies(CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT));
> +	if (!rc) {
> +		dev_err(ts->dev, "HID output cmd execution timed out\n");
> +		rc = -ETIME;
> +		goto error;
> +	}
> +
> +	rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_GET_SYSINFO);
> +	if (rc) {
> +		dev_err(ts->dev, "Validation of the response failed\n");
> +		goto error;
> +	}
> +
> +	return cyttsp5_get_sysinfo_regs(ts);
> +
> +error:
> +	mutex_lock(&ts->system_lock);
> +	ts->hid_cmd_state = HID_CMD_DONE;
> +	mutex_unlock(&ts->system_lock);
> +	return rc;
> +}
> +
> +static int cyttsp5_hid_output_bl_launch_app(struct cyttsp5 *ts)
> +{
> +	int rc;
> +	u8 cmd[HID_OUTPUT_BL_LAUNCH_APP];
> +	u16 crc;
> +
> +	mutex_lock(&ts->system_lock);
> +	ts->hid_cmd_state = HID_CMD_BUSY;
> +	mutex_unlock(&ts->system_lock);
> +
> +	cmd[0] = LOW_BYTE(HID_OUTPUT_BL_LAUNCH_APP_SIZE);
> +	cmd[1] = HI_BYTE(HID_OUTPUT_BL_LAUNCH_APP_SIZE);
> +	cmd[2] = HID_BL_OUTPUT_REPORT_ID;
> +	cmd[3] = 0x0; /* Reserved */
> +	cmd[4] = HID_OUTPUT_BL_SOP;
> +	cmd[5] = HID_OUTPUT_BL_LAUNCH_APP;
> +	cmd[6] = 0x0; /* Low bytes of data */
> +	cmd[7] = 0x0; /* Hi bytes of data */
> +	crc = cyttsp5_compute_crc(&cmd[4], 4);
> +	cmd[8] = LOW_BYTE(crc);
> +	cmd[9] = HI_BYTE(crc);
> +	cmd[10] = HID_OUTPUT_BL_EOP;
> +
> +	rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
> +			   HID_OUTPUT_BL_LAUNCH_APP_SIZE);
> +	if (rc) {
> +		dev_err(ts->dev, "Failed to write command %d", rc);
> +		goto error;
> +	}
> +
> +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
> +				msecs_to_jiffies(CY_HID_OUTPUT_TIMEOUT));
> +	if (!rc) {
> +		dev_err(ts->dev, "HID output cmd execution timed out\n");
> +		rc = -ETIME;
> +		goto error;
> +	}
> +
> +	rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_BL_LAUNCH_APP);
> +	if (rc) {
> +		dev_err(ts->dev, "Validation of the response failed\n");
> +		goto error;
> +	}
> +
> +	return rc;
> +
> +error:
> +	mutex_lock(&ts->system_lock);
> +	ts->hid_cmd_state = HID_CMD_DONE;
> +	mutex_unlock(&ts->system_lock);
> +
> +	return rc;
> +}
> +
> +static int cyttsp5_get_hid_descriptor(struct cyttsp5 *ts,
> +				      struct cyttsp5_hid_desc *desc)
> +{
> +	struct device *dev = ts->dev;
> +	__le16 hid_desc_register = HID_DESC_REG;
> +	int rc;
> +	u8 cmd[2];
> +
> +	/* Read HID descriptor length and version */
> +	mutex_lock(&ts->system_lock);
> +	ts->hid_cmd_state = HID_CMD_BUSY;
> +	mutex_unlock(&ts->system_lock);
> +
> +	/* Set HID descriptor register */
> +	memcpy(cmd, &hid_desc_register, sizeof(hid_desc_register));
> +
> +	rc = cyttsp5_write(ts, HID_DESC_REG, NULL, 0);
> +	if (rc < 0) {
> +		dev_err(dev, "Failed to get HID descriptor, rc=%d\n", rc);
> +		goto error;
> +	}
> +
> +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
> +				msecs_to_jiffies(CY_HID_GET_HID_DESCRIPTOR_TIMEOUT));
> +	if (!rc) {
> +		dev_err(ts->dev, "HID get descriptor timed out\n");
> +		rc = -ETIME;
> +		goto error;
> +	}
> +
> +	memcpy(desc, ts->response_buf, sizeof(struct cyttsp5_hid_desc));
> +
> +	/* Check HID descriptor length and version */
> +	if (le16_to_cpu(desc->hid_desc_len) != sizeof(*desc) ||
> +	    le16_to_cpu(desc->bcd_version) != HID_VERSION) {
> +		dev_err(dev, "Unsupported HID version\n");
> +		return -ENODEV;
> +	}
> +
> +	goto exit;
> +
> +error:
> +	mutex_lock(&ts->system_lock);
> +	ts->hid_cmd_state = HID_CMD_DONE;
> +	mutex_unlock(&ts->system_lock);
> +exit:
> +	return rc;
> +}
> +
> +static int fill_tch_abs(struct cyttsp5_tch_abs_params *tch_abs, int report_size,
> +			int offset)
> +{
> +	tch_abs->ofs = offset / 8;
> +	tch_abs->size = report_size / 8;
> +	if (report_size % 8)
> +		tch_abs->size += 1;
> +	tch_abs->min = 0;
> +	tch_abs->max = 1 << report_size;
> +	tch_abs->bofs = offset - (tch_abs->ofs << 3);
> +
> +	return 0;
> +}
> +
> +static int move_button_data(struct cyttsp5 *ts, struct cyttsp5_sysinfo *si)
> +{
> +	memcpy(si->xy_mode, ts->input_buf, BTN_INPUT_HEADER_SIZE);
> +	memcpy(si->xy_data, &ts->input_buf[BTN_INPUT_HEADER_SIZE],
> +	       BTN_REPORT_SIZE);
> +
> +	return 0;
> +}
> +
> +static int move_touch_data(struct cyttsp5 *ts, struct cyttsp5_sysinfo *si)
> +{
> +	int max_tch = si->sensing_conf_data.max_tch;
> +	int num_cur_tch;
> +	int length;
> +	struct cyttsp5_tch_abs_params *tch = &si->tch_hdr;
> +
> +	memcpy(si->xy_mode, ts->input_buf, TOUCH_INPUT_HEADER_SIZE);
> +
> +	cyttsp5_get_touch_axis(&num_cur_tch, tch->size,
> +			       tch->max, si->xy_mode + 3 + tch->ofs, tch->bofs);
> +	if (unlikely(num_cur_tch > max_tch))
> +		num_cur_tch = max_tch;
> +
> +	length = num_cur_tch * TOUCH_REPORT_SIZE;
> +
> +	memcpy(si->xy_data, &ts->input_buf[TOUCH_INPUT_HEADER_SIZE], length);
> +
> +	return 0;
> +}
> +
> +static irqreturn_t cyttsp5_handle_irq(int irq, void *handle)
> +{
> +	struct cyttsp5 *ts = handle;
> +	int report_id;
> +	int size;
> +	int rc;
> +
> +	rc = cyttsp5_read(ts, ts->input_buf, CY_MAX_INPUT);
> +	if (rc)
> +		return IRQ_HANDLED;
> +
> +	size = get_unaligned_le16(&ts->input_buf[0]);
> +
> +	/* check reset */
> +	if (size == 0) {
> +		memcpy(ts->response_buf, ts->input_buf, 2);
> +
> +		mutex_lock(&ts->system_lock);
> +		ts->hid_cmd_state = HID_CMD_DONE;
> +		mutex_unlock(&ts->system_lock);
> +		wake_up(&ts->wait_q);

I'd use spinlock in wait queue and wake_up_locked() instead of a
separate mutex.

> +		return IRQ_HANDLED;
> +	}
> +
> +	report_id = ts->input_buf[2];
> +

	switch(report_id) {
	}

> +	if (report_id == HID_TOUCH_REPORT_ID) {
> +		move_touch_data(ts, &ts->sysinfo);
> +		cyttsp5_mt_attention(ts->dev);
> +	} else if (report_id == HID_BTN_REPORT_ID) {
> +		move_button_data(ts, &ts->sysinfo);
> +		cyttsp5_btn_attention(ts->dev);
> +	} else {
> +		/* It is not an input but a command response */
> +		memcpy(ts->response_buf, ts->input_buf, size);
> +
> +		mutex_lock(&ts->system_lock);
> +		ts->hid_cmd_state = HID_CMD_DONE;
> +		mutex_unlock(&ts->system_lock);
> +		wake_up(&ts->wait_q);
> +	}
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int cyttsp5_deassert_int(struct cyttsp5 *ts)
> +{
> +	u16 size;
> +	u8 buf[2];
> +	int rc;
> +
> +	rc = regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, 2);
> +	if (rc < 0)
> +		return rc;
> +
> +	size = get_unaligned_le16(&buf[0]);
> +	if (size == 2 || size == 0)
> +		return 0;
> +
> +	return -EINVAL;
> +}
> +
> +static int cyttsp5_fill_all_touch(struct cyttsp5 *ts)
> +{
> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> +
> +	fill_tch_abs(&si->tch_abs[CY_TCH_X], REPORT_SIZE_16,
> +		     TOUCH_REPORT_DESC_X);
> +	fill_tch_abs(&si->tch_abs[CY_TCH_Y], REPORT_SIZE_16,
> +		     TOUCH_REPORT_DESC_Y);
> +	fill_tch_abs(&si->tch_abs[CY_TCH_P], REPORT_SIZE_8,
> +		     TOUCH_REPORT_DESC_P);
> +	fill_tch_abs(&si->tch_abs[CY_TCH_T], REPORT_SIZE_5,
> +		     TOUCH_REPORT_DESC_CONTACTID);
> +	fill_tch_abs(&si->tch_hdr, REPORT_SIZE_5,
> +		     TOUCH_REPORT_DESC_HDR_CONTACTCOUNT);
> +	fill_tch_abs(&si->tch_abs[CY_TCH_MAJ], REPORT_SIZE_8,
> +		     TOUCH_REPORT_DESC_MAJ);
> +	fill_tch_abs(&si->tch_abs[CY_TCH_MIN], REPORT_SIZE_8,
> +		     TOUCH_REPORT_DESC_MIN);
> +
> +	return 0;
> +}
> +
> +static int cyttsp5_startup(struct cyttsp5 *ts)
> +{
> +	int rc;
> +
> +	rc = cyttsp5_deassert_int(ts);
> +	if (rc) {
> +		dev_err(ts->dev, "Error on deassert int r=%d\n", rc);
> +		return -ENODEV;
> +	}
> +
> +	/*
> +	 * Launch the application as the device starts in bootloader mode
> +	 * because of a power-on-reset
> +	 */
> +	rc = cyttsp5_hid_output_bl_launch_app(ts);
> +	if (rc < 0) {
> +		dev_err(ts->dev, "Error on launch app r=%d\n", rc);
> +		return rc;
> +	}
> +
> +	rc = cyttsp5_get_hid_descriptor(ts, &ts->hid_desc);
> +	if (rc < 0) {
> +		dev_err(ts->dev, "Error on getting HID descriptor r=%d\n", rc);
> +		return rc;
> +	}
> +
> +	rc = cyttsp5_fill_all_touch(ts);
> +	if (rc < 0) {
> +		dev_err(ts->dev, "Error on report descriptor r=%d\n", rc);
> +		return rc;
> +	}
> +
> +	rc = cyttsp5_hid_output_get_sysinfo(ts);
> +	if (rc) {
> +		dev_err(ts->dev, "Error on getting sysinfo r=%d\n", rc);
> +		return rc;
> +	}
> +
> +	return rc;
> +}
> +
> +#ifdef CONFIG_OF
> +static const struct of_device_id cyttsp5_of_match[] = {
> +	{ .compatible = "cypress,cyttsp5", },
> +	{ }
> +};
> +MODULE_DEVICE_TABLE(of, cyttsp5_of_match);
> +#endif
> +
> +static const struct i2c_device_id cyttsp5_i2c_id[] = {
> +	{ CYTTSP5_NAME, 0, },
> +	{ }
> +};
> +MODULE_DEVICE_TABLE(i2c, cyttsp5_i2c_id);
> +
> +static int cyttsp5_probe(struct device *dev, struct regmap *regmap, int irq,
> +			 const char *name)
> +{
> +	struct cyttsp5 *ts;
> +	struct cyttsp5_sysinfo *si;
> +	int rc = 0, i;
> +
> +	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
> +	if (!ts)
> +		return -ENOMEM;
> +
> +	/* Initialize device info */
> +	ts->regmap = regmap;
> +	ts->dev = dev;
> +	si = &ts->sysinfo;
> +	dev_set_drvdata(dev, ts);
> +
> +	/* Initialize mutexes and spinlocks */
> +	mutex_init(&ts->system_lock);
> +
> +	/* Initialize wait queue */
> +	init_waitqueue_head(&ts->wait_q);
> +
> +	/* Reset the gpio to be in a reset state */
> +	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
> +	if (IS_ERR(ts->reset_gpio)) {
> +		rc = PTR_ERR(ts->reset_gpio);
> +		dev_err(dev, "Failed to request reset gpio, error %d\n", rc);
> +		return rc;
> +	}
> +	gpiod_set_value(ts->reset_gpio, 1);

Why not request it as GPIOD_OUT_HIGH if you going to activate it
immediately? However it sounds as if you have a reset line that is
active low and you want to driver it low to reset, and then release. In
this case you need to do

	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
	<delay> - chip usually needs to be some time in reset state
	gpiod_set_value(ts->reset_gpio, 0);

and make sure that correct polarity is specified in device tree.

> +
> +	/* Need a delay to have device up */
> +	msleep(20);
> +
> +	rc = devm_request_threaded_irq(dev, irq, NULL, cyttsp5_handle_irq,
> +				       IRQF_TRIGGER_FALLING | IRQF_ONESHOT,

Just use IRQF_ONESHOT and make sure DTS specifies interrupt properly.
BTW,I'd recommend using level, not edge interrupts. It is so easy to
miss an edge.

> +				       name, ts);
> +	if (rc) {
> +		dev_err(dev, "unable to request IRQ\n");
> +		return rc;
> +	}
> +
> +	rc = cyttsp5_startup(ts);
> +	if (rc) {
> +		dev_err(ts->dev, "Fail initial startup r=%d\n", rc);
> +		return rc;
> +	}
> +
> +	rc = cyttsp5_parse_dt_key_code(dev);
> +	if (rc < 0) {
> +		dev_err(ts->dev, "Error while parsing dts %d\n", rc);
> +		return rc;
> +	}
> +
> +	ts->input = devm_input_allocate_device(dev);
> +	if (!ts->input) {
> +		dev_err(dev, "Error, failed to allocate input device\n");
> +		return -ENODEV;
> +	}
> +
> +	ts->input->name = "cyttsp5";
> +	scnprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
> +	ts->input->phys = ts->phys;
> +	ts->input->dev.parent = ts->dev;
> +	input_set_drvdata(ts->input, ts);
> +
> +	touchscreen_parse_properties(ts->input, true, NULL);
> +
> +	__set_bit(EV_KEY, ts->input->evbit);
> +	for (i = 0; i < si->num_btns; i++)
> +		__set_bit(si->key_code[i], ts->input->keybit);
> +
> +	return cyttsp5_setup_input_device(dev);
> +}
> +
> +static int cyttsp5_i2c_probe(struct i2c_client *client,
> +			     const struct i2c_device_id *id)
> +{
> +	struct regmap *regmap;
> +	static const struct regmap_config config = {
> +		.reg_bits = 8,
> +		.val_bits = 8,
> +	};
> +
> +	regmap = devm_regmap_init_i2c(client, &config);
> +	if (IS_ERR(regmap)) {
> +		dev_err(&client->dev, "regmap allocation failed: %ld\n",
> +			PTR_ERR(regmap));
> +		return PTR_ERR(regmap);
> +	}
> +
> +	return cyttsp5_probe(&client->dev, regmap, client->irq, client->name);
> +}
> +
> +static int cyttsp5_remove(struct device *dev)
> +{
> +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> +
> +	input_unregister_device(ts->input);

Not needed: you are using managed input device.

> +
> +	return 0;
> +}
> +
> +static int cyttsp5_i2c_remove(struct i2c_client *client)
> +{
> +	struct device *dev = &client->dev;
> +
> +	return cyttsp5_remove(dev);

Not needed if you remove cyttsp5_remove().

> +}
> +
> +static struct i2c_driver cyttsp5_i2c_driver = {
> +	.driver = {
> +		.name = CYTTSP5_NAME,
> +		.owner = THIS_MODULE,
> +		.of_match_table = of_match_ptr(cyttsp5_of_match),
> +	},
> +	.probe = cyttsp5_i2c_probe,
> +	.remove = cyttsp5_i2c_remove,
> +	.id_table = cyttsp5_i2c_id,
> +};
> +
> +module_i2c_driver(cyttsp5_i2c_driver);
> +
> +MODULE_LICENSE("GPL");
> +MODULE_DESCRIPTION("Touchscreen driver for Cypress TrueTouch Gen 5 Product");
> +MODULE_AUTHOR("Mylène Josserand <mylene.josserand-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org>");
> -- 
> 2.11.0
> 

Thanks.

-- 
Dmitry
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH v4 1/2] Input: Add driver for Cypress Generation 5 touchscreen

[Mylene Josserand]

Hi Dmitry,

Thank you for the review.

Le Mon, 22 Jan 2018 20:15:03 -0800,
Dmitry Torokhov <dmitry.torokhov@gmail.com> a écrit :

> Hi Mylène,
> 
> On Fri, Dec 01, 2017 at 04:39:56PM +0100, Mylène Josserand wrote:
> > This is the basic driver for the Cypress TrueTouch Gen5 touchscreen
> > controllers. This driver supports only the I2C bus but it uses regmap
> > so SPI support could be added later.
> > The touchscreen can retrieve some defined zone that are handled as
> > buttons (according to the hardware). That is why it handles
> > button and multitouch events.
> > 
> > Reviewed-by: Maxime Ripard <maxime.ripard@free-electrons.com>
> > Signed-off-by: Mylène Josserand <mylene.josserand@free-electrons.com>
> > ---
> >  drivers/input/touchscreen/Kconfig   |   16 +
> >  drivers/input/touchscreen/Makefile  |    1 +
> >  drivers/input/touchscreen/cyttsp5.c | 1110 +++++++++++++++++++++++++++++++++++
> >  3 files changed, 1127 insertions(+)
> >  create mode 100644 drivers/input/touchscreen/cyttsp5.c
> > 
> > diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
> > index 0cfdb7cb610e..28eea6d5f1bb 100644
> > --- a/drivers/input/touchscreen/Kconfig
> > +++ b/drivers/input/touchscreen/Kconfig
> > @@ -238,6 +238,22 @@ config TOUCHSCREEN_CYTTSP4_SPI
> >  	  To compile this driver as a module, choose M here: the
> >  	  module will be called cyttsp4_spi.
> >  
> > +config TOUCHSCREEN_CYTTSP5
> > +	tristate "Cypress TrueTouch Gen5 Touchscreen Driver"
> > +	depends on OF  
> 
> Does it have to be? Please use generic device properties
> (device_property_* API) and it can be used with ACPI and static board
> files, of needed.

Okay, I will try with that.

> 
> > +	select REGMAP_I2C
> > +	select CRC_ITU_T
> > +	help
> > +	  Driver for Parade TrueTouch Standard Product
> > +	  Generation 5 touchscreen controllers.
> > +	  I2C bus interface support only.
> > +
> > +	  Say Y here if you have a Cypress Gen5 touchscreen.
> > +	  If unsure, say N.
> > +
> > +	  To compile this driver as a module, choose M here: the
> > +	  module will be called cyttsp5.
> > +
> >  config TOUCHSCREEN_DA9034
> >  	tristate "Touchscreen support for Dialog Semiconductor DA9034"
> >  	depends on PMIC_DA903X
> > diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
> > index d2a2b3b7af27..e7d124901dd9 100644
> > --- a/drivers/input/touchscreen/Makefile
> > +++ b/drivers/input/touchscreen/Makefile
> > @@ -26,6 +26,7 @@ obj-$(CONFIG_TOUCHSCREEN_CYTTSP_SPI)	+= cyttsp_spi.o
> >  obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_CORE)	+= cyttsp4_core.o
> >  obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_I2C)	+= cyttsp4_i2c.o cyttsp_i2c_common.o
> >  obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_SPI)	+= cyttsp4_spi.o
> > +obj-$(CONFIG_TOUCHSCREEN_CYTTSP5)	+= cyttsp5.o
> >  obj-$(CONFIG_TOUCHSCREEN_DA9034)	+= da9034-ts.o
> >  obj-$(CONFIG_TOUCHSCREEN_DA9052)	+= da9052_tsi.o
> >  obj-$(CONFIG_TOUCHSCREEN_DYNAPRO)	+= dynapro.o
> > diff --git a/drivers/input/touchscreen/cyttsp5.c b/drivers/input/touchscreen/cyttsp5.c
> > new file mode 100644
> > index 000000000000..a41feea2cd5a
> > --- /dev/null
> > +++ b/drivers/input/touchscreen/cyttsp5.c
> > @@ -0,0 +1,1110 @@
> > +/*
> > + * Parade TrueTouch(TM) Standard Product V5 Module.
> > + * For use with Parade touchscreen controllers.
> > + *
> > + * Copyright (C) 2015 Parade Technologies
> > + * Copyright (C) 2012-2015 Cypress Semiconductor
> > + * Copyright (C) 2017 Free Electrons
> > + *
> > + * Author: Mylène Josserand <mylene.josserand@free-electrons.com>
> > + *
> > + * This program is free software; you can redistribute it and/or
> > + * modify it under the terms of the GNU General Public License
> > + * version 2, and only version 2, 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.
> > + *
> > + */
> > +
> > +#include <asm/unaligned.h>
> > +#include <linux/crc-itu-t.h>
> > +#include <linux/delay.h>
> > +#include <linux/device.h>
> > +#include <linux/gpio.h>
> > +#include <linux/input/mt.h>
> > +#include <linux/input/touchscreen.h>
> > +#include <linux/interrupt.h>
> > +#include <linux/i2c.h>
> > +#include <linux/module.h>
> > +#include <linux/of_device.h>
> > +#include <linux/regmap.h>
> > +
> > +#define CYTTSP5_NAME				"cyttsp5"
> > +#define CY_I2C_DATA_SIZE			(2 * 256)
> > +#define HID_VERSION				0x0100
> > +#define CY_MAX_INPUT				512
> > +#define CYTTSP5_PREALLOCATED_CMD_BUFFER	32
> > +#define CY_BITS_PER_BTN			1
> > +#define CY_NUM_BTN_EVENT_ID			((1 << CY_BITS_PER_BTN) - 1)
> > +
> > +#define MAX_AREA				255
> > +#define HID_OUTPUT_BL_SOP			0x1
> > +#define HID_OUTPUT_BL_EOP			0x17
> > +#define HID_OUTPUT_BL_LAUNCH_APP		0x3B
> > +#define HID_OUTPUT_BL_LAUNCH_APP_SIZE		11
> > +#define HID_OUTPUT_GET_SYSINFO			0x2
> > +#define HID_OUTPUT_GET_SYSINFO_SIZE		5
> > +
> > +#define HID_DESC_REG				0x1
> > +#define HID_INPUT_REG				0x3
> > +#define HID_OUTPUT_REG				0x4
> > +
> > +#define REPORT_ID_TOUCH			0x1
> > +#define REPORT_ID_BTN				0x3
> > +#define REPORT_SIZE_5				5
> > +#define REPORT_SIZE_8				8
> > +#define REPORT_SIZE_16				16
> > +
> > +/* Touch reports offsets */
> > +/* Header offsets */
> > +#define TOUCH_REPORT_DESC_HDR_CONTACTCOUNT	16
> > +/* Record offsets */
> > +#define TOUCH_REPORT_DESC_CONTACTID		8
> > +#define TOUCH_REPORT_DESC_X			16
> > +#define TOUCH_REPORT_DESC_Y			32
> > +#define TOUCH_REPORT_DESC_P			48
> > +#define TOUCH_REPORT_DESC_MAJ			56
> > +#define TOUCH_REPORT_DESC_MIN			64
> > +
> > +/* HID */
> > +#define HID_TOUCH_REPORT_ID			0x1
> > +#define HID_BTN_REPORT_ID			0x3
> > +#define HID_APP_RESPONSE_REPORT_ID		0x1F
> > +#define HID_APP_OUTPUT_REPORT_ID		0x2F
> > +#define HID_BL_RESPONSE_REPORT_ID		0x30
> > +#define HID_BL_OUTPUT_REPORT_ID		0x40
> > +
> > +#define HID_OUTPUT_RESPONSE_REPORT_OFFSET	2
> > +#define HID_OUTPUT_RESPONSE_CMD_OFFSET		4
> > +#define HID_OUTPUT_RESPONSE_CMD_MASK		0x7F
> > +
> > +#define HID_SYSINFO_SENSING_OFFSET		33
> > +#define HID_SYSINFO_BTN_OFFSET			48
> > +#define HID_SYSINFO_BTN_MASK			0xFF
> > +#define HID_SYSINFO_MAX_BTN			8
> > +
> > +/*  Timeout in ms */
> > +#define CY_HID_OUTPUT_TIMEOUT			200
> > +#define CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT	3000
> > +#define CY_HID_GET_HID_DESCRIPTOR_TIMEOUT	4000
> > +
> > +/* maximum number of concurrent tracks */
> > +#define TOUCH_REPORT_SIZE			10
> > +#define TOUCH_INPUT_HEADER_SIZE		7
> > +#define BTN_REPORT_SIZE			9
> > +#define BTN_INPUT_HEADER_SIZE			5
> > +
> > +/* All usage pages for Touch Report */
> > +#define TOUCH_REPORT_USAGE_PG_X		0x00010030
> > +#define TOUCH_REPORT_USAGE_PG_Y		0x00010031
> > +#define TOUCH_REPORT_USAGE_PG_P		0x000D0030
> > +#define TOUCH_REPORT_USAGE_PG_CONTACTID	0x000D0051
> > +#define TOUCH_REPORT_USAGE_PG_CONTACTCOUNT	0x000D0054
> > +#define TOUCH_REPORT_USAGE_PG_MAJ		0xFF010062
> > +#define TOUCH_REPORT_USAGE_PG_MIN		0xFF010063
> > +#define TOUCH_COL_USAGE_PG			0x000D0022
> > +
> > +/* helpers */
> > +#define HI_BYTE(x)				(u8)(((x) >> 8) & 0xFF)
> > +#define LOW_BYTE(x)				(u8)((x) & 0xFF)
> > +
> > +/* System Information interface definitions */
> > +struct cyttsp5_sensing_conf_data_dev {
> > +	u8 electrodes_x;
> > +	u8 electrodes_y;
> > +	__le16 len_x;
> > +	__le16 len_y;
> > +	__le16 res_x;
> > +	__le16 res_y;
> > +	__le16 max_z;
> > +	u8 origin_x;
> > +	u8 origin_y;
> > +	u8 btn;
> > +	u8 scan_mode;
> > +	u8 max_num_of_tch_per_refresh_cycle;
> > +} __packed;
> > +
> > +struct cyttsp5_sensing_conf_data {
> > +	u16 res_x;
> > +	u16 res_y;
> > +	u16 max_z;
> > +	u16 len_x;
> > +	u16 len_y;
> > +	u8 origin_x;
> > +	u8 origin_y;
> > +	u8 max_tch;
> > +};
> > +
> > +enum { HID_CMD_DONE, HID_CMD_BUSY } hid_cmd_state;
> > +
> > +enum cyttsp5_tch_abs {	/* for ordering within the extracted touch data array */
> > +	CY_TCH_X,	/* X */
> > +	CY_TCH_Y,	/* Y */
> > +	CY_TCH_P,	/* P (Z) */
> > +	CY_TCH_T,	/* TOUCH ID */
> > +	CY_TCH_MAJ,	/* TOUCH_MAJOR */
> > +	CY_TCH_MIN,	/* TOUCH_MINOR */
> > +	CY_TCH_NUM_ABS,
> > +};
> > +
> > +struct cyttsp5_tch_abs_params {
> > +	size_t ofs;	/* abs byte offset */
> > +	size_t size;	/* size in bits */
> > +	size_t min;	/* min value */
> > +	size_t max;	/* max value */
> > +	size_t bofs;	/* bit offset */
> > +};
> > +
> > +struct cyttsp5_touch {
> > +	int hdr;
> > +	int abs[CY_TCH_NUM_ABS];
> > +};
> > +
> > +struct cyttsp5_sysinfo {
> > +	struct cyttsp5_sensing_conf_data sensing_conf_data;
> > +	int num_btns;
> > +	struct cyttsp5_tch_abs_params tch_hdr;
> > +	struct cyttsp5_tch_abs_params tch_abs[CY_TCH_NUM_ABS];
> > +	u32 key_code[HID_SYSINFO_MAX_BTN];
> > +	u8 *xy_mode;
> > +	u8 *xy_data;
> > +};
> > +
> > +struct cyttsp5_hid_desc {
> > +	__le16 hid_desc_len;
> > +	u8 packet_id;
> > +	u8 reserved_byte;
> > +	__le16 bcd_version;
> > +	__le16 report_desc_len;
> > +	__le16 report_desc_register;
> > +	__le16 input_register;
> > +	__le16 max_input_len;
> > +	__le16 output_register;
> > +	__le16 max_output_len;
> > +	__le16 command_register;
> > +	__le16 data_register;
> > +	__le16 vendor_id;
> > +	__le16 product_id;
> > +	__le16 version_id;
> > +	u8 reserved[4];
> > +} __packed;
> > +
> > +struct cyttsp5 {
> > +	struct device *dev;
> > +	struct mutex system_lock;
> > +	wait_queue_head_t wait_q;
> > +	struct cyttsp5_sysinfo sysinfo;
> > +	int hid_cmd_state;
> > +	struct cyttsp5_hid_desc hid_desc;
> > +	u8 cmd_buf[CYTTSP5_PREALLOCATED_CMD_BUFFER];
> > +	u8 input_buf[CY_MAX_INPUT];
> > +	u8 response_buf[CY_MAX_INPUT];
> > +	struct gpio_desc *reset_gpio;
> > +	struct input_dev *input;
> > +	char phys[NAME_MAX];
> > +	int num_prv_rec;
> > +	struct regmap *regmap;
> > +};
> > +
> > +/*
> > + * For what understood in the datasheet, the register does not
> > + * matter. For consistency, used the Input Register address
> > + * but it does mean anything to the device. The important data
> > + * to send is the I2C address
> > + */
> > +static int cyttsp5_read(struct cyttsp5 *ts, u8 *buf, u32 max)
> > +{
> > +	int rc;
> > +	u32 size;
> > +	u8 temp[2];
> > +
> > +	if (!buf)
> > +		return -EINVAL;  
> 
> Is it really possible? This is not a publicly facing API but private
> driver data, do you ever happen to call it with NULL?

hm, I do not think so but I will check that.

> 
> > +
> > +	/* Read the frame to retrieve the size */
> > +	rc = regmap_bulk_read(ts->regmap, HID_INPUT_REG, temp, 2);
> > +	if (rc < 0)
> > +		return rc;  
> 
> Can we call this kind of variables "error" pelase?

Sure.

> 
> > +
> > +	size = get_unaligned_le16(temp);
> > +	if (!size || size == 2)
> > +		return 0;
> > +
> > +	if (size > max)
> > +		return -EINVAL;
> > +
> > +	/* Get the real value */
> > +	return regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, size);
> > +}
> > +
> > +static int cyttsp5_write(struct cyttsp5 *ts, unsigned int reg, u8 *data,
> > +			 size_t size)
> > +{
> > +	u8 cmd[size + 1];
> > +
> > +	/* High bytes of register address needed as first byte of cmd */
> > +	cmd[0] = HI_BYTE(reg);
> > +
> > +	/* Copy the rest of the data */
> > +	if (data)
> > +		memcpy(&cmd[1], data, size);
> > +
> > +	/* The hardware wants to receive a frame with the address register  
> 
> The multiline comment block should start with "/*" on a separate line
> please.

I will change that.

> 
> > +	 * contains in the first two bytes. As the regmap_write function
> > +	 * add the register adresse in the frame, we use the LOW_BYTE as
> > +	 * first frame byte for the address register and the first
> > +	 * data byte is the high register + left of the cmd to send
> > +	 */
> > +	return regmap_bulk_write(ts->regmap, LOW_BYTE(reg), cmd, size + 1);
> > +}
> > +
> > +static void cyttsp5_final_sync(struct input_dev *input, int max_slots,
> > +			       unsigned long *ids)
> > +{
> > +	int t;
> > +
> > +	for (t = 0; t < max_slots; t++) {  
> 
> 	for_each_set_bit() {
> 	}

I did not know this macro, I will try that.

> 
> > +		if (test_bit(t, ids))
> > +			continue;
> > +		input_mt_slot(input, t);
> > +		input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
> > +	}
> > +
> > +	input_sync(input);
> > +}
> > +
> > +static void cyttsp5_report_slot_liftoff(struct cyttsp5 *ts, int max_slots)
> > +{
> > +	int t;
> > +
> > +	if (ts->num_prv_rec == 0)
> > +		return;  
> 
> Do you need this check? The caller checks the same condition.

True, I will remove it.

> 
> > +
> > +	for (t = 0; t < max_slots; t++) {
> > +		input_mt_slot(ts->input, t);
> > +		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, false);
> > +	}
> > +}
> > +
> > +static void cyttsp5_mt_lift_all(struct cyttsp5 *ts)
> > +{
> > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > +	int max = si->tch_abs[CY_TCH_T].max;
> > +
> > +	if (ts->num_prv_rec != 0) {
> > +		cyttsp5_report_slot_liftoff(ts, max);
> > +		input_sync(ts->input);
> > +		ts->num_prv_rec = 0;
> > +	}
> > +}
> > +
> > +static void cyttsp5_get_touch_axis(int *axis, int size, int max, u8 *xy_data,
> > +				   int bofs)
> > +{
> > +	int nbyte;
> > +	int next;
> > +
> > +	for (nbyte = 0, *axis = 0, next = 0; nbyte < size; nbyte++)
> > +		*axis = *axis + ((xy_data[nbyte] >> bofs) << (nbyte * 8));
> > +
> > +	*axis &= max - 1;
> > +}
> > +
> > +static void cyttsp5_get_touch_record(struct cyttsp5 *ts,
> > +				     struct cyttsp5_touch *touch, u8 *xy_data)
> > +{
> > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > +	enum cyttsp5_tch_abs abs;
> > +
> > +	for (abs = CY_TCH_X; abs < CY_TCH_NUM_ABS; abs++) {
> > +		cyttsp5_get_touch_axis(&touch->abs[abs],
> > +				       si->tch_abs[abs].size,
> > +				       si->tch_abs[abs].max,
> > +				       xy_data + si->tch_abs[abs].ofs,
> > +				       si->tch_abs[abs].bofs);
> > +	}
> > +}
> > +
> > +static void cyttsp5_get_mt_touches(struct cyttsp5 *ts,
> > +				   struct cyttsp5_touch *tch, int num_cur_tch)
> > +{
> > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > +	int i, t = 0;
> > +	DECLARE_BITMAP(ids, si->tch_abs[CY_TCH_T].max);
> > +	u8 *tch_addr;
> > +	int tmp;
> > +
> > +	bitmap_zero(ids, si->tch_abs[CY_TCH_T].max);
> > +	memset(tch->abs, 0, sizeof(tch->abs));
> > +
> > +	for (i = 0; i < num_cur_tch; i++) {
> > +		tch_addr = si->xy_data + (i * TOUCH_REPORT_SIZE);
> > +		cyttsp5_get_touch_record(ts, tch, tch_addr);
> > +
> > +		/* Convert MAJOR/MINOR from mm to resolution */
> > +		tmp = tch->abs[CY_TCH_MAJ] * 100 * si->sensing_conf_data.res_x;
> > +		tch->abs[CY_TCH_MAJ] = tmp / si->sensing_conf_data.len_x;
> > +		tmp = tch->abs[CY_TCH_MIN] * 100 * si->sensing_conf_data.res_x;
> > +		tch->abs[CY_TCH_MIN] = tmp / si->sensing_conf_data.len_x;
> > +
> > +		t = tch->abs[CY_TCH_T];
> > +		input_mt_slot(ts->input, t);
> > +		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
> > +		__set_bit(t, ids);
> > +
> > +		/* position and pressure fields */
> > +		input_report_abs(ts->input, ABS_MT_POSITION_X,
> > +				 tch->abs[CY_TCH_X]);
> > +		input_report_abs(ts->input, ABS_MT_POSITION_Y,
> > +				 tch->abs[CY_TCH_Y]);
> > +		input_report_abs(ts->input, ABS_MT_PRESSURE,
> > +				 tch->abs[CY_TCH_P]);
> > +
> > +		/* Get the extended touch fields */
> > +		input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR,
> > +				 tch->abs[CY_TCH_MAJ]);
> > +		input_report_abs(ts->input, ABS_MT_TOUCH_MINOR,
> > +				 tch->abs[CY_TCH_MIN]);
> > +	}
> > +
> > +	cyttsp5_final_sync(ts->input, si->tch_abs[CY_TCH_T].max, ids);
> > +
> > +	ts->num_prv_rec = num_cur_tch;
> > +}
> > +
> > +/* read xy_data for all current touches */
> > +static int cyttsp5_xy_worker(struct cyttsp5 *ts)
> > +{
> > +	struct device *dev = ts->dev;
> > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > +	int max_tch = si->sensing_conf_data.max_tch;
> > +	struct cyttsp5_touch tch;
> > +	u8 num_cur_tch;
> > +
> > +	cyttsp5_get_touch_axis(&tch.hdr, si->tch_hdr.size,
> > +			       si->tch_hdr.max,
> > +			       si->xy_mode + 3 + si->tch_hdr.ofs,
> > +			       si->tch_hdr.bofs);
> > +
> > +	num_cur_tch = tch.hdr;
> > +	if (num_cur_tch > max_tch) {
> > +		dev_err(dev, "Num touch err detected (n=%d)\n", num_cur_tch);
> > +		num_cur_tch = max_tch;
> > +	}
> > +
> > +	if (num_cur_tch == 0 && ts->num_prv_rec == 0)
> > +		return 0;
> > +
> > +	/* extract xy_data for all currently reported touches */
> > +	if (num_cur_tch)
> > +		cyttsp5_get_mt_touches(ts, &tch, num_cur_tch);
> > +	else
> > +		cyttsp5_mt_lift_all(ts);
> > +
> > +	return 0;
> > +}
> > +
> > +static int cyttsp5_mt_attention(struct device *dev)
> > +{
> > +	struct cyttsp5 *ts = dev_get_drvdata(dev);  
> 
> Why don't you pass ts into cyttsp5_mt_attention?

Yep, you are right, I will update it.

> 
> > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > +	int rc;
> > +
> > +	if (si->xy_mode[2] != HID_TOUCH_REPORT_ID)
> > +		return 0;
> > +
> > +	/* core handles handshake */
> > +	rc = cyttsp5_xy_worker(ts);
> > +	if (rc < 0)
> > +		dev_err(dev, "xy_worker error r=%d\n", rc);
> > +
> > +	return rc;
> > +}
> > +
> > +static int cyttsp5_setup_input_device(struct device *dev)
> > +{
> > +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > +	int max_x, max_y, max_p;
> > +	int max_x_tmp, max_y_tmp;
> > +	int rc;
> > +
> > +	__set_bit(EV_ABS, ts->input->evbit);
> > +	__set_bit(EV_REL, ts->input->evbit);
> > +	__set_bit(EV_KEY, ts->input->evbit);
> > +
> > +	max_x_tmp = si->sensing_conf_data.res_x;
> > +	max_y_tmp = si->sensing_conf_data.res_y;
> > +	max_x = max_y_tmp - 1;
> > +	max_y = max_x_tmp - 1;
> > +	max_p = si->sensing_conf_data.max_z;
> > +
> > +	input_mt_init_slots(ts->input, si->tch_abs[CY_TCH_T].max, 0);  
> 
> Error handling.

Thanks.

> 
> > +
> > +	__set_bit(ABS_MT_POSITION_X, ts->input->absbit);
> > +	__set_bit(ABS_MT_POSITION_Y, ts->input->absbit);
> > +	__set_bit(ABS_MT_PRESSURE, ts->input->absbit);
> > +
> > +	input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
> > +	input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
> > +	input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, max_p, 0, 0);
> > +
> > +	input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);
> > +	input_set_abs_params(ts->input, ABS_MT_TOUCH_MINOR, 0, MAX_AREA, 0, 0);  
> 
> You might want to use the standard DT touchscreen properties and
> reporting functions to support axis inversion and swapping of axes.

Hm, I am not sure to see what you are referring to.
Could you explain me what you think of?

> 
> > +
> > +	rc = input_register_device(ts->input);
> > +	if (rc < 0)
> > +		dev_err(dev, "Error, failed register input device r=%d\n", rc);
> > +
> > +	return rc;
> > +}
> > +
> > +#ifdef CONFIG_OF
> > +static int cyttsp5_parse_dt_key_code(struct device *dev)
> > +{
> > +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > +	struct device_node *np;
> > +	int i;
> > +
> > +	np = dev->of_node;
> > +	if (!np)
> > +		return -EINVAL;
> > +
> > +	if (!si->num_btns)
> > +		return 0;
> > +
> > +	/* Initialize the button to RESERVED */
> > +	for (i = 0; i < si->num_btns; i++)
> > +		si->key_code[i] = KEY_RESERVED;
> > +
> > +	return of_property_read_u32_array(np, "linux,keycodes",
> > +				   si->key_code, si->num_btns);
> > +}
> > +#else
> > +static int cyttsp5_parse_dt_key_code(struct device *dev)
> > +{
> > +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > +	int i;
> > +
> > +	if (!si->num_btns)
> > +		return 0;
> > +
> > +	/* Initialize the button to RESERVED */
> > +	for (i = 0; i < si->num_btns; i++)
> > +		si->key_code[i] = KEY_RESERVED;
> > +
> > +	return 0;
> > +}
> > +#endif
> > +
> > +static int cyttsp5_btn_attention(struct device *dev)
> > +{
> > +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > +	int cur_btn;
> > +	int cur_btn_state;
> > +
> > +	if (si->xy_mode[2] != HID_BTN_REPORT_ID || !si->num_btns)
> > +		return 0;
> > +
> > +	/* extract button press/release touch information */
> > +	for (cur_btn = 0; cur_btn < si->num_btns; cur_btn++) {
> > +		/* Get current button state */
> > +		cur_btn_state = (si->xy_data[0] >> (cur_btn * CY_BITS_PER_BTN))
> > +			& CY_NUM_BTN_EVENT_ID;
> > +
> > +		input_report_key(ts->input, si->key_code[cur_btn],
> > +				 cur_btn_state);
> > +		input_sync(ts->input);  
> 
> You do not need to sen sync after each button, send it once after all
> buttons sent.

Oh, yes, I will do that!

> 
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static u16 cyttsp5_compute_crc(u8 *buf, u32 size)
> > +{
> > +	u16 remainder = 0xFFFF;
> > +	u16 xor_mask = 0x0000;
> > +	u32 index;
> > +	u32 byte_value;
> > +	u32 table_index;
> > +	u32 crc_bit_width = sizeof(u16) * 8;
> > +
> > +	/* Divide the message by polynomial, via the table. */
> > +	for (index = 0; index < size; index++) {
> > +		byte_value = buf[index];
> > +		table_index = ((byte_value >> 4) & 0x0F)
> > +			^ (remainder >> (crc_bit_width - 4));
> > +		remainder = crc_itu_t_table[table_index]
> > +			^ (remainder << 4);
> > +		table_index = (byte_value & 0x0F)
> > +			^ (remainder >> (crc_bit_width - 4));
> > +		remainder = crc_itu_t_table[table_index]
> > +			^ (remainder << 4);
> > +	}
> > +
> > +	/* Perform the final remainder CRC. */
> > +	return remainder ^ xor_mask;
> > +}
> > +
> > +static int cyttsp5_validate_cmd_response(struct cyttsp5 *ts, u8 code)
> > +{
> > +	u16 size, crc;
> > +	u8 status, offset;
> > +	int command_code;
> > +
> > +	size = get_unaligned_le16(&ts->response_buf[0]);
> > +
> > +	if (!size)
> > +		return 0;
> > +
> > +	offset = ts->response_buf[HID_OUTPUT_RESPONSE_REPORT_OFFSET];
> > +
> > +	if (offset == HID_BL_RESPONSE_REPORT_ID) {
> > +		if (ts->response_buf[4] != HID_OUTPUT_BL_SOP) {
> > +			dev_err(ts->dev, "HID output response, wrong SOP\n");
> > +			return -EPROTO;
> > +		}
> > +
> > +		if (ts->response_buf[size - 1] != HID_OUTPUT_BL_EOP) {
> > +			dev_err(ts->dev, "HID output response, wrong EOP\n");
> > +			return -EPROTO;
> > +		}
> > +
> > +		crc = cyttsp5_compute_crc(&ts->response_buf[4], size - 7);
> > +		if (ts->response_buf[size - 3] != LOW_BYTE(crc) ||
> > +		    ts->response_buf[size - 2] != HI_BYTE(crc)) {
> > +			dev_err(ts->dev, "HID output response, wrong CRC 0x%X\n",
> > +				crc);
> > +			return -EPROTO;
> > +		}
> > +
> > +		status = ts->response_buf[5];
> > +		if (status) {
> > +			dev_err(ts->dev, "HID output response, ERROR:%d\n",
> > +				status);
> > +			return -EPROTO;
> > +		}
> > +	}
> > +
> > +	if (offset == HID_APP_RESPONSE_REPORT_ID) {
> > +		command_code = ts->response_buf[HID_OUTPUT_RESPONSE_CMD_OFFSET]
> > +			& HID_OUTPUT_RESPONSE_CMD_MASK;
> > +		if (command_code != code) {
> > +			dev_err(ts->dev,
> > +				"HID output response, wrong command_code:%X\n",
> > +				command_code);
> > +			return -EPROTO;
> > +		}
> > +	}
> > +
> > +	return 0;
> > +}
> > +
> > +static void cyttsp5_si_get_btn_data(struct cyttsp5 *ts)
> > +{
> > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > +	int i;
> > +	unsigned int btns = ts->response_buf[HID_SYSINFO_BTN_OFFSET]
> > +		& HID_SYSINFO_BTN_MASK;
> > +
> > +	si->num_btns = 0;
> > +	for (i = 0; i < HID_SYSINFO_MAX_BTN; i++) {
> > +		if (btns & BIT(i))
> > +			si->num_btns++;
> > +	}  
> 
> 	si->num_btns = hweight8(ts->response_buf[HID_SYSINFO_BTN_OFFSET]);

Great, I will try that!

> 
> > +}
> > +
> > +static int cyttsp5_get_sysinfo_regs(struct cyttsp5 *ts)
> > +{
> > +	struct cyttsp5_sensing_conf_data *scd = &ts->sysinfo.sensing_conf_data;
> > +	struct cyttsp5_sensing_conf_data_dev *scd_dev =
> > +		(struct cyttsp5_sensing_conf_data_dev *)
> > +		&ts->response_buf[HID_SYSINFO_SENSING_OFFSET];
> > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > +
> > +	cyttsp5_si_get_btn_data(ts);
> > +
> > +	scd->max_tch = scd_dev->max_num_of_tch_per_refresh_cycle;
> > +	scd->res_x = get_unaligned_le16(&scd_dev->res_x);
> > +	scd->res_y = get_unaligned_le16(&scd_dev->res_y);
> > +	scd->max_z = get_unaligned_le16(&scd_dev->max_z);
> > +	scd->len_x = get_unaligned_le16(&scd_dev->len_x);
> > +	scd->len_y = get_unaligned_le16(&scd_dev->len_y);
> > +
> > +	si->xy_data = devm_kzalloc(ts->dev, scd->max_tch * TOUCH_REPORT_SIZE,
> > +				   GFP_KERNEL);
> > +	if (!si->xy_data)
> > +		return -ENOMEM;
> > +
> > +	si->xy_mode = devm_kzalloc(ts->dev, TOUCH_INPUT_HEADER_SIZE,
> > +				   GFP_KERNEL);
> > +	if (!si->xy_mode)
> > +		return -ENOMEM;  
> 
> Why do we need these 2 allocated separately form the driver data?

xy_mode and particularly xy_data are used to retrieve buttons or touch
data that we received from the input buffer (see move_button_data()
and move_touch_data()). I guess that I can try to remove them, if you
want.

> 
> > +
> > +	return 0;
> > +}
> > +
> > +static int cyttsp5_hid_output_get_sysinfo(struct cyttsp5 *ts)
> > +{
> > +	int rc;
> > +	u8 cmd[HID_OUTPUT_GET_SYSINFO_SIZE];
> > +
> > +	ts->hid_cmd_state = HID_CMD_BUSY;
> > +
> > +	/* HI bytes of Output register address */
> > +	cmd[0] = LOW_BYTE(HID_OUTPUT_GET_SYSINFO_SIZE);
> > +	cmd[1] = HI_BYTE(HID_OUTPUT_GET_SYSINFO_SIZE);
> > +	cmd[2] = HID_APP_OUTPUT_REPORT_ID;
> > +	cmd[3] = 0x0; /* Reserved */
> > +	cmd[4] = HID_OUTPUT_GET_SYSINFO;
> > +
> > +	rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
> > +			   HID_OUTPUT_GET_SYSINFO_SIZE);
> > +	if (rc) {
> > +		dev_err(ts->dev, "Failed to write command %d", rc);
> > +		goto error;
> > +	}
> > +
> > +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
> > +				msecs_to_jiffies(CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT));
> > +	if (!rc) {
> > +		dev_err(ts->dev, "HID output cmd execution timed out\n");
> > +		rc = -ETIME;
> > +		goto error;
> > +	}
> > +
> > +	rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_GET_SYSINFO);
> > +	if (rc) {
> > +		dev_err(ts->dev, "Validation of the response failed\n");
> > +		goto error;
> > +	}
> > +
> > +	return cyttsp5_get_sysinfo_regs(ts);
> > +
> > +error:
> > +	mutex_lock(&ts->system_lock);
> > +	ts->hid_cmd_state = HID_CMD_DONE;
> > +	mutex_unlock(&ts->system_lock);
> > +	return rc;
> > +}
> > +
> > +static int cyttsp5_hid_output_bl_launch_app(struct cyttsp5 *ts)
> > +{
> > +	int rc;
> > +	u8 cmd[HID_OUTPUT_BL_LAUNCH_APP];
> > +	u16 crc;
> > +
> > +	mutex_lock(&ts->system_lock);
> > +	ts->hid_cmd_state = HID_CMD_BUSY;
> > +	mutex_unlock(&ts->system_lock);
> > +
> > +	cmd[0] = LOW_BYTE(HID_OUTPUT_BL_LAUNCH_APP_SIZE);
> > +	cmd[1] = HI_BYTE(HID_OUTPUT_BL_LAUNCH_APP_SIZE);
> > +	cmd[2] = HID_BL_OUTPUT_REPORT_ID;
> > +	cmd[3] = 0x0; /* Reserved */
> > +	cmd[4] = HID_OUTPUT_BL_SOP;
> > +	cmd[5] = HID_OUTPUT_BL_LAUNCH_APP;
> > +	cmd[6] = 0x0; /* Low bytes of data */
> > +	cmd[7] = 0x0; /* Hi bytes of data */
> > +	crc = cyttsp5_compute_crc(&cmd[4], 4);
> > +	cmd[8] = LOW_BYTE(crc);
> > +	cmd[9] = HI_BYTE(crc);
> > +	cmd[10] = HID_OUTPUT_BL_EOP;
> > +
> > +	rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
> > +			   HID_OUTPUT_BL_LAUNCH_APP_SIZE);
> > +	if (rc) {
> > +		dev_err(ts->dev, "Failed to write command %d", rc);
> > +		goto error;
> > +	}
> > +
> > +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
> > +				msecs_to_jiffies(CY_HID_OUTPUT_TIMEOUT));
> > +	if (!rc) {
> > +		dev_err(ts->dev, "HID output cmd execution timed out\n");
> > +		rc = -ETIME;
> > +		goto error;
> > +	}
> > +
> > +	rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_BL_LAUNCH_APP);
> > +	if (rc) {
> > +		dev_err(ts->dev, "Validation of the response failed\n");
> > +		goto error;
> > +	}
> > +
> > +	return rc;
> > +
> > +error:
> > +	mutex_lock(&ts->system_lock);
> > +	ts->hid_cmd_state = HID_CMD_DONE;
> > +	mutex_unlock(&ts->system_lock);
> > +
> > +	return rc;
> > +}
> > +
> > +static int cyttsp5_get_hid_descriptor(struct cyttsp5 *ts,
> > +				      struct cyttsp5_hid_desc *desc)
> > +{
> > +	struct device *dev = ts->dev;
> > +	__le16 hid_desc_register = HID_DESC_REG;
> > +	int rc;
> > +	u8 cmd[2];
> > +
> > +	/* Read HID descriptor length and version */
> > +	mutex_lock(&ts->system_lock);
> > +	ts->hid_cmd_state = HID_CMD_BUSY;
> > +	mutex_unlock(&ts->system_lock);
> > +
> > +	/* Set HID descriptor register */
> > +	memcpy(cmd, &hid_desc_register, sizeof(hid_desc_register));
> > +
> > +	rc = cyttsp5_write(ts, HID_DESC_REG, NULL, 0);
> > +	if (rc < 0) {
> > +		dev_err(dev, "Failed to get HID descriptor, rc=%d\n", rc);
> > +		goto error;
> > +	}
> > +
> > +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
> > +				msecs_to_jiffies(CY_HID_GET_HID_DESCRIPTOR_TIMEOUT));
> > +	if (!rc) {
> > +		dev_err(ts->dev, "HID get descriptor timed out\n");
> > +		rc = -ETIME;
> > +		goto error;
> > +	}
> > +
> > +	memcpy(desc, ts->response_buf, sizeof(struct cyttsp5_hid_desc));
> > +
> > +	/* Check HID descriptor length and version */
> > +	if (le16_to_cpu(desc->hid_desc_len) != sizeof(*desc) ||
> > +	    le16_to_cpu(desc->bcd_version) != HID_VERSION) {
> > +		dev_err(dev, "Unsupported HID version\n");
> > +		return -ENODEV;
> > +	}
> > +
> > +	goto exit;
> > +
> > +error:
> > +	mutex_lock(&ts->system_lock);
> > +	ts->hid_cmd_state = HID_CMD_DONE;
> > +	mutex_unlock(&ts->system_lock);
> > +exit:
> > +	return rc;
> > +}
> > +
> > +static int fill_tch_abs(struct cyttsp5_tch_abs_params *tch_abs, int report_size,
> > +			int offset)
> > +{
> > +	tch_abs->ofs = offset / 8;
> > +	tch_abs->size = report_size / 8;
> > +	if (report_size % 8)
> > +		tch_abs->size += 1;
> > +	tch_abs->min = 0;
> > +	tch_abs->max = 1 << report_size;
> > +	tch_abs->bofs = offset - (tch_abs->ofs << 3);
> > +
> > +	return 0;
> > +}
> > +
> > +static int move_button_data(struct cyttsp5 *ts, struct cyttsp5_sysinfo *si)
> > +{
> > +	memcpy(si->xy_mode, ts->input_buf, BTN_INPUT_HEADER_SIZE);
> > +	memcpy(si->xy_data, &ts->input_buf[BTN_INPUT_HEADER_SIZE],
> > +	       BTN_REPORT_SIZE);
> > +
> > +	return 0;
> > +}
> > +
> > +static int move_touch_data(struct cyttsp5 *ts, struct cyttsp5_sysinfo *si)
> > +{
> > +	int max_tch = si->sensing_conf_data.max_tch;
> > +	int num_cur_tch;
> > +	int length;
> > +	struct cyttsp5_tch_abs_params *tch = &si->tch_hdr;
> > +
> > +	memcpy(si->xy_mode, ts->input_buf, TOUCH_INPUT_HEADER_SIZE);
> > +
> > +	cyttsp5_get_touch_axis(&num_cur_tch, tch->size,
> > +			       tch->max, si->xy_mode + 3 + tch->ofs, tch->bofs);
> > +	if (unlikely(num_cur_tch > max_tch))
> > +		num_cur_tch = max_tch;
> > +
> > +	length = num_cur_tch * TOUCH_REPORT_SIZE;
> > +
> > +	memcpy(si->xy_data, &ts->input_buf[TOUCH_INPUT_HEADER_SIZE], length);
> > +
> > +	return 0;
> > +}
> > +
> > +static irqreturn_t cyttsp5_handle_irq(int irq, void *handle)
> > +{
> > +	struct cyttsp5 *ts = handle;
> > +	int report_id;
> > +	int size;
> > +	int rc;
> > +
> > +	rc = cyttsp5_read(ts, ts->input_buf, CY_MAX_INPUT);
> > +	if (rc)
> > +		return IRQ_HANDLED;
> > +
> > +	size = get_unaligned_le16(&ts->input_buf[0]);
> > +
> > +	/* check reset */
> > +	if (size == 0) {
> > +		memcpy(ts->response_buf, ts->input_buf, 2);
> > +
> > +		mutex_lock(&ts->system_lock);
> > +		ts->hid_cmd_state = HID_CMD_DONE;
> > +		mutex_unlock(&ts->system_lock);
> > +		wake_up(&ts->wait_q);  
> 
> I'd use spinlock in wait queue and wake_up_locked() instead of a
> separate mutex.

Hum, okay, I will try that.

> 
> > +		return IRQ_HANDLED;
> > +	}
> > +
> > +	report_id = ts->input_buf[2];
> > +  
> 
> 	switch(report_id) {
> 	}

Yep, it will be easier to understand.

> 
> > +	if (report_id == HID_TOUCH_REPORT_ID) {
> > +		move_touch_data(ts, &ts->sysinfo);
> > +		cyttsp5_mt_attention(ts->dev);
> > +	} else if (report_id == HID_BTN_REPORT_ID) {
> > +		move_button_data(ts, &ts->sysinfo);
> > +		cyttsp5_btn_attention(ts->dev);
> > +	} else {
> > +		/* It is not an input but a command response */
> > +		memcpy(ts->response_buf, ts->input_buf, size);
> > +
> > +		mutex_lock(&ts->system_lock);
> > +		ts->hid_cmd_state = HID_CMD_DONE;
> > +		mutex_unlock(&ts->system_lock);
> > +		wake_up(&ts->wait_q);
> > +	}
> > +
> > +	return IRQ_HANDLED;
> > +}
> > +
> > +static int cyttsp5_deassert_int(struct cyttsp5 *ts)
> > +{
> > +	u16 size;
> > +	u8 buf[2];
> > +	int rc;
> > +
> > +	rc = regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, 2);
> > +	if (rc < 0)
> > +		return rc;
> > +
> > +	size = get_unaligned_le16(&buf[0]);
> > +	if (size == 2 || size == 0)
> > +		return 0;
> > +
> > +	return -EINVAL;
> > +}
> > +
> > +static int cyttsp5_fill_all_touch(struct cyttsp5 *ts)
> > +{
> > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > +
> > +	fill_tch_abs(&si->tch_abs[CY_TCH_X], REPORT_SIZE_16,
> > +		     TOUCH_REPORT_DESC_X);
> > +	fill_tch_abs(&si->tch_abs[CY_TCH_Y], REPORT_SIZE_16,
> > +		     TOUCH_REPORT_DESC_Y);
> > +	fill_tch_abs(&si->tch_abs[CY_TCH_P], REPORT_SIZE_8,
> > +		     TOUCH_REPORT_DESC_P);
> > +	fill_tch_abs(&si->tch_abs[CY_TCH_T], REPORT_SIZE_5,
> > +		     TOUCH_REPORT_DESC_CONTACTID);
> > +	fill_tch_abs(&si->tch_hdr, REPORT_SIZE_5,
> > +		     TOUCH_REPORT_DESC_HDR_CONTACTCOUNT);
> > +	fill_tch_abs(&si->tch_abs[CY_TCH_MAJ], REPORT_SIZE_8,
> > +		     TOUCH_REPORT_DESC_MAJ);
> > +	fill_tch_abs(&si->tch_abs[CY_TCH_MIN], REPORT_SIZE_8,
> > +		     TOUCH_REPORT_DESC_MIN);
> > +
> > +	return 0;
> > +}
> > +
> > +static int cyttsp5_startup(struct cyttsp5 *ts)
> > +{
> > +	int rc;
> > +
> > +	rc = cyttsp5_deassert_int(ts);
> > +	if (rc) {
> > +		dev_err(ts->dev, "Error on deassert int r=%d\n", rc);
> > +		return -ENODEV;
> > +	}
> > +
> > +	/*
> > +	 * Launch the application as the device starts in bootloader mode
> > +	 * because of a power-on-reset
> > +	 */
> > +	rc = cyttsp5_hid_output_bl_launch_app(ts);
> > +	if (rc < 0) {
> > +		dev_err(ts->dev, "Error on launch app r=%d\n", rc);
> > +		return rc;
> > +	}
> > +
> > +	rc = cyttsp5_get_hid_descriptor(ts, &ts->hid_desc);
> > +	if (rc < 0) {
> > +		dev_err(ts->dev, "Error on getting HID descriptor r=%d\n", rc);
> > +		return rc;
> > +	}
> > +
> > +	rc = cyttsp5_fill_all_touch(ts);
> > +	if (rc < 0) {
> > +		dev_err(ts->dev, "Error on report descriptor r=%d\n", rc);
> > +		return rc;
> > +	}
> > +
> > +	rc = cyttsp5_hid_output_get_sysinfo(ts);
> > +	if (rc) {
> > +		dev_err(ts->dev, "Error on getting sysinfo r=%d\n", rc);
> > +		return rc;
> > +	}
> > +
> > +	return rc;
> > +}
> > +
> > +#ifdef CONFIG_OF
> > +static const struct of_device_id cyttsp5_of_match[] = {
> > +	{ .compatible = "cypress,cyttsp5", },
> > +	{ }
> > +};
> > +MODULE_DEVICE_TABLE(of, cyttsp5_of_match);
> > +#endif
> > +
> > +static const struct i2c_device_id cyttsp5_i2c_id[] = {
> > +	{ CYTTSP5_NAME, 0, },
> > +	{ }
> > +};
> > +MODULE_DEVICE_TABLE(i2c, cyttsp5_i2c_id);
> > +
> > +static int cyttsp5_probe(struct device *dev, struct regmap *regmap, int irq,
> > +			 const char *name)
> > +{
> > +	struct cyttsp5 *ts;
> > +	struct cyttsp5_sysinfo *si;
> > +	int rc = 0, i;
> > +
> > +	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
> > +	if (!ts)
> > +		return -ENOMEM;
> > +
> > +	/* Initialize device info */
> > +	ts->regmap = regmap;
> > +	ts->dev = dev;
> > +	si = &ts->sysinfo;
> > +	dev_set_drvdata(dev, ts);
> > +
> > +	/* Initialize mutexes and spinlocks */
> > +	mutex_init(&ts->system_lock);
> > +
> > +	/* Initialize wait queue */
> > +	init_waitqueue_head(&ts->wait_q);
> > +
> > +	/* Reset the gpio to be in a reset state */
> > +	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
> > +	if (IS_ERR(ts->reset_gpio)) {
> > +		rc = PTR_ERR(ts->reset_gpio);
> > +		dev_err(dev, "Failed to request reset gpio, error %d\n", rc);
> > +		return rc;
> > +	}
> > +	gpiod_set_value(ts->reset_gpio, 1);  
> 
> Why not request it as GPIOD_OUT_HIGH if you going to activate it
> immediately? However it sounds as if you have a reset line that is
> active low and you want to driver it low to reset, and then release. In
> this case you need to do
> 
> 	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
> 	<delay> - chip usually needs to be some time in reset state
> 	gpiod_set_value(ts->reset_gpio, 0);
> 
> and make sure that correct polarity is specified in device tree.

Okay, I will update it too.

> 
> > +
> > +	/* Need a delay to have device up */
> > +	msleep(20);
> > +
> > +	rc = devm_request_threaded_irq(dev, irq, NULL, cyttsp5_handle_irq,
> > +				       IRQF_TRIGGER_FALLING | IRQF_ONESHOT,  
> 
> Just use IRQF_ONESHOT and make sure DTS specifies interrupt properly.
> BTW,I'd recommend using level, not edge interrupts. It is so easy to
> miss an edge.

Okay, thank you for the advice.

> 
> > +				       name, ts);
> > +	if (rc) {
> > +		dev_err(dev, "unable to request IRQ\n");
> > +		return rc;
> > +	}
> > +
> > +	rc = cyttsp5_startup(ts);
> > +	if (rc) {
> > +		dev_err(ts->dev, "Fail initial startup r=%d\n", rc);
> > +		return rc;
> > +	}
> > +
> > +	rc = cyttsp5_parse_dt_key_code(dev);
> > +	if (rc < 0) {
> > +		dev_err(ts->dev, "Error while parsing dts %d\n", rc);
> > +		return rc;
> > +	}
> > +
> > +	ts->input = devm_input_allocate_device(dev);
> > +	if (!ts->input) {
> > +		dev_err(dev, "Error, failed to allocate input device\n");
> > +		return -ENODEV;
> > +	}
> > +
> > +	ts->input->name = "cyttsp5";
> > +	scnprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
> > +	ts->input->phys = ts->phys;
> > +	ts->input->dev.parent = ts->dev;
> > +	input_set_drvdata(ts->input, ts);
> > +
> > +	touchscreen_parse_properties(ts->input, true, NULL);
> > +
> > +	__set_bit(EV_KEY, ts->input->evbit);
> > +	for (i = 0; i < si->num_btns; i++)
> > +		__set_bit(si->key_code[i], ts->input->keybit);
> > +
> > +	return cyttsp5_setup_input_device(dev);
> > +}
> > +
> > +static int cyttsp5_i2c_probe(struct i2c_client *client,
> > +			     const struct i2c_device_id *id)
> > +{
> > +	struct regmap *regmap;
> > +	static const struct regmap_config config = {
> > +		.reg_bits = 8,
> > +		.val_bits = 8,
> > +	};
> > +
> > +	regmap = devm_regmap_init_i2c(client, &config);
> > +	if (IS_ERR(regmap)) {
> > +		dev_err(&client->dev, "regmap allocation failed: %ld\n",
> > +			PTR_ERR(regmap));
> > +		return PTR_ERR(regmap);
> > +	}
> > +
> > +	return cyttsp5_probe(&client->dev, regmap, client->irq, client->name);
> > +}
> > +
> > +static int cyttsp5_remove(struct device *dev)
> > +{
> > +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> > +
> > +	input_unregister_device(ts->input);  
> 
> Not needed: you are using managed input device.

You are right, thanks.

> 
> > +
> > +	return 0;
> > +}
> > +
> > +static int cyttsp5_i2c_remove(struct i2c_client *client)
> > +{
> > +	struct device *dev = &client->dev;
> > +
> > +	return cyttsp5_remove(dev);  
> 
> Not needed if you remove cyttsp5_remove().

Sure.

> 
> > +}
> > +
> > +static struct i2c_driver cyttsp5_i2c_driver = {
> > +	.driver = {
> > +		.name = CYTTSP5_NAME,
> > +		.owner = THIS_MODULE,
> > +		.of_match_table = of_match_ptr(cyttsp5_of_match),
> > +	},
> > +	.probe = cyttsp5_i2c_probe,
> > +	.remove = cyttsp5_i2c_remove,
> > +	.id_table = cyttsp5_i2c_id,
> > +};
> > +
> > +module_i2c_driver(cyttsp5_i2c_driver);
> > +
> > +MODULE_LICENSE("GPL");
> > +MODULE_DESCRIPTION("Touchscreen driver for Cypress TrueTouch Gen 5 Product");
> > +MODULE_AUTHOR("Mylène Josserand <mylene.josserand@free-electrons.com>");
> > -- 
> > 2.11.0
> >   
> 
> Thanks.
> 

Best regards,

-- 
Mylène Josserand, Free Electrons
Embedded Linux and Kernel engineering
http://free-electrons.com

Re: [PATCH v4 1/2] Input: Add driver for Cypress Generation 5 touchscreen

[landyn.lawrence-jHc5sQ61u836K7/ahGyk6A]

Hey,

thanks for the great work on this one!

Best regards

On 01/23/2018 11:44 AM, Mylene Josserand wrote:
> Hi Dmitry,
> 
> Thank you for the review.
> 
> Le Mon, 22 Jan 2018 20:15:03 -0800,
> Dmitry Torokhov <dmitry.torokhov-Re5JQEeQqe8AvxtiuMwx3w@public.gmane.org> a écrit :
> 
>> Hi Mylène,
>>
>> On Fri, Dec 01, 2017 at 04:39:56PM +0100, Mylène Josserand wrote:
>>> This is the basic driver for the Cypress TrueTouch Gen5 touchscreen
>>> controllers. This driver supports only the I2C bus but it uses regmap
>>> so SPI support could be added later.
>>> The touchscreen can retrieve some defined zone that are handled as
>>> buttons (according to the hardware). That is why it handles
>>> button and multitouch events.
>>>
>>> Reviewed-by: Maxime Ripard <maxime.ripard-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org>
>>> Signed-off-by: Mylène Josserand <mylene.josserand-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org>
>>> ---
>>>   drivers/input/touchscreen/Kconfig   |   16 +
>>>   drivers/input/touchscreen/Makefile  |    1 +
>>>   drivers/input/touchscreen/cyttsp5.c | 1110 +++++++++++++++++++++++++++++++++++
>>>   3 files changed, 1127 insertions(+)
>>>   create mode 100644 drivers/input/touchscreen/cyttsp5.c
>>>
>>> diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
>>> index 0cfdb7cb610e..28eea6d5f1bb 100644
>>> --- a/drivers/input/touchscreen/Kconfig
>>> +++ b/drivers/input/touchscreen/Kconfig
>>> @@ -238,6 +238,22 @@ config TOUCHSCREEN_CYTTSP4_SPI
>>>   	  To compile this driver as a module, choose M here: the
>>>   	  module will be called cyttsp4_spi.
>>>   
>>> +config TOUCHSCREEN_CYTTSP5
>>> +	tristate "Cypress TrueTouch Gen5 Touchscreen Driver"
>>> +	depends on OF
>>
>> Does it have to be? Please use generic device properties
>> (device_property_* API) and it can be used with ACPI and static board
>> files, of needed.
> 
> Okay, I will try with that.
> 
>>
>>> +	select REGMAP_I2C
>>> +	select CRC_ITU_T
>>> +	help
>>> +	  Driver for Parade TrueTouch Standard Product
>>> +	  Generation 5 touchscreen controllers.
>>> +	  I2C bus interface support only.
>>> +
>>> +	  Say Y here if you have a Cypress Gen5 touchscreen.
>>> +	  If unsure, say N.
>>> +
>>> +	  To compile this driver as a module, choose M here: the
>>> +	  module will be called cyttsp5.
>>> +
>>>   config TOUCHSCREEN_DA9034
>>>   	tristate "Touchscreen support for Dialog Semiconductor DA9034"
>>>   	depends on PMIC_DA903X
>>> diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
>>> index d2a2b3b7af27..e7d124901dd9 100644
>>> --- a/drivers/input/touchscreen/Makefile
>>> +++ b/drivers/input/touchscreen/Makefile
>>> @@ -26,6 +26,7 @@ obj-$(CONFIG_TOUCHSCREEN_CYTTSP_SPI)	+= cyttsp_spi.o
>>>   obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_CORE)	+= cyttsp4_core.o
>>>   obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_I2C)	+= cyttsp4_i2c.o cyttsp_i2c_common.o
>>>   obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_SPI)	+= cyttsp4_spi.o
>>> +obj-$(CONFIG_TOUCHSCREEN_CYTTSP5)	+= cyttsp5.o
>>>   obj-$(CONFIG_TOUCHSCREEN_DA9034)	+= da9034-ts.o
>>>   obj-$(CONFIG_TOUCHSCREEN_DA9052)	+= da9052_tsi.o
>>>   obj-$(CONFIG_TOUCHSCREEN_DYNAPRO)	+= dynapro.o
>>> diff --git a/drivers/input/touchscreen/cyttsp5.c b/drivers/input/touchscreen/cyttsp5.c
>>> new file mode 100644
>>> index 000000000000..a41feea2cd5a
>>> --- /dev/null
>>> +++ b/drivers/input/touchscreen/cyttsp5.c
>>> @@ -0,0 +1,1110 @@
>>> +/*
>>> + * Parade TrueTouch(TM) Standard Product V5 Module.
>>> + * For use with Parade touchscreen controllers.
>>> + *
>>> + * Copyright (C) 2015 Parade Technologies
>>> + * Copyright (C) 2012-2015 Cypress Semiconductor
>>> + * Copyright (C) 2017 Free Electrons
>>> + *
>>> + * Author: Mylène Josserand <mylene.josserand-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org>
>>> + *
>>> + * This program is free software; you can redistribute it and/or
>>> + * modify it under the terms of the GNU General Public License
>>> + * version 2, and only version 2, 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.
>>> + *
>>> + */
>>> +
>>> +#include <asm/unaligned.h>
>>> +#include <linux/crc-itu-t.h>
>>> +#include <linux/delay.h>
>>> +#include <linux/device.h>
>>> +#include <linux/gpio.h>
>>> +#include <linux/input/mt.h>
>>> +#include <linux/input/touchscreen.h>
>>> +#include <linux/interrupt.h>
>>> +#include <linux/i2c.h>
>>> +#include <linux/module.h>
>>> +#include <linux/of_device.h>
>>> +#include <linux/regmap.h>
>>> +
>>> +#define CYTTSP5_NAME				"cyttsp5"
>>> +#define CY_I2C_DATA_SIZE			(2 * 256)
>>> +#define HID_VERSION				0x0100
>>> +#define CY_MAX_INPUT				512
>>> +#define CYTTSP5_PREALLOCATED_CMD_BUFFER	32
>>> +#define CY_BITS_PER_BTN			1
>>> +#define CY_NUM_BTN_EVENT_ID			((1 << CY_BITS_PER_BTN) - 1)
>>> +
>>> +#define MAX_AREA				255
>>> +#define HID_OUTPUT_BL_SOP			0x1
>>> +#define HID_OUTPUT_BL_EOP			0x17
>>> +#define HID_OUTPUT_BL_LAUNCH_APP		0x3B
>>> +#define HID_OUTPUT_BL_LAUNCH_APP_SIZE		11
>>> +#define HID_OUTPUT_GET_SYSINFO			0x2
>>> +#define HID_OUTPUT_GET_SYSINFO_SIZE		5
>>> +
>>> +#define HID_DESC_REG				0x1
>>> +#define HID_INPUT_REG				0x3
>>> +#define HID_OUTPUT_REG				0x4
>>> +
>>> +#define REPORT_ID_TOUCH			0x1
>>> +#define REPORT_ID_BTN				0x3
>>> +#define REPORT_SIZE_5				5
>>> +#define REPORT_SIZE_8				8
>>> +#define REPORT_SIZE_16				16
>>> +
>>> +/* Touch reports offsets */
>>> +/* Header offsets */
>>> +#define TOUCH_REPORT_DESC_HDR_CONTACTCOUNT	16
>>> +/* Record offsets */
>>> +#define TOUCH_REPORT_DESC_CONTACTID		8
>>> +#define TOUCH_REPORT_DESC_X			16
>>> +#define TOUCH_REPORT_DESC_Y			32
>>> +#define TOUCH_REPORT_DESC_P			48
>>> +#define TOUCH_REPORT_DESC_MAJ			56
>>> +#define TOUCH_REPORT_DESC_MIN			64
>>> +
>>> +/* HID */
>>> +#define HID_TOUCH_REPORT_ID			0x1
>>> +#define HID_BTN_REPORT_ID			0x3
>>> +#define HID_APP_RESPONSE_REPORT_ID		0x1F
>>> +#define HID_APP_OUTPUT_REPORT_ID		0x2F
>>> +#define HID_BL_RESPONSE_REPORT_ID		0x30
>>> +#define HID_BL_OUTPUT_REPORT_ID		0x40
>>> +
>>> +#define HID_OUTPUT_RESPONSE_REPORT_OFFSET	2
>>> +#define HID_OUTPUT_RESPONSE_CMD_OFFSET		4
>>> +#define HID_OUTPUT_RESPONSE_CMD_MASK		0x7F
>>> +
>>> +#define HID_SYSINFO_SENSING_OFFSET		33
>>> +#define HID_SYSINFO_BTN_OFFSET			48
>>> +#define HID_SYSINFO_BTN_MASK			0xFF
>>> +#define HID_SYSINFO_MAX_BTN			8
>>> +
>>> +/*  Timeout in ms */
>>> +#define CY_HID_OUTPUT_TIMEOUT			200
>>> +#define CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT	3000
>>> +#define CY_HID_GET_HID_DESCRIPTOR_TIMEOUT	4000
>>> +
>>> +/* maximum number of concurrent tracks */
>>> +#define TOUCH_REPORT_SIZE			10
>>> +#define TOUCH_INPUT_HEADER_SIZE		7
>>> +#define BTN_REPORT_SIZE			9
>>> +#define BTN_INPUT_HEADER_SIZE			5
>>> +
>>> +/* All usage pages for Touch Report */
>>> +#define TOUCH_REPORT_USAGE_PG_X		0x00010030
>>> +#define TOUCH_REPORT_USAGE_PG_Y		0x00010031
>>> +#define TOUCH_REPORT_USAGE_PG_P		0x000D0030
>>> +#define TOUCH_REPORT_USAGE_PG_CONTACTID	0x000D0051
>>> +#define TOUCH_REPORT_USAGE_PG_CONTACTCOUNT	0x000D0054
>>> +#define TOUCH_REPORT_USAGE_PG_MAJ		0xFF010062
>>> +#define TOUCH_REPORT_USAGE_PG_MIN		0xFF010063
>>> +#define TOUCH_COL_USAGE_PG			0x000D0022
>>> +
>>> +/* helpers */
>>> +#define HI_BYTE(x)				(u8)(((x) >> 8) & 0xFF)
>>> +#define LOW_BYTE(x)				(u8)((x) & 0xFF)
>>> +
>>> +/* System Information interface definitions */
>>> +struct cyttsp5_sensing_conf_data_dev {
>>> +	u8 electrodes_x;
>>> +	u8 electrodes_y;
>>> +	__le16 len_x;
>>> +	__le16 len_y;
>>> +	__le16 res_x;
>>> +	__le16 res_y;
>>> +	__le16 max_z;
>>> +	u8 origin_x;
>>> +	u8 origin_y;
>>> +	u8 btn;
>>> +	u8 scan_mode;
>>> +	u8 max_num_of_tch_per_refresh_cycle;
>>> +} __packed;
>>> +
>>> +struct cyttsp5_sensing_conf_data {
>>> +	u16 res_x;
>>> +	u16 res_y;
>>> +	u16 max_z;
>>> +	u16 len_x;
>>> +	u16 len_y;
>>> +	u8 origin_x;
>>> +	u8 origin_y;
>>> +	u8 max_tch;
>>> +};
>>> +
>>> +enum { HID_CMD_DONE, HID_CMD_BUSY } hid_cmd_state;
>>> +
>>> +enum cyttsp5_tch_abs {	/* for ordering within the extracted touch data array */
>>> +	CY_TCH_X,	/* X */
>>> +	CY_TCH_Y,	/* Y */
>>> +	CY_TCH_P,	/* P (Z) */
>>> +	CY_TCH_T,	/* TOUCH ID */
>>> +	CY_TCH_MAJ,	/* TOUCH_MAJOR */
>>> +	CY_TCH_MIN,	/* TOUCH_MINOR */
>>> +	CY_TCH_NUM_ABS,
>>> +};
>>> +
>>> +struct cyttsp5_tch_abs_params {
>>> +	size_t ofs;	/* abs byte offset */
>>> +	size_t size;	/* size in bits */
>>> +	size_t min;	/* min value */
>>> +	size_t max;	/* max value */
>>> +	size_t bofs;	/* bit offset */
>>> +};
>>> +
>>> +struct cyttsp5_touch {
>>> +	int hdr;
>>> +	int abs[CY_TCH_NUM_ABS];
>>> +};
>>> +
>>> +struct cyttsp5_sysinfo {
>>> +	struct cyttsp5_sensing_conf_data sensing_conf_data;
>>> +	int num_btns;
>>> +	struct cyttsp5_tch_abs_params tch_hdr;
>>> +	struct cyttsp5_tch_abs_params tch_abs[CY_TCH_NUM_ABS];
>>> +	u32 key_code[HID_SYSINFO_MAX_BTN];
>>> +	u8 *xy_mode;
>>> +	u8 *xy_data;
>>> +};
>>> +
>>> +struct cyttsp5_hid_desc {
>>> +	__le16 hid_desc_len;
>>> +	u8 packet_id;
>>> +	u8 reserved_byte;
>>> +	__le16 bcd_version;
>>> +	__le16 report_desc_len;
>>> +	__le16 report_desc_register;
>>> +	__le16 input_register;
>>> +	__le16 max_input_len;
>>> +	__le16 output_register;
>>> +	__le16 max_output_len;
>>> +	__le16 command_register;
>>> +	__le16 data_register;
>>> +	__le16 vendor_id;
>>> +	__le16 product_id;
>>> +	__le16 version_id;
>>> +	u8 reserved[4];
>>> +} __packed;
>>> +
>>> +struct cyttsp5 {
>>> +	struct device *dev;
>>> +	struct mutex system_lock;
>>> +	wait_queue_head_t wait_q;
>>> +	struct cyttsp5_sysinfo sysinfo;
>>> +	int hid_cmd_state;
>>> +	struct cyttsp5_hid_desc hid_desc;
>>> +	u8 cmd_buf[CYTTSP5_PREALLOCATED_CMD_BUFFER];
>>> +	u8 input_buf[CY_MAX_INPUT];
>>> +	u8 response_buf[CY_MAX_INPUT];
>>> +	struct gpio_desc *reset_gpio;
>>> +	struct input_dev *input;
>>> +	char phys[NAME_MAX];
>>> +	int num_prv_rec;
>>> +	struct regmap *regmap;
>>> +};
>>> +
>>> +/*
>>> + * For what understood in the datasheet, the register does not
>>> + * matter. For consistency, used the Input Register address
>>> + * but it does mean anything to the device. The important data
>>> + * to send is the I2C address
>>> + */
>>> +static int cyttsp5_read(struct cyttsp5 *ts, u8 *buf, u32 max)
>>> +{
>>> +	int rc;
>>> +	u32 size;
>>> +	u8 temp[2];
>>> +
>>> +	if (!buf)
>>> +		return -EINVAL;
>>
>> Is it really possible? This is not a publicly facing API but private
>> driver data, do you ever happen to call it with NULL?
> 
> hm, I do not think so but I will check that.
> 
>>
>>> +
>>> +	/* Read the frame to retrieve the size */
>>> +	rc = regmap_bulk_read(ts->regmap, HID_INPUT_REG, temp, 2);
>>> +	if (rc < 0)
>>> +		return rc;
>>
>> Can we call this kind of variables "error" pelase?
> 
> Sure.
> 
>>
>>> +
>>> +	size = get_unaligned_le16(temp);
>>> +	if (!size || size == 2)
>>> +		return 0;
>>> +
>>> +	if (size > max)
>>> +		return -EINVAL;
>>> +
>>> +	/* Get the real value */
>>> +	return regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, size);
>>> +}
>>> +
>>> +static int cyttsp5_write(struct cyttsp5 *ts, unsigned int reg, u8 *data,
>>> +			 size_t size)
>>> +{
>>> +	u8 cmd[size + 1];
>>> +
>>> +	/* High bytes of register address needed as first byte of cmd */
>>> +	cmd[0] = HI_BYTE(reg);
>>> +
>>> +	/* Copy the rest of the data */
>>> +	if (data)
>>> +		memcpy(&cmd[1], data, size);
>>> +
>>> +	/* The hardware wants to receive a frame with the address register
>>
>> The multiline comment block should start with "/*" on a separate line
>> please.
> 
> I will change that.
> 
>>
>>> +	 * contains in the first two bytes. As the regmap_write function
>>> +	 * add the register adresse in the frame, we use the LOW_BYTE as
>>> +	 * first frame byte for the address register and the first
>>> +	 * data byte is the high register + left of the cmd to send
>>> +	 */
>>> +	return regmap_bulk_write(ts->regmap, LOW_BYTE(reg), cmd, size + 1);
>>> +}
>>> +
>>> +static void cyttsp5_final_sync(struct input_dev *input, int max_slots,
>>> +			       unsigned long *ids)
>>> +{
>>> +	int t;
>>> +
>>> +	for (t = 0; t < max_slots; t++) {
>>
>> 	for_each_set_bit() {
>> 	}
> 
> I did not know this macro, I will try that.
> 
>>
>>> +		if (test_bit(t, ids))
>>> +			continue;
>>> +		input_mt_slot(input, t);
>>> +		input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
>>> +	}
>>> +
>>> +	input_sync(input);
>>> +}
>>> +
>>> +static void cyttsp5_report_slot_liftoff(struct cyttsp5 *ts, int max_slots)
>>> +{
>>> +	int t;
>>> +
>>> +	if (ts->num_prv_rec == 0)
>>> +		return;
>>
>> Do you need this check? The caller checks the same condition.
> 
> True, I will remove it.
> 
>>
>>> +
>>> +	for (t = 0; t < max_slots; t++) {
>>> +		input_mt_slot(ts->input, t);
>>> +		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, false);
>>> +	}
>>> +}
>>> +
>>> +static void cyttsp5_mt_lift_all(struct cyttsp5 *ts)
>>> +{
>>> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
>>> +	int max = si->tch_abs[CY_TCH_T].max;
>>> +
>>> +	if (ts->num_prv_rec != 0) {
>>> +		cyttsp5_report_slot_liftoff(ts, max);
>>> +		input_sync(ts->input);
>>> +		ts->num_prv_rec = 0;
>>> +	}
>>> +}
>>> +
>>> +static void cyttsp5_get_touch_axis(int *axis, int size, int max, u8 *xy_data,
>>> +				   int bofs)
>>> +{
>>> +	int nbyte;
>>> +	int next;
>>> +
>>> +	for (nbyte = 0, *axis = 0, next = 0; nbyte < size; nbyte++)
>>> +		*axis = *axis + ((xy_data[nbyte] >> bofs) << (nbyte * 8));
>>> +
>>> +	*axis &= max - 1;
>>> +}
>>> +
>>> +static void cyttsp5_get_touch_record(struct cyttsp5 *ts,
>>> +				     struct cyttsp5_touch *touch, u8 *xy_data)
>>> +{
>>> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
>>> +	enum cyttsp5_tch_abs abs;
>>> +
>>> +	for (abs = CY_TCH_X; abs < CY_TCH_NUM_ABS; abs++) {
>>> +		cyttsp5_get_touch_axis(&touch->abs[abs],
>>> +				       si->tch_abs[abs].size,
>>> +				       si->tch_abs[abs].max,
>>> +				       xy_data + si->tch_abs[abs].ofs,
>>> +				       si->tch_abs[abs].bofs);
>>> +	}
>>> +}
>>> +
>>> +static void cyttsp5_get_mt_touches(struct cyttsp5 *ts,
>>> +				   struct cyttsp5_touch *tch, int num_cur_tch)
>>> +{
>>> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
>>> +	int i, t = 0;
>>> +	DECLARE_BITMAP(ids, si->tch_abs[CY_TCH_T].max);
>>> +	u8 *tch_addr;
>>> +	int tmp;
>>> +
>>> +	bitmap_zero(ids, si->tch_abs[CY_TCH_T].max);
>>> +	memset(tch->abs, 0, sizeof(tch->abs));
>>> +
>>> +	for (i = 0; i < num_cur_tch; i++) {
>>> +		tch_addr = si->xy_data + (i * TOUCH_REPORT_SIZE);
>>> +		cyttsp5_get_touch_record(ts, tch, tch_addr);
>>> +
>>> +		/* Convert MAJOR/MINOR from mm to resolution */
>>> +		tmp = tch->abs[CY_TCH_MAJ] * 100 * si->sensing_conf_data.res_x;
>>> +		tch->abs[CY_TCH_MAJ] = tmp / si->sensing_conf_data.len_x;
>>> +		tmp = tch->abs[CY_TCH_MIN] * 100 * si->sensing_conf_data.res_x;
>>> +		tch->abs[CY_TCH_MIN] = tmp / si->sensing_conf_data.len_x;
>>> +
>>> +		t = tch->abs[CY_TCH_T];
>>> +		input_mt_slot(ts->input, t);
>>> +		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
>>> +		__set_bit(t, ids);
>>> +
>>> +		/* position and pressure fields */
>>> +		input_report_abs(ts->input, ABS_MT_POSITION_X,
>>> +				 tch->abs[CY_TCH_X]);
>>> +		input_report_abs(ts->input, ABS_MT_POSITION_Y,
>>> +				 tch->abs[CY_TCH_Y]);
>>> +		input_report_abs(ts->input, ABS_MT_PRESSURE,
>>> +				 tch->abs[CY_TCH_P]);
>>> +
>>> +		/* Get the extended touch fields */
>>> +		input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR,
>>> +				 tch->abs[CY_TCH_MAJ]);
>>> +		input_report_abs(ts->input, ABS_MT_TOUCH_MINOR,
>>> +				 tch->abs[CY_TCH_MIN]);
>>> +	}
>>> +
>>> +	cyttsp5_final_sync(ts->input, si->tch_abs[CY_TCH_T].max, ids);
>>> +
>>> +	ts->num_prv_rec = num_cur_tch;
>>> +}
>>> +
>>> +/* read xy_data for all current touches */
>>> +static int cyttsp5_xy_worker(struct cyttsp5 *ts)
>>> +{
>>> +	struct device *dev = ts->dev;
>>> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
>>> +	int max_tch = si->sensing_conf_data.max_tch;
>>> +	struct cyttsp5_touch tch;
>>> +	u8 num_cur_tch;
>>> +
>>> +	cyttsp5_get_touch_axis(&tch.hdr, si->tch_hdr.size,
>>> +			       si->tch_hdr.max,
>>> +			       si->xy_mode + 3 + si->tch_hdr.ofs,
>>> +			       si->tch_hdr.bofs);
>>> +
>>> +	num_cur_tch = tch.hdr;
>>> +	if (num_cur_tch > max_tch) {
>>> +		dev_err(dev, "Num touch err detected (n=%d)\n", num_cur_tch);
>>> +		num_cur_tch = max_tch;
>>> +	}
>>> +
>>> +	if (num_cur_tch == 0 && ts->num_prv_rec == 0)
>>> +		return 0;
>>> +
>>> +	/* extract xy_data for all currently reported touches */
>>> +	if (num_cur_tch)
>>> +		cyttsp5_get_mt_touches(ts, &tch, num_cur_tch);
>>> +	else
>>> +		cyttsp5_mt_lift_all(ts);
>>> +
>>> +	return 0;
>>> +}
>>> +
>>> +static int cyttsp5_mt_attention(struct device *dev)
>>> +{
>>> +	struct cyttsp5 *ts = dev_get_drvdata(dev);
>>
>> Why don't you pass ts into cyttsp5_mt_attention?
> 
> Yep, you are right, I will update it.
> 
>>
>>> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
>>> +	int rc;
>>> +
>>> +	if (si->xy_mode[2] != HID_TOUCH_REPORT_ID)
>>> +		return 0;
>>> +
>>> +	/* core handles handshake */
>>> +	rc = cyttsp5_xy_worker(ts);
>>> +	if (rc < 0)
>>> +		dev_err(dev, "xy_worker error r=%d\n", rc);
>>> +
>>> +	return rc;
>>> +}
>>> +
>>> +static int cyttsp5_setup_input_device(struct device *dev)
>>> +{
>>> +	struct cyttsp5 *ts = dev_get_drvdata(dev);
>>> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
>>> +	int max_x, max_y, max_p;
>>> +	int max_x_tmp, max_y_tmp;
>>> +	int rc;
>>> +
>>> +	__set_bit(EV_ABS, ts->input->evbit);
>>> +	__set_bit(EV_REL, ts->input->evbit);
>>> +	__set_bit(EV_KEY, ts->input->evbit);
>>> +
>>> +	max_x_tmp = si->sensing_conf_data.res_x;
>>> +	max_y_tmp = si->sensing_conf_data.res_y;
>>> +	max_x = max_y_tmp - 1;
>>> +	max_y = max_x_tmp - 1;
>>> +	max_p = si->sensing_conf_data.max_z;
>>> +
>>> +	input_mt_init_slots(ts->input, si->tch_abs[CY_TCH_T].max, 0);
>>
>> Error handling.
> 
> Thanks.
> 
>>
>>> +
>>> +	__set_bit(ABS_MT_POSITION_X, ts->input->absbit);
>>> +	__set_bit(ABS_MT_POSITION_Y, ts->input->absbit);
>>> +	__set_bit(ABS_MT_PRESSURE, ts->input->absbit);
>>> +
>>> +	input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
>>> +	input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
>>> +	input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, max_p, 0, 0);
>>> +
>>> +	input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);
>>> +	input_set_abs_params(ts->input, ABS_MT_TOUCH_MINOR, 0, MAX_AREA, 0, 0);
>>
>> You might want to use the standard DT touchscreen properties and
>> reporting functions to support axis inversion and swapping of axes.
> 
> Hm, I am not sure to see what you are referring to.
> Could you explain me what you think of?
> 
>>
>>> +
>>> +	rc = input_register_device(ts->input);
>>> +	if (rc < 0)
>>> +		dev_err(dev, "Error, failed register input device r=%d\n", rc);
>>> +
>>> +	return rc;
>>> +}
>>> +
>>> +#ifdef CONFIG_OF
>>> +static int cyttsp5_parse_dt_key_code(struct device *dev)
>>> +{
>>> +	struct cyttsp5 *ts = dev_get_drvdata(dev);
>>> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
>>> +	struct device_node *np;
>>> +	int i;
>>> +
>>> +	np = dev->of_node;
>>> +	if (!np)
>>> +		return -EINVAL;
>>> +
>>> +	if (!si->num_btns)
>>> +		return 0;
>>> +
>>> +	/* Initialize the button to RESERVED */
>>> +	for (i = 0; i < si->num_btns; i++)
>>> +		si->key_code[i] = KEY_RESERVED;
>>> +
>>> +	return of_property_read_u32_array(np, "linux,keycodes",
>>> +				   si->key_code, si->num_btns);
>>> +}
>>> +#else
>>> +static int cyttsp5_parse_dt_key_code(struct device *dev)
>>> +{
>>> +	struct cyttsp5 *ts = dev_get_drvdata(dev);
>>> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
>>> +	int i;
>>> +
>>> +	if (!si->num_btns)
>>> +		return 0;
>>> +
>>> +	/* Initialize the button to RESERVED */
>>> +	for (i = 0; i < si->num_btns; i++)
>>> +		si->key_code[i] = KEY_RESERVED;
>>> +
>>> +	return 0;
>>> +}
>>> +#endif
>>> +
>>> +static int cyttsp5_btn_attention(struct device *dev)
>>> +{
>>> +	struct cyttsp5 *ts = dev_get_drvdata(dev);
>>> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
>>> +	int cur_btn;
>>> +	int cur_btn_state;
>>> +
>>> +	if (si->xy_mode[2] != HID_BTN_REPORT_ID || !si->num_btns)
>>> +		return 0;
>>> +
>>> +	/* extract button press/release touch information */
>>> +	for (cur_btn = 0; cur_btn < si->num_btns; cur_btn++) {
>>> +		/* Get current button state */
>>> +		cur_btn_state = (si->xy_data[0] >> (cur_btn * CY_BITS_PER_BTN))
>>> +			& CY_NUM_BTN_EVENT_ID;
>>> +
>>> +		input_report_key(ts->input, si->key_code[cur_btn],
>>> +				 cur_btn_state);
>>> +		input_sync(ts->input);
>>
>> You do not need to sen sync after each button, send it once after all
>> buttons sent.
> 
> Oh, yes, I will do that!
> 
>>
>>> +	}
>>> +
>>> +	return 0;
>>> +}
>>> +
>>> +static u16 cyttsp5_compute_crc(u8 *buf, u32 size)
>>> +{
>>> +	u16 remainder = 0xFFFF;
>>> +	u16 xor_mask = 0x0000;
>>> +	u32 index;
>>> +	u32 byte_value;
>>> +	u32 table_index;
>>> +	u32 crc_bit_width = sizeof(u16) * 8;
>>> +
>>> +	/* Divide the message by polynomial, via the table. */
>>> +	for (index = 0; index < size; index++) {
>>> +		byte_value = buf[index];
>>> +		table_index = ((byte_value >> 4) & 0x0F)
>>> +			^ (remainder >> (crc_bit_width - 4));
>>> +		remainder = crc_itu_t_table[table_index]
>>> +			^ (remainder << 4);
>>> +		table_index = (byte_value & 0x0F)
>>> +			^ (remainder >> (crc_bit_width - 4));
>>> +		remainder = crc_itu_t_table[table_index]
>>> +			^ (remainder << 4);
>>> +	}
>>> +
>>> +	/* Perform the final remainder CRC. */
>>> +	return remainder ^ xor_mask;
>>> +}
>>> +
>>> +static int cyttsp5_validate_cmd_response(struct cyttsp5 *ts, u8 code)
>>> +{
>>> +	u16 size, crc;
>>> +	u8 status, offset;
>>> +	int command_code;
>>> +
>>> +	size = get_unaligned_le16(&ts->response_buf[0]);
>>> +
>>> +	if (!size)
>>> +		return 0;
>>> +
>>> +	offset = ts->response_buf[HID_OUTPUT_RESPONSE_REPORT_OFFSET];
>>> +
>>> +	if (offset == HID_BL_RESPONSE_REPORT_ID) {
>>> +		if (ts->response_buf[4] != HID_OUTPUT_BL_SOP) {
>>> +			dev_err(ts->dev, "HID output response, wrong SOP\n");
>>> +			return -EPROTO;
>>> +		}
>>> +
>>> +		if (ts->response_buf[size - 1] != HID_OUTPUT_BL_EOP) {
>>> +			dev_err(ts->dev, "HID output response, wrong EOP\n");
>>> +			return -EPROTO;
>>> +		}
>>> +
>>> +		crc = cyttsp5_compute_crc(&ts->response_buf[4], size - 7);
>>> +		if (ts->response_buf[size - 3] != LOW_BYTE(crc) ||
>>> +		    ts->response_buf[size - 2] != HI_BYTE(crc)) {
>>> +			dev_err(ts->dev, "HID output response, wrong CRC 0x%X\n",
>>> +				crc);
>>> +			return -EPROTO;
>>> +		}
>>> +
>>> +		status = ts->response_buf[5];
>>> +		if (status) {
>>> +			dev_err(ts->dev, "HID output response, ERROR:%d\n",
>>> +				status);
>>> +			return -EPROTO;
>>> +		}
>>> +	}
>>> +
>>> +	if (offset == HID_APP_RESPONSE_REPORT_ID) {
>>> +		command_code = ts->response_buf[HID_OUTPUT_RESPONSE_CMD_OFFSET]
>>> +			& HID_OUTPUT_RESPONSE_CMD_MASK;
>>> +		if (command_code != code) {
>>> +			dev_err(ts->dev,
>>> +				"HID output response, wrong command_code:%X\n",
>>> +				command_code);
>>> +			return -EPROTO;
>>> +		}
>>> +	}
>>> +
>>> +	return 0;
>>> +}
>>> +
>>> +static void cyttsp5_si_get_btn_data(struct cyttsp5 *ts)
>>> +{
>>> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
>>> +	int i;
>>> +	unsigned int btns = ts->response_buf[HID_SYSINFO_BTN_OFFSET]
>>> +		& HID_SYSINFO_BTN_MASK;
>>> +
>>> +	si->num_btns = 0;
>>> +	for (i = 0; i < HID_SYSINFO_MAX_BTN; i++) {
>>> +		if (btns & BIT(i))
>>> +			si->num_btns++;
>>> +	}
>>
>> 	si->num_btns = hweight8(ts->response_buf[HID_SYSINFO_BTN_OFFSET]);
> 
> Great, I will try that!
> 
>>
>>> +}
>>> +
>>> +static int cyttsp5_get_sysinfo_regs(struct cyttsp5 *ts)
>>> +{
>>> +	struct cyttsp5_sensing_conf_data *scd = &ts->sysinfo.sensing_conf_data;
>>> +	struct cyttsp5_sensing_conf_data_dev *scd_dev =
>>> +		(struct cyttsp5_sensing_conf_data_dev *)
>>> +		&ts->response_buf[HID_SYSINFO_SENSING_OFFSET];
>>> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
>>> +
>>> +	cyttsp5_si_get_btn_data(ts);
>>> +
>>> +	scd->max_tch = scd_dev->max_num_of_tch_per_refresh_cycle;
>>> +	scd->res_x = get_unaligned_le16(&scd_dev->res_x);
>>> +	scd->res_y = get_unaligned_le16(&scd_dev->res_y);
>>> +	scd->max_z = get_unaligned_le16(&scd_dev->max_z);
>>> +	scd->len_x = get_unaligned_le16(&scd_dev->len_x);
>>> +	scd->len_y = get_unaligned_le16(&scd_dev->len_y);
>>> +
>>> +	si->xy_data = devm_kzalloc(ts->dev, scd->max_tch * TOUCH_REPORT_SIZE,
>>> +				   GFP_KERNEL);
>>> +	if (!si->xy_data)
>>> +		return -ENOMEM;
>>> +
>>> +	si->xy_mode = devm_kzalloc(ts->dev, TOUCH_INPUT_HEADER_SIZE,
>>> +				   GFP_KERNEL);
>>> +	if (!si->xy_mode)
>>> +		return -ENOMEM;
>>
>> Why do we need these 2 allocated separately form the driver data?
> 
> xy_mode and particularly xy_data are used to retrieve buttons or touch
> data that we received from the input buffer (see move_button_data()
> and move_touch_data()). I guess that I can try to remove them, if you
> want.
> 
>>
>>> +
>>> +	return 0;
>>> +}
>>> +
>>> +static int cyttsp5_hid_output_get_sysinfo(struct cyttsp5 *ts)
>>> +{
>>> +	int rc;
>>> +	u8 cmd[HID_OUTPUT_GET_SYSINFO_SIZE];
>>> +
>>> +	ts->hid_cmd_state = HID_CMD_BUSY;
>>> +
>>> +	/* HI bytes of Output register address */
>>> +	cmd[0] = LOW_BYTE(HID_OUTPUT_GET_SYSINFO_SIZE);
>>> +	cmd[1] = HI_BYTE(HID_OUTPUT_GET_SYSINFO_SIZE);
>>> +	cmd[2] = HID_APP_OUTPUT_REPORT_ID;
>>> +	cmd[3] = 0x0; /* Reserved */
>>> +	cmd[4] = HID_OUTPUT_GET_SYSINFO;
>>> +
>>> +	rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
>>> +			   HID_OUTPUT_GET_SYSINFO_SIZE);
>>> +	if (rc) {
>>> +		dev_err(ts->dev, "Failed to write command %d", rc);
>>> +		goto error;
>>> +	}
>>> +
>>> +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
>>> +				msecs_to_jiffies(CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT));
>>> +	if (!rc) {
>>> +		dev_err(ts->dev, "HID output cmd execution timed out\n");
>>> +		rc = -ETIME;
>>> +		goto error;
>>> +	}
>>> +
>>> +	rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_GET_SYSINFO);
>>> +	if (rc) {
>>> +		dev_err(ts->dev, "Validation of the response failed\n");
>>> +		goto error;
>>> +	}
>>> +
>>> +	return cyttsp5_get_sysinfo_regs(ts);
>>> +
>>> +error:
>>> +	mutex_lock(&ts->system_lock);
>>> +	ts->hid_cmd_state = HID_CMD_DONE;
>>> +	mutex_unlock(&ts->system_lock);
>>> +	return rc;
>>> +}
>>> +
>>> +static int cyttsp5_hid_output_bl_launch_app(struct cyttsp5 *ts)
>>> +{
>>> +	int rc;
>>> +	u8 cmd[HID_OUTPUT_BL_LAUNCH_APP];
>>> +	u16 crc;
>>> +
>>> +	mutex_lock(&ts->system_lock);
>>> +	ts->hid_cmd_state = HID_CMD_BUSY;
>>> +	mutex_unlock(&ts->system_lock);
>>> +
>>> +	cmd[0] = LOW_BYTE(HID_OUTPUT_BL_LAUNCH_APP_SIZE);
>>> +	cmd[1] = HI_BYTE(HID_OUTPUT_BL_LAUNCH_APP_SIZE);
>>> +	cmd[2] = HID_BL_OUTPUT_REPORT_ID;
>>> +	cmd[3] = 0x0; /* Reserved */
>>> +	cmd[4] = HID_OUTPUT_BL_SOP;
>>> +	cmd[5] = HID_OUTPUT_BL_LAUNCH_APP;
>>> +	cmd[6] = 0x0; /* Low bytes of data */
>>> +	cmd[7] = 0x0; /* Hi bytes of data */
>>> +	crc = cyttsp5_compute_crc(&cmd[4], 4);
>>> +	cmd[8] = LOW_BYTE(crc);
>>> +	cmd[9] = HI_BYTE(crc);
>>> +	cmd[10] = HID_OUTPUT_BL_EOP;
>>> +
>>> +	rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
>>> +			   HID_OUTPUT_BL_LAUNCH_APP_SIZE);
>>> +	if (rc) {
>>> +		dev_err(ts->dev, "Failed to write command %d", rc);
>>> +		goto error;
>>> +	}
>>> +
>>> +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
>>> +				msecs_to_jiffies(CY_HID_OUTPUT_TIMEOUT));
>>> +	if (!rc) {
>>> +		dev_err(ts->dev, "HID output cmd execution timed out\n");
>>> +		rc = -ETIME;
>>> +		goto error;
>>> +	}
>>> +
>>> +	rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_BL_LAUNCH_APP);
>>> +	if (rc) {
>>> +		dev_err(ts->dev, "Validation of the response failed\n");
>>> +		goto error;
>>> +	}
>>> +
>>> +	return rc;
>>> +
>>> +error:
>>> +	mutex_lock(&ts->system_lock);
>>> +	ts->hid_cmd_state = HID_CMD_DONE;
>>> +	mutex_unlock(&ts->system_lock);
>>> +
>>> +	return rc;
>>> +}
>>> +
>>> +static int cyttsp5_get_hid_descriptor(struct cyttsp5 *ts,
>>> +				      struct cyttsp5_hid_desc *desc)
>>> +{
>>> +	struct device *dev = ts->dev;
>>> +	__le16 hid_desc_register = HID_DESC_REG;
>>> +	int rc;
>>> +	u8 cmd[2];
>>> +
>>> +	/* Read HID descriptor length and version */
>>> +	mutex_lock(&ts->system_lock);
>>> +	ts->hid_cmd_state = HID_CMD_BUSY;
>>> +	mutex_unlock(&ts->system_lock);
>>> +
>>> +	/* Set HID descriptor register */
>>> +	memcpy(cmd, &hid_desc_register, sizeof(hid_desc_register));
>>> +
>>> +	rc = cyttsp5_write(ts, HID_DESC_REG, NULL, 0);
>>> +	if (rc < 0) {
>>> +		dev_err(dev, "Failed to get HID descriptor, rc=%d\n", rc);
>>> +		goto error;
>>> +	}
>>> +
>>> +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
>>> +				msecs_to_jiffies(CY_HID_GET_HID_DESCRIPTOR_TIMEOUT));
>>> +	if (!rc) {
>>> +		dev_err(ts->dev, "HID get descriptor timed out\n");
>>> +		rc = -ETIME;
>>> +		goto error;
>>> +	}
>>> +
>>> +	memcpy(desc, ts->response_buf, sizeof(struct cyttsp5_hid_desc));
>>> +
>>> +	/* Check HID descriptor length and version */
>>> +	if (le16_to_cpu(desc->hid_desc_len) != sizeof(*desc) ||
>>> +	    le16_to_cpu(desc->bcd_version) != HID_VERSION) {
>>> +		dev_err(dev, "Unsupported HID version\n");
>>> +		return -ENODEV;
>>> +	}
>>> +
>>> +	goto exit;
>>> +
>>> +error:
>>> +	mutex_lock(&ts->system_lock);
>>> +	ts->hid_cmd_state = HID_CMD_DONE;
>>> +	mutex_unlock(&ts->system_lock);
>>> +exit:
>>> +	return rc;
>>> +}
>>> +
>>> +static int fill_tch_abs(struct cyttsp5_tch_abs_params *tch_abs, int report_size,
>>> +			int offset)
>>> +{
>>> +	tch_abs->ofs = offset / 8;
>>> +	tch_abs->size = report_size / 8;
>>> +	if (report_size % 8)
>>> +		tch_abs->size += 1;
>>> +	tch_abs->min = 0;
>>> +	tch_abs->max = 1 << report_size;
>>> +	tch_abs->bofs = offset - (tch_abs->ofs << 3);
>>> +
>>> +	return 0;
>>> +}
>>> +
>>> +static int move_button_data(struct cyttsp5 *ts, struct cyttsp5_sysinfo *si)
>>> +{
>>> +	memcpy(si->xy_mode, ts->input_buf, BTN_INPUT_HEADER_SIZE);
>>> +	memcpy(si->xy_data, &ts->input_buf[BTN_INPUT_HEADER_SIZE],
>>> +	       BTN_REPORT_SIZE);
>>> +
>>> +	return 0;
>>> +}
>>> +
>>> +static int move_touch_data(struct cyttsp5 *ts, struct cyttsp5_sysinfo *si)
>>> +{
>>> +	int max_tch = si->sensing_conf_data.max_tch;
>>> +	int num_cur_tch;
>>> +	int length;
>>> +	struct cyttsp5_tch_abs_params *tch = &si->tch_hdr;
>>> +
>>> +	memcpy(si->xy_mode, ts->input_buf, TOUCH_INPUT_HEADER_SIZE);
>>> +
>>> +	cyttsp5_get_touch_axis(&num_cur_tch, tch->size,
>>> +			       tch->max, si->xy_mode + 3 + tch->ofs, tch->bofs);
>>> +	if (unlikely(num_cur_tch > max_tch))
>>> +		num_cur_tch = max_tch;
>>> +
>>> +	length = num_cur_tch * TOUCH_REPORT_SIZE;
>>> +
>>> +	memcpy(si->xy_data, &ts->input_buf[TOUCH_INPUT_HEADER_SIZE], length);
>>> +
>>> +	return 0;
>>> +}
>>> +
>>> +static irqreturn_t cyttsp5_handle_irq(int irq, void *handle)
>>> +{
>>> +	struct cyttsp5 *ts = handle;
>>> +	int report_id;
>>> +	int size;
>>> +	int rc;
>>> +
>>> +	rc = cyttsp5_read(ts, ts->input_buf, CY_MAX_INPUT);
>>> +	if (rc)
>>> +		return IRQ_HANDLED;
>>> +
>>> +	size = get_unaligned_le16(&ts->input_buf[0]);
>>> +
>>> +	/* check reset */
>>> +	if (size == 0) {
>>> +		memcpy(ts->response_buf, ts->input_buf, 2);
>>> +
>>> +		mutex_lock(&ts->system_lock);
>>> +		ts->hid_cmd_state = HID_CMD_DONE;
>>> +		mutex_unlock(&ts->system_lock);
>>> +		wake_up(&ts->wait_q);
>>
>> I'd use spinlock in wait queue and wake_up_locked() instead of a
>> separate mutex.
> 
> Hum, okay, I will try that.
> 
>>
>>> +		return IRQ_HANDLED;
>>> +	}
>>> +
>>> +	report_id = ts->input_buf[2];
>>> +
>>
>> 	switch(report_id) {
>> 	}
> 
> Yep, it will be easier to understand.
> 
>>
>>> +	if (report_id == HID_TOUCH_REPORT_ID) {
>>> +		move_touch_data(ts, &ts->sysinfo);
>>> +		cyttsp5_mt_attention(ts->dev);
>>> +	} else if (report_id == HID_BTN_REPORT_ID) {
>>> +		move_button_data(ts, &ts->sysinfo);
>>> +		cyttsp5_btn_attention(ts->dev);
>>> +	} else {
>>> +		/* It is not an input but a command response */
>>> +		memcpy(ts->response_buf, ts->input_buf, size);
>>> +
>>> +		mutex_lock(&ts->system_lock);
>>> +		ts->hid_cmd_state = HID_CMD_DONE;
>>> +		mutex_unlock(&ts->system_lock);
>>> +		wake_up(&ts->wait_q);
>>> +	}
>>> +
>>> +	return IRQ_HANDLED;
>>> +}
>>> +
>>> +static int cyttsp5_deassert_int(struct cyttsp5 *ts)
>>> +{
>>> +	u16 size;
>>> +	u8 buf[2];
>>> +	int rc;
>>> +
>>> +	rc = regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, 2);
>>> +	if (rc < 0)
>>> +		return rc;
>>> +
>>> +	size = get_unaligned_le16(&buf[0]);
>>> +	if (size == 2 || size == 0)
>>> +		return 0;
>>> +
>>> +	return -EINVAL;
>>> +}
>>> +
>>> +static int cyttsp5_fill_all_touch(struct cyttsp5 *ts)
>>> +{
>>> +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
>>> +
>>> +	fill_tch_abs(&si->tch_abs[CY_TCH_X], REPORT_SIZE_16,
>>> +		     TOUCH_REPORT_DESC_X);
>>> +	fill_tch_abs(&si->tch_abs[CY_TCH_Y], REPORT_SIZE_16,
>>> +		     TOUCH_REPORT_DESC_Y);
>>> +	fill_tch_abs(&si->tch_abs[CY_TCH_P], REPORT_SIZE_8,
>>> +		     TOUCH_REPORT_DESC_P);
>>> +	fill_tch_abs(&si->tch_abs[CY_TCH_T], REPORT_SIZE_5,
>>> +		     TOUCH_REPORT_DESC_CONTACTID);
>>> +	fill_tch_abs(&si->tch_hdr, REPORT_SIZE_5,
>>> +		     TOUCH_REPORT_DESC_HDR_CONTACTCOUNT);
>>> +	fill_tch_abs(&si->tch_abs[CY_TCH_MAJ], REPORT_SIZE_8,
>>> +		     TOUCH_REPORT_DESC_MAJ);
>>> +	fill_tch_abs(&si->tch_abs[CY_TCH_MIN], REPORT_SIZE_8,
>>> +		     TOUCH_REPORT_DESC_MIN);
>>> +
>>> +	return 0;
>>> +}
>>> +
>>> +static int cyttsp5_startup(struct cyttsp5 *ts)
>>> +{
>>> +	int rc;
>>> +
>>> +	rc = cyttsp5_deassert_int(ts);
>>> +	if (rc) {
>>> +		dev_err(ts->dev, "Error on deassert int r=%d\n", rc);
>>> +		return -ENODEV;
>>> +	}
>>> +
>>> +	/*
>>> +	 * Launch the application as the device starts in bootloader mode
>>> +	 * because of a power-on-reset
>>> +	 */
>>> +	rc = cyttsp5_hid_output_bl_launch_app(ts);
>>> +	if (rc < 0) {
>>> +		dev_err(ts->dev, "Error on launch app r=%d\n", rc);
>>> +		return rc;
>>> +	}
>>> +
>>> +	rc = cyttsp5_get_hid_descriptor(ts, &ts->hid_desc);
>>> +	if (rc < 0) {
>>> +		dev_err(ts->dev, "Error on getting HID descriptor r=%d\n", rc);
>>> +		return rc;
>>> +	}
>>> +
>>> +	rc = cyttsp5_fill_all_touch(ts);
>>> +	if (rc < 0) {
>>> +		dev_err(ts->dev, "Error on report descriptor r=%d\n", rc);
>>> +		return rc;
>>> +	}
>>> +
>>> +	rc = cyttsp5_hid_output_get_sysinfo(ts);
>>> +	if (rc) {
>>> +		dev_err(ts->dev, "Error on getting sysinfo r=%d\n", rc);
>>> +		return rc;
>>> +	}
>>> +
>>> +	return rc;
>>> +}
>>> +
>>> +#ifdef CONFIG_OF
>>> +static const struct of_device_id cyttsp5_of_match[] = {
>>> +	{ .compatible = "cypress,cyttsp5", },
>>> +	{ }
>>> +};
>>> +MODULE_DEVICE_TABLE(of, cyttsp5_of_match);
>>> +#endif
>>> +
>>> +static const struct i2c_device_id cyttsp5_i2c_id[] = {
>>> +	{ CYTTSP5_NAME, 0, },
>>> +	{ }
>>> +};
>>> +MODULE_DEVICE_TABLE(i2c, cyttsp5_i2c_id);
>>> +
>>> +static int cyttsp5_probe(struct device *dev, struct regmap *regmap, int irq,
>>> +			 const char *name)
>>> +{
>>> +	struct cyttsp5 *ts;
>>> +	struct cyttsp5_sysinfo *si;
>>> +	int rc = 0, i;
>>> +
>>> +	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
>>> +	if (!ts)
>>> +		return -ENOMEM;
>>> +
>>> +	/* Initialize device info */
>>> +	ts->regmap = regmap;
>>> +	ts->dev = dev;
>>> +	si = &ts->sysinfo;
>>> +	dev_set_drvdata(dev, ts);
>>> +
>>> +	/* Initialize mutexes and spinlocks */
>>> +	mutex_init(&ts->system_lock);
>>> +
>>> +	/* Initialize wait queue */
>>> +	init_waitqueue_head(&ts->wait_q);
>>> +
>>> +	/* Reset the gpio to be in a reset state */
>>> +	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
>>> +	if (IS_ERR(ts->reset_gpio)) {
>>> +		rc = PTR_ERR(ts->reset_gpio);
>>> +		dev_err(dev, "Failed to request reset gpio, error %d\n", rc);
>>> +		return rc;
>>> +	}
>>> +	gpiod_set_value(ts->reset_gpio, 1);
>>
>> Why not request it as GPIOD_OUT_HIGH if you going to activate it
>> immediately? However it sounds as if you have a reset line that is
>> active low and you want to driver it low to reset, and then release. In
>> this case you need to do
>>
>> 	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
>> 	<delay> - chip usually needs to be some time in reset state
>> 	gpiod_set_value(ts->reset_gpio, 0);
>>
>> and make sure that correct polarity is specified in device tree.
> 
> Okay, I will update it too.
> 
>>
>>> +
>>> +	/* Need a delay to have device up */
>>> +	msleep(20);
>>> +
>>> +	rc = devm_request_threaded_irq(dev, irq, NULL, cyttsp5_handle_irq,
>>> +				       IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
>>
>> Just use IRQF_ONESHOT and make sure DTS specifies interrupt properly.
>> BTW,I'd recommend using level, not edge interrupts. It is so easy to
>> miss an edge.
> 
> Okay, thank you for the advice.
> 
>>
>>> +				       name, ts);
>>> +	if (rc) {
>>> +		dev_err(dev, "unable to request IRQ\n");
>>> +		return rc;
>>> +	}
>>> +
>>> +	rc = cyttsp5_startup(ts);
>>> +	if (rc) {
>>> +		dev_err(ts->dev, "Fail initial startup r=%d\n", rc);
>>> +		return rc;
>>> +	}
>>> +
>>> +	rc = cyttsp5_parse_dt_key_code(dev);
>>> +	if (rc < 0) {
>>> +		dev_err(ts->dev, "Error while parsing dts %d\n", rc);
>>> +		return rc;
>>> +	}
>>> +
>>> +	ts->input = devm_input_allocate_device(dev);
>>> +	if (!ts->input) {
>>> +		dev_err(dev, "Error, failed to allocate input device\n");
>>> +		return -ENODEV;
>>> +	}
>>> +
>>> +	ts->input->name = "cyttsp5";
>>> +	scnprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
>>> +	ts->input->phys = ts->phys;
>>> +	ts->input->dev.parent = ts->dev;
>>> +	input_set_drvdata(ts->input, ts);
>>> +
>>> +	touchscreen_parse_properties(ts->input, true, NULL);
>>> +
>>> +	__set_bit(EV_KEY, ts->input->evbit);
>>> +	for (i = 0; i < si->num_btns; i++)
>>> +		__set_bit(si->key_code[i], ts->input->keybit);
>>> +
>>> +	return cyttsp5_setup_input_device(dev);
>>> +}
>>> +
>>> +static int cyttsp5_i2c_probe(struct i2c_client *client,
>>> +			     const struct i2c_device_id *id)
>>> +{
>>> +	struct regmap *regmap;
>>> +	static const struct regmap_config config = {
>>> +		.reg_bits = 8,
>>> +		.val_bits = 8,
>>> +	};
>>> +
>>> +	regmap = devm_regmap_init_i2c(client, &config);
>>> +	if (IS_ERR(regmap)) {
>>> +		dev_err(&client->dev, "regmap allocation failed: %ld\n",
>>> +			PTR_ERR(regmap));
>>> +		return PTR_ERR(regmap);
>>> +	}
>>> +
>>> +	return cyttsp5_probe(&client->dev, regmap, client->irq, client->name);
>>> +}
>>> +
>>> +static int cyttsp5_remove(struct device *dev)
>>> +{
>>> +	struct cyttsp5 *ts = dev_get_drvdata(dev);
>>> +
>>> +	input_unregister_device(ts->input);
>>
>> Not needed: you are using managed input device.
> 
> You are right, thanks.
> 
>>
>>> +
>>> +	return 0;
>>> +}
>>> +
>>> +static int cyttsp5_i2c_remove(struct i2c_client *client)
>>> +{
>>> +	struct device *dev = &client->dev;
>>> +
>>> +	return cyttsp5_remove(dev);
>>
>> Not needed if you remove cyttsp5_remove().
> 
> Sure.
> 
>>
>>> +}
>>> +
>>> +static struct i2c_driver cyttsp5_i2c_driver = {
>>> +	.driver = {
>>> +		.name = CYTTSP5_NAME,
>>> +		.owner = THIS_MODULE,
>>> +		.of_match_table = of_match_ptr(cyttsp5_of_match),
>>> +	},
>>> +	.probe = cyttsp5_i2c_probe,
>>> +	.remove = cyttsp5_i2c_remove,
>>> +	.id_table = cyttsp5_i2c_id,
>>> +};
>>> +
>>> +module_i2c_driver(cyttsp5_i2c_driver);
>>> +
>>> +MODULE_LICENSE("GPL");
>>> +MODULE_DESCRIPTION("Touchscreen driver for Cypress TrueTouch Gen 5 Product");
>>> +MODULE_AUTHOR("Mylène Josserand <mylene.josserand-wi1+55ScJUtKEb57/3fJTNBPR1lH4CV8@public.gmane.org>");
>>> -- 
>>> 2.11.0
>>>    
>>
>> Thanks.
>>
> 
> Best regards,
> 
--
To unsubscribe from this list: send the line "unsubscribe devicetree" in
the body of a message to majordomo-u79uwXL29TY76Z2rM5mHXA@public.gmane.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Re: [PATCH v4 1/2] Input: Add driver for Cypress Generation 5 touchscreen

[Dmitry Torokhov]

On Tue, Jan 23, 2018 at 11:44:59AM +0100, Mylene Josserand wrote:
> Hi Dmitry,
> 
> Thank you for the review.
> 
> Le Mon, 22 Jan 2018 20:15:03 -0800,
> Dmitry Torokhov <dmitry.torokhov@gmail.com> a écrit :
> 
> > Hi Mylène,
> > 
> > On Fri, Dec 01, 2017 at 04:39:56PM +0100, Mylène Josserand wrote:
> > > This is the basic driver for the Cypress TrueTouch Gen5 touchscreen
> > > controllers. This driver supports only the I2C bus but it uses regmap
> > > so SPI support could be added later.
> > > The touchscreen can retrieve some defined zone that are handled as
> > > buttons (according to the hardware). That is why it handles
> > > button and multitouch events.
> > > 
> > > Reviewed-by: Maxime Ripard <maxime.ripard@free-electrons.com>
> > > Signed-off-by: Mylène Josserand <mylene.josserand@free-electrons.com>
> > > ---
> > >  drivers/input/touchscreen/Kconfig   |   16 +
> > >  drivers/input/touchscreen/Makefile  |    1 +
> > >  drivers/input/touchscreen/cyttsp5.c | 1110 +++++++++++++++++++++++++++++++++++
> > >  3 files changed, 1127 insertions(+)
> > >  create mode 100644 drivers/input/touchscreen/cyttsp5.c
> > > 
> > > diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
> > > index 0cfdb7cb610e..28eea6d5f1bb 100644
> > > --- a/drivers/input/touchscreen/Kconfig
> > > +++ b/drivers/input/touchscreen/Kconfig
> > > @@ -238,6 +238,22 @@ config TOUCHSCREEN_CYTTSP4_SPI
> > >  	  To compile this driver as a module, choose M here: the
> > >  	  module will be called cyttsp4_spi.
> > >  
> > > +config TOUCHSCREEN_CYTTSP5
> > > +	tristate "Cypress TrueTouch Gen5 Touchscreen Driver"
> > > +	depends on OF  
> > 
> > Does it have to be? Please use generic device properties
> > (device_property_* API) and it can be used with ACPI and static board
> > files, of needed.
> 
> Okay, I will try with that.
> 
> > 
> > > +	select REGMAP_I2C
> > > +	select CRC_ITU_T
> > > +	help
> > > +	  Driver for Parade TrueTouch Standard Product
> > > +	  Generation 5 touchscreen controllers.
> > > +	  I2C bus interface support only.
> > > +
> > > +	  Say Y here if you have a Cypress Gen5 touchscreen.
> > > +	  If unsure, say N.
> > > +
> > > +	  To compile this driver as a module, choose M here: the
> > > +	  module will be called cyttsp5.
> > > +
> > >  config TOUCHSCREEN_DA9034
> > >  	tristate "Touchscreen support for Dialog Semiconductor DA9034"
> > >  	depends on PMIC_DA903X
> > > diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
> > > index d2a2b3b7af27..e7d124901dd9 100644
> > > --- a/drivers/input/touchscreen/Makefile
> > > +++ b/drivers/input/touchscreen/Makefile
> > > @@ -26,6 +26,7 @@ obj-$(CONFIG_TOUCHSCREEN_CYTTSP_SPI)	+= cyttsp_spi.o
> > >  obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_CORE)	+= cyttsp4_core.o
> > >  obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_I2C)	+= cyttsp4_i2c.o cyttsp_i2c_common.o
> > >  obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_SPI)	+= cyttsp4_spi.o
> > > +obj-$(CONFIG_TOUCHSCREEN_CYTTSP5)	+= cyttsp5.o
> > >  obj-$(CONFIG_TOUCHSCREEN_DA9034)	+= da9034-ts.o
> > >  obj-$(CONFIG_TOUCHSCREEN_DA9052)	+= da9052_tsi.o
> > >  obj-$(CONFIG_TOUCHSCREEN_DYNAPRO)	+= dynapro.o
> > > diff --git a/drivers/input/touchscreen/cyttsp5.c b/drivers/input/touchscreen/cyttsp5.c
> > > new file mode 100644
> > > index 000000000000..a41feea2cd5a
> > > --- /dev/null
> > > +++ b/drivers/input/touchscreen/cyttsp5.c
> > > @@ -0,0 +1,1110 @@
> > > +/*
> > > + * Parade TrueTouch(TM) Standard Product V5 Module.
> > > + * For use with Parade touchscreen controllers.
> > > + *
> > > + * Copyright (C) 2015 Parade Technologies
> > > + * Copyright (C) 2012-2015 Cypress Semiconductor
> > > + * Copyright (C) 2017 Free Electrons
> > > + *
> > > + * Author: Mylène Josserand <mylene.josserand@free-electrons.com>
> > > + *
> > > + * This program is free software; you can redistribute it and/or
> > > + * modify it under the terms of the GNU General Public License
> > > + * version 2, and only version 2, 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.
> > > + *
> > > + */
> > > +
> > > +#include <asm/unaligned.h>
> > > +#include <linux/crc-itu-t.h>
> > > +#include <linux/delay.h>
> > > +#include <linux/device.h>
> > > +#include <linux/gpio.h>
> > > +#include <linux/input/mt.h>
> > > +#include <linux/input/touchscreen.h>
> > > +#include <linux/interrupt.h>
> > > +#include <linux/i2c.h>
> > > +#include <linux/module.h>
> > > +#include <linux/of_device.h>
> > > +#include <linux/regmap.h>
> > > +
> > > +#define CYTTSP5_NAME				"cyttsp5"
> > > +#define CY_I2C_DATA_SIZE			(2 * 256)
> > > +#define HID_VERSION				0x0100
> > > +#define CY_MAX_INPUT				512
> > > +#define CYTTSP5_PREALLOCATED_CMD_BUFFER	32
> > > +#define CY_BITS_PER_BTN			1
> > > +#define CY_NUM_BTN_EVENT_ID			((1 << CY_BITS_PER_BTN) - 1)
> > > +
> > > +#define MAX_AREA				255
> > > +#define HID_OUTPUT_BL_SOP			0x1
> > > +#define HID_OUTPUT_BL_EOP			0x17
> > > +#define HID_OUTPUT_BL_LAUNCH_APP		0x3B
> > > +#define HID_OUTPUT_BL_LAUNCH_APP_SIZE		11
> > > +#define HID_OUTPUT_GET_SYSINFO			0x2
> > > +#define HID_OUTPUT_GET_SYSINFO_SIZE		5
> > > +
> > > +#define HID_DESC_REG				0x1
> > > +#define HID_INPUT_REG				0x3
> > > +#define HID_OUTPUT_REG				0x4
> > > +
> > > +#define REPORT_ID_TOUCH			0x1
> > > +#define REPORT_ID_BTN				0x3
> > > +#define REPORT_SIZE_5				5
> > > +#define REPORT_SIZE_8				8
> > > +#define REPORT_SIZE_16				16
> > > +
> > > +/* Touch reports offsets */
> > > +/* Header offsets */
> > > +#define TOUCH_REPORT_DESC_HDR_CONTACTCOUNT	16
> > > +/* Record offsets */
> > > +#define TOUCH_REPORT_DESC_CONTACTID		8
> > > +#define TOUCH_REPORT_DESC_X			16
> > > +#define TOUCH_REPORT_DESC_Y			32
> > > +#define TOUCH_REPORT_DESC_P			48
> > > +#define TOUCH_REPORT_DESC_MAJ			56
> > > +#define TOUCH_REPORT_DESC_MIN			64
> > > +
> > > +/* HID */
> > > +#define HID_TOUCH_REPORT_ID			0x1
> > > +#define HID_BTN_REPORT_ID			0x3
> > > +#define HID_APP_RESPONSE_REPORT_ID		0x1F
> > > +#define HID_APP_OUTPUT_REPORT_ID		0x2F
> > > +#define HID_BL_RESPONSE_REPORT_ID		0x30
> > > +#define HID_BL_OUTPUT_REPORT_ID		0x40
> > > +
> > > +#define HID_OUTPUT_RESPONSE_REPORT_OFFSET	2
> > > +#define HID_OUTPUT_RESPONSE_CMD_OFFSET		4
> > > +#define HID_OUTPUT_RESPONSE_CMD_MASK		0x7F
> > > +
> > > +#define HID_SYSINFO_SENSING_OFFSET		33
> > > +#define HID_SYSINFO_BTN_OFFSET			48
> > > +#define HID_SYSINFO_BTN_MASK			0xFF
> > > +#define HID_SYSINFO_MAX_BTN			8
> > > +
> > > +/*  Timeout in ms */
> > > +#define CY_HID_OUTPUT_TIMEOUT			200
> > > +#define CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT	3000
> > > +#define CY_HID_GET_HID_DESCRIPTOR_TIMEOUT	4000
> > > +
> > > +/* maximum number of concurrent tracks */
> > > +#define TOUCH_REPORT_SIZE			10
> > > +#define TOUCH_INPUT_HEADER_SIZE		7
> > > +#define BTN_REPORT_SIZE			9
> > > +#define BTN_INPUT_HEADER_SIZE			5
> > > +
> > > +/* All usage pages for Touch Report */
> > > +#define TOUCH_REPORT_USAGE_PG_X		0x00010030
> > > +#define TOUCH_REPORT_USAGE_PG_Y		0x00010031
> > > +#define TOUCH_REPORT_USAGE_PG_P		0x000D0030
> > > +#define TOUCH_REPORT_USAGE_PG_CONTACTID	0x000D0051
> > > +#define TOUCH_REPORT_USAGE_PG_CONTACTCOUNT	0x000D0054
> > > +#define TOUCH_REPORT_USAGE_PG_MAJ		0xFF010062
> > > +#define TOUCH_REPORT_USAGE_PG_MIN		0xFF010063
> > > +#define TOUCH_COL_USAGE_PG			0x000D0022
> > > +
> > > +/* helpers */
> > > +#define HI_BYTE(x)				(u8)(((x) >> 8) & 0xFF)
> > > +#define LOW_BYTE(x)				(u8)((x) & 0xFF)
> > > +
> > > +/* System Information interface definitions */
> > > +struct cyttsp5_sensing_conf_data_dev {
> > > +	u8 electrodes_x;
> > > +	u8 electrodes_y;
> > > +	__le16 len_x;
> > > +	__le16 len_y;
> > > +	__le16 res_x;
> > > +	__le16 res_y;
> > > +	__le16 max_z;
> > > +	u8 origin_x;
> > > +	u8 origin_y;
> > > +	u8 btn;
> > > +	u8 scan_mode;
> > > +	u8 max_num_of_tch_per_refresh_cycle;
> > > +} __packed;
> > > +
> > > +struct cyttsp5_sensing_conf_data {
> > > +	u16 res_x;
> > > +	u16 res_y;
> > > +	u16 max_z;
> > > +	u16 len_x;
> > > +	u16 len_y;
> > > +	u8 origin_x;
> > > +	u8 origin_y;
> > > +	u8 max_tch;
> > > +};
> > > +
> > > +enum { HID_CMD_DONE, HID_CMD_BUSY } hid_cmd_state;
> > > +
> > > +enum cyttsp5_tch_abs {	/* for ordering within the extracted touch data array */
> > > +	CY_TCH_X,	/* X */
> > > +	CY_TCH_Y,	/* Y */
> > > +	CY_TCH_P,	/* P (Z) */
> > > +	CY_TCH_T,	/* TOUCH ID */
> > > +	CY_TCH_MAJ,	/* TOUCH_MAJOR */
> > > +	CY_TCH_MIN,	/* TOUCH_MINOR */
> > > +	CY_TCH_NUM_ABS,
> > > +};
> > > +
> > > +struct cyttsp5_tch_abs_params {
> > > +	size_t ofs;	/* abs byte offset */
> > > +	size_t size;	/* size in bits */
> > > +	size_t min;	/* min value */
> > > +	size_t max;	/* max value */
> > > +	size_t bofs;	/* bit offset */
> > > +};
> > > +
> > > +struct cyttsp5_touch {
> > > +	int hdr;
> > > +	int abs[CY_TCH_NUM_ABS];
> > > +};
> > > +
> > > +struct cyttsp5_sysinfo {
> > > +	struct cyttsp5_sensing_conf_data sensing_conf_data;
> > > +	int num_btns;
> > > +	struct cyttsp5_tch_abs_params tch_hdr;
> > > +	struct cyttsp5_tch_abs_params tch_abs[CY_TCH_NUM_ABS];
> > > +	u32 key_code[HID_SYSINFO_MAX_BTN];
> > > +	u8 *xy_mode;
> > > +	u8 *xy_data;
> > > +};
> > > +
> > > +struct cyttsp5_hid_desc {
> > > +	__le16 hid_desc_len;
> > > +	u8 packet_id;
> > > +	u8 reserved_byte;
> > > +	__le16 bcd_version;
> > > +	__le16 report_desc_len;
> > > +	__le16 report_desc_register;
> > > +	__le16 input_register;
> > > +	__le16 max_input_len;
> > > +	__le16 output_register;
> > > +	__le16 max_output_len;
> > > +	__le16 command_register;
> > > +	__le16 data_register;
> > > +	__le16 vendor_id;
> > > +	__le16 product_id;
> > > +	__le16 version_id;
> > > +	u8 reserved[4];
> > > +} __packed;
> > > +
> > > +struct cyttsp5 {
> > > +	struct device *dev;
> > > +	struct mutex system_lock;
> > > +	wait_queue_head_t wait_q;
> > > +	struct cyttsp5_sysinfo sysinfo;
> > > +	int hid_cmd_state;
> > > +	struct cyttsp5_hid_desc hid_desc;
> > > +	u8 cmd_buf[CYTTSP5_PREALLOCATED_CMD_BUFFER];
> > > +	u8 input_buf[CY_MAX_INPUT];
> > > +	u8 response_buf[CY_MAX_INPUT];
> > > +	struct gpio_desc *reset_gpio;
> > > +	struct input_dev *input;
> > > +	char phys[NAME_MAX];
> > > +	int num_prv_rec;
> > > +	struct regmap *regmap;
> > > +};
> > > +
> > > +/*
> > > + * For what understood in the datasheet, the register does not
> > > + * matter. For consistency, used the Input Register address
> > > + * but it does mean anything to the device. The important data
> > > + * to send is the I2C address
> > > + */
> > > +static int cyttsp5_read(struct cyttsp5 *ts, u8 *buf, u32 max)
> > > +{
> > > +	int rc;
> > > +	u32 size;
> > > +	u8 temp[2];
> > > +
> > > +	if (!buf)
> > > +		return -EINVAL;  
> > 
> > Is it really possible? This is not a publicly facing API but private
> > driver data, do you ever happen to call it with NULL?
> 
> hm, I do not think so but I will check that.
> 
> > 
> > > +
> > > +	/* Read the frame to retrieve the size */
> > > +	rc = regmap_bulk_read(ts->regmap, HID_INPUT_REG, temp, 2);
> > > +	if (rc < 0)
> > > +		return rc;  
> > 
> > Can we call this kind of variables "error" pelase?
> 
> Sure.
> 
> > 
> > > +
> > > +	size = get_unaligned_le16(temp);
> > > +	if (!size || size == 2)
> > > +		return 0;
> > > +
> > > +	if (size > max)
> > > +		return -EINVAL;
> > > +
> > > +	/* Get the real value */
> > > +	return regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, size);
> > > +}
> > > +
> > > +static int cyttsp5_write(struct cyttsp5 *ts, unsigned int reg, u8 *data,
> > > +			 size_t size)
> > > +{
> > > +	u8 cmd[size + 1];
> > > +
> > > +	/* High bytes of register address needed as first byte of cmd */
> > > +	cmd[0] = HI_BYTE(reg);
> > > +
> > > +	/* Copy the rest of the data */
> > > +	if (data)
> > > +		memcpy(&cmd[1], data, size);
> > > +
> > > +	/* The hardware wants to receive a frame with the address register  
> > 
> > The multiline comment block should start with "/*" on a separate line
> > please.
> 
> I will change that.
> 
> > 
> > > +	 * contains in the first two bytes. As the regmap_write function
> > > +	 * add the register adresse in the frame, we use the LOW_BYTE as
> > > +	 * first frame byte for the address register and the first
> > > +	 * data byte is the high register + left of the cmd to send
> > > +	 */
> > > +	return regmap_bulk_write(ts->regmap, LOW_BYTE(reg), cmd, size + 1);
> > > +}
> > > +
> > > +static void cyttsp5_final_sync(struct input_dev *input, int max_slots,
> > > +			       unsigned long *ids)
> > > +{
> > > +	int t;
> > > +
> > > +	for (t = 0; t < max_slots; t++) {  
> > 
> > 	for_each_set_bit() {
> > 	}
> 
> I did not know this macro, I will try that.
> 
> > 
> > > +		if (test_bit(t, ids))
> > > +			continue;
> > > +		input_mt_slot(input, t);
> > > +		input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
> > > +	}
> > > +
> > > +	input_sync(input);
> > > +}
> > > +
> > > +static void cyttsp5_report_slot_liftoff(struct cyttsp5 *ts, int max_slots)
> > > +{
> > > +	int t;
> > > +
> > > +	if (ts->num_prv_rec == 0)
> > > +		return;  
> > 
> > Do you need this check? The caller checks the same condition.
> 
> True, I will remove it.
> 
> > 
> > > +
> > > +	for (t = 0; t < max_slots; t++) {
> > > +		input_mt_slot(ts->input, t);
> > > +		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, false);
> > > +	}
> > > +}
> > > +
> > > +static void cyttsp5_mt_lift_all(struct cyttsp5 *ts)
> > > +{
> > > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > > +	int max = si->tch_abs[CY_TCH_T].max;
> > > +
> > > +	if (ts->num_prv_rec != 0) {
> > > +		cyttsp5_report_slot_liftoff(ts, max);
> > > +		input_sync(ts->input);
> > > +		ts->num_prv_rec = 0;
> > > +	}
> > > +}
> > > +
> > > +static void cyttsp5_get_touch_axis(int *axis, int size, int max, u8 *xy_data,
> > > +				   int bofs)
> > > +{
> > > +	int nbyte;
> > > +	int next;
> > > +
> > > +	for (nbyte = 0, *axis = 0, next = 0; nbyte < size; nbyte++)
> > > +		*axis = *axis + ((xy_data[nbyte] >> bofs) << (nbyte * 8));
> > > +
> > > +	*axis &= max - 1;
> > > +}
> > > +
> > > +static void cyttsp5_get_touch_record(struct cyttsp5 *ts,
> > > +				     struct cyttsp5_touch *touch, u8 *xy_data)
> > > +{
> > > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > > +	enum cyttsp5_tch_abs abs;
> > > +
> > > +	for (abs = CY_TCH_X; abs < CY_TCH_NUM_ABS; abs++) {
> > > +		cyttsp5_get_touch_axis(&touch->abs[abs],
> > > +				       si->tch_abs[abs].size,
> > > +				       si->tch_abs[abs].max,
> > > +				       xy_data + si->tch_abs[abs].ofs,
> > > +				       si->tch_abs[abs].bofs);
> > > +	}
> > > +}
> > > +
> > > +static void cyttsp5_get_mt_touches(struct cyttsp5 *ts,
> > > +				   struct cyttsp5_touch *tch, int num_cur_tch)
> > > +{
> > > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > > +	int i, t = 0;
> > > +	DECLARE_BITMAP(ids, si->tch_abs[CY_TCH_T].max);
> > > +	u8 *tch_addr;
> > > +	int tmp;
> > > +
> > > +	bitmap_zero(ids, si->tch_abs[CY_TCH_T].max);
> > > +	memset(tch->abs, 0, sizeof(tch->abs));
> > > +
> > > +	for (i = 0; i < num_cur_tch; i++) {
> > > +		tch_addr = si->xy_data + (i * TOUCH_REPORT_SIZE);
> > > +		cyttsp5_get_touch_record(ts, tch, tch_addr);
> > > +
> > > +		/* Convert MAJOR/MINOR from mm to resolution */
> > > +		tmp = tch->abs[CY_TCH_MAJ] * 100 * si->sensing_conf_data.res_x;
> > > +		tch->abs[CY_TCH_MAJ] = tmp / si->sensing_conf_data.len_x;
> > > +		tmp = tch->abs[CY_TCH_MIN] * 100 * si->sensing_conf_data.res_x;
> > > +		tch->abs[CY_TCH_MIN] = tmp / si->sensing_conf_data.len_x;
> > > +
> > > +		t = tch->abs[CY_TCH_T];
> > > +		input_mt_slot(ts->input, t);
> > > +		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
> > > +		__set_bit(t, ids);
> > > +
> > > +		/* position and pressure fields */
> > > +		input_report_abs(ts->input, ABS_MT_POSITION_X,
> > > +				 tch->abs[CY_TCH_X]);
> > > +		input_report_abs(ts->input, ABS_MT_POSITION_Y,
> > > +				 tch->abs[CY_TCH_Y]);
> > > +		input_report_abs(ts->input, ABS_MT_PRESSURE,
> > > +				 tch->abs[CY_TCH_P]);
> > > +
> > > +		/* Get the extended touch fields */
> > > +		input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR,
> > > +				 tch->abs[CY_TCH_MAJ]);
> > > +		input_report_abs(ts->input, ABS_MT_TOUCH_MINOR,
> > > +				 tch->abs[CY_TCH_MIN]);
> > > +	}
> > > +
> > > +	cyttsp5_final_sync(ts->input, si->tch_abs[CY_TCH_T].max, ids);
> > > +
> > > +	ts->num_prv_rec = num_cur_tch;
> > > +}
> > > +
> > > +/* read xy_data for all current touches */
> > > +static int cyttsp5_xy_worker(struct cyttsp5 *ts)
> > > +{
> > > +	struct device *dev = ts->dev;
> > > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > > +	int max_tch = si->sensing_conf_data.max_tch;
> > > +	struct cyttsp5_touch tch;
> > > +	u8 num_cur_tch;
> > > +
> > > +	cyttsp5_get_touch_axis(&tch.hdr, si->tch_hdr.size,
> > > +			       si->tch_hdr.max,
> > > +			       si->xy_mode + 3 + si->tch_hdr.ofs,
> > > +			       si->tch_hdr.bofs);
> > > +
> > > +	num_cur_tch = tch.hdr;
> > > +	if (num_cur_tch > max_tch) {
> > > +		dev_err(dev, "Num touch err detected (n=%d)\n", num_cur_tch);
> > > +		num_cur_tch = max_tch;
> > > +	}
> > > +
> > > +	if (num_cur_tch == 0 && ts->num_prv_rec == 0)
> > > +		return 0;
> > > +
> > > +	/* extract xy_data for all currently reported touches */
> > > +	if (num_cur_tch)
> > > +		cyttsp5_get_mt_touches(ts, &tch, num_cur_tch);
> > > +	else
> > > +		cyttsp5_mt_lift_all(ts);
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static int cyttsp5_mt_attention(struct device *dev)
> > > +{
> > > +	struct cyttsp5 *ts = dev_get_drvdata(dev);  
> > 
> > Why don't you pass ts into cyttsp5_mt_attention?
> 
> Yep, you are right, I will update it.
> 
> > 
> > > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > > +	int rc;
> > > +
> > > +	if (si->xy_mode[2] != HID_TOUCH_REPORT_ID)
> > > +		return 0;
> > > +
> > > +	/* core handles handshake */
> > > +	rc = cyttsp5_xy_worker(ts);
> > > +	if (rc < 0)
> > > +		dev_err(dev, "xy_worker error r=%d\n", rc);
> > > +
> > > +	return rc;
> > > +}
> > > +
> > > +static int cyttsp5_setup_input_device(struct device *dev)
> > > +{
> > > +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> > > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > > +	int max_x, max_y, max_p;
> > > +	int max_x_tmp, max_y_tmp;
> > > +	int rc;
> > > +
> > > +	__set_bit(EV_ABS, ts->input->evbit);
> > > +	__set_bit(EV_REL, ts->input->evbit);
> > > +	__set_bit(EV_KEY, ts->input->evbit);
> > > +
> > > +	max_x_tmp = si->sensing_conf_data.res_x;
> > > +	max_y_tmp = si->sensing_conf_data.res_y;
> > > +	max_x = max_y_tmp - 1;
> > > +	max_y = max_x_tmp - 1;
> > > +	max_p = si->sensing_conf_data.max_z;
> > > +
> > > +	input_mt_init_slots(ts->input, si->tch_abs[CY_TCH_T].max, 0);  
> > 
> > Error handling.
> 
> Thanks.
> 
> > 
> > > +
> > > +	__set_bit(ABS_MT_POSITION_X, ts->input->absbit);
> > > +	__set_bit(ABS_MT_POSITION_Y, ts->input->absbit);
> > > +	__set_bit(ABS_MT_PRESSURE, ts->input->absbit);
> > > +
> > > +	input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
> > > +	input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
> > > +	input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, max_p, 0, 0);
> > > +
> > > +	input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);
> > > +	input_set_abs_params(ts->input, ABS_MT_TOUCH_MINOR, 0, MAX_AREA, 0, 0);  
> > 
> > You might want to use the standard DT touchscreen properties and
> > reporting functions to support axis inversion and swapping of axes.
> 
> Hm, I am not sure to see what you are referring to.
> Could you explain me what you think of?

Please take a look at include/linux/input/touchscreen.h and in the other
driver you are hacking on there is example of how to use this API.

Basically you need to call touchscreen_parse_properties() somewhere in
probe path, and then use touchscreen_report_pos() to report contact
coordinates within given slot.

> 
> > 
> > > +
> > > +	rc = input_register_device(ts->input);
> > > +	if (rc < 0)
> > > +		dev_err(dev, "Error, failed register input device r=%d\n", rc);
> > > +
> > > +	return rc;
> > > +}
> > > +
> > > +#ifdef CONFIG_OF
> > > +static int cyttsp5_parse_dt_key_code(struct device *dev)
> > > +{
> > > +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> > > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > > +	struct device_node *np;
> > > +	int i;
> > > +
> > > +	np = dev->of_node;
> > > +	if (!np)
> > > +		return -EINVAL;
> > > +
> > > +	if (!si->num_btns)
> > > +		return 0;
> > > +
> > > +	/* Initialize the button to RESERVED */
> > > +	for (i = 0; i < si->num_btns; i++)
> > > +		si->key_code[i] = KEY_RESERVED;
> > > +
> > > +	return of_property_read_u32_array(np, "linux,keycodes",
> > > +				   si->key_code, si->num_btns);
> > > +}
> > > +#else
> > > +static int cyttsp5_parse_dt_key_code(struct device *dev)
> > > +{
> > > +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> > > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > > +	int i;
> > > +
> > > +	if (!si->num_btns)
> > > +		return 0;
> > > +
> > > +	/* Initialize the button to RESERVED */
> > > +	for (i = 0; i < si->num_btns; i++)
> > > +		si->key_code[i] = KEY_RESERVED;
> > > +
> > > +	return 0;
> > > +}
> > > +#endif
> > > +
> > > +static int cyttsp5_btn_attention(struct device *dev)
> > > +{
> > > +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> > > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > > +	int cur_btn;
> > > +	int cur_btn_state;
> > > +
> > > +	if (si->xy_mode[2] != HID_BTN_REPORT_ID || !si->num_btns)
> > > +		return 0;
> > > +
> > > +	/* extract button press/release touch information */
> > > +	for (cur_btn = 0; cur_btn < si->num_btns; cur_btn++) {
> > > +		/* Get current button state */
> > > +		cur_btn_state = (si->xy_data[0] >> (cur_btn * CY_BITS_PER_BTN))
> > > +			& CY_NUM_BTN_EVENT_ID;
> > > +
> > > +		input_report_key(ts->input, si->key_code[cur_btn],
> > > +				 cur_btn_state);
> > > +		input_sync(ts->input);  
> > 
> > You do not need to sen sync after each button, send it once after all
> > buttons sent.
> 
> Oh, yes, I will do that!
> 
> > 
> > > +	}
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static u16 cyttsp5_compute_crc(u8 *buf, u32 size)
> > > +{
> > > +	u16 remainder = 0xFFFF;
> > > +	u16 xor_mask = 0x0000;
> > > +	u32 index;
> > > +	u32 byte_value;
> > > +	u32 table_index;
> > > +	u32 crc_bit_width = sizeof(u16) * 8;
> > > +
> > > +	/* Divide the message by polynomial, via the table. */
> > > +	for (index = 0; index < size; index++) {
> > > +		byte_value = buf[index];
> > > +		table_index = ((byte_value >> 4) & 0x0F)
> > > +			^ (remainder >> (crc_bit_width - 4));
> > > +		remainder = crc_itu_t_table[table_index]
> > > +			^ (remainder << 4);
> > > +		table_index = (byte_value & 0x0F)
> > > +			^ (remainder >> (crc_bit_width - 4));
> > > +		remainder = crc_itu_t_table[table_index]
> > > +			^ (remainder << 4);
> > > +	}
> > > +
> > > +	/* Perform the final remainder CRC. */
> > > +	return remainder ^ xor_mask;
> > > +}
> > > +
> > > +static int cyttsp5_validate_cmd_response(struct cyttsp5 *ts, u8 code)
> > > +{
> > > +	u16 size, crc;
> > > +	u8 status, offset;
> > > +	int command_code;
> > > +
> > > +	size = get_unaligned_le16(&ts->response_buf[0]);
> > > +
> > > +	if (!size)
> > > +		return 0;
> > > +
> > > +	offset = ts->response_buf[HID_OUTPUT_RESPONSE_REPORT_OFFSET];
> > > +
> > > +	if (offset == HID_BL_RESPONSE_REPORT_ID) {
> > > +		if (ts->response_buf[4] != HID_OUTPUT_BL_SOP) {
> > > +			dev_err(ts->dev, "HID output response, wrong SOP\n");
> > > +			return -EPROTO;
> > > +		}
> > > +
> > > +		if (ts->response_buf[size - 1] != HID_OUTPUT_BL_EOP) {
> > > +			dev_err(ts->dev, "HID output response, wrong EOP\n");
> > > +			return -EPROTO;
> > > +		}
> > > +
> > > +		crc = cyttsp5_compute_crc(&ts->response_buf[4], size - 7);
> > > +		if (ts->response_buf[size - 3] != LOW_BYTE(crc) ||
> > > +		    ts->response_buf[size - 2] != HI_BYTE(crc)) {
> > > +			dev_err(ts->dev, "HID output response, wrong CRC 0x%X\n",
> > > +				crc);
> > > +			return -EPROTO;
> > > +		}
> > > +
> > > +		status = ts->response_buf[5];
> > > +		if (status) {
> > > +			dev_err(ts->dev, "HID output response, ERROR:%d\n",
> > > +				status);
> > > +			return -EPROTO;
> > > +		}
> > > +	}
> > > +
> > > +	if (offset == HID_APP_RESPONSE_REPORT_ID) {
> > > +		command_code = ts->response_buf[HID_OUTPUT_RESPONSE_CMD_OFFSET]
> > > +			& HID_OUTPUT_RESPONSE_CMD_MASK;
> > > +		if (command_code != code) {
> > > +			dev_err(ts->dev,
> > > +				"HID output response, wrong command_code:%X\n",
> > > +				command_code);
> > > +			return -EPROTO;
> > > +		}
> > > +	}
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static void cyttsp5_si_get_btn_data(struct cyttsp5 *ts)
> > > +{
> > > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > > +	int i;
> > > +	unsigned int btns = ts->response_buf[HID_SYSINFO_BTN_OFFSET]
> > > +		& HID_SYSINFO_BTN_MASK;
> > > +
> > > +	si->num_btns = 0;
> > > +	for (i = 0; i < HID_SYSINFO_MAX_BTN; i++) {
> > > +		if (btns & BIT(i))
> > > +			si->num_btns++;
> > > +	}  
> > 
> > 	si->num_btns = hweight8(ts->response_buf[HID_SYSINFO_BTN_OFFSET]);
> 
> Great, I will try that!
> 
> > 
> > > +}
> > > +
> > > +static int cyttsp5_get_sysinfo_regs(struct cyttsp5 *ts)
> > > +{
> > > +	struct cyttsp5_sensing_conf_data *scd = &ts->sysinfo.sensing_conf_data;
> > > +	struct cyttsp5_sensing_conf_data_dev *scd_dev =
> > > +		(struct cyttsp5_sensing_conf_data_dev *)
> > > +		&ts->response_buf[HID_SYSINFO_SENSING_OFFSET];
> > > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > > +
> > > +	cyttsp5_si_get_btn_data(ts);
> > > +
> > > +	scd->max_tch = scd_dev->max_num_of_tch_per_refresh_cycle;
> > > +	scd->res_x = get_unaligned_le16(&scd_dev->res_x);
> > > +	scd->res_y = get_unaligned_le16(&scd_dev->res_y);
> > > +	scd->max_z = get_unaligned_le16(&scd_dev->max_z);
> > > +	scd->len_x = get_unaligned_le16(&scd_dev->len_x);
> > > +	scd->len_y = get_unaligned_le16(&scd_dev->len_y);
> > > +
> > > +	si->xy_data = devm_kzalloc(ts->dev, scd->max_tch * TOUCH_REPORT_SIZE,
> > > +				   GFP_KERNEL);
> > > +	if (!si->xy_data)
> > > +		return -ENOMEM;
> > > +
> > > +	si->xy_mode = devm_kzalloc(ts->dev, TOUCH_INPUT_HEADER_SIZE,
> > > +				   GFP_KERNEL);
> > > +	if (!si->xy_mode)
> > > +		return -ENOMEM;  
> > 
> > Why do we need these 2 allocated separately form the driver data?
> 
> xy_mode and particularly xy_data are used to retrieve buttons or touch
> data that we received from the input buffer (see gggggggggggggggg()
> and move_touch_data()). I guess that I can try to remove them, if you
> want.

You probably do not need them, you already have all data in input_buf,
just the right offset to cyttsp5_btn_attention() , like

		...
		cyttsp5_btn_attention(ts, ts->input_buf + BTN_INPUT_HEADER_SIZE);
		...

> 
> > 
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static int cyttsp5_hid_output_get_sysinfo(struct cyttsp5 *ts)
> > > +{
> > > +	int rc;
> > > +	u8 cmd[HID_OUTPUT_GET_SYSINFO_SIZE];
> > > +
> > > +	ts->hid_cmd_state = HID_CMD_BUSY;
> > > +
> > > +	/* HI bytes of Output register address */
> > > +	cmd[0] = LOW_BYTE(HID_OUTPUT_GET_SYSINFO_SIZE);
> > > +	cmd[1] = HI_BYTE(HID_OUTPUT_GET_SYSINFO_SIZE);
> > > +	cmd[2] = HID_APP_OUTPUT_REPORT_ID;
> > > +	cmd[3] = 0x0; /* Reserved */
> > > +	cmd[4] = HID_OUTPUT_GET_SYSINFO;
> > > +
> > > +	rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
> > > +			   HID_OUTPUT_GET_SYSINFO_SIZE);
> > > +	if (rc) {
> > > +		dev_err(ts->dev, "Failed to write command %d", rc);
> > > +		goto error;
> > > +	}
> > > +
> > > +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
> > > +				msecs_to_jiffies(CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT));
> > > +	if (!rc) {
> > > +		dev_err(ts->dev, "HID output cmd execution timed out\n");
> > > +		rc = -ETIME;
> > > +		goto error;
> > > +	}
> > > +
> > > +	rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_GET_SYSINFO);
> > > +	if (rc) {
> > > +		dev_err(ts->dev, "Validation of the response failed\n");
> > > +		goto error;
> > > +	}
> > > +
> > > +	return cyttsp5_get_sysinfo_regs(ts);
> > > +
> > > +error:
> > > +	mutex_lock(&ts->system_lock);
> > > +	ts->hid_cmd_state = HID_CMD_DONE;
> > > +	mutex_unlock(&ts->system_lock);
> > > +	return rc;
> > > +}
> > > +
> > > +static int cyttsp5_hid_output_bl_launch_app(struct cyttsp5 *ts)
> > > +{
> > > +	int rc;
> > > +	u8 cmd[HID_OUTPUT_BL_LAUNCH_APP];
> > > +	u16 crc;
> > > +
> > > +	mutex_lock(&ts->system_lock);
> > > +	ts->hid_cmd_state = HID_CMD_BUSY;
> > > +	mutex_unlock(&ts->system_lock);
> > > +
> > > +	cmd[0] = LOW_BYTE(HID_OUTPUT_BL_LAUNCH_APP_SIZE);
> > > +	cmd[1] = HI_BYTE(HID_OUTPUT_BL_LAUNCH_APP_SIZE);
> > > +	cmd[2] = HID_BL_OUTPUT_REPORT_ID;
> > > +	cmd[3] = 0x0; /* Reserved */
> > > +	cmd[4] = HID_OUTPUT_BL_SOP;
> > > +	cmd[5] = HID_OUTPUT_BL_LAUNCH_APP;
> > > +	cmd[6] = 0x0; /* Low bytes of data */
> > > +	cmd[7] = 0x0; /* Hi bytes of data */
> > > +	crc = cyttsp5_compute_crc(&cmd[4], 4);
> > > +	cmd[8] = LOW_BYTE(crc);
> > > +	cmd[9] = HI_BYTE(crc);
> > > +	cmd[10] = HID_OUTPUT_BL_EOP;
> > > +
> > > +	rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
> > > +			   HID_OUTPUT_BL_LAUNCH_APP_SIZE);
> > > +	if (rc) {
> > > +		dev_err(ts->dev, "Failed to write command %d", rc);
> > > +		goto error;
> > > +	}
> > > +
> > > +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
> > > +				msecs_to_jiffies(CY_HID_OUTPUT_TIMEOUT));
> > > +	if (!rc) {
> > > +		dev_err(ts->dev, "HID output cmd execution timed out\n");
> > > +		rc = -ETIME;
> > > +		goto error;
> > > +	}
> > > +
> > > +	rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_BL_LAUNCH_APP);
> > > +	if (rc) {
> > > +		dev_err(ts->dev, "Validation of the response failed\n");
> > > +		goto error;
> > > +	}
> > > +
> > > +	return rc;
> > > +
> > > +error:
> > > +	mutex_lock(&ts->system_lock);
> > > +	ts->hid_cmd_state = HID_CMD_DONE;
> > > +	mutex_unlock(&ts->system_lock);
> > > +
> > > +	return rc;
> > > +}
> > > +
> > > +static int cyttsp5_get_hid_descriptor(struct cyttsp5 *ts,
> > > +				      struct cyttsp5_hid_desc *desc)
> > > +{
> > > +	struct device *dev = ts->dev;
> > > +	__le16 hid_desc_register = HID_DESC_REG;
> > > +	int rc;
> > > +	u8 cmd[2];
> > > +
> > > +	/* Read HID descriptor length and version */
> > > +	mutex_lock(&ts->system_lock);
> > > +	ts->hid_cmd_state = HID_CMD_BUSY;
> > > +	mutex_unlock(&ts->system_lock);
> > > +
> > > +	/* Set HID descriptor register */
> > > +	memcpy(cmd, &hid_desc_register, sizeof(hid_desc_register));
> > > +
> > > +	rc = cyttsp5_write(ts, HID_DESC_REG, NULL, 0);
> > > +	if (rc < 0) {
> > > +		dev_err(dev, "Failed to get HID descriptor, rc=%d\n", rc);
> > > +		goto error;
> > > +	}
> > > +
> > > +	rc = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == HID_CMD_DONE),
> > > +				msecs_to_jiffies(CY_HID_GET_HID_DESCRIPTOR_TIMEOUT));
> > > +	if (!rc) {
> > > +		dev_err(ts->dev, "HID get descriptor timed out\n");
> > > +		rc = -ETIME;
> > > +		goto error;
> > > +	}
> > > +
> > > +	memcpy(desc, ts->response_buf, sizeof(struct cyttsp5_hid_desc));
> > > +
> > > +	/* Check HID descriptor length and version */
> > > +	if (le16_to_cpu(desc->hid_desc_len) != sizeof(*desc) ||
> > > +	    le16_to_cpu(desc->bcd_version) != HID_VERSION) {
> > > +		dev_err(dev, "Unsupported HID version\n");
> > > +		return -ENODEV;
> > > +	}
> > > +
> > > +	goto exit;
> > > +
> > > +error:
> > > +	mutex_lock(&ts->system_lock);
> > > +	ts->hid_cmd_state = HID_CMD_DONE;
> > > +	mutex_unlock(&ts->system_lock);
> > > +exit:
> > > +	return rc;
> > > +}
> > > +
> > > +static int fill_tch_abs(struct cyttsp5_tch_abs_params *tch_abs, int report_size,
> > > +			int offset)
> > > +{
> > > +	tch_abs->ofs = offset / 8;
> > > +	tch_abs->size = report_size / 8;
> > > +	if (report_size % 8)
> > > +		tch_abs->size += 1;
> > > +	tch_abs->min = 0;
> > > +	tch_abs->max = 1 << report_size;
> > > +	tch_abs->bofs = offset - (tch_abs->ofs << 3);
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static int move_button_data(struct cyttsp5 *ts, struct cyttsp5_sysinfo *si)
> > > +{
> > > +	memcpy(si->xy_mode, ts->input_buf, BTN_INPUT_HEADER_SIZE);
> > > +	memcpy(si->xy_data, &ts->input_buf[BTN_INPUT_HEADER_SIZE],
> > > +	       BTN_REPORT_SIZE);
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static int move_touch_data(struct cyttsp5 *ts, struct cyttsp5_sysinfo *si)
> > > +{
> > > +	int max_tch = si->sensing_conf_data.max_tch;
> > > +	int num_cur_tch;
> > > +	int length;
> > > +	struct cyttsp5_tch_abs_params *tch = &si->tch_hdr;
> > > +
> > > +	memcpy(si->xy_mode, ts->input_buf, TOUCH_INPUT_HEADER_SIZE);
> > > +
> > > +	cyttsp5_get_touch_axis(&num_cur_tch, tch->size,
> > > +			       tch->max, si->xy_mode + 3 + tch->ofs, tch->bofs);
> > > +	if (unlikely(num_cur_tch > max_tch))
> > > +		num_cur_tch = max_tch;
> > > +
> > > +	length = num_cur_tch * TOUCH_REPORT_SIZE;
> > > +
> > > +	memcpy(si->xy_data, &ts->input_buf[TOUCH_INPUT_HEADER_SIZE], length);
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static irqreturn_t cyttsp5_handle_irq(int irq, void *handle)
> > > +{
> > > +	struct cyttsp5 *ts = handle;
> > > +	int report_id;
> > > +	int size;
> > > +	int rc;
> > > +
> > > +	rc = cyttsp5_read(ts, ts->input_buf, CY_MAX_INPUT);
> > > +	if (rc)
> > > +		return IRQ_HANDLED;
> > > +
> > > +	size = get_unaligned_le16(&ts->input_buf[0]);
> > > +
> > > +	/* check reset */
> > > +	if (size == 0) {
> > > +		memcpy(ts->response_buf, ts->input_buf, 2);
> > > +
> > > +		mutex_lock(&ts->system_lock);
> > > +		ts->hid_cmd_state = HID_CMD_DONE;
> > > +		mutex_unlock(&ts->system_lock);
> > > +		wake_up(&ts->wait_q);  
> > 
> > I'd use spinlock in wait queue and wake_up_locked() instead of a
> > separate mutex.
> 
> Hum, okay, I will try that.
> 
> > 
> > > +		return IRQ_HANDLED;
> > > +	}
> > > +
> > > +	report_id = ts->input_buf[2];
> > > +  
> > 
> > 	switch(report_id) {
> > 	}
> 
> Yep, it will be easier to understand.
> 
> > 
> > > +	if (report_id == HID_TOUCH_REPORT_ID) {
> > > +		move_touch_data(ts, &ts->sysinfo);
> > > +		cyttsp5_mt_attention(ts->dev);
> > > +	} else if (report_id == HID_BTN_REPORT_ID) {
> > > +		move_button_data(ts, &ts->sysinfo);
> > > +		cyttsp5_btn_attention(ts->dev);
> > > +	} else {
> > > +		/* It is not an input but a command response */
> > > +		memcpy(ts->response_buf, ts->input_buf, size);
> > > +
> > > +		mutex_lock(&ts->system_lock);
> > > +		ts->hid_cmd_state = HID_CMD_DONE;
> > > +		mutex_unlock(&ts->system_lock);
> > > +		wake_up(&ts->wait_q);
> > > +	}
> > > +
> > > +	return IRQ_HANDLED;
> > > +}
> > > +
> > > +static int cyttsp5_deassert_int(struct cyttsp5 *ts)
> > > +{
> > > +	u16 size;
> > > +	u8 buf[2];
> > > +	int rc;
> > > +
> > > +	rc = regmap_bulk_read(ts->regmap, HID_INPUT_REG, buf, 2);
> > > +	if (rc < 0)
> > > +		return rc;
> > > +
> > > +	size = get_unaligned_le16(&buf[0]);
> > > +	if (size == 2 || size == 0)
> > > +		return 0;
> > > +
> > > +	return -EINVAL;
> > > +}
> > > +
> > > +static int cyttsp5_fill_all_touch(struct cyttsp5 *ts)
> > > +{
> > > +	struct cyttsp5_sysinfo *si = &ts->sysinfo;
> > > +
> > > +	fill_tch_abs(&si->tch_abs[CY_TCH_X], REPORT_SIZE_16,
> > > +		     TOUCH_REPORT_DESC_X);
> > > +	fill_tch_abs(&si->tch_abs[CY_TCH_Y], REPORT_SIZE_16,
> > > +		     TOUCH_REPORT_DESC_Y);
> > > +	fill_tch_abs(&si->tch_abs[CY_TCH_P], REPORT_SIZE_8,
> > > +		     TOUCH_REPORT_DESC_P);
> > > +	fill_tch_abs(&si->tch_abs[CY_TCH_T], REPORT_SIZE_5,
> > > +		     TOUCH_REPORT_DESC_CONTACTID);
> > > +	fill_tch_abs(&si->tch_hdr, REPORT_SIZE_5,
> > > +		     TOUCH_REPORT_DESC_HDR_CONTACTCOUNT);
> > > +	fill_tch_abs(&si->tch_abs[CY_TCH_MAJ], REPORT_SIZE_8,
> > > +		     TOUCH_REPORT_DESC_MAJ);
> > > +	fill_tch_abs(&si->tch_abs[CY_TCH_MIN], REPORT_SIZE_8,
> > > +		     TOUCH_REPORT_DESC_MIN);
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static int cyttsp5_startup(struct cyttsp5 *ts)
> > > +{
> > > +	int rc;
> > > +
> > > +	rc = cyttsp5_deassert_int(ts);
> > > +	if (rc) {
> > > +		dev_err(ts->dev, "Error on deassert int r=%d\n", rc);
> > > +		return -ENODEV;
> > > +	}
> > > +
> > > +	/*
> > > +	 * Launch the application as the device starts in bootloader mode
> > > +	 * because of a power-on-reset
> > > +	 */
> > > +	rc = cyttsp5_hid_output_bl_launch_app(ts);
> > > +	if (rc < 0) {
> > > +		dev_err(ts->dev, "Error on launch app r=%d\n", rc);
> > > +		return rc;
> > > +	}
> > > +
> > > +	rc = cyttsp5_get_hid_descriptor(ts, &ts->hid_desc);
> > > +	if (rc < 0) {
> > > +		dev_err(ts->dev, "Error on getting HID descriptor r=%d\n", rc);
> > > +		return rc;
> > > +	}
> > > +
> > > +	rc = cyttsp5_fill_all_touch(ts);
> > > +	if (rc < 0) {
> > > +		dev_err(ts->dev, "Error on report descriptor r=%d\n", rc);
> > > +		return rc;
> > > +	}
> > > +
> > > +	rc = cyttsp5_hid_output_get_sysinfo(ts);
> > > +	if (rc) {
> > > +		dev_err(ts->dev, "Error on getting sysinfo r=%d\n", rc);
> > > +		return rc;
> > > +	}
> > > +
> > > +	return rc;
> > > +}
> > > +
> > > +#ifdef CONFIG_OF
> > > +static const struct of_device_id cyttsp5_of_match[] = {
> > > +	{ .compatible = "cypress,cyttsp5", },
> > > +	{ }
> > > +};
> > > +MODULE_DEVICE_TABLE(of, cyttsp5_of_match);
> > > +#endif
> > > +
> > > +static const struct i2c_device_id cyttsp5_i2c_id[] = {
> > > +	{ CYTTSP5_NAME, 0, },
> > > +	{ }
> > > +};
> > > +MODULE_DEVICE_TABLE(i2c, cyttsp5_i2c_id);
> > > +
> > > +static int cyttsp5_probe(struct device *dev, struct regmap *regmap, int irq,
> > > +			 const char *name)
> > > +{
> > > +	struct cyttsp5 *ts;
> > > +	struct cyttsp5_sysinfo *si;
> > > +	int rc = 0, i;
> > > +
> > > +	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
> > > +	if (!ts)
> > > +		return -ENOMEM;
> > > +
> > > +	/* Initialize device info */
> > > +	ts->regmap = regmap;
> > > +	ts->dev = dev;
> > > +	si = &ts->sysinfo;
> > > +	dev_set_drvdata(dev, ts);
> > > +
> > > +	/* Initialize mutexes and spinlocks */
> > > +	mutex_init(&ts->system_lock);
> > > +
> > > +	/* Initialize wait queue */
> > > +	init_waitqueue_head(&ts->wait_q);
> > > +
> > > +	/* Reset the gpio to be in a reset state */
> > > +	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
> > > +	if (IS_ERR(ts->reset_gpio)) {
> > > +		rc = PTR_ERR(ts->reset_gpio);
> > > +		dev_err(dev, "Failed to request reset gpio, error %d\n", rc);
> > > +		return rc;
> > > +	}
> > > +	gpiod_set_value(ts->reset_gpio, 1);  
> > 
> > Why not request it as GPIOD_OUT_HIGH if you going to activate it
> > immediately? However it sounds as if you have a reset line that is
> > active low and you want to driver it low to reset, and then release. In
> > this case you need to do
> > 
> > 	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
> > 	<delay> - chip usually needs to be some time in reset state
> > 	gpiod_set_value(ts->reset_gpio, 0);
> > 
> > and make sure that correct polarity is specified in device tree.
> 
> Okay, I will update it too.
> 
> > 
> > > +
> > > +	/* Need a delay to have device up */
> > > +	msleep(20);
> > > +
> > > +	rc = devm_request_threaded_irq(dev, irq, NULL, cyttsp5_handle_irq,
> > > +				       IRQF_TRIGGER_FALLING | IRQF_ONESHOT,  
> > 
> > Just use IRQF_ONESHOT and make sure DTS specifies interrupt properly.
> > BTW,I'd recommend using level, not edge interrupts. It is so easy to
> > miss an edge.
> 
> Okay, thank you for the advice.
> 
> > 
> > > +				       name, ts);
> > > +	if (rc) {
> > > +		dev_err(dev, "unable to request IRQ\n");
> > > +		return rc;
> > > +	}
> > > +
> > > +	rc = cyttsp5_startup(ts);
> > > +	if (rc) {
> > > +		dev_err(ts->dev, "Fail initial startup r=%d\n", rc);
> > > +		return rc;
> > > +	}
> > > +
> > > +	rc = cyttsp5_parse_dt_key_code(dev);
> > > +	if (rc < 0) {
> > > +		dev_err(ts->dev, "Error while parsing dts %d\n", rc);
> > > +		return rc;
> > > +	}
> > > +
> > > +	ts->input = devm_input_allocate_device(dev);
> > > +	if (!ts->input) {
> > > +		dev_err(dev, "Error, failed to allocate input device\n");
> > > +		return -ENODEV;
> > > +	}
> > > +
> > > +	ts->input->name = "cyttsp5";
> > > +	scnprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
> > > +	ts->input->phys = ts->phys;
> > > +	ts->input->dev.parent = ts->dev;
> > > +	input_set_drvdata(ts->input, ts);
> > > +
> > > +	touchscreen_parse_properties(ts->input, true, NULL);
> > > +
> > > +	__set_bit(EV_KEY, ts->input->evbit);
> > > +	for (i = 0; i < si->num_btns; i++)
> > > +		__set_bit(si->key_code[i], ts->input->keybit);
> > > +
> > > +	return cyttsp5_setup_input_device(dev);
> > > +}
> > > +
> > > +static int cyttsp5_i2c_probe(struct i2c_client *client,
> > > +			     const struct i2c_device_id *id)
> > > +{
> > > +	struct regmap *regmap;
> > > +	static const struct regmap_config config = {
> > > +		.reg_bits = 8,
> > > +		.val_bits = 8,
> > > +	};
> > > +
> > > +	regmap = devm_regmap_init_i2c(client, &config);
> > > +	if (IS_ERR(regmap)) {
> > > +		dev_err(&client->dev, "regmap allocation failed: %ld\n",
> > > +			PTR_ERR(regmap));
> > > +		return PTR_ERR(regmap);
> > > +	}
> > > +
> > > +	return cyttsp5_probe(&client->dev, regmap, client->irq, client->name);
> > > +}
> > > +
> > > +static int cyttsp5_remove(struct device *dev)
> > > +{
> > > +	struct cyttsp5 *ts = dev_get_drvdata(dev);
> > > +
> > > +	input_unregister_device(ts->input);  
> > 
> > Not needed: you are using managed input device.
> 
> You are right, thanks.
> 
> > 
> > > +
> > > +	return 0;
> > > +}
> > > +
> > > +static int cyttsp5_i2c_remove(struct i2c_client *client)
> > > +{
> > > +	struct device *dev = &client->dev;
> > > +
> > > +	return cyttsp5_remove(dev);  
> > 
> > Not needed if you remove cyttsp5_remove().
> 
> Sure.
> 
> > 
> > > +}
> > > +
> > > +static struct i2c_driver cyttsp5_i2c_driver = {
> > > +	.driver = {
> > > +		.name = CYTTSP5_NAME,
> > > +		.owner = THIS_MODULE,
> > > +		.of_match_table = of_match_ptr(cyttsp5_of_match),
> > > +	},
> > > +	.probe = cyttsp5_i2c_probe,
> > > +	.remove = cyttsp5_i2c_remove,
> > > +	.id_table = cyttsp5_i2c_id,
> > > +};
> > > +
> > > +module_i2c_driver(cyttsp5_i2c_driver);
> > > +
> > > +MODULE_LICENSE("GPL");
> > > +MODULE_DESCRIPTION("Touchscreen driver for Cypress TrueTouch Gen 5 Product");
> > > +MODULE_AUTHOR("Mylène Josserand <mylene.josserand@free-electrons.com>");
> > > -- 
> > > 2.11.0
> > >   
> > 
> > Thanks.
> > 
> 
> Best regards,
> 
> -- 
> Mylène Josserand, Free Electrons
> Embedded Linux and Kernel engineering
> http://free-electrons.com
> 

-- 
Dmitry

[PATCH v4 2/2] dt-bindings: input: Add documentation for cyttsp5

[Mylène Josserand]

Add the Cypress TrueTouch Generation 5 touchscreen device tree bindings
documentation. It can use I2C or SPI bus.
This touchscreen can handle some defined zone that are designed and
sent as button. To be able to customize the keycode sent, the
"linux,keycodes" property can be used.

Acked-by: Rob Herring <robh@kernel.org>
Signed-off-by: Mylène Josserand <mylene.josserand@free-electrons.com>
---
 .../bindings/input/touchscreen/cypress,cyttsp5.txt | 39 ++++++++++++++++++++++
 1 file changed, 39 insertions(+)
 create mode 100644 Documentation/devicetree/bindings/input/touchscreen/cypress,cyttsp5.txt

diff --git a/Documentation/devicetree/bindings/input/touchscreen/cypress,cyttsp5.txt b/Documentation/devicetree/bindings/input/touchscreen/cypress,cyttsp5.txt
new file mode 100644
index 000000000000..1e0e90e322c7
--- /dev/null
+++ b/Documentation/devicetree/bindings/input/touchscreen/cypress,cyttsp5.txt
@@ -0,0 +1,39 @@
+* Cypress cyttsp touchscreen controller, generation 5
+
+Required properties:
+ - compatible		: must be "cypress,cyttsp5"
+ - reg			: Device I2C address or SPI chip select number
+ - interrupt-parent	: the phandle for the gpio controller
+			  (see interrupt binding[0]).
+ - interrupts		: (gpio) interrupt to which the chip is connected
+			  (see interrupt binding[0]).
+
+Optional properties:
+ - reset-gpios		: the reset gpio the chip is connected to
+			  (see GPIO binding[1] for more details).
+Some other touchscreen optional properties can be defined such as
+"touchscreen-size-x". See ./touchscreen.txt[2] for more details.
+
+This touchscreen can handle some buttons that are touchscreen's defined zones.
+Each button's event can be customized using a property:
+	- linux,keycodes: List of keycode to emit.
+
+[0]: Documentation/devicetree/bindings/interrupt-controller/interrupts.txt
+[1]: Documentation/devicetree/bindings/gpio/gpio.txt
+[2]: Documentation/devicetree/bindings/input/touchscreen/touchscreen.txt
+
+Example:
+&i2c0 {
+	[...]
+
+	touchscreen@24 {
+		compatible = "cypress,cyttsp5";
+		reg = <0x24>;
+
+		interrupt-parent = <&pio>;
+		interrupts = <1 5 IRQ_TYPE_LEVEL_LOW>;
+		reset-gpios = <&pio 7 1 GPIO_ACTIVE_HIGH>;
+		touchscreen-swapped-x-y;
+		linux,keycodes = <KEY_HOMEPAGE>, <KEY_MENU>, <KEY_BACK>;
+	};
+};
-- 
2.11.0

Re: [PATCH v2] Input: Add driver for GOODiX GTx5 series touchsereen

[kbuild test robot]

Hi Wang,

[auto build test WARNING on input/next]
[also build test WARNING on v4.12-rc5 next-20170619]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Wang-Yafei/Input-Add-driver-for-GOODiX-GTx5-series-touchsereen/20170619-200451
base:   https://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git next


coccinelle warnings: (new ones prefixed by >>)

>> drivers/input/touchscreen/goodix-ts-sunrise/goodix_gtx5_i2c.c:872:3-8: No need to set .owner here. The core will do it.
--
>> drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_core.c:1335:3-8: No need to set .owner here. The core will do it.
--
>> drivers/input/touchscreen/goodix-ts-sunrise/goodix_gtx5_update.c:752:2-3: Unneeded semicolon

Please review and possibly fold the followup patch.

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[PATCH v2] Input: Add driver for GOODiX GTx5 series touchsereen

[Wang Yafei]

This driver is for GOODiX GTx5 series touchscreen controllers
such as GT8589, GT7589. This driver designed with hierarchial structure,
for that can be modified to support subsequent controllers easily.
Some zones of the touchscreen can be set to buttons(according to the
hardware). That is why it handles button and multitouch events.

A brief description of driver structure
- Core Layer: This layer responsible for basic input events report,
  GPIO pinctrl, Interrupt, Power resources manager and submodules manager.
- Hardware Layer: This layer responsible for controllers initialization,
  irq handle as well as bus read/write.
- External Module Layer: This layer used for support more features
  such as firmware update, debug tools and gesture wakeup.

Signed-off-by: Wang Yafei <wangyafei@goodix.com>
---
Goodix driver that the kernel already have, is for our gt9xx series
touchscreen controllers. This new driver is for out new generation
touchscreen controllers, consider this two generations are very
different with each other. We wrote a new driver instead of make
a patch on the old driver.

Since v1:
- replace touchscreen properties according to the description in
  Documentation/devicetree/bindings/input/touchscreen/touchscreen.txt
- Droped all compat stuff for older kernels
- Removed Android stuff (EARLY_SUSPEND, CONFIG_FB)
- Use device_property_read_*  get device properties
- use get-unaligned_*() API
- Use dev_err() dev_dbg() for logging
- remove pinctrl functions
- remove some unused functions
---
 drivers/input/touchscreen/Kconfig                  |    1 +
 drivers/input/touchscreen/Makefile                 |    1 +
 .../input/touchscreen/goodix-ts-sunrise/Kconfig    |   36 +
 .../input/touchscreen/goodix-ts-sunrise/Makefile   |    6 +
 .../goodix-ts-sunrise/goodix_gtx5_i2c.c            |  895 ++++++++++++
 .../goodix-ts-sunrise/goodix_gtx5_update.c         | 1454 ++++++++++++++++++++
 .../touchscreen/goodix-ts-sunrise/goodix_ts_core.c | 1366 ++++++++++++++++++
 .../touchscreen/goodix-ts-sunrise/goodix_ts_core.h |  553 ++++++++
 .../goodix-ts-sunrise/goodix_ts_tools.c            |  542 ++++++++
 9 files changed, 4854 insertions(+)
 create mode 100755 drivers/input/touchscreen/goodix-ts-sunrise/Kconfig
 create mode 100755 drivers/input/touchscreen/goodix-ts-sunrise/Makefile
 create mode 100755 drivers/input/touchscreen/goodix-ts-sunrise/goodix_gtx5_i2c.c
 create mode 100755 drivers/input/touchscreen/goodix-ts-sunrise/goodix_gtx5_update.c
 create mode 100755 drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_core.c
 create mode 100755 drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_core.h
 create mode 100755 drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_tools.c

diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index cf26ca4..f3642bb 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -15,6 +15,7 @@ config TOUCHSCREEN_PROPERTIES
 	def_tristate INPUT
 	depends on INPUT
 
+source "drivers/input/touchscreen/goodix-ts-sunrise/Kconfig"
 config TOUCHSCREEN_88PM860X
 	tristate "Marvell 88PM860x touchscreen"
 	depends on MFD_88PM860X
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 18e4769..d9408c0 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -6,6 +6,7 @@
 
 wm97xx-ts-y := wm97xx-core.o
 
+obj-$(CONFIG_TOUCHSCREEN_GOODIX_GTX5)	+= goodix-ts-sunrise/
 obj-$(CONFIG_TOUCHSCREEN_PROPERTIES)	+= of_touchscreen.o
 obj-$(CONFIG_TOUCHSCREEN_88PM860X)	+= 88pm860x-ts.o
 obj-$(CONFIG_TOUCHSCREEN_AD7877)	+= ad7877.o
diff --git a/drivers/input/touchscreen/goodix-ts-sunrise/Kconfig b/drivers/input/touchscreen/goodix-ts-sunrise/Kconfig
new file mode 100755
index 0000000..8e16595
--- /dev/null
+++ b/drivers/input/touchscreen/goodix-ts-sunrise/Kconfig
@@ -0,0 +1,36 @@
+#
+# Goodix touchscreen driver configuration
+#
+menuconfig TOUCHSCREEN_GOODIX_GTX5
+	bool "Goodix GTx5 touchscreen"
+	depends on I2C
+	default y
+	help
+	  Say Y here if you have a Goodix GTx5xx touchscreen connected
+	  to your system.
+
+	  If unsure, say N.
+
+if TOUCHSCREEN_GOODIX_GTX5
+
+config TOUCHSCREEN_GOODIX_GTX5_UPDATE
+	tristate "Goodix GTx5xx firmware update module"
+	default y
+	help
+	  Say Y here to enable support for doing firmware update.
+
+	  If unsure, say N.
+
+	  To compile this driver as a module, choose M here.
+
+config TOUCHSCREEN_GOODIX_GTX5_TOOLS
+	tristate "Goodix touch tools support"
+	default n
+	help
+	  Say Y here to enable debug tools.
+
+	  If unsure, say N.
+
+	  To compile this driver as a module, choose M here.
+
+endif
diff --git a/drivers/input/touchscreen/goodix-ts-sunrise/Makefile b/drivers/input/touchscreen/goodix-ts-sunrise/Makefile
new file mode 100755
index 0000000..690f256
--- /dev/null
+++ b/drivers/input/touchscreen/goodix-ts-sunrise/Makefile
@@ -0,0 +1,6 @@
+# Goodix Touchscreen Makefile
+
+obj-$(CONFIG_TOUCHSCREEN_GOODIX_GTX5)           += goodix_gtx5_i2c.o
+obj-$(CONFIG_TOUCHSCREEN_GOODIX_GTX5)           += goodix_ts_core.o
+obj-$(CONFIG_TOUCHSCREEN_GOODIX_GTX5_TOOLS)    += goodix_ts_tools.o
+obj-$(CONFIG_TOUCHSCREEN_GOODIX_GTX5_UPDATE)    += goodix_gtx5_update.o
diff --git a/drivers/input/touchscreen/goodix-ts-sunrise/goodix_gtx5_i2c.c b/drivers/input/touchscreen/goodix-ts-sunrise/goodix_gtx5_i2c.c
new file mode 100755
index 0000000..a02a2eb
--- /dev/null
+++ b/drivers/input/touchscreen/goodix-ts-sunrise/goodix_gtx5_i2c.c
@@ -0,0 +1,895 @@
+/*
+ * Goodix GTx5 Touchscreen Dirver
+ * Hardware interface layer of touchdriver architecture.
+ *
+ * Copyright (C) 2015 - 2016 Goodix, Inc.
+ * Authors:  Wang Yafei <wangyafei@goodix.com>
+ *
+ * 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/kernel.h>
+#include <linux/module.h>
+#include <linux/delay.h>
+#include <linux/ctype.h>
+#include <linux/slab.h>
+#include <linux/i2c.h>
+#include <linux/property.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include "goodix_ts_core.h"
+
+#define TS_DT_COMPATIBLE	"goodix,gtx5"
+#define TS_DRIVER_NAME		"goodix_i2c"
+#define I2C_MAX_TRANSFER_SIZE	256
+#define TS_ADDR_LENGTH		2
+
+#define TS_REG_COORDS_BASE	0x824E
+#define TS_REG_CMD		0x8040
+#define TS_REG_REQUEST		0x8044
+#define TS_REG_VERSION		0x8240
+#define TS_REG_CFG_BASE		0x8050
+
+#define CFG_XMAX_OFFSET (0x8052 - 0x8050)
+#define CFG_YMAX_OFFSET	(0x8054 - 0x8050)
+
+#define REQUEST_HANDLED	0x00
+#define REQUEST_CONFIG	0x01
+#define REQUEST_BAKREF	0x02
+#define REQUEST_RESET	0x03
+#define REQUEST_MAINCLK	0x04
+#define REQUEST_IDLE	0x05
+
+#define TS_MAX_SENSORID	5
+#define TS_CFG_MAX_LEN	495
+/* set defalut irq flags as Falling edge */
+#define DEFAULT_IRQ_FLAGS 2
+#if TS_CFG_MAX_LEN > GOODIX_CFG_MAX_SIZE
+#error GOODIX_CFG_MAX_SIZE too small, please fix.
+#endif
+
+#ifdef CONFIG_OF
+/*
+ * goodix_parse_dt_resolution - parse resolution from dt
+ * @dev: device
+ * @board_data: pointer to board data structure
+ * return: 0 - no error, <0 error
+ */
+static int goodix_parse_dt_resolution(struct device *dev,
+		struct goodix_ts_board_data *board_data)
+{
+	int r, err = 0;
+
+	r = device_property_read_u32(dev, "touchscreen-max-id",
+				&board_data->panel_max_id);
+	if (r || board_data->panel_max_id > GOODIX_MAX_TOUCH)
+		board_data->panel_max_id = GOODIX_MAX_TOUCH;
+
+	r = device_property_read_u32(dev, "touchscreen-size-x",
+				 &board_data->panel_max_x);
+	if (r)
+		err = -ENOENT;
+
+	r = device_property_read_u32(dev, "touchscreen-size-y",
+				&board_data->panel_max_y);
+	if (r)
+		err = -ENOENT;
+
+	r = device_property_read_u32(dev, "touchscreen-max-w",
+				&board_data->panel_max_w);
+	if (r)
+		err = -ENOENT;
+
+	board_data->swap_axis = device_property_read_bool(dev,
+			"touchscreen-swapped-x-y");
+
+	return err;
+}
+
+/**
+ * goodix_parse_dt - parse board data from dt
+ * @dev: pointer to device
+ * @board_data: pointer to board data structure
+ * return: 0 - no error, <0 error
+ */
+static int goodix_parse_dt(struct device *dev,
+	struct goodix_ts_board_data *board_data)
+{
+	int r;
+
+	if (!board_data) {
+		dev_err(dev, "Invalid board data\n");
+		return -EINVAL;
+	}
+
+	r = device_property_read_u32(dev, "irq-flags",
+			&board_data->irq_flags);
+	if (r) {
+		dev_info(dev, "Use default irq flags:falling_edge\n");
+		board_data->irq_flags = DEFAULT_IRQ_FLAGS;
+	}
+
+	board_data->avdd_name = "vtouch";
+	r = device_property_read_u32(dev, "power-on-delay-us",
+				&board_data->power_on_delay_us);
+	if (!r) {
+		/* 1000ms is too large, maybe you have pass a wrong value */
+		if (board_data->power_on_delay_us > 1000 * 1000) {
+			dev_warn(dev, "Power on delay time exceed 1s\n");
+			board_data->power_on_delay_us = 0;
+		}
+	}
+
+	r = device_property_read_u32(dev, "power-off-delay-us",
+				&board_data->power_off_delay_us);
+	if (!r) {
+		/* 1000ms is too large, maybe you have pass a wrong value */
+		if (board_data->power_off_delay_us > 1000 * 1000) {
+			dev_warn(dev, "Power off delay time exceed 1s\n");
+			board_data->power_off_delay_us = 0;
+		}
+	}
+
+	/* get xyz resolutions */
+	r = goodix_parse_dt_resolution(dev, board_data);
+	if (r < 0) {
+		dev_err(dev, "Failed to parse resolutions:%d\n", r);
+		return r;
+	}
+
+	/* parse key map */
+	r = device_property_read_u32_array(dev, "panel-key-map",
+			NULL, GOODIX_MAX_KEY);
+	if (r > 0 && r <= GOODIX_MAX_KEY) {
+		board_data->panel_max_key = r;
+		r = device_property_read_u32_array(dev,
+				"panel-key-map",
+				&board_data->panel_key_map[0],
+				board_data->panel_max_key);
+		if (r)
+			dev_err(dev, "Failed get key map info\n");
+	} else {
+		dev_info(dev, "No key map found\n");
+	}
+
+	dev_dbg(dev, "[DT]id:%d, x:%d, y:%d, w:%d\n",
+			board_data->panel_max_id,
+			board_data->panel_max_x,
+			board_data->panel_max_y,
+			board_data->panel_max_w);
+	return 0;
+}
+
+/**
+ * goodix_parse_dt_cfg - pares config data from devicetree dev
+ * @dev: pointer to device
+ * @cfg_type: config type such as normal_config, highsense_cfg ...
+ * @config: pointer to config data structure
+ * @sensor_id: sensor id
+ * return: 0 - no error, <0 error
+ */
+static int goodix_parse_dt_cfg(struct goodix_ts_device *ts_dev,
+		char *cfg_type, struct goodix_ts_config *config,
+		unsigned int sensor_id)
+{
+	int r, len;
+	char sub_node_name[24] = {0};
+	struct fwnode_handle *fwnode;
+	struct device *dev = ts_dev->dev;
+	struct goodix_ts_board_data *ts_bdata = ts_dev->board_data;
+
+	u16 checksum;
+
+	BUG_ON(config == NULL);
+	if (sensor_id > TS_MAX_SENSORID) {
+		dev_err(dev, "Invalid sensor id\n");
+		return -EINVAL;
+	}
+
+	if (config->initialized) {
+		dev_dbg(dev, "Config already initialized\n");
+		return 0;
+	}
+
+	/*
+	 * config data are located in child node called
+	 * 'sensorx', x is the sensor ID got from touch
+	 * device.
+	 */
+	snprintf(sub_node_name, sizeof(sub_node_name),
+			"sensor%u", sensor_id);
+	fwnode = device_get_named_child_node(dev, "sub_node_name");
+	if (!fwnode) {
+		dev_dbg(dev, "Child property[%s] not found\n",
+				sub_node_name);
+		return -EINVAL;
+	}
+
+	len = fwnode_property_read_u8_array(fwnode, cfg_type,
+		NULL, TS_CFG_MAX_LEN);
+	if (len <= 0 || len % 2 != 1) {
+		dev_err(dev, "Invalid cfg type%s, size:%u\n", cfg_type, len);
+		return -EINVAL;
+	}
+
+	config->length = len;
+
+	mutex_init(&config->lock);
+	mutex_lock(&config->lock);
+
+	r = fwnode_property_read_u8_array(fwnode, cfg_type,
+		config->data, TS_CFG_MAX_LEN);
+	if (r) {
+		mutex_unlock(&config->lock);
+		return r;
+	}
+
+	/* modify max-x max-y resolution, little-endian */
+	config->data[CFG_XMAX_OFFSET] = (u8)ts_bdata->panel_max_x;
+	config->data[CFG_XMAX_OFFSET + 1] = (u8)(ts_bdata->panel_max_x >> 8);
+	config->data[CFG_YMAX_OFFSET] = (u8)ts_bdata->panel_max_y;
+	config->data[CFG_YMAX_OFFSET + 1] = (u8)(ts_bdata->panel_max_y >> 8);
+
+	/*
+	 * checksum: u16 little-endian format
+	 * the last byte of config is the config update flag
+	 */
+	checksum = checksum_le16(config->data, len - 3);
+	checksum = 0 - checksum;
+	config->data[len - 3] = (u8)checksum;
+	config->data[len - 2] = (u8)(checksum >> 8 & 0xff);
+	config->data[len - 1] = 0x01;
+
+	strlcpy(config->name, cfg_type, sizeof(config->name));
+	config->reg_base = TS_REG_CFG_BASE;
+	config->delay = 0;
+	config->initialized = true;
+	mutex_unlock(&config->lock);
+
+	dev_dbg(dev, "Config name:%s,ver:%02xh,size:%d,checksum:%04xh\n",
+			config->name, config->data[0],
+			config->length, checksum);
+	return 0;
+}
+#endif
+
+/**
+ * goodix_i2c_read - read device register through i2c bus
+ * @dev: pointer to device data
+ * @addr: register address
+ * @data: read buffer
+ * @len: bytes to read
+ * return: 0 - read ok, < 0 - i2c transter error
+ */
+static int goodix_i2c_read(struct goodix_ts_device *dev, unsigned int reg,
+	unsigned char *data, unsigned int len)
+{
+	struct i2c_client *client = to_i2c_client(dev->dev);
+	unsigned int transfer_length = 0;
+	unsigned int pos = 0, address = reg;
+	unsigned char get_buf[64], addr_buf[2];
+	int retry, r = 0;
+	struct i2c_msg msgs[] = {
+		{
+			.addr = client->addr,
+			.flags = !I2C_M_RD,
+			.buf = &addr_buf[0],
+			.len = TS_ADDR_LENGTH,
+		}, {
+			.addr = client->addr,
+			.flags = I2C_M_RD,
+		}
+	};
+
+	if (likely(len < sizeof(get_buf))) {
+		/* code optimize, use stack memory */
+		msgs[1].buf = &get_buf[0];
+	} else {
+		msgs[1].buf = kzalloc(len > I2C_MAX_TRANSFER_SIZE
+				? I2C_MAX_TRANSFER_SIZE : len, GFP_KERNEL);
+		if (!msgs[1].buf)
+			return -ENOMEM;
+	}
+
+	while (pos != len) {
+		if (unlikely(len - pos > I2C_MAX_TRANSFER_SIZE))
+			transfer_length = I2C_MAX_TRANSFER_SIZE;
+		else
+			transfer_length = len - pos;
+
+		msgs[0].buf[0] = (address >> 8) & 0xFF;
+		msgs[0].buf[1] = address & 0xFF;
+		msgs[1].len = transfer_length;
+
+		for (retry = 0; retry < GOODIX_BUS_RETRY_TIMES; retry++) {
+			if (likely(i2c_transfer(client->adapter, msgs, 2) == 2)) {
+				memcpy(&data[pos], msgs[1].buf, transfer_length);
+				pos += transfer_length;
+				address += transfer_length;
+				break;
+			}
+			dev_info(&client->dev, "I2c read retry[%d]:0x%x\n",
+				retry + 1, reg);
+			msleep(20);
+		}
+		if (unlikely(retry == GOODIX_BUS_RETRY_TIMES)) {
+			dev_err(&client->dev,
+				"I2c read failed,dev:%02x,reg:%04x,size:%u\n",
+				client->addr, reg, len);
+			r = -EBUS;
+			goto read_exit;
+		}
+	}
+
+read_exit:
+	if (unlikely(len >= sizeof(get_buf)))
+		kfree(msgs[1].buf);
+	return r;
+}
+
+/**
+ * goodix_i2c_write - write device register through i2c bus
+ * @ts_dev: pointer to goodix device data
+ * @addr: register address
+ * @data: write buffer
+ * @len: bytes to write
+ * return: 0 - write ok; < 0 - i2c transter error.
+ */
+static int goodix_i2c_write(struct goodix_ts_device *ts_dev, unsigned int reg,
+		unsigned char *data, unsigned int len)
+{
+	struct i2c_client *client = to_i2c_client(ts_dev->dev);
+	unsigned int pos = 0, transfer_length = 0;
+	unsigned int address = reg;
+	unsigned char put_buf[64];
+	int retry, r = 0;
+	struct i2c_msg msg = {
+			.addr = client->addr,
+			.flags = !I2C_M_RD,
+	};
+
+	if (likely(len + TS_ADDR_LENGTH < sizeof(put_buf))) {
+		/* code optimize,use stack memory*/
+		msg.buf = &put_buf[0];
+	} else {
+		msg.buf = kmalloc(len + TS_ADDR_LENGTH > I2C_MAX_TRANSFER_SIZE
+			? I2C_MAX_TRANSFER_SIZE : len + TS_ADDR_LENGTH, GFP_KERNEL);
+		if (!msg.buf)
+			return -ENOMEM;
+	}
+
+	while (pos != len) {
+		if (unlikely(len - pos > I2C_MAX_TRANSFER_SIZE - TS_ADDR_LENGTH))
+			transfer_length = I2C_MAX_TRANSFER_SIZE - TS_ADDR_LENGTH;
+		else
+			transfer_length = len - pos;
+
+		msg.buf[0] = (unsigned char)((address >> 8) & 0xFF);
+		msg.buf[1] = (unsigned char)(address & 0xFF);
+		msg.len = transfer_length + 2;
+		memcpy(&msg.buf[2], &data[pos], transfer_length);
+
+		for (retry = 0; retry < GOODIX_BUS_RETRY_TIMES; retry++) {
+			if (likely(i2c_transfer(client->adapter, &msg, 1) == 1)) {
+				pos += transfer_length;
+				address += transfer_length;
+				break;
+			}
+			dev_info(&client->dev, "I2c write retry[%d]\n", retry + 1);
+			msleep(20);
+		}
+		if (unlikely(retry == GOODIX_BUS_RETRY_TIMES)) {
+			dev_err(&client->dev,
+				"I2c write failed,dev:%02x,reg:%04x,size:%u",
+				client->addr, reg, len);
+			r = -EBUS;
+			goto write_exit;
+		}
+	}
+
+write_exit:
+	if (likely(len + TS_ADDR_LENGTH >= sizeof(put_buf)))
+		kfree(msg.buf);
+	return r;
+}
+
+static int goodix_read_version(struct goodix_ts_device *ts_dev,
+		struct goodix_ts_version *version)
+{
+	u8 buffer[12];
+	int r;
+
+	r = goodix_i2c_read(ts_dev, TS_REG_VERSION,
+			buffer, sizeof(buffer));
+	if (r < 0) {
+		dev_err(ts_dev->dev, "Read chip version failed\n");
+		if (version)
+			version->valid = false;
+		return r;
+	}
+
+	/* if checksum is right and first 4 bytes are not invalid value */
+	if (checksum_u8(buffer, sizeof(buffer)) == 0 &&
+			isalnum(buffer[0]) && isalnum(buffer[1]) &&
+			isalnum(buffer[2]) && isalnum(buffer[3])) {
+		if (version) {
+			memcpy(&version->pid[0], buffer, 4);
+			version->pid[4] = '\0';
+			version->cid = buffer[4];
+			/* vid = main version + minor version */
+			version->vid = get_unaligned_be16(&buffer[5]);
+			version->sensor_id = buffer[10] & 0x0F;
+			version->valid = true;
+
+			if (version->cid)
+				dev_info(ts_dev->dev,
+					"PID:%s,CID: %c,VID:%04x,SensorID:%u\n",
+					version->pid, version->cid + 'A' - 1,
+					version->vid, version->sensor_id);
+			else
+				dev_info(ts_dev->dev,
+					"PID:%s,VID:%04x,SensorID:%u\n",
+					version->pid, version->vid,
+					version->sensor_id);
+		}
+	} else {
+		dev_warn(ts_dev->dev, "Checksum error:%*ph\n",
+			(int)sizeof(buffer), buffer);
+		/* mark this version is invalid */
+		if (version)
+			version->valid = false;
+		r = -EINVAL;
+	}
+
+	return r;
+}
+
+/**
+ * goodix_send_config - send config data to device.
+ * @ts_dev: pointer to goodix device data
+ * @config: pointer to config data struct to be send
+ * @return: 0 - succeed, < 0 - failed
+ */
+static int goodix_send_config(struct goodix_ts_device *ts_dev,
+		struct goodix_ts_config *config)
+{
+	int r = 0;
+
+	if (!config || !config->data) {
+		dev_warn(ts_dev->dev, "Null config data\n");
+		return -EINVAL;
+	}
+
+	dev_dbg(ts_dev->dev, "Send %s,ver:%02xh,size:%d\n",
+		config->name, config->data[0],
+		config->length);
+
+	mutex_lock(&config->lock);
+	r = goodix_i2c_write(ts_dev, config->reg_base,
+			config->data, config->length);
+	if (r)
+		goto exit;
+
+	/* make sure the firmware accept the config data*/
+	if (config->delay)
+		msleep(config->delay);
+exit:
+	mutex_unlock(&config->lock);
+	return r;
+}
+
+static inline int goodix_cmds_init(struct goodix_ts_device *ts_dev)
+{
+	/* low power mode command */
+	ts_dev->sleep_cmd.cmd_reg = TS_REG_CMD;
+	ts_dev->sleep_cmd.length = 3;
+	ts_dev->sleep_cmd.cmds[0] = 0x05;
+	ts_dev->sleep_cmd.cmds[1] = 0x0;
+	ts_dev->sleep_cmd.cmds[2] = 0 - 0x05;
+	ts_dev->sleep_cmd.initialized = true;
+
+	return 0;
+}
+
+/**
+ * goodix_hw_init - hardware initialize
+ *   Called by touch core module when bootup
+ * @ts_dev: pointer to touch device
+ * return: 0 - no error, <0 error
+ */
+static int goodix_hw_init(struct goodix_ts_device *ts_dev)
+{
+	int r;
+
+	BUG_ON(!ts_dev);
+	goodix_cmds_init(ts_dev);
+
+	/* goodix_hw_init may be called many times */
+	if (!ts_dev->normal_cfg) {
+		ts_dev->normal_cfg = devm_kzalloc(ts_dev->dev,
+				sizeof(*ts_dev->normal_cfg), GFP_KERNEL);
+		if (!ts_dev->normal_cfg) {
+			dev_err(ts_dev->dev,
+				"Failed to alloc memory for normal cfg\n");
+			return -ENOMEM;
+		}
+	}
+
+	/* read chip version: PID/VID/sensor ID,etc.*/
+	r = goodix_read_version(ts_dev, &ts_dev->chip_version);
+	if (r < 0)
+		return r;
+
+#ifdef CONFIG_OF
+	/* parse normal-cfg from devicetree node */
+	r = goodix_parse_dt_cfg(ts_dev, "normal-cfg",
+			ts_dev->normal_cfg,
+			ts_dev->chip_version.sensor_id);
+	if (r < 0) {
+		dev_warn(ts_dev->dev, "Failed to obtain normal-cfg\n");
+		return r;
+	}
+#endif
+
+	ts_dev->normal_cfg->delay = 500;
+	/* send normal-cfg to firmware */
+	r = goodix_send_config(ts_dev, ts_dev->normal_cfg);
+
+	return r;
+}
+
+/**
+ * goodix_hw_reset - reset device
+ *
+ * @dev: pointer to touch device
+ * Returns 0 - succeed,<0 - failed
+ */
+static void goodix_hw_reset(struct goodix_ts_device *dev)
+{
+	dev_dbg(dev->dev, "HW reset\n");
+
+	if (!dev->board_data->reset_gpiod) {
+		msleep(80);
+		return;
+	}
+	gpiod_direction_output(dev->board_data->reset_gpiod, 0);
+	udelay(200);
+	gpiod_direction_output(dev->board_data->reset_gpiod, 1);
+	msleep(80);
+}
+
+/**
+ * goodix_request_handler - handle firmware request
+ *
+ * @dev: pointer to touch device
+ * @request_data: requset information
+ * Returns 0 - succeed,<0 - failed
+ */
+static int goodix_request_handler(struct goodix_ts_device *dev,
+		struct goodix_request_data *request_data) {
+	unsigned char buffer[1];
+	int r;
+
+	r = goodix_i2c_read(dev, TS_REG_REQUEST, buffer, 1);
+	if (r < 0)
+		return r;
+
+	switch (buffer[0]) {
+	case REQUEST_CONFIG:
+		dev_dbg(dev->dev, "HW request config\n");
+		goodix_send_config(dev, dev->normal_cfg);
+		goto clear_requ;
+	case REQUEST_BAKREF:
+		dev_dbg(dev->dev, "HW request bakref\n");
+		goto clear_requ;
+	case REQUEST_RESET:
+		dev_dbg(dev->dev, "HW requset reset\n");
+		goto clear_requ;
+	case REQUEST_MAINCLK:
+		dev_dbg(dev->dev, "HW request mainclk\n");
+		goto clear_requ;
+	default:
+		dev_dbg(dev->dev, "Unknown hw request:%d\n", buffer[0]);
+		return 0;
+	}
+
+clear_requ:
+	buffer[0] = 0x00;
+	r = goodix_i2c_write(dev, TS_REG_REQUEST, buffer, 1);
+	return r;
+}
+
+/**
+ * goodix_eventt_handler - handle firmware event
+ *
+ * @dev: pointer to touch device
+ * @ts_event: pointer to touch event structure
+ * Returns 0 - succeed,<0 - failed
+ */
+static int goodix_event_handler(struct goodix_ts_device *dev,
+		struct goodix_ts_event *ts_event)
+{
+#define BYTES_PER_COORD 8
+	struct goodix_touch_data *touch_data =
+			&ts_event->event_data.touch_data;
+	struct goodix_ts_coords *coords = &touch_data->coords[0];
+	int max_touch_num = dev->board_data->panel_max_id;
+	unsigned char buffer[2 + BYTES_PER_COORD * max_touch_num];
+	unsigned char coord_sta;
+	int touch_num = 0, i, r;
+	unsigned char chksum = 0;
+
+	r = goodix_i2c_read(dev, TS_REG_COORDS_BASE,
+			buffer, 3 + BYTES_PER_COORD/* * 1*/);
+	if (unlikely(r < 0))
+		return r;
+
+	/* buffer[0]: event state */
+	coord_sta = buffer[0];
+	if (unlikely(coord_sta == 0x00)) {
+		/* handle request event */
+		ts_event->event_type = EVENT_REQUEST;
+		goodix_request_handler(dev,
+				&ts_event->event_data.request_data);
+		goto exit_clean_sta;
+	} else if (unlikely((coord_sta & 0x80) != 0x80)) {
+		r = -EINVAL;
+		return r;
+	}
+
+	/* bit7 of coord_sta is 1, touch data is ready */
+	/* handle touch event */
+	touch_data->key_value = (coord_sta >> 4) & 0x01;
+	touch_num = coord_sta & 0x0F;
+	if (unlikely(touch_num > max_touch_num)) {
+		touch_num = -EINVAL;
+		goto exit_clean_sta;
+	} else if (unlikely(touch_num > 1)) {
+		r = goodix_i2c_read(dev,
+				TS_REG_COORDS_BASE + 3 + BYTES_PER_COORD,
+				&buffer[3 + BYTES_PER_COORD],
+				(touch_num - 1) * BYTES_PER_COORD);
+		if (unlikely(r < 0))
+			goto exit_clean_sta;
+	}
+
+	/* touch_num * BYTES_PER_COORD + 1(touch event state) + 1(checksum)
+	 * + 1(key value)
+	 */
+	chksum = checksum_u8(&buffer[0], touch_num * BYTES_PER_COORD + 3);
+	if (unlikely(chksum != 0)) {
+		dev_warn(dev->dev, "Checksum error:%X\n", chksum);
+		r = -EINVAL;
+		goto exit_clean_sta;
+	}
+
+	memset(touch_data->coords, 0x00, sizeof(touch_data->coords));
+	for (i = 0; i < touch_num; i++) {
+		coords->id = buffer[i * BYTES_PER_COORD + 1] & 0x0f;
+		coords->x = get_unaligned_le16(&buffer[i * BYTES_PER_COORD + 2]);
+		coords->y = get_unaligned_le16(&buffer[i * BYTES_PER_COORD + 4]);
+		coords->w = get_unaligned_le16(&buffer[i * BYTES_PER_COORD + 6]);
+
+		dev_dbg(dev->dev, "D:[%d](%d, %d)[%d]\n",
+			coords->id, coords->x, coords->y, coords->w);
+		coords++;
+	}
+
+	touch_data->touch_num = touch_num;
+	/* mark this event as touch event */
+	ts_event->event_type = EVENT_TOUCH;
+	r = 0;
+
+exit_clean_sta:
+	/* handshake */
+	buffer[0] = 0x00;
+	goodix_i2c_write(dev, TS_REG_COORDS_BASE, buffer, 1);
+	return r;
+}
+
+/**
+ * goodix_send_command - seng cmd to firmware
+ *
+ * @dev: pointer to device
+ * @cmd: pointer to command struct which cotain command data
+ * Returns 0 - succeed,<0 - failed
+ */
+int goodix_send_command(struct goodix_ts_device *dev,
+		struct goodix_ts_cmd *cmd)
+{
+	int ret;
+
+	if (!cmd || !cmd->initialized)
+		return -EINVAL;
+	ret = goodix_i2c_write(dev, cmd->cmd_reg, cmd->cmds,
+			cmd->length);
+	return ret;
+}
+
+/**
+ * goodix_hw_suspend - Let touch deivce stay in lowpower mode.
+ * @dev: pointer to goodix touch device
+ * @return: 0 - succeed, < 0 - failed
+ */
+static int goodix_hw_suspend(struct goodix_ts_device *dev)
+{
+	struct goodix_ts_cmd *sleep_cmd =
+			&dev->sleep_cmd;
+	int r = 0;
+
+	if (sleep_cmd->initialized) {
+		r = goodix_send_command(dev, sleep_cmd);
+		if (!r)
+			dev_dbg(dev->dev, "Chip in sleep mode\n");
+	} else {
+		dev_dbg(dev->dev, "Uninitialized sleep command\n");
+	}
+
+	return r;
+}
+
+/**
+ * goodix_hw_resume - Let touch deivce stay in active  mode.
+ * @dev: pointer to goodix touch device
+ * @return: 0 - succeed, < 0 - failed
+ */
+static int goodix_hw_resume(struct goodix_ts_device *dev)
+{
+	struct goodix_ts_version ver;
+	int r, retry = GOODIX_BUS_RETRY_TIMES;
+
+	for (; retry--;) {
+		goodix_hw_reset(dev);
+		r = goodix_read_version(dev, &ver);
+		if (!r)
+			break;
+	}
+
+	return r;
+}
+
+/* hardware opeation funstions */
+static const struct goodix_ts_hw_ops hw_i2c_ops = {
+	.init = goodix_hw_init,
+	.read = goodix_i2c_read,
+	.write = goodix_i2c_write,
+	.reset = goodix_hw_reset,
+	.event_handler = goodix_event_handler,
+	.send_config = goodix_send_config,
+	.send_cmd = goodix_send_command,
+	.read_version = goodix_read_version,
+	.suspend = goodix_hw_suspend,
+	.resume = goodix_hw_resume,
+};
+
+static struct platform_device *goodix_pdev;
+static void goodix_pdev_release(struct device *dev)
+{
+	kfree(goodix_pdev);
+}
+
+static int goodix_i2c_probe(struct i2c_client *client,
+	const struct i2c_device_id *dev_id)
+{
+	struct goodix_ts_device *ts_device = NULL;
+	struct goodix_ts_board_data *ts_bdata = NULL;
+	int r = 0;
+
+	r = i2c_check_functionality(client->adapter,
+		I2C_FUNC_I2C);
+	if (!r)
+		return -EIO;
+
+	/* board data */
+	ts_bdata = devm_kzalloc(&client->dev,
+			sizeof(struct goodix_ts_board_data), GFP_KERNEL);
+	if (!ts_bdata)
+		return -ENOMEM;
+
+#ifdef CONFIG_OF
+	if (IS_ENABLED(CONFIG_OF) && client->dev.of_node) {
+		/* parse devicetree property */
+		r = goodix_parse_dt(&client->dev, ts_bdata);
+		if (r < 0)
+			return r;
+	} else
+#endif
+	{
+		/* use platform data */
+		dev_info(&client->dev, "use platform data\n");
+		devm_kfree(&client->dev, ts_bdata);
+		ts_bdata = client->dev.platform_data;
+	}
+
+	if (!ts_bdata)
+		return -ENODEV;
+
+	ts_device = devm_kzalloc(&client->dev,
+		sizeof(struct goodix_ts_device), GFP_KERNEL);
+	if (!ts_device)
+		return -ENOMEM;
+
+	ts_bdata->irq = client->irq;
+	ts_device->name = "GTx5 TouchDevcie";
+	ts_device->dev = &client->dev;
+	ts_device->board_data = ts_bdata;
+	ts_device->hw_ops = &hw_i2c_ops;
+
+	/* ts core device */
+	goodix_pdev = kzalloc(sizeof(struct platform_device), GFP_KERNEL);
+	if (!goodix_pdev)
+		return -ENOMEM;
+
+	goodix_pdev->name = GOODIX_CORE_DRIVER_NAME;
+	goodix_pdev->id = 0;
+	goodix_pdev->num_resources = 0;
+	/*
+	 * you could find this platform dev in
+	 * /sys/devices/platform/goodix_ts.0
+	 * goodix_pdev->dev.parent = &client->dev;
+	 */
+	goodix_pdev->dev.platform_data = ts_device;
+	goodix_pdev->dev.release = goodix_pdev_release;
+
+	/* register platform device, then the goodix_ts_core module will probe
+	 * the touch deivce.
+	 */
+	r = platform_device_register(goodix_pdev);
+	return r;
+}
+
+static int goodix_i2c_remove(struct i2c_client *client)
+{
+	platform_device_unregister(goodix_pdev);
+	return 0;
+}
+
+#ifdef CONFIG_OF
+static const struct of_device_id gtx5_of_matchs[] = {
+	{.compatible = TS_DT_COMPATIBLE,},
+	{},
+};
+MODULE_DEVICE_TABLE(of, gtx5_of_matchs);
+#endif
+
+static const struct i2c_device_id gtx5_id_table[] = {
+	{TS_DRIVER_NAME, 0},
+	{},
+};
+MODULE_DEVICE_TABLE(i2c, gtx5_id_table);
+
+static struct i2c_driver goodix_i2c_driver = {
+	.driver = {
+		.name = TS_DRIVER_NAME,
+		.owner = THIS_MODULE,
+		.of_match_table = of_match_ptr(gtx5_of_matchs),
+	},
+	.probe = goodix_i2c_probe,
+	.remove = goodix_i2c_remove,
+	.id_table = gtx5_id_table,
+};
+
+static int __init goodix_i2c_init(void)
+{
+	return i2c_add_driver(&goodix_i2c_driver);
+}
+
+static void __exit goodix_i2c_exit(void)
+{
+	i2c_del_driver(&goodix_i2c_driver);
+}
+
+module_init(goodix_i2c_init);
+module_exit(goodix_i2c_exit);
+
+MODULE_DESCRIPTION("Goodix GTx5 Touchscreen Hardware Module");
+MODULE_AUTHOR("Goodix, Inc.");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/touchscreen/goodix-ts-sunrise/goodix_gtx5_update.c b/drivers/input/touchscreen/goodix-ts-sunrise/goodix_gtx5_update.c
new file mode 100755
index 0000000..48b6077
--- /dev/null
+++ b/drivers/input/touchscreen/goodix-ts-sunrise/goodix_gtx5_update.c
@@ -0,0 +1,1454 @@
+/*
+ * Goodix GTx5 Touchscreen Driver.
+ *
+ * Copyright (C) 2015 - 2016 Goodix, Inc.
+ * Authors:  Wang Yafei <wangyafei@goodix.com>
+ *
+ * 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"
+
+/* COMMON PART - START */
+#define TS_DEFAULT_FIRMWARE			"goodix_ts_fw.bin"
+
+#define FW_HEADER_SIZE				256
+#define FW_SUBSYS_INFO_SIZE			8
+#define FW_SUBSYS_INFO_OFFSET			32
+#define FW_SUBSYS_MAX_NUM			24
+#define FW_NAME_MAX				128
+
+#define ISP_MAX_BUFFERSIZE			(1024 * 16)
+
+#define HW_REG_CPU_EN				0x4180
+#define HW_REG_ILM_ACCESS			0x50C0
+#define HW_REG_BANK_SELECT			0x50C4
+#define HW_REG_ISP_ADDR				0x8000
+#define HW_REG_ISP_STAT				0x4195
+#define HW_REG_ISP_CMD				0x4196
+#define HW_REG_ISP_PKT_INFO			0xFFF0
+#define HW_REG_ISP_RESULT			0x4197
+#define HW_REG_ISP_BUFFER			0x8000
+#define HW_REG_BOOT_FLAG			0x434C
+#define HW_REG_BOOT_CTRL0			0xF7CC
+#define HW_REG_BOOT_CTRL1			0xF7EC
+#define HW_REG_WDT				0x40B0
+
+#define CPU_CTRL_PENDING			0x00
+#define CPU_CTRL_RUNNING			0x01
+
+#define ISP_STAT_IDLE				0xFF
+#define ISP_STAT_READY				0xAA
+#define ISP_STAT_WRITING			0xCC
+#define ISP_FLASH_ERROR				0xEE
+#define ISP_FLASH_SUCCESS			0xDD
+#define ISP_CMD_PREPARE				0x55
+#define ISP_CMD_FLASH				0xAA
+
+/**
+ * fw_subsys_info - subsytem firmware information
+ * @type: sybsystem type
+ * @size: firmware size
+ * @flash_addr: flash address
+ * @data: firmware data
+ */
+struct fw_subsys_info {
+	u8 type;
+	u32 size;
+	u32 flash_addr;
+	const u8 *data;
+};
+
+#pragma pack(1)
+/**
+ * firmware_info
+ * @size: fw total length
+ * @checksum: checksum of fw
+ * @hw_pid: mask pid string
+ * @hw_pid: mask vid code
+ * @fw_pid: fw pid string
+ * @fw_vid: fw vid code
+ * @subsys_num: number of fw subsystem
+ * @chip_type: chip type
+ * @protocol_ver: firmware packing
+ *   protocol version
+ * @subsys: sybsystem info
+ */
+struct firmware_info {
+	u32 size;
+	u16 checksum;
+	u8 hw_pid[6];
+	u8 hw_vid[3];
+	u8 fw_pid[8];
+	u8 fw_vid[3];
+	u8 subsys_num;
+	u8 chip_type;
+	u8 protocol_ver;
+	u8 reserved[3];
+	struct fw_subsys_info subsys[FW_SUBSYS_MAX_NUM];
+};
+
+/**
+ * firmware_packet - firmware packet information
+ * @packet_size: firmware packet size, max 4Kbytes.
+ * @flash_addr: device flash address
+ * @packet_checksum: checksum of the firmware in this packet
+ * @data: pointer to firmware data.
+ */
+struct firmware_packet {
+	u32 packet_size;
+	u32 flash_addr;
+	u32 packet_checksum;
+	const u8 *data;
+};
+#pragma pack()
+
+/**
+ * firmware_data - firmware data structure
+ * @fw_info: firmware infromation
+ * @firmware: firmware data structure
+ */
+struct firmware_data {
+	struct firmware_info fw_info;
+	const struct firmware *firmware;
+};
+
+enum update_status {
+	UPSTA_NOTWORK = 0,
+	UPSTA_PREPARING,
+	UPSTA_UPDATING,
+	UPSTA_ABORT,
+	UPSTA_SUCCESS,
+	UPSTA_FAILED
+};
+
+/**
+ * fw_update_ctrl - structure used to control the
+ *  firmware update process
+ * @status: update status
+ * @progress: indicate the progress of update
+ * @allow_reset: control the reset callback
+ * @allow_irq: control the irq callback
+ * @allow_suspend: control the suspend callback
+ * @allow_resume: allow resume callback
+ * @fw_data: firmware data
+ * @ts_dev: touch device
+ * @fw_name: firmware name
+ * @attr_fwimage: sysfs bin attrs, for storing fw image
+ * @fw_from_sysfs: whether the firmware image is loadind
+ *		from sysfs
+ */
+struct fw_update_ctrl {
+	enum update_status status;
+	unsigned int progress;
+	bool force_update;
+
+	bool allow_reset;
+	bool allow_irq;
+	bool allow_suspend;
+	bool allow_resume;
+
+	struct firmware_data fw_data;
+	struct goodix_ts_device *ts_dev;
+
+	char fw_name[FW_NAME_MAX];
+	struct bin_attribute attr_fwimage;
+	bool fw_from_sysfs;
+};
+
+static struct goodix_ext_module goodix_fwu_module;
+/**
+ * goodix_parse_firmware - parse firmware header information
+ *	and subsystem information from firmware data buffer
+ *
+ * @fw_data: firmware struct, contains firmware header info
+ *	and firmware data.
+ * return: 0 - OK, < 0 - error
+ */
+static int goodix_parse_firmware(struct fw_update_ctrl *fwu_ctrl)
+{
+	const struct firmware *firmware;
+	struct firmware_info *fw_info;
+	struct firmware_data *fw_data = &fwu_ctrl->fw_data;
+	const struct device *dev = fwu_ctrl->ts_dev->dev;
+	unsigned int i, fw_offset, info_offset;
+	u16 checksum;
+	int r = 0;
+
+	if (!fw_data || !fw_data->firmware) {
+		dev_err(dev, "Invalid firmware data\n");
+		return -EINVAL;
+	}
+	fw_info = &fw_data->fw_info;
+
+	/* copy firmware head info */
+	firmware = fw_data->firmware;
+	if (firmware->size < FW_SUBSYS_INFO_OFFSET) {
+		dev_err(dev, "Invalid firmware size:%zu\n", firmware->size);
+		r = -EINVAL;
+		goto err_size;
+	}
+	memcpy(fw_info, firmware->data, FW_SUBSYS_INFO_OFFSET);
+
+	/* check firmware size */
+	fw_info->size = be32_to_cpu(fw_info->size);
+	if (firmware->size != fw_info->size + 6) {
+		dev_err(dev, "Bad firmware, size not match\n");
+		r = -EINVAL;
+		goto err_size;
+	}
+
+	/* calculate checksum, note: sum of bytes, but check by u16 checksum */
+	for (i = 6, checksum = 0; i < firmware->size; i++)
+		checksum += firmware->data[i];
+
+	/* byte order change, and check */
+	fw_info->checksum = be16_to_cpu(fw_info->checksum);
+	if (checksum != fw_info->checksum) {
+		dev_err(dev, "Bad firmware, cheksum error\n");
+		r = -EINVAL;
+		goto err_size;
+	}
+
+	if (fw_info->subsys_num > FW_SUBSYS_MAX_NUM) {
+		dev_err(dev, "Bad firmware, invalid subsys num\n");
+		r = -EINVAL;
+		goto err_size;
+	}
+
+	/* parse subsystem info */
+	fw_offset = FW_HEADER_SIZE;
+	for (i = 0; i < fw_info->subsys_num; i++) {
+		info_offset = FW_SUBSYS_INFO_OFFSET +
+					i * FW_SUBSYS_INFO_SIZE;
+
+		fw_info->subsys[i].type = firmware->data[info_offset];
+		fw_info->subsys[i].size =
+			be32_to_cpup((__be32 *)&firmware->data[info_offset + 1]);
+		fw_info->subsys[i].flash_addr =
+			be16_to_cpup((__be16 *)&firmware->data[info_offset + 5]);
+		fw_info->subsys[i].flash_addr <<= 8; /* important! */
+
+		if (fw_offset > firmware->size) {
+			dev_err(dev, "Sybsys offset exceed Firmware size\n");
+			goto err_size;
+		}
+
+		fw_info->subsys[i].data = firmware->data + fw_offset;
+		fw_offset += fw_info->subsys[i].size;
+	}
+
+	dev_info(dev, "Firmware package protocol: V%u\n", fw_info->protocol_ver);
+	dev_info(dev, "Fimware PID:GT%s\n", fw_info->fw_pid);
+	dev_info(dev, "Fimware VID:%02X%02X%02X\n", fw_info->fw_vid[0],
+				fw_info->fw_vid[1], fw_info->fw_vid[2]);
+	dev_info(dev, "Firmware chip type:%02X\n", fw_info->chip_type);
+	dev_info(dev, "Firmware size:%u\n", fw_info->size);
+	dev_info(dev, "Firmware subsystem num:%u\n", fw_info->subsys_num);
+
+	for (i = 0; i < fw_info->subsys_num; i++) {
+		dev_dbg(dev, "Index:%d\n", i);
+		dev_dbg(dev, "Subsystem type:%02X\n", fw_info->subsys[i].type);
+		dev_dbg(dev, "Subsystem size:%u\n", fw_info->subsys[i].size);
+		dev_dbg(dev, "Subsystem flash_addr:%08X\n",
+			fw_info->subsys[i].flash_addr);
+		dev_dbg(dev, "Subsystem Ptr:%p\n", fw_info->subsys[i].data);
+	}
+
+err_size:
+	return r;
+}
+
+/**
+ * goodix_check_update - compare the version of firmware running in
+ *  touch device with the version getting from the firmware file.
+ * @fw_info: firmware information to be compared
+ * return: 0 firmware in the touch device needs to be updated
+ *			< 0 no need to update firmware
+ */
+static int goodix_check_update(struct goodix_ts_device *ts_dev,
+		const struct firmware_info *fw_info)
+{
+	struct goodix_ts_version fw_ver = {0};
+	const struct device *dev = ts_dev->dev;
+	u16 fwimg_vid;
+	u8 fwimg_cid;
+	int r = 0;
+
+	/* read version from chip, if we got invalid firmware version, maybe
+	 * fimware in flash is incorrect, so we need to update firmware
+	 */
+	r = ts_dev->hw_ops->read_version(ts_dev, &fw_ver);
+	if (r == -EBUS)
+		return r;
+
+	if (fw_ver.valid) {
+		if (memcmp(fw_ver.pid, fw_info->fw_pid, 4)) {
+			dev_err(dev, "Product ID is not match\n");
+			return -EPERM;
+		}
+
+		fwimg_cid = fw_info->fw_vid[0];
+		fwimg_vid = fw_info->fw_vid[1] << 8 | fw_info->fw_vid[2];
+		if (fw_ver.vid == fwimg_vid && fw_ver.cid == fwimg_cid) {
+			dev_err(dev, "FW version is equal to the IC's\n");
+			return -EPERM;
+		} else if (fw_ver.vid > fwimg_vid) {
+			dev_info(dev, "Warning: fw version is lower the IC's\n");
+		}
+	} /* else invalid firmware, update firmware */
+
+	dev_info(dev, "Firmware needs to be updated\n");
+	return 0;
+}
+
+/**
+ * goodix_reg_write_confirm - write register and confirm the value
+ *  in the register.
+ * @ts_dev: pointer to touch device
+ * @addr: register address
+ * @data: pointer to data buffer
+ * @len: data length
+ * return: 0 write success and confirm ok
+ *		   < 0 failed
+ */
+static int goodix_reg_write_confirm(struct goodix_ts_device *ts_dev,
+		unsigned int addr, unsigned char *data, unsigned int len)
+{
+	u8 *cfm, cfm_buf[32];
+	int r, i;
+
+	if (len > sizeof(cfm_buf)) {
+		cfm = kzalloc(len, GFP_KERNEL);
+		if (!cfm)
+			return -ENOMEM;
+	} else {
+		cfm = &cfm_buf[0];
+	}
+
+	for (i = 0; i < GOODIX_BUS_RETRY_TIMES; i++) {
+		r = ts_dev->hw_ops->write(ts_dev, addr, data, len);
+		if (r < 0)
+			goto exit;
+
+		r = ts_dev->hw_ops->read(ts_dev, addr, cfm, len);
+		if (r < 0)
+			goto exit;
+
+		if (memcmp(data, cfm, len)) {
+			r = -EMEMCMP;
+			continue;
+		} else {
+			r = 0;
+			break;
+		}
+	}
+
+exit:
+	if (cfm != &cfm_buf[0])
+		kfree(cfm);
+	return r;
+}
+
+static inline int goodix_reg_write(struct goodix_ts_device *ts_dev,
+		unsigned int addr, unsigned char *data, unsigned int len)
+{
+	return ts_dev->hw_ops->write(ts_dev, addr, data, len);
+}
+
+static inline int goodix_reg_read(struct goodix_ts_device *ts_dev,
+		unsigned int addr, unsigned char *data, unsigned int len)
+{
+	return ts_dev->hw_ops->read(ts_dev, addr, data, len);
+}
+
+/**
+ * goodix_cpu_ctrl - Let cpu stay in pending state or running state
+ * @ts_dev: pointer to touch device
+ * @flag: control flag, which can be:
+ *		CPU_CTRL_PENDING - Pending cpu
+ *	Other type of control to cpu is not support.
+ * return: 0 OK, < 0 Failed, -EAGAIN try again
+ */
+static int goodix_cpu_ctrl(struct goodix_ts_device *ts_dev, int flag)
+{
+	const struct device *dev = ts_dev->dev;
+	u8 ctrl;
+	int r;
+
+	if (flag == CPU_CTRL_PENDING) {
+		dev_info(dev, "Pending CPU\n");
+		ctrl = 0x04;
+	} else if (flag == CPU_CTRL_RUNNING) {
+		dev_info(dev, "Running CPU\n");
+		ctrl = 0x00;
+	} else {
+		dev_err(dev, "Invalid cpu ctrl flag\n");
+		return -EPERM;
+	}
+
+	/* Pending Cpu */
+	r = goodix_reg_write_confirm(ts_dev, HW_REG_CPU_EN, &ctrl, 1);
+	if (unlikely(r < 0)) {
+		dev_err(dev, "CPU ctrl failed:%d\n", r);
+		r = -EAGAIN; /* hw reset and try again */
+	}
+
+	return r;
+}
+
+/**
+ * goodix_isp_wait_stat - waitting ISP state
+ * @ts_dev: pointer to touch device
+ * @state: state to wait
+ * return: 0 - ok, < 0 error, -ETIMEOUT timeout
+ */
+static int goodix_isp_wait_stat(struct goodix_ts_device *ts_dev, u16 state)
+{
+	const struct device *dev = ts_dev->dev;
+	static u8 last_state;
+	u8  isp_state;
+	int i, r, err_cnt = 0;
+
+	for (i = 0; i < 200; i++) {
+		/* read isp state */
+		r = goodix_reg_read(ts_dev, HW_REG_ISP_STAT,
+					&isp_state, 1);
+		if (r < 0) {
+			dev_err(dev, "Failed to read ISP state\n");
+			if (++err_cnt > GOODIX_BUS_RETRY_TIMES)
+				return r;
+			continue;
+		}
+		err_cnt = 0;
+
+		if (isp_state != last_state) {
+			switch (isp_state) {
+			case ISP_STAT_IDLE:
+				dev_info(dev, "ISP state: Idle\n");
+				break;
+			case ISP_STAT_WRITING:
+				dev_info(dev, "ISP state: Writing...\n");
+				break;
+			case ISP_STAT_READY:
+				dev_info(dev, "ISP state: Ready to write\n");
+				break;
+			default:
+				dev_err(dev, "ISP state: Unknown\n");
+				break;
+			}
+		}
+
+		last_state = isp_state;
+		r = -ETIMEOUT;
+		if (isp_state == state) {
+			r = 0;
+			break;
+		}
+
+		usleep_range(5000, 5010);
+	}
+
+	return r;
+}
+
+/**
+ * goodix_isp_flash_done - check whether flash is successful
+ * @ts_dev: pointer to touch device
+ * return: 0 - ok, < 0 error
+ */
+static int goodix_isp_flash_done(struct goodix_ts_device *ts_dev)
+{
+	u8  isp_result;
+	int r, i;
+
+	for (i = 0; i < 2; i++) {
+		r = goodix_reg_read(ts_dev, HW_REG_ISP_RESULT,
+				&isp_result, 1);
+		if (r < 0) {
+			/* bus error */
+			break;
+		} else if (isp_result == ISP_FLASH_SUCCESS) {
+			dev_info(ts_dev->dev, "ISP result: OK!\n");
+			r = 0;
+			break;
+		} else if (isp_result == ISP_FLASH_ERROR) {
+			dev_err(ts_dev->dev, "ISP result: ERROR!\n");
+			r = -EAGAIN;
+		}
+	}
+	return r;
+}
+
+/**
+ * goodix_isp_command - communication with ISP.
+ * @cmd: ISP command.
+ * return: 0 ok, <0 error
+ */
+static int goodix_isp_command(struct goodix_ts_device *ts_dev, u8 cmd)
+{
+	switch (cmd) {
+	case ISP_CMD_PREPARE:
+		break;
+	case ISP_CMD_FLASH:
+		break;
+	default:
+		dev_err(ts_dev->dev, "Invalid ISP cmd\n");
+		return -EINVAL;
+	}
+
+	return goodix_reg_write(ts_dev, HW_REG_ISP_CMD, &cmd, 1);
+}
+
+/**
+ * goodix_load_isp - load ISP program to deivce ram
+ * @ts_dev: pointer to touch device
+ * @fw_data: firmware data
+ * return 0 ok, <0 error
+ */
+static inline int goodix_load_isp(struct goodix_ts_device *ts_dev,
+			struct firmware_data *fw_data)
+{
+	struct fw_subsys_info *fw_isp;
+	int r;
+
+	fw_isp = &fw_data->fw_info.subsys[0];
+
+	dev_info(ts_dev->dev, "Loading ISP program\n");
+	r = goodix_reg_write_confirm(ts_dev, HW_REG_ISP_ADDR,
+				(u8 *)fw_isp->data, fw_isp->size);
+	if (r < 0)
+		dev_err(ts_dev->dev, "Loading ISP error\n");
+
+	return r;
+}
+
+/**
+ * goodix_enter_update - update prepare, loading ISP program
+ *  and make sure the ISP is running.
+ * @fwu_ctrl: pointer to fimrware control structure
+ * return: 0 ok, <0 error
+ */
+static int goodix_update_prepare(struct fw_update_ctrl *fwu_ctrl)
+{
+	struct goodix_ts_device *ts_dev = fwu_ctrl->ts_dev;
+	const struct device *dev = fwu_ctrl->ts_dev->dev;
+	u8 boot_val0[4] = {0xb8, 0x3f, 0x35, 0x56};
+	u8 boot_val1[4] = {0xb9, 0x3e, 0xb5, 0x54};
+	u8 reg_val[4] = {0x00};
+	int r;
+
+	fwu_ctrl->allow_reset = true;
+	ts_dev->hw_ops->reset(ts_dev);
+	fwu_ctrl->allow_reset = false;
+
+	/* enable ILM access */
+	reg_val[0] = 0x06;
+	r = goodix_reg_write_confirm(ts_dev, HW_REG_ILM_ACCESS,
+			reg_val, 1);
+	if (r < 0) {
+		dev_err(dev, "Failed to enable ILM access\n");
+		return r;
+	}
+
+	/* Pending CPU */
+	r = goodix_cpu_ctrl(ts_dev, CPU_CTRL_PENDING);
+	if (r < 0)
+		return r;
+
+	/* disable watchdog timer */
+	reg_val[0] = 0x00;
+	r = goodix_reg_write_confirm(ts_dev, HW_REG_WDT,
+			reg_val, 1);
+	if (r < 0) {
+		dev_err(dev, "Failed to disable watchdog\n");
+		return r;
+	}
+
+	/* select bank 2 */
+	reg_val[0] = 0x02;
+	r = goodix_reg_write_confirm(ts_dev, HW_REG_BANK_SELECT,
+			reg_val, 1);
+	if (r < 0) {
+		dev_err(dev, "Failed to select bank2\n");
+		return r;
+	}
+
+	/* load ISP code */
+	r = goodix_load_isp(ts_dev, &fwu_ctrl->fw_data);
+	if (r < 0)
+		return r;
+
+	/* Clear ISP state */
+	reg_val[0] = reg_val[1] = 0x00;
+	r = goodix_reg_write_confirm(ts_dev, HW_REG_ISP_STAT,
+			reg_val, 2);
+	if (r < 0) {
+		dev_err(dev, "Failed to clear ISP state\n");
+		return r;
+	}
+
+	/* set boot flag */
+	reg_val[0] = 0;
+	r = goodix_reg_write_confirm(ts_dev, HW_REG_BOOT_FLAG,
+			reg_val, 1);
+	if (r < 0) {
+		dev_err(dev, "Failed to set boot flag\n");
+		return r;
+	}
+
+	/* set boot from sRam */
+	r = goodix_reg_write_confirm(ts_dev, HW_REG_BOOT_CTRL0,
+			boot_val0, sizeof(boot_val0));
+	if (r < 0) {
+		dev_err(dev, "Failed to set boot flag\n");
+		return r;
+	}
+
+	/* set boot from sRam */
+	r = goodix_reg_write_confirm(ts_dev, HW_REG_BOOT_CTRL1,
+			boot_val1, sizeof(boot_val1));
+	if (r < 0) {
+		dev_err(dev, "Failed to set boot flag\n");
+		return r;
+	}
+
+	/* disbale ILM access */
+	reg_val[0] = 0x00;
+	r = goodix_reg_write_confirm(ts_dev, HW_REG_ILM_ACCESS,
+			reg_val, 1);
+	if (r < 0) {
+		dev_err(dev, "Failed to disable ILM access\n");
+		return r;
+	}
+
+	/* Release CPU */
+	r = goodix_cpu_ctrl(ts_dev, CPU_CTRL_RUNNING);
+	if (r < 0)
+		return r;
+
+	/* wait isp idel */
+	r = goodix_isp_wait_stat(ts_dev, ISP_STAT_IDLE);
+	if (r < 0) {
+		dev_err(dev, "Wait ISP IDLE timeout\n");
+		return r;
+	}
+
+	return r;
+}
+
+/**
+ * goodix_write_fwdata - write firmware data to ISP buffer
+ * @ts_dev: pointer to touch device
+ * @fw_data: firmware data
+ * @size: size of data, size can not exceed ISP_MAX_BUFFERSIZE
+ *  + checksum size{2},
+ * return: 0 ok, <0 error
+ */
+static int goodix_write_fwdata(struct goodix_ts_device *ts_dev,
+			const u8 *fw_data, u32 size)
+{
+	if (!fw_data || size > ISP_MAX_BUFFERSIZE)
+		return -EINVAL;
+
+	return  goodix_reg_write(ts_dev, HW_REG_ISP_BUFFER,
+				(u8 *)fw_data, size);
+}
+
+/**
+ * goodix_format_fw_packet - formate one flash packet
+ * @pkt: target firmware packet
+ * @flash_addr: flash address
+ * @size: packet size
+ * @data: packet data
+ */
+static int goodix_format_fw_packet(struct firmware_packet *pkt,
+	u32 flash_addr, u32 size, const u8 *data)
+{
+	if (!pkt || !data || size % 4)
+		return -EINVAL;
+
+	/*
+	 * checksum rule:sum of data in one format is equal to zero
+	 * data format: byte/le16/be16/le32/be32/le64/be64
+	 */
+	pkt->flash_addr = cpu_to_le32(flash_addr);
+	pkt->packet_size = cpu_to_le32(size);
+	pkt->packet_checksum = checksum_le32((u8 *)data, size);
+	pkt->data = data;
+	return 0;
+}
+
+/**
+ * goodix_send_fw_packet - send one firmware packet to ISP
+ * @ts_dev: target touch device
+ * @pkt: firmware packet
+ * return：0 ok, <0 error
+ */
+static int goodix_send_fw_packet(struct goodix_ts_device *ts_dev,
+		struct firmware_packet *pkt)
+{
+	u8 pkt_info[12];
+	int r;
+
+	if (!pkt)
+		return -EINVAL;
+
+	/* 1: wait ISP idle */
+	r = goodix_isp_wait_stat(ts_dev, ISP_STAT_IDLE);
+	if (r < 0)
+		return r;
+
+	/* 2: write packet information */
+	memcpy(pkt_info, pkt, sizeof(pkt_info));
+	r = goodix_reg_write(ts_dev, HW_REG_ISP_PKT_INFO,
+			pkt_info, sizeof(pkt_info));
+	if (r < 0) {
+		dev_err(ts_dev->dev, "Failed to write packet info\n");
+		return r;
+	}
+
+	/* 3: Make ISP ready to flash */
+	r = goodix_isp_command(ts_dev, ISP_CMD_PREPARE);
+	if (r  < 0) {
+		dev_err(ts_dev->dev, "Failed to make ISP ready\n");
+		return r;
+	}
+
+	/* 4: write packet data(firmware block) to ISP buffer */
+	r = goodix_write_fwdata(ts_dev, pkt->data, pkt->packet_size);
+	if (r < 0) {
+		dev_err(ts_dev->dev, "Failed to write firmware packet\n");
+		return r;
+	}
+
+	/* 5: wait ISP ready */
+	r = goodix_isp_wait_stat(ts_dev, ISP_STAT_READY);
+	if (r < 0) {
+		dev_err(ts_dev->dev, "Failed to wait ISP ready\n");
+		return r;
+	}
+
+	/* 6: start writting to flash */
+	r = goodix_isp_command(ts_dev, ISP_CMD_FLASH);
+	if (r < 0) {
+		dev_err(ts_dev->dev, "Failed to start flash\n");
+		return r;
+	}
+
+	/* 7: wait idle */
+	r = goodix_isp_wait_stat(ts_dev, ISP_STAT_IDLE);
+	if (r < 0) {
+		dev_err(ts_dev->dev, "Error occurred when wait ISP idle\n");
+		return r;
+	};
+
+	/* check ISP result */
+	r = goodix_isp_flash_done(ts_dev);
+	if (r < 0) {
+		dev_err(ts_dev->dev, "Flash fw packet failed:%d\n", r);
+		return r;
+	}
+
+	return 0;
+}
+
+/**
+ * goodix_flash_subsystem - flash subsystem firmware,
+ *  Main flow of flashing firmware.
+ *	Each firmware subsystem is divided into several
+ *	packets, the max size of packet is limited to
+ *	@{ISP_MAX_BUFFERSIZE}
+ * @ts_dev: pointer to touch device
+ * @subsys: subsystem information
+ * return: 0 ok, < 0 error
+ */
+static int goodix_flash_subsystem(struct goodix_ts_device *ts_dev,
+				struct fw_subsys_info *subsys)
+{
+	struct firmware_packet fw_pkt;
+	u32 data_size, total_size, offset;
+	int r = 0;
+
+	/*
+	 * if bus(i2c/spi) error occued, then exit, we will do
+	 * hardware reset and re-prepare ISP and then retry
+	 * flashing
+	 */
+	total_size = subsys->size;
+	offset = 0;
+	while (total_size > 0) {
+		data_size = total_size > ISP_MAX_BUFFERSIZE ?
+				ISP_MAX_BUFFERSIZE : total_size;
+		dev_info(ts_dev->dev, "Flash firmware to %08x,size:%u bytes\n",
+				subsys->flash_addr + offset, data_size);
+
+		/* format one firmware packet */
+		r = goodix_format_fw_packet(&fw_pkt, subsys->flash_addr + offset,
+				data_size, &subsys->data[offset]);
+		if (r < 0) {
+			dev_err(ts_dev->dev, "Invalid packet params\n");
+			goto exit;
+		}
+
+		/* send one firmware packet */
+		r = goodix_send_fw_packet(ts_dev, &fw_pkt);
+		if (r < 0) {
+			dev_err(ts_dev->dev,
+				"Failed to send firmware packet,err:%d\n", r);
+			goto exit;
+		}
+
+		offset += data_size;
+		total_size -= data_size;
+	} /* end while */
+
+exit:
+	return r;
+}
+
+/**
+ * goodix_flash_firmware - flash firmware
+ * @ts_dev: pointer to touch device
+ * @fw_data: firmware data
+ * return: 0 ok, < 0 error
+ */
+static int goodix_flash_firmware(struct goodix_ts_device *ts_dev,
+				struct firmware_data *fw_data)
+{
+	struct fw_update_ctrl *fw_ctrl;
+	struct firmware_info  *fw_info;
+	struct fw_subsys_info *fw_x;
+	int retry = GOODIX_BUS_RETRY_TIMES;
+	int i, r = 0, fw_num, prog_step;
+
+	/* start from subsystem 1, subsystem 0 is the ISP program */
+	fw_ctrl = container_of(fw_data, struct fw_update_ctrl, fw_data);
+	fw_info = &fw_data->fw_info;
+	fw_num = fw_info->subsys_num;
+
+	/* we have 80% work here */
+	prog_step = 80 / (fw_num - 1);
+
+	for (i = 1; i < fw_num && retry;) {
+		dev_info(ts_dev->dev,
+			"--- Start to flash subsystem[%d] ---", i);
+		fw_x = &fw_info->subsys[i];
+		r = goodix_flash_subsystem(ts_dev, fw_x);
+		if (r == 0) {
+			dev_info(ts_dev->dev,
+				"--- End flash subsystem[%d]: OK ---", i);
+			fw_ctrl->progress += prog_step;
+			i++;
+		} else if (r == -EAGAIN) {
+			retry--;
+			dev_err(ts_dev->dev,
+				"--- End flash subsystem%d: Fail, errno:%d, retry:%d ---",
+				i, r, GOODIX_BUS_RETRY_TIMES - retry);
+		} else if (r < 0) { /* bus error */
+			dev_err(ts_dev->dev,
+				"--- End flash subsystem%d: Fatal error:%d exit ---",
+				i, r);
+			goto exit_flash;
+		}
+	}
+
+exit_flash:
+	return r;
+}
+
+/**
+ * goodix_update_finish - update finished, free resource
+ *  and reset flags---
+ * @fwu_ctrl: pointer to fw_update_ctrl structrue
+ * return: 0 ok, < 0 error
+ */
+static int goodix_update_finish(struct fw_update_ctrl *fwu_ctrl)
+{
+	struct goodix_ts_version ver;
+	int r = 0;
+
+	fwu_ctrl->ts_dev->hw_ops->reset(fwu_ctrl->ts_dev);
+	r = fwu_ctrl->ts_dev->hw_ops->read_version(fwu_ctrl->ts_dev, &ver);
+	return r;
+}
+
+/**
+ * goodix_fw_update_proc - firmware update process, the entry of
+ *  firmware update flow
+ * @fwu_ctrl: firmware control
+ * return: 0 ok, < 0 error
+ */
+int goodix_fw_update_proc(struct fw_update_ctrl *fwu_ctrl)
+{
+#define FW_UPDATE_RETRY	2
+	const struct device *dev = fwu_ctrl->ts_dev->dev;
+	int retry0 = FW_UPDATE_RETRY, retry1 = FW_UPDATE_RETRY;
+	int r = 0;
+
+	if (fwu_ctrl->status == UPSTA_PREPARING ||
+			fwu_ctrl->status == UPSTA_UPDATING) {
+		dev_err(dev, "Firmware update already in progress\n");
+		return -EBUSY;
+	}
+	fwu_ctrl->progress = 0;
+	fwu_ctrl->status = UPSTA_PREPARING;
+	r = goodix_parse_firmware(fwu_ctrl);
+	if (r < 0) {
+		fwu_ctrl->status = UPSTA_ABORT;
+		goto err_parse_fw;
+	}
+	fwu_ctrl->progress = 10;
+	if (fwu_ctrl->force_update == false) {
+		r = goodix_check_update(fwu_ctrl->ts_dev,
+				&fwu_ctrl->fw_data.fw_info);
+		if (r < 0) {
+			fwu_ctrl->status = UPSTA_ABORT;
+			goto err_check_update;
+		}
+	}
+start_update:
+	fwu_ctrl->progress = 20;
+	fwu_ctrl->status = UPSTA_UPDATING; /* show upgrading status */
+	r = goodix_update_prepare(fwu_ctrl);
+	if ((r == -EBUS || r == -EAGAIN) && --retry0 > 0) {
+		dev_err(dev, "Bus error, retry prepare ISP:%d\n",
+				FW_UPDATE_RETRY - retry0);
+		goto start_update;
+	} else if (r < 0) {
+		dev_err(dev, "Failed to prepare ISP, exit update:%d\n", r);
+		fwu_ctrl->status = UPSTA_FAILED;
+		goto err_fw_prepare;
+	}
+	/* progress: 20%~100% */
+	r = goodix_flash_firmware(fwu_ctrl->ts_dev, &fwu_ctrl->fw_data);
+	if ((r == -EBUS || r == -ETIMEOUT) && --retry1 > 0) {
+		/* we will retry[twice] if returns bus error[i2c/spi]
+		 * we will do hardware reset and re-prepare ISP and then retry
+		 * flashing
+		 */
+		dev_err(dev, "Bus error, retry firmware update:%d\n",
+				FW_UPDATE_RETRY - retry1);
+		goto start_update;
+	} else if (r < 0) {
+		dev_err(dev, "Fatal error, exit update:%d\n", r);
+		fwu_ctrl->status = UPSTA_FAILED;
+		goto err_fw_flash;
+	}
+	fwu_ctrl->status = UPSTA_SUCCESS;
+err_fw_flash:
+err_fw_prepare:
+	goodix_update_finish(fwu_ctrl);
+err_check_update:
+err_parse_fw:
+	if (fwu_ctrl->status == UPSTA_SUCCESS)
+		dev_info(dev, "Firmware update successfully\n");
+	else if (fwu_ctrl->status == UPSTA_FAILED)
+		dev_err(dev, "Firmware update failed\n");
+	fwu_ctrl->progress = 100; /* 100% */
+	return r;
+}
+/* COMMON PART - END */
+
+/**
+ * goodix_request_firmware - request firmware data from user space
+ *
+ * @fw_data: firmware struct, contains firmware header info
+ *	and firmware data pointer.
+ * return: 0 - OK, < 0 - error
+ */
+static int goodix_request_firmware(struct firmware_data *fw_data,
+				const char *name)
+{
+	struct fw_update_ctrl *fw_ctrl =
+		container_of(fw_data, struct fw_update_ctrl, fw_data);
+	struct device *dev = fw_ctrl->ts_dev->dev;
+	int r;
+
+	r = request_firmware(&fw_data->firmware, name, dev);
+	if (r < 0)
+		dev_err(dev,
+			"Firmware image [%s] not available,errno:%d\n", name, r);
+	else
+		dev_info(dev, "Firmware image [%s] is ready\n", name);
+	return r;
+}
+
+/**
+ * relase firmware resources
+ *
+ */
+static inline void goodix_release_firmware(struct firmware_data *fw_data)
+{
+	if (fw_data->firmware) {
+		release_firmware(fw_data->firmware);
+		fw_data->firmware = NULL;
+	}
+}
+
+static int goodix_fw_update_thread(void *data)
+{
+	struct fw_update_ctrl *fwu_ctrl = data;
+	static DEFINE_MUTEX(fwu_lock);
+	int r = -EINVAL;
+
+	if (!fwu_ctrl)
+		return r;
+
+	if (goodix_register_ext_module(&goodix_fwu_module))
+		return -EIO;
+
+	mutex_lock(&fwu_lock);
+	/* judge where to get firmware data */
+	if (!fwu_ctrl->fw_from_sysfs) {
+		r = goodix_request_firmware(&fwu_ctrl->fw_data,
+				fwu_ctrl->fw_name);
+		if (r < 0) {
+			fwu_ctrl->status = UPSTA_ABORT;
+			fwu_ctrl->progress = 100;
+			goto out;
+		}
+	} else {
+		if (!fwu_ctrl->fw_data.firmware) {
+			fwu_ctrl->status = UPSTA_ABORT;
+			fwu_ctrl->progress = 100;
+			r = -EINVAL;
+			goto out;
+		}
+	}
+
+	/* DONT allow reset/irq/suspend/resume during update */
+	fwu_ctrl->allow_irq = false;
+	fwu_ctrl->allow_suspend = false;
+	fwu_ctrl->allow_resume = false;
+	goodix_ts_blocking_notify(NOTIFY_FWUPDATE_START, NULL);
+
+	/* ready to update */
+	r = goodix_fw_update_proc(fwu_ctrl);
+
+	goodix_ts_blocking_notify(NOTIFY_FWUPDATE_END, NULL);
+	fwu_ctrl->allow_reset = true;
+	fwu_ctrl->allow_irq = true;
+	fwu_ctrl->allow_suspend = true;
+	fwu_ctrl->allow_resume = true;
+
+	/* clean */
+	if (!fwu_ctrl->fw_from_sysfs) {
+		goodix_release_firmware(&fwu_ctrl->fw_data);
+	} else {
+		fwu_ctrl->fw_from_sysfs = false;
+		vfree(fwu_ctrl->fw_data.firmware);
+		fwu_ctrl->fw_data.firmware = NULL;
+	}
+
+out:
+	goodix_unregister_ext_module(&goodix_fwu_module);
+	mutex_unlock(&fwu_lock);
+	return r;
+}
+
+/* sysfs attributes */
+static ssize_t goodix_sysfs_update_fw_store(
+		struct goodix_ext_module *module,
+		const char *buf, size_t count)
+{
+	int ret;
+
+	ret = goodix_fw_update_thread(module->priv_data);
+	if (ret)
+		count = ret;
+
+	return count;
+}
+
+static ssize_t goodix_sysfs_update_progress_show(
+		struct goodix_ext_module *module,
+		char *buf)
+{
+	struct fw_update_ctrl *fw_ctrl = module->priv_data;
+
+	return scnprintf(buf, PAGE_SIZE, "%d\n", fw_ctrl->progress);
+}
+
+static ssize_t goodix_sysfs_update_result_show(
+		struct goodix_ext_module *module,
+		char *buf)
+{
+	char *result = NULL;
+	struct fw_update_ctrl *fw_ctrl = module->priv_data;
+
+	switch (fw_ctrl->status) {
+	case UPSTA_NOTWORK:
+		result = "notwork";
+		break;
+	case UPSTA_PREPARING:
+		result = "preparing";
+		break;
+	case UPSTA_UPDATING:
+		result = "upgrading";
+		break;
+	case UPSTA_ABORT:
+		result = "abort";
+		break;
+	case UPSTA_SUCCESS:
+		result = "success";
+		break;
+	case UPSTA_FAILED:
+		result = "failed";
+		break;
+	default:
+		break;
+	}
+
+	return scnprintf(buf, PAGE_SIZE, "%s\n", result);
+}
+
+static ssize_t goodix_sysfs_update_fwversion_show(
+		struct goodix_ext_module *module,
+		char *buf)
+{
+	struct goodix_ts_version fw_ver;
+	struct fw_update_ctrl *fw_ctrl = module->priv_data;
+	int r = 0;
+	char str[5];
+
+	/* read version from chip */
+	r = fw_ctrl->ts_dev->hw_ops->read_version(fw_ctrl->ts_dev,
+			&fw_ver);
+	if (!r) {
+		memcpy(str, fw_ver.pid, 4);
+		str[4] = '\0';
+		return scnprintf(buf, PAGE_SIZE, "PID:%s VID:%04x SENSOR_ID:%d\n",
+				str, fw_ver.vid, fw_ver.sensor_id);
+	}
+	return 0;
+}
+
+static ssize_t goodix_sysfs_fwsize_show(struct goodix_ext_module *module,
+		char *buf)
+{
+	struct fw_update_ctrl *fw_ctrl = module->priv_data;
+	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 goodix_ext_module *module,
+		const char *buf, size_t count)
+{
+	struct fw_update_ctrl *fw_ctrl = module->priv_data;
+	struct firmware *fw;
+	u8 **data;
+	size_t size = 0;
+
+	if (!fw_ctrl)
+		return -EINVAL;
+
+	if (sscanf(buf, "%zu", &size) < 0 || !size) {
+		dev_err(fw_ctrl->ts_dev->dev, "Failed to get fwsize");
+		return -EFAULT;
+	}
+
+	fw = vmalloc(sizeof(*fw) + size);
+	if (!fw)
+		return -ENOMEM;
+
+	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->fw_from_sysfs = true;
+
+	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;
+	struct firmware_data *fw_data;
+
+	fw_ctrl = container_of(attr, struct fw_update_ctrl,
+			attr_fwimage);
+	fw_data = &fw_ctrl->fw_data;
+
+	if (!fw_data->firmware) {
+		dev_err(fw_ctrl->ts_dev->dev, "Need set fw image size first");
+		return -ENOMEM;
+	}
+
+	if (fw_data->firmware->size == 0) {
+		dev_err(fw_ctrl->ts_dev->dev, "Invalid firmware size");
+		return -EINVAL;
+	}
+
+	if (pos + count > fw_data->firmware->size)
+		return -EFAULT;
+
+	memcpy((u8 *)&fw_data->firmware->data[pos], buf, count);
+	fw_ctrl->force_update = true;
+
+	return count;
+}
+
+static ssize_t goodix_sysfs_force_update_store(
+		struct goodix_ext_module *module,
+		const char *buf, size_t count)
+{
+	struct fw_update_ctrl *fw_ctrl = module->priv_data;
+	int val;
+
+	if (kstrtoint(buf, 10, &val))
+		return -EINVAL;
+
+	if (val)
+		fw_ctrl->force_update = true;
+	else
+		fw_ctrl->force_update = false;
+
+	return count;
+}
+
+
+static ssize_t goodix_sysfs_update_hwversion_show(
+		struct goodix_ext_module *module,
+		char *buf)
+{
+	struct goodix_ts_version fw_ver;
+	struct fw_update_ctrl *fw_ctrl = module->priv_data;
+	int r = 0;
+	char str[5];
+
+	/* read version from chip */
+	r = fw_ctrl->ts_dev->hw_ops->read_version(fw_ctrl->ts_dev,
+			&fw_ver);
+	if (!r) {
+		memcpy(str, fw_ver.pid, 4);
+		str[4] = '\0';
+		return scnprintf(buf, PAGE_SIZE, "%s\n", str);
+	}
+	return 0;
+}
+
+static ssize_t goodix_sysfs_update_fw_version_show(
+		struct goodix_ext_module *module,
+		char *buf)
+{
+	struct goodix_ts_version fw_ver;
+	struct fw_update_ctrl *fw_ctrl = module->priv_data;
+	int r = 0;
+
+	/* read version from chip */
+	r = fw_ctrl->ts_dev->hw_ops->read_version(fw_ctrl->ts_dev,
+			&fw_ver);
+	if (!r) {
+		/* firmversion major+minor store formate is 2byte compress BCD */
+		return scnprintf(buf, PAGE_SIZE, "%2x.%2x\n",
+				fw_ver.vid >> 8, fw_ver.vid & 0xff);
+
+	}
+	return 0;
+}
+
+static ssize_t goodix_sysfs_fw_name_store(
+		struct goodix_ext_module *module,
+		const char *buf, size_t count)
+{
+	struct fw_update_ctrl *fwu_ctrl;
+
+	if (!module || !module->priv_data)
+		return -ENOMEM;
+
+	fwu_ctrl = module->priv_data;
+	if (count > FW_NAME_MAX) {
+		dev_err(fwu_ctrl->ts_dev->dev, "Firmware name too long");
+		return -EINVAL;
+	}
+	memset(fwu_ctrl->fw_name, 0, FW_NAME_MAX);
+	memcpy(fwu_ctrl->fw_name, buf, count);
+
+	return count;
+}
+
+static struct goodix_ext_attribute goodix_fwu_attrs[] = {
+	__EXTMOD_ATTR(progress, 0444, goodix_sysfs_update_progress_show, NULL),
+	__EXTMOD_ATTR(result, 0444, goodix_sysfs_update_result_show, NULL),
+	__EXTMOD_ATTR(fwversion, 0444, goodix_sysfs_update_fwversion_show, NULL),
+	__EXTMOD_ATTR(fwsize, 0644, goodix_sysfs_fwsize_show,
+			goodix_sysfs_fwsize_store),
+	__EXTMOD_ATTR(force_update, 0200, NULL, goodix_sysfs_force_update_store),
+	__EXTMOD_ATTR(update_fw, 0200, NULL, goodix_sysfs_update_fw_store),
+	__EXTMOD_ATTR(fw_version, 0444, goodix_sysfs_update_fw_version_show, NULL),
+	__EXTMOD_ATTR(fw_name, 0200, NULL, goodix_sysfs_fw_name_store),
+	__EXTMOD_ATTR(hw_version, 0444, goodix_sysfs_update_hwversion_show, NULL),
+};
+
+static int goodix_syfs_init(struct goodix_ts_core *core_data,
+		struct goodix_ext_module *module)
+{
+	struct fw_update_ctrl *fw_ctrl = module->priv_data;
+	const struct device *dev = &core_data->pdev->dev;
+	struct kobj_type *ktype;
+	int ret = 0, i;
+
+	ktype = goodix_get_default_ktype();
+	ret = kobject_init_and_add(&module->kobj,
+			ktype,
+			&core_data->pdev->dev.kobj,
+			"fwupdate");
+	if (ret) {
+		dev_err(dev, "Create fwupdate sysfs node error!\n");
+		goto exit_sysfs_init;
+	}
+
+	for (i = 0; i < ARRAY_SIZE(goodix_fwu_attrs); i++) {
+		if (sysfs_create_file(&module->kobj,
+				&goodix_fwu_attrs[i].attr)) {
+			dev_warn(dev, "Create sysfs attr file error\n");
+			kobject_put(&module->kobj);
+			ret = -EINVAL;
+			goto exit_sysfs_init;
+		}
+	}
+
+	fw_ctrl->attr_fwimage.attr.name = "fwimage";
+	fw_ctrl->attr_fwimage.attr.mode = 0200;
+	fw_ctrl->attr_fwimage.size = 0;
+	fw_ctrl->attr_fwimage.write = goodix_sysfs_fwimage_store;
+	ret = sysfs_create_bin_file(&module->kobj,
+			&fw_ctrl->attr_fwimage);
+
+exit_sysfs_init:
+	return ret;
+}
+
+static int goodix_fw_update_init(struct goodix_ts_core *core_data,
+				struct goodix_ext_module *module)
+{
+	struct goodix_ts_board_data *ts_bdata = board_data(core_data);
+	struct fw_update_ctrl *fwu_ctrl;
+	static bool init_sysfs = true;
+
+	if (!core_data->ts_dev)
+		return -ENODEV;
+
+	if (!module->priv_data) {
+		module->priv_data = kzalloc(sizeof(struct fw_update_ctrl),
+							GFP_KERNEL);
+		if (!module->priv_data)
+			return -ENOMEM;
+	}
+	fwu_ctrl = module->priv_data;
+	fwu_ctrl->ts_dev = core_data->ts_dev;
+	fwu_ctrl->allow_reset = true;
+	fwu_ctrl->allow_irq = true;
+	fwu_ctrl->allow_suspend = true;
+	fwu_ctrl->allow_resume = true;
+
+	/* find a valid firmware image name */
+	if (strlen(fwu_ctrl->fw_name) == 0) {
+		if (ts_bdata && ts_bdata->fw_name)
+			strlcpy(fwu_ctrl->fw_name, ts_bdata->fw_name,
+					sizeof(fwu_ctrl->fw_name));
+		else
+			strlcpy(fwu_ctrl->fw_name, TS_DEFAULT_FIRMWARE,
+					sizeof(fwu_ctrl->fw_name));
+	}
+
+	/* create sysfs interface */
+	if (init_sysfs) {
+		if (!goodix_syfs_init(core_data, module))
+			init_sysfs = false;
+	}
+
+	return 0;
+}
+
+static int goodix_fw_update_exit(struct goodix_ts_core *core_data,
+				struct goodix_ext_module *module)
+{
+	return 0;
+}
+
+static int goodix_fw_before_suspend(struct goodix_ts_core *core_data,
+				struct goodix_ext_module *module)
+{
+	struct fw_update_ctrl *fwu_ctrl = module->priv_data;
+
+	return fwu_ctrl->allow_suspend ?
+				EVT_HANDLED : EVT_CANCEL_SUSPEND;
+}
+
+static int goodix_fw_before_resume(struct goodix_ts_core *core_data,
+				struct goodix_ext_module *module)
+{
+	struct fw_update_ctrl *fwu_ctrl = module->priv_data;
+
+	return fwu_ctrl->allow_resume ?
+				EVT_HANDLED : EVT_CANCEL_RESUME;
+}
+
+static int goodix_fw_irq_event(struct goodix_ts_core *core_data,
+				struct goodix_ext_module *module)
+{
+	struct fw_update_ctrl *fwu_ctrl = module->priv_data;
+
+	return fwu_ctrl->allow_irq ?
+				EVT_HANDLED : EVT_CANCEL_IRQEVT;
+}
+
+static int goodix_fw_before_reset(struct goodix_ts_core *core_data,
+				struct goodix_ext_module *module)
+{
+	struct fw_update_ctrl *fwu_ctrl = module->priv_data;
+
+	return fwu_ctrl->allow_reset ?
+				EVT_HANDLED : EVT_CANCEL_RESET;
+}
+
+static const struct goodix_ext_module_funcs goodix_ext_funcs = {
+	.init = goodix_fw_update_init,
+	.exit = goodix_fw_update_exit,
+	.before_reset = goodix_fw_before_reset,
+	.after_reset = NULL,
+	.before_suspend = goodix_fw_before_suspend,
+	.after_suspend = NULL,
+	.before_resume = goodix_fw_before_resume,
+	.after_resume = NULL,
+	.irq_event = goodix_fw_irq_event,
+};
+
+static struct goodix_ext_module goodix_fwu_module = {
+	.name = "goodix-fwu",
+	.funcs = &goodix_ext_funcs,
+	.priority = EXTMOD_PRIO_FWUPDATE,
+};
+
+static int __init goodix_fwu_module_init(void)
+{
+	return goodix_register_ext_module(&goodix_fwu_module);
+}
+
+static void __exit goodix_fwu_module_exit(void)
+{
+}
+
+module_init(goodix_fwu_module_init);
+module_exit(goodix_fwu_module_exit);
+
+MODULE_DESCRIPTION("Goodix FWU Module");
+MODULE_AUTHOR("Goodix, Inc.");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_core.c b/drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_core.c
new file mode 100755
index 0000000..f562b36
--- /dev/null
+++ b/drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_core.c
@@ -0,0 +1,1366 @@
+ /*
+  * Goodix GTx5 Touchscreen Driver
+  * Core layer of touchdriver architecture.
+  *
+  * Copyright (C) 2015 - 2016 Goodix, Inc.
+  * Authors:  Wang Yafei <wangyafei@goodix.com>
+  *
+  * 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/module.h>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/of_platform.h>
+#include <linux/completion.h>
+#include <linux/debugfs.h>
+#include <linux/of_irq.h>
+#include <linux/regulator/consumer.h>
+#include <linux/input/mt.h>
+#include "goodix_ts_core.h"
+
+#define INPUT_TYPE_B_PROTOCOL
+
+#define GOOIDX_INPUT_PHYS	"goodix_ts/input0"
+#define PINCTRL_STATE_ACTIVE    "pmx_ts_active"
+#define PINCTRL_STATE_SUSPEND   "pmx_ts_suspend"
+
+/*
+ * struct goodix_modules - external modules container
+ * @head: external modules list
+ * @initilized: whether this struct is initilized
+ * @mutex: mutex lock
+ * @count: current number of registered external module
+ * @wq: workqueue to do register work
+ * @core_exit: if goodix touch core exit, then no
+ *   registration is allowed.
+ * @core_data: core_data pointer
+ */
+struct goodix_modules {
+	struct list_head head;
+	bool initilized;
+	struct mutex mutex;
+	unsigned int count;
+	struct workqueue_struct *wq;
+	bool core_exit;
+	struct completion core_comp;
+	struct goodix_ts_core *core_data;
+};
+static struct goodix_modules goodix_modules;
+
+/**
+ * __do_register_ext_module - register external module
+ * to register into touch core modules structure
+ */
+static void  __do_register_ext_module(struct work_struct *work)
+{
+	struct goodix_ext_module *module =
+			container_of(work, struct goodix_ext_module, work);
+	struct goodix_ext_module *ext_module;
+	struct list_head *insert_point = &goodix_modules.head;
+
+	/* waitting for core layer */
+	if (!wait_for_completion_timeout(&goodix_modules.core_comp, 5 * HZ))
+		return;
+
+	/* driver probe failed */
+	if (goodix_modules.core_exit)
+		return;
+
+	/* prority level *must* be set */
+	if (module->priority == EXTMOD_PRIO_RESERVED)
+		return;
+
+	mutex_lock(&goodix_modules.mutex);
+	if (!list_empty(&goodix_modules.head)) {
+		list_for_each_entry(ext_module, &goodix_modules.head, list) {
+			if (ext_module == module) {
+				mutex_unlock(&goodix_modules.mutex);
+				return;
+			}
+		}
+
+		list_for_each_entry(ext_module, &goodix_modules.head, list) {
+			/* small value of priority have higher priority level */
+			if (ext_module->priority >= module->priority) {
+				insert_point = &ext_module->list;
+				break;
+			}
+		}
+		/* else module will be inserted to goodix_modules->head */
+	}
+
+	if (module->funcs && module->funcs->init) {
+		if (module->funcs->init(goodix_modules.core_data,
+					module) < 0) {
+			mutex_unlock(&goodix_modules.mutex);
+			return;
+		}
+	}
+
+	list_add(&module->list, insert_point->prev);
+	goodix_modules.count++;
+	mutex_unlock(&goodix_modules.mutex);
+}
+
+/**
+ * goodix_register_ext_module - interface for external module
+ * to register into touch core modules structure
+ *
+ * @module: pointer to external module to be register
+ * return: 0 ok, <0 failed
+ */
+int goodix_register_ext_module(struct goodix_ext_module *module)
+{
+	if (!module)
+		return -EINVAL;
+
+	if (!goodix_modules.initilized) {
+		goodix_modules.initilized = true;
+		INIT_LIST_HEAD(&goodix_modules.head);
+		mutex_init(&goodix_modules.mutex);
+		init_completion(&goodix_modules.core_comp);
+	}
+
+	if (goodix_modules.core_exit)
+		return -EFAULT;
+
+	INIT_WORK(&module->work, __do_register_ext_module);
+	schedule_work(&module->work);
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(goodix_register_ext_module);
+
+/**
+ * goodix_unregister_ext_module - interface for external module
+ * to unregister external modules
+ *
+ * @module: pointer to external module
+ * return: 0 ok, <0 failed
+ */
+int goodix_unregister_ext_module(struct goodix_ext_module *module)
+{
+	struct goodix_ext_module *ext_module;
+	bool found = false;
+
+	if (!module)
+		return -EINVAL;
+
+	if (!goodix_modules.initilized)
+		return -EINVAL;
+
+	if (!goodix_modules.core_data)
+		return -ENODEV;
+
+	mutex_lock(&goodix_modules.mutex);
+	if (!list_empty(&goodix_modules.head)) {
+		list_for_each_entry(ext_module, &goodix_modules.head, list) {
+			if (ext_module == module) {
+				found = true;
+				break;
+			}
+		}
+	} else {
+		mutex_unlock(&goodix_modules.mutex);
+		return -EFAULT;
+	}
+
+	if (!found) {
+		mutex_unlock(&goodix_modules.mutex);
+		return -EFAULT;
+	}
+
+	list_del(&module->list);
+	mutex_unlock(&goodix_modules.mutex);
+
+	if (module->funcs && module->funcs->exit)
+		module->funcs->exit(goodix_modules.core_data, module);
+	goodix_modules.count--;
+
+	return 0;
+}
+EXPORT_SYMBOL_GPL(goodix_unregister_ext_module);
+
+static void goodix_ext_sysfs_release(struct kobject *kobj)
+{
+	return;
+}
+
+#define to_ext_module(kobj) container_of(kobj,\
+				struct goodix_ext_module, kobj)
+#define to_ext_attr(attr) container_of(attr,\
+				struct goodix_ext_attribute, attr)
+
+static ssize_t goodix_ext_sysfs_show(struct kobject *kobj,
+		struct attribute *attr, char *buf)
+{
+	struct goodix_ext_module *module = to_ext_module(kobj);
+	struct goodix_ext_attribute *ext_attr = to_ext_attr(attr);
+
+	if (ext_attr->show)
+		return ext_attr->show(module, buf);
+
+	return -EIO;
+}
+
+static ssize_t goodix_ext_sysfs_store(struct kobject *kobj,
+		struct attribute *attr, const char *buf, size_t count)
+{
+	struct goodix_ext_module *module = to_ext_module(kobj);
+	struct goodix_ext_attribute *ext_attr = to_ext_attr(attr);
+
+	if (ext_attr->store)
+		return ext_attr->store(module, buf, count);
+
+	return -EIO;
+}
+
+static const struct sysfs_ops goodix_ext_ops = {
+	.show = goodix_ext_sysfs_show,
+	.store = goodix_ext_sysfs_store
+};
+
+static struct kobj_type goodix_ext_ktype = {
+	.release = goodix_ext_sysfs_release,
+	.sysfs_ops = &goodix_ext_ops,
+};
+
+struct kobj_type *goodix_get_default_ktype(void)
+{
+	return &goodix_ext_ktype;
+}
+EXPORT_SYMBOL_GPL(goodix_get_default_ktype);
+
+struct kobject *goodix_get_default_kobj(void)
+{
+	struct kobject *kobj = NULL;
+
+	if (goodix_modules.core_data &&
+			goodix_modules.core_data->pdev)
+		kobj = &goodix_modules.core_data->pdev->dev.kobj;
+	return kobj;
+}
+EXPORT_SYMBOL_GPL(goodix_get_default_kobj);
+
+/* show external module information */
+static ssize_t goodix_ts_extmod_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct goodix_ext_module *module;
+	size_t offset = 0;
+	int r;
+
+	mutex_lock(&goodix_modules.mutex);
+	if (!list_empty(&goodix_modules.head)) {
+		list_for_each_entry(module, &goodix_modules.head, list) {
+			r = snprintf(&buf[offset], PAGE_SIZE,
+					"priority:%u module:%s\n",
+					module->priority, module->name);
+			if (r < 0) {
+				mutex_unlock(&goodix_modules.mutex);
+				return -EINVAL;
+			}
+			offset += r;
+		}
+	}
+
+	mutex_unlock(&goodix_modules.mutex);
+	return offset;
+}
+
+/* show driver information */
+static ssize_t goodix_ts_driver_info_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	return snprintf(buf, PAGE_SIZE, "DriverVersion:%s\n",
+			GOODIX_DRIVER_VERSION);
+}
+
+/* show chip infoamtion */
+static ssize_t goodix_ts_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_device *ts_dev = core_data->ts_dev;
+	struct goodix_ts_version chip_ver;
+	int r, cnt = 0;
+
+	cnt += snprintf(buf, PAGE_SIZE,
+			"TouchDeviceName:%s\n", ts_dev->name);
+	if (ts_dev->hw_ops->read_version) {
+		r = ts_dev->hw_ops->read_version(ts_dev, &chip_ver);
+		if (!r && chip_ver.valid) {
+			cnt += snprintf(&buf[cnt], PAGE_SIZE,
+					"PID:%s\nVID:%04x\nSensorID:%02x\n",
+					chip_ver.pid, chip_ver.vid,
+					chip_ver.sensor_id);
+		}
+	}
+
+	return cnt;
+}
+
+/* show chip configuration data */
+static ssize_t goodix_ts_config_data_show(struct device *dev,
+		struct device_attribute *attr, char *buf)
+{
+	struct goodix_ts_core *core_data =
+		dev_get_drvdata(dev);
+	struct goodix_ts_device *ts_dev = core_data->ts_dev;
+	struct goodix_ts_config *ncfg = ts_dev->normal_cfg;
+	u8 *data;
+	int i, r, offset = 0;
+
+	if (ncfg && ncfg->initialized && ncfg->length < PAGE_SIZE) {
+		data = kmalloc(ncfg->length, GFP_KERNEL);
+		if (!data)
+			return -ENOMEM;
+
+		r = ts_dev->hw_ops->read(ts_dev, ncfg->reg_base,
+				&data[0], ncfg->length);
+		if (r < 0) {
+			kfree(data);
+			return -EINVAL;
+		}
+
+		for (i = 0; i < ncfg->length; i++) {
+			if (i != 0 && i % 20 == 0)
+				buf[offset++] = '\n';
+			offset += snprintf(&buf[offset], PAGE_SIZE - offset,
+					"%02x ", data[i]);
+		}
+		buf[offset++] = '\n';
+		buf[offset++] = '\0';
+		kfree(data);
+		return offset;
+	}
+
+	return -EINVAL;
+}
+
+/* reset chip */
+static ssize_t goodix_ts_reset_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf,
+		size_t count)
+{
+	struct goodix_ts_core *core_data =
+		dev_get_drvdata(dev);
+	struct goodix_ts_device *ts_dev = core_data->ts_dev;
+	int en;
+
+	if (kstrtoint(buf, 10, &en))
+		return -EINVAL;
+
+	if (en != 1)
+		return -EINVAL;
+
+	if (ts_dev->hw_ops->reset)
+		ts_dev->hw_ops->reset(ts_dev);
+	return count;
+
+}
+
+/* show irq information */
+static ssize_t goodix_ts_irq_info_show(struct device *dev,
+		struct device_attribute *attr,
+		char *buf)
+{
+	struct goodix_ts_core *core_data =
+		dev_get_drvdata(dev);
+	struct irq_desc *desc;
+	size_t offset = 0;
+	int r;
+
+	r = snprintf(&buf[offset], PAGE_SIZE, "irq:%u\n",
+			core_data->irq);
+	if (r < 0)
+		return -EINVAL;
+
+	offset += r;
+	r = snprintf(&buf[offset], PAGE_SIZE - offset, "state:%s\n",
+		atomic_read(&core_data->irq_enabled) ?
+		"enabled" : "disabled");
+	if (r < 0)
+		return -EINVAL;
+
+	desc = irq_to_desc(core_data->irq);
+	offset += r;
+	r = snprintf(&buf[offset], PAGE_SIZE - offset, "disable-depth:%d\n",
+		desc->depth);
+	if (r < 0)
+		return -EINVAL;
+
+	offset += r;
+	r = snprintf(&buf[offset], PAGE_SIZE - offset, "trigger-count:%zu\n",
+		core_data->irq_trig_cnt);
+	if (r < 0)
+		return -EINVAL;
+
+	offset += r;
+	r = snprintf(&buf[offset], PAGE_SIZE - offset,
+			"echo 0/1 > irq_info to disable/enable irq");
+	if (r < 0)
+		return -EINVAL;
+
+	offset += r;
+	return offset;
+}
+
+/* enable/disable irq */
+static ssize_t goodix_ts_irq_info_store(struct device *dev,
+		struct device_attribute *attr,
+		const char *buf,
+		size_t count)
+{
+	struct goodix_ts_core *core_data =
+		dev_get_drvdata(dev);
+	int en;
+
+	if (kstrtoint(buf, 10, &en))
+		return -EINVAL;
+
+	goodix_ts_irq_enable(core_data, en);
+	return count;
+}
+
+static DEVICE_ATTR(extmod_info, 0444, goodix_ts_extmod_show, NULL);
+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(config_data, 0444, goodix_ts_config_data_show, NULL);
+static DEVICE_ATTR(reset, 0200, NULL, goodix_ts_reset_store);
+static DEVICE_ATTR(irq_info, 0644,
+		goodix_ts_irq_info_show, goodix_ts_irq_info_store);
+
+static struct attribute *sysfs_attrs[] = {
+	&dev_attr_extmod_info.attr,
+	&dev_attr_driver_info.attr,
+	&dev_attr_chip_info.attr,
+	&dev_attr_config_data.attr,
+	&dev_attr_reset.attr,
+	&dev_attr_irq_info.attr,
+	NULL,
+};
+
+static const struct attribute_group sysfs_group = {
+	.attrs = sysfs_attrs,
+};
+
+static int goodix_ts_sysfs_init(struct goodix_ts_core *core_data)
+{
+	return sysfs_create_group(&core_data->pdev->dev.kobj, &sysfs_group);
+}
+
+static void goodix_ts_sysfs_exit(struct goodix_ts_core *core_data)
+{
+	sysfs_remove_group(&core_data->pdev->dev.kobj, &sysfs_group);
+}
+
+/* event notifier */
+static BLOCKING_NOTIFIER_HEAD(ts_notifier_list);
+/**
+ * goodix_ts_register_client - register a client notifier
+ * @nb: notifier block to callback on events
+ *  see enum ts_notify_event in goodix_ts_core.h
+ */
+int goodix_ts_register_notifier(struct notifier_block *nb)
+{
+	return blocking_notifier_chain_register(&ts_notifier_list, nb);
+}
+EXPORT_SYMBOL(goodix_ts_register_notifier);
+
+/**
+ * goodix_ts_unregister_client - unregister a client notifier
+ * @nb: notifier block to callback on events
+ *	see enum ts_notify_event in goodix_ts_core.h
+ */
+int goodix_ts_unregister_notifier(struct notifier_block *nb)
+{
+	return blocking_notifier_chain_unregister(&ts_notifier_list, nb);
+}
+EXPORT_SYMBOL(goodix_ts_unregister_notifier);
+
+/**
+ * goodix_ts_blocking_notify - notify clients of certain events
+ *	see enum ts_notify_event in goodix_ts_core.h
+ */
+int goodix_ts_blocking_notify(enum ts_notify_event evt, void *v)
+{
+	return blocking_notifier_call_chain(&ts_notifier_list,
+			(unsigned long)evt, v);
+}
+EXPORT_SYMBOL_GPL(goodix_ts_blocking_notify);
+
+/**
+ * goodix_ts_input_report - report touch event to input subsystem
+ *
+ * @dev: input device pointer
+ * @touch_data: touch data pointer
+ * return: 0 ok, <0 failed
+ */
+static int goodix_ts_input_report(struct input_dev *dev,
+		struct goodix_touch_data *touch_data)
+{
+	struct goodix_ts_coords *coords = &touch_data->coords[0];
+	struct goodix_ts_core *core_data = input_get_drvdata(dev);
+	struct goodix_ts_board_data *ts_bdata = board_data(core_data);
+	unsigned int touch_num = touch_data->touch_num, x, y;
+	static u16 pre_fin;
+	int i, id;
+
+	/* report touch-key */
+	if (unlikely(touch_data->key_value)) {
+		for (i = 0; i < ts_bdata->panel_max_key; i++) {
+			input_report_key(dev, ts_bdata->panel_key_map[i],
+					touch_data->key_value & (1 << i));
+		}
+	}
+
+	/* first touch down and last touch up condition */
+	if (touch_num != 0 && pre_fin == 0x0000) {
+		/* first touch down event */
+		input_report_key(dev, BTN_TOUCH, 1);
+		input_report_key(dev, BTN_TOOL_FINGER, 1);
+	} else if (touch_num == 0 && pre_fin != 0x0000) {
+		/* no finger exist */
+		input_report_key(dev, BTN_TOUCH, 0);
+		input_report_key(dev, BTN_TOOL_FINGER, 0);
+	} else if (touch_num == 0 && pre_fin == 0x0000) {
+		return 0;
+	}
+
+	/* report abs */
+	id = coords->id;
+	for (i = 0; i < ts_bdata->panel_max_id; i++) {
+		if (touch_num && i == id) {
+			/* this is a valid touch down event */
+#ifdef INPUT_TYPE_B_PROTOCOL
+			input_mt_slot(dev, id);
+			input_mt_report_slot_state(dev, MT_TOOL_FINGER, true);
+#else
+			input_report_abs(dev, ABS_MT_TRACKING_ID, id);
+#endif
+			if (unlikely(ts_bdata->swap_axis)) {
+				x = coords->y;
+				y = coords->x;
+			} else {
+				x = coords->x;
+				y = coords->y;
+			}
+			input_report_abs(dev, ABS_MT_POSITION_X, x);
+			input_report_abs(dev, ABS_MT_POSITION_Y, y);
+			input_report_abs(dev, ABS_MT_TOUCH_MAJOR, coords->w);
+			pre_fin |= 1 << i;
+			id = (++coords)->id;
+#ifndef INPUT_TYPE_B_PROTOCOL
+			input_mt_sync(dev);
+#endif
+		} else {
+			if (pre_fin & (1 << i)) {/* release touch */
+#ifdef INPUT_TYPE_B_PROTOCOL
+				input_mt_slot(dev, i);
+				input_mt_report_slot_state(dev, MT_TOOL_FINGER,
+						false);
+#endif
+				pre_fin &= ~(1 << i);
+			}
+		}
+	}
+
+#ifndef INPUT_TYPE_B_PROTOCOL
+	if (!pre_fin)
+		input_mt_sync(dev);
+#endif
+	input_sync(dev);
+	return 0;
+}
+
+/**
+ * goodix_ts_threadirq_func - Bottom half of interrupt
+ * This functions is excuted in thread context,
+ * sleep in this function is permit.
+ *
+ * @core_data: pointer to touch core data
+ * return: 0 ok, <0 failed
+ */
+static irqreturn_t goodix_ts_threadirq_func(int irq, void *data)
+{
+	struct goodix_ts_core *core_data = data;
+	struct goodix_ts_device *ts_dev =  core_data->ts_dev;
+	struct goodix_ext_module *ext_module;
+	struct goodix_ts_event *ts_event = &core_data->ts_event;
+	int r;
+
+	core_data->irq_trig_cnt++;
+	/* inform external module */
+	list_for_each_entry(ext_module, &goodix_modules.head, list) {
+		if (!ext_module->funcs->irq_event)
+			continue;
+		r = ext_module->funcs->irq_event(core_data, ext_module);
+		if (r == EVT_CANCEL_IRQEVT)
+			return IRQ_HANDLED;
+	}
+
+	/* read touch data from touch device */
+	r = ts_dev->hw_ops->event_handler(ts_dev, ts_event);
+	if (likely(r >= 0)) {
+		if (ts_event->event_type == EVENT_TOUCH) {
+			/* report touch */
+			goodix_ts_input_report(core_data->input_dev,
+					&ts_event->event_data.touch_data);
+		}
+	}
+
+	return IRQ_HANDLED;
+}
+
+/**
+ * goodix_ts_init_irq - Requset interrupt line from system
+ * @core_data: pointer to touch core data
+ * return: 0 ok, <0 failed
+ */
+static int goodix_ts_irq_setup(struct goodix_ts_core *core_data)
+{
+	const struct goodix_ts_board_data *ts_bdata =
+			board_data(core_data);
+	const struct device *dev = &core_data->pdev->dev;
+	int r;
+
+	/* if ts_bdata->irq is invalid get it from irq-gpio */
+	if (ts_bdata->irq <= 0)
+		core_data->irq = gpiod_to_irq(ts_bdata->irq_gpiod);
+	else
+		core_data->irq = ts_bdata->irq;
+
+	dev_info(dev, "IRQ:%u,flags:%d\n", core_data->irq, (int)ts_bdata->irq_flags);
+	r = devm_request_threaded_irq(&core_data->pdev->dev,
+			core_data->irq, NULL,
+			goodix_ts_threadirq_func,
+			ts_bdata->irq_flags | IRQF_ONESHOT,
+			GOODIX_CORE_DRIVER_NAME,
+			core_data);
+	if (r < 0)
+		dev_err(dev, "Failed to requeset threaded irq:%d\n", r);
+	else
+		atomic_set(&core_data->irq_enabled, 1);
+
+	return r;
+}
+
+/**
+ * goodix_ts_irq_enable - Enable/Disable a irq
+ * @core_data: pointer to touch core data
+ * enable: enable or disable irq
+ * return: 0 ok, <0 failed
+ */
+int goodix_ts_irq_enable(struct goodix_ts_core *core_data,
+			bool enable)
+{
+	const struct device *dev = &core_data->pdev->dev;
+
+	if (enable) {
+		if (!atomic_cmpxchg(&core_data->irq_enabled, 0, 1)) {
+			enable_irq(core_data->irq);
+			dev_dbg(dev, "Irq enabled\n");
+		}
+	} else {
+		if (atomic_cmpxchg(&core_data->irq_enabled, 1, 0)) {
+			disable_irq(core_data->irq);
+			dev_dbg(dev, "Irq disabled\n");
+		}
+	}
+
+	return 0;
+}
+EXPORT_SYMBOL(goodix_ts_irq_enable);
+/**
+ * goodix_ts_power_init - Get regulator for touch device
+ * @core_data: pointer to touch core data
+ * return: 0 ok, <0 failed
+ */
+static int goodix_ts_power_init(struct goodix_ts_core *core_data)
+{
+	struct device *dev = NULL;
+	struct goodix_ts_board_data *ts_bdata;
+
+	/* dev:i2c client device or spi slave device*/
+	dev =  core_data->ts_dev->dev;
+	ts_bdata = board_data(core_data);
+
+	if (ts_bdata->avdd_name) {
+		core_data->avdd = devm_regulator_get(dev, ts_bdata->avdd_name);
+		if (IS_ERR_OR_NULL(core_data->avdd)) {
+			core_data->avdd = NULL;
+			return -ENOENT;
+		}
+	} else {
+		return -EINVAL;
+	}
+
+	return 0;
+}
+
+/**
+ * goodix_ts_power_on - Turn on power to the touch device
+ * @core_data: pointer to touch core data
+ * return: 0 ok, <0 failed
+ */
+static int goodix_ts_power_on(struct goodix_ts_core *core_data)
+{
+	struct goodix_ts_board_data *ts_bdata =
+			board_data(core_data);
+	const struct device *dev = &core_data->pdev->dev;
+	int r;
+
+	dev_info(dev, "Device power on\n");
+	if (core_data->power_on)
+		return 0;
+
+	if (core_data->avdd) {
+		r = regulator_enable(core_data->avdd);
+		if (!r) {
+			if (ts_bdata->power_on_delay_us)
+				usleep_range(ts_bdata->power_on_delay_us,
+					ts_bdata->power_on_delay_us);
+		} else {
+			dev_err(dev, "Failed to enable analog power:%d\n", r);
+			return r;
+		}
+	}
+
+	core_data->power_on = 1;
+	return 0;
+}
+
+/**
+ * goodix_ts_power_off - Turn off power to the touch device
+ * @core_data: pointer to touch core data
+ * return: 0 ok, <0 failed
+ */
+static int goodix_ts_power_off(struct goodix_ts_core *core_data)
+{
+	struct goodix_ts_board_data *ts_bdata =
+			board_data(core_data);
+	const struct device *dev = &core_data->pdev->dev;
+	int r;
+
+	dev_info(dev, "Device power off\n");
+	if (!core_data->power_on)
+		return 0;
+
+	if (core_data->avdd) {
+		r = regulator_disable(core_data->avdd);
+		if (!r) {
+			if (ts_bdata->power_off_delay_us)
+				usleep_range(ts_bdata->power_off_delay_us,
+						ts_bdata->power_off_delay_us);
+		} else {
+			dev_err(dev, "Failed to disable analog power:%d\n", r);
+			return r;
+		}
+	}
+
+	core_data->power_on = 0;
+	return 0;
+}
+
+/**
+ * goodix_ts_gpio_setup - Request gpio resources from GPIO subsysten
+ *	reset_gpio and irq_gpio number are obtained from goodix_ts_device
+ *  which created in hardware layer driver. e.g.goodix_xx_i2c.c
+ *	A goodix_ts_device should set those two fileds to right value
+ *	before registed to touch core driver.
+ * @core_data: pointer to touch core data
+ * return: 0 ok, <0 failed
+ */
+static void goodix_ts_gpio_setup(struct goodix_ts_core *core_data)
+{
+	struct goodix_ts_board_data *ts_bdata = board_data(core_data);
+	struct goodix_ts_device *ts_dev = core_data->ts_dev;
+	const struct device *dev = &core_data->pdev->dev;
+
+	ts_bdata->reset_gpiod = devm_gpiod_get_optional(ts_dev->dev,
+			"reset", GPIOD_OUT_LOW);
+	if (!ts_bdata->reset_gpiod)
+		dev_info(dev, "No reset gpio found\n");
+
+	ts_bdata->irq_gpiod = devm_gpiod_get_optional(ts_dev->dev,
+			"irq", GPIOD_IN);
+	if (!ts_bdata->irq_gpiod)
+		dev_info(dev, "No irq gpio found\n");
+
+}
+
+/**
+ * goodix_input_set_params - set input parameters
+ */
+static void goodix_ts_set_input_params(struct input_dev *input_dev,
+		struct goodix_ts_board_data *ts_bdata)
+{
+	int i;
+
+	if (ts_bdata->swap_axis)
+		swap(ts_bdata->panel_max_x, ts_bdata->panel_max_y);
+
+	input_set_abs_params(input_dev, ABS_MT_TRACKING_ID,
+			0, ts_bdata->panel_max_id, 0, 0);
+	input_set_abs_params(input_dev, ABS_MT_POSITION_X,
+			0, ts_bdata->panel_max_x, 0, 0);
+
+	input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
+			0, ts_bdata->panel_max_y, 0, 0);
+
+	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
+			0, ts_bdata->panel_max_w, 0, 0);
+	if (ts_bdata->panel_max_key) {
+		for (i = 0; i < ts_bdata->panel_max_key; i++)
+			input_set_capability(input_dev, EV_KEY,
+					ts_bdata->panel_key_map[i]);
+	}
+}
+
+/**
+ * goodix_ts_input_dev_config - Requset and config a input device
+ *  then register it to input sybsystem.
+ *  NOTE that some hardware layer may provide a input device
+ *  (ts_dev->input_dev not NULL).
+ * @core_data: pointer to touch core data
+ * return: 0 ok, <0 failed
+ */
+static int goodix_ts_input_dev_config(struct goodix_ts_core *core_data)
+{
+	struct goodix_ts_board_data *ts_bdata = board_data(core_data);
+	struct device *dev = &core_data->pdev->dev;
+	struct input_dev *input_dev = NULL;
+	int r;
+
+	input_dev = devm_input_allocate_device(dev);
+	if (!input_dev) {
+		dev_err(dev, "Failed to allocated input device\n");
+		return -ENOMEM;
+	}
+
+	core_data->input_dev = input_dev;
+	input_set_drvdata(input_dev, core_data);
+
+	input_dev->name = GOODIX_CORE_DRIVER_NAME;
+	input_dev->phys = GOOIDX_INPUT_PHYS;
+	input_dev->id.product = 0xDEAD;
+	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 input parameters */
+	goodix_ts_set_input_params(input_dev, ts_bdata);
+
+#ifdef INPUT_TYPE_B_PROTOCOL
+	input_mt_init_slots(input_dev, ts_bdata->panel_max_id,
+			INPUT_MT_DIRECT);
+#endif
+
+	input_set_capability(input_dev, EV_KEY, KEY_POWER);
+	r = input_register_device(input_dev);
+	if (r < 0) {
+		dev_err(dev, "Unable to register input device\n");
+		return r;
+	}
+
+	return 0;
+}
+
+/**
+ * goodix_ts_hw_init - Hardware initialize
+ *  poweron - hardware reset - sendconfig
+ * @core_data: pointer to touch core data
+ * return: 0 intilize ok, <0 failed
+ */
+static int goodix_ts_hw_init(struct goodix_ts_core *core_data)
+{
+	const struct goodix_ts_hw_ops *hw_ops =
+		ts_hw_ops(core_data);
+	int r;
+
+	r = goodix_ts_power_on(core_data);
+	if (r < 0)
+		goto exit;
+
+	/* reset touch device */
+	if (hw_ops->reset)
+		hw_ops->reset(core_data->ts_dev);
+
+	/* init */
+	if (hw_ops->init) {
+		r = hw_ops->init(core_data->ts_dev);
+		if (r < 0) {
+			core_data->hw_err = true;
+			goto exit;
+		}
+	}
+
+exit:
+	/* if bus communication error occurred then exit driver binding, other
+	 * errors will be ignored
+	 */
+	if (r != -EBUS)
+		r = 0;
+	return r;
+}
+
+/**
+ * goodix_ts_esd_work - check hardware status and recovery
+ *  the hardware if needed.
+ */
+static void goodix_ts_esd_work(struct work_struct *work)
+{
+	struct delayed_work *dwork = to_delayed_work(work);
+	struct goodix_ts_esd *ts_esd = container_of(dwork,
+			struct goodix_ts_esd, esd_work);
+	struct goodix_ts_core *core = container_of(ts_esd,
+			struct goodix_ts_core, ts_esd);
+	const struct goodix_ts_hw_ops *hw_ops = ts_hw_ops(core);
+	int r = 0;
+
+	if (ts_esd->esd_on == false)
+		return;
+
+	if (hw_ops->check_hw)
+		r = hw_ops->check_hw(core->ts_dev);
+	if (r < 0) {
+		goodix_ts_power_off(core);
+		goodix_ts_power_on(core);
+		if (hw_ops->reset)
+			hw_ops->reset(core->ts_dev);
+	}
+
+	mutex_lock(&ts_esd->esd_mutex);
+	if (ts_esd->esd_on)
+		schedule_delayed_work(&ts_esd->esd_work, 2 * HZ);
+	mutex_unlock(&ts_esd->esd_mutex);
+}
+
+/**
+ * goodix_ts_esd_on - turn on esd protection
+ */
+static void goodix_ts_esd_on(struct goodix_ts_core *core_data)
+{
+	struct goodix_ts_esd *ts_esd = &core_data->ts_esd;
+	const struct device *dev = &core_data->pdev->dev;
+
+	mutex_lock(&ts_esd->esd_mutex);
+	if (ts_esd->esd_on == false) {
+		ts_esd->esd_on = true;
+		schedule_delayed_work(&ts_esd->esd_work, 2 * HZ);
+		mutex_unlock(&ts_esd->esd_mutex);
+		dev_info(dev, "Esd on\n");
+		return;
+	}
+	mutex_unlock(&ts_esd->esd_mutex);
+}
+
+/**
+ * goodix_ts_esd_off - turn off esd protection
+ */
+static void goodix_ts_esd_off(struct goodix_ts_core *core_data)
+{
+	struct goodix_ts_esd *ts_esd = &core_data->ts_esd;
+	const struct device *dev = &core_data->pdev->dev;
+
+	mutex_lock(&ts_esd->esd_mutex);
+	if (ts_esd->esd_on == true) {
+		ts_esd->esd_on = false;
+		cancel_delayed_work(&ts_esd->esd_work);
+		mutex_unlock(&ts_esd->esd_mutex);
+		dev_info(dev, "Esd off\n");
+		return;
+	}
+	mutex_unlock(&ts_esd->esd_mutex);
+}
+
+/**
+ * goodix_esd_notifier_callback - notification callback
+ *  under certain condition, we need to turn off/on the esd
+ *  protector, we use kernel notify call chain to achieve this.
+ *
+ *  for example: before firmware update we need to turn off the
+ *  esd protector and after firmware update finished, we should
+ *  turn on the esd protector.
+ */
+static int goodix_esd_notifier_callback(struct notifier_block *nb,
+		unsigned long action, void *data)
+{
+	struct goodix_ts_esd *ts_esd = container_of(nb,
+			struct goodix_ts_esd, esd_notifier);
+
+	switch (action) {
+	case NOTIFY_FWUPDATE_START:
+	case NOTIFY_SUSPEND:
+		goodix_ts_esd_off(ts_esd->ts_core);
+		break;
+	case NOTIFY_FWUPDATE_END:
+	case NOTIFY_RESUME:
+		goodix_ts_esd_on(ts_esd->ts_core);
+		break;
+	}
+
+	return 0;
+}
+
+/**
+ * goodix_ts_esd_init - initialize esd protection
+ */
+static int goodix_ts_esd_init(struct goodix_ts_core *core)
+{
+	struct goodix_ts_esd *ts_esd = &core->ts_esd;
+
+	INIT_DELAYED_WORK(&ts_esd->esd_work, goodix_ts_esd_work);
+	mutex_init(&ts_esd->esd_mutex);
+	ts_esd->ts_core = core;
+	ts_esd->esd_on = false;
+	ts_esd->esd_notifier.notifier_call = goodix_esd_notifier_callback;
+	goodix_ts_register_notifier(&ts_esd->esd_notifier);
+
+	if (core->ts_dev->board_data->esd_default_on == true
+			&& core->ts_dev->hw_ops->check_hw)
+		goodix_ts_esd_on(core);
+	return 0;
+}
+
+/**
+ * goodix_ts_suspend - Touchscreen suspend function
+ */
+static int goodix_ts_suspend(struct goodix_ts_core *core_data)
+{
+	struct goodix_ext_module *ext_module;
+	struct goodix_ts_device *ts_dev = core_data->ts_dev;
+	const struct device *dev = &core_data->pdev->dev;
+	int r;
+
+	dev_dbg(dev, "Suspend start\n");
+	/*
+	 * notify suspend event, inform the esd protector
+	 * and charger detector to turn off the work
+	 */
+	goodix_ts_blocking_notify(NOTIFY_SUSPEND, NULL);
+
+	/* inform external module */
+	mutex_lock(&goodix_modules.mutex);
+	if (!list_empty(&goodix_modules.head)) {
+		list_for_each_entry(ext_module, &goodix_modules.head, list) {
+			if (!ext_module->funcs->before_suspend)
+				continue;
+
+			r = ext_module->funcs->before_suspend(core_data, ext_module);
+			if (r == EVT_CANCEL_SUSPEND) {
+				mutex_unlock(&goodix_modules.mutex);
+				dev_dbg(dev, "Canceled by module:%s\n",
+					ext_module->name);
+				goto out;
+			}
+		}
+	}
+	mutex_unlock(&goodix_modules.mutex);
+
+	/* disable irq */
+	goodix_ts_irq_enable(core_data, false);
+
+	/* let touch ic work in sleep mode */
+	if (ts_dev && ts_dev->hw_ops->suspend)
+		ts_dev->hw_ops->suspend(ts_dev);
+	atomic_set(&core_data->suspended, 1);
+
+	/* inform exteranl modules */
+	mutex_lock(&goodix_modules.mutex);
+	if (!list_empty(&goodix_modules.head)) {
+		list_for_each_entry(ext_module, &goodix_modules.head, list) {
+			if (!ext_module->funcs->after_suspend)
+				continue;
+
+			r = ext_module->funcs->after_suspend(core_data, ext_module);
+			if (r == EVT_CANCEL_SUSPEND) {
+				mutex_unlock(&goodix_modules.mutex);
+				dev_dbg(dev, "Canceled by module:%s\n",
+					ext_module->name);
+				goto out;
+			}
+		}
+	}
+	mutex_unlock(&goodix_modules.mutex);
+
+out:
+	/* release all the touch IDs */
+	core_data->ts_event.event_data.touch_data.touch_num = 0;
+	goodix_ts_input_report(core_data->input_dev,
+			&core_data->ts_event.event_data.touch_data);
+	dev_dbg(dev, "Suspend end\n");
+	return 0;
+}
+
+/**
+ * goodix_ts_resume - Touchscreen resume function
+ * Called by PM/FB/EARLYSUSPEN module to wakeup device
+ */
+static int goodix_ts_resume(struct goodix_ts_core *core_data)
+{
+	struct goodix_ext_module *ext_module;
+	struct goodix_ts_device *ts_dev = core_data->ts_dev;
+	const struct device *dev = &core_data->pdev->dev;
+	int r;
+
+	dev_dbg(dev, "Resume start\n");
+	mutex_lock(&goodix_modules.mutex);
+	if (!list_empty(&goodix_modules.head)) {
+		list_for_each_entry(ext_module, &goodix_modules.head, list) {
+			if (!ext_module->funcs->before_resume)
+				continue;
+
+			r = ext_module->funcs->before_resume(core_data, ext_module);
+			if (r == EVT_CANCEL_RESUME) {
+				mutex_unlock(&goodix_modules.mutex);
+				dev_dbg(dev, "Canceled by module:%s\n",
+					ext_module->name);
+				goto out;
+			}
+		}
+	}
+	mutex_unlock(&goodix_modules.mutex);
+
+	atomic_set(&core_data->suspended, 0);
+	/* resume device */
+	if (ts_dev && ts_dev->hw_ops->resume)
+		ts_dev->hw_ops->resume(ts_dev);
+
+	goodix_ts_irq_enable(core_data, true);
+
+	mutex_lock(&goodix_modules.mutex);
+	if (!list_empty(&goodix_modules.head)) {
+		list_for_each_entry(ext_module, &goodix_modules.head, list) {
+			if (!ext_module->funcs->after_resume)
+				continue;
+
+			r = ext_module->funcs->after_resume(core_data, ext_module);
+			if (r == EVT_CANCEL_RESUME) {
+				mutex_unlock(&goodix_modules.mutex);
+				dev_dbg(dev, "Canceled by module:%s\n",
+					ext_module->name);
+				goto out;
+			}
+		}
+	}
+	mutex_unlock(&goodix_modules.mutex);
+
+out:
+	/*
+	 * notify resume event, inform the esd protector
+	 * and charger detector to turn on the work
+	 */
+	goodix_ts_blocking_notify(NOTIFY_RESUME, NULL);
+	dev_dbg(dev, "Resume end\n");
+	return 0;
+}
+
+/**
+ * goodix_ts_pm_suspend - PM suspend function
+ * Called by kernel during system suspend phrase
+ */
+static int __maybe_unused goodix_ts_pm_suspend(struct device *dev)
+{
+	struct goodix_ts_core *core_data =
+		dev_get_drvdata(dev);
+
+	return goodix_ts_suspend(core_data);
+}
+/**
+ * goodix_ts_pm_resume - PM resume function
+ * Called by kernel during system wakeup
+ */
+static int __maybe_unused goodix_ts_pm_resume(struct device *dev)
+{
+	struct goodix_ts_core *core_data =
+		dev_get_drvdata(dev);
+
+	return goodix_ts_resume(core_data);
+}
+
+/**
+ * goodix_generic_noti_callback - generic notifier callback
+ *  for goodix touch notification event.
+ */
+static int goodix_generic_noti_callback(struct notifier_block *self,
+		unsigned long action, void *data)
+{
+	struct goodix_ts_core *ts_core = container_of(self,
+			struct goodix_ts_core, ts_notifier);
+	const struct goodix_ts_hw_ops *hw_ops = ts_hw_ops(ts_core);
+	int r;
+
+	switch (action) {
+	case NOTIFY_FWUPDATE_END:
+		if (ts_core->hw_err && hw_ops->init) {
+			/* Firmware has been updated, we need to reinit
+			 * the chip, read the sensor ID and send the
+			 * correct config data based on sensor ID.
+			 * The input parameters also needs to be updated.
+			 */
+			r = hw_ops->init(ts_core->ts_dev);
+			if (r < 0)
+				goto exit;
+
+			goodix_ts_set_input_params(ts_core->input_dev,
+					ts_core->ts_dev->board_data);
+			ts_core->hw_err = false;
+		}
+		break;
+	}
+
+exit:
+	return 0;
+}
+
+/**
+ * goodix_ts_probe - called by kernel when a Goodix touch
+ *  platform driver is added.
+ */
+static int goodix_ts_probe(struct platform_device *pdev)
+{
+	struct goodix_ts_core *core_data = NULL;
+	struct goodix_ts_device *ts_device;
+	int r;
+
+	ts_device = pdev->dev.platform_data;
+	if (!ts_device || !ts_device->hw_ops || !ts_device->board_data) {
+		dev_err(&pdev->dev, "Invalid touch device\n");
+		return -ENODEV;
+	}
+
+	core_data = devm_kzalloc(&pdev->dev, sizeof(struct goodix_ts_core),
+						GFP_KERNEL);
+	if (!core_data)
+		return -ENOMEM;
+
+	/* touch core layer is a platform driver */
+	core_data->pdev = pdev;
+	core_data->ts_dev = ts_device;
+	platform_set_drvdata(pdev, core_data);
+
+	r = goodix_ts_power_init(core_data);
+	if (r < 0)
+		dev_err(&pdev->dev, "Failed power init\n");
+
+	/* get GPIO resource if have */
+	goodix_ts_gpio_setup(core_data);
+
+	/* initialize firmware */
+	r = goodix_ts_hw_init(core_data);
+	if (r < 0)
+		goto out;
+
+	/* alloc/config/register input device */
+	r = goodix_ts_input_dev_config(core_data);
+	if (r < 0)
+		goto out;
+
+	/* request irq line */
+	r = goodix_ts_irq_setup(core_data);
+	if (r < 0)
+		goto out;
+
+	/* inform the external module manager that
+	 * touch core layer is ready now
+	 */
+	goodix_modules.core_data = core_data;
+	complete_all(&goodix_modules.core_comp);
+
+	/* create sysfs files */
+	goodix_ts_sysfs_init(core_data);
+
+	/* esd protector */
+	goodix_ts_esd_init(core_data);
+
+	/* generic notifier callback */
+	core_data->ts_notifier.notifier_call = goodix_generic_noti_callback;
+	goodix_ts_register_notifier(&core_data->ts_notifier);
+
+	return 0;
+	/* we use resource managed api(devm_), no need to free resource */
+out:
+	goodix_modules.core_exit = true;
+	complete_all(&goodix_modules.core_comp);
+	dev_err(&pdev->dev, "Core layer probe failed");
+	return r;
+}
+
+static int goodix_ts_remove(struct platform_device *pdev)
+{
+	struct goodix_ts_core *core_data =
+		platform_get_drvdata(pdev);
+
+	goodix_ts_power_off(core_data);
+	goodix_ts_sysfs_exit(core_data);
+	return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(dev_pm_ops, goodix_ts_pm_suspend, goodix_ts_pm_resume);
+
+static const struct platform_device_id ts_core_ids[] = {
+	{.name = GOODIX_CORE_DRIVER_NAME},
+	{}
+};
+MODULE_DEVICE_TABLE(platform, ts_core_ids);
+
+static struct platform_driver goodix_ts_driver = {
+	.driver = {
+		.name = GOODIX_CORE_DRIVER_NAME,
+		.owner = THIS_MODULE,
+		.pm = &dev_pm_ops,
+	},
+	.probe = goodix_ts_probe,
+	.remove = goodix_ts_remove,
+	.id_table = ts_core_ids,
+};
+
+static int __init goodix_ts_core_init(void)
+{
+	if (!goodix_modules.initilized) {
+		goodix_modules.initilized = true;
+		INIT_LIST_HEAD(&goodix_modules.head);
+		mutex_init(&goodix_modules.mutex);
+		init_completion(&goodix_modules.core_comp);
+	}
+
+	return platform_driver_register(&goodix_ts_driver);
+}
+
+
+static void __exit goodix_ts_core_exit(void)
+{
+	platform_driver_unregister(&goodix_ts_driver);
+}
+
+module_init(goodix_ts_core_init);
+module_exit(goodix_ts_core_exit);
+
+MODULE_DESCRIPTION("Goodix Touchscreen Core Module");
+MODULE_AUTHOR("Goodix, Inc.");
+MODULE_LICENSE("GPL v2");
diff --git a/drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_core.h b/drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_core.h
new file mode 100755
index 0000000..400746e
--- /dev/null
+++ b/drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_core.h
@@ -0,0 +1,553 @@
+/*
+ * Goodix GTx5 Touchscreen Driver
+ * Core layer of touchdriver architecture.
+ *
+ * Copyright (C) 2015 - 2016 Goodix, Inc.
+ * Authors:  Wang Yafei <wangyafei@goodix.com>
+ *
+ * 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>
+#include <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/firmware.h>
+#include <linux/slab.h>
+#include <linux/vmalloc.h>
+#include <linux/kthread.h>
+#include <linux/version.h>
+#include <linux/delay.h>
+#include <linux/mutex.h>
+#include <linux/platform_device.h>
+#include <linux/input.h>
+#include <asm/unaligned.h>
+#ifdef CONFIG_OF
+#include <linux/of_gpio.h>
+#include <linux/regulator/consumer.h>
+#endif
+
+#include <linux/gpio/consumer.h>
+
+/* macros definition */
+#define GOODIX_CORE_DRIVER_NAME	"goodix_ts"
+#define GOODIX_DRIVER_VERSION	"v0.8"
+#define GOODIX_BUS_RETRY_TIMES	3
+#define GOODIX_MAX_TOUCH	10
+#define GOODIX_MAX_KEY		3
+#define GOODIX_CFG_MAX_SIZE	1024
+
+/*
+ * struct goodix_ts_board_data -  board data
+ * @avdd_name: name of analoy regulator
+ * @reset_gpio: reset gpio number
+ * @irq_gpio: interrupt gpio number
+ * @irq_flag: irq trigger type
+ * @power_on_delay_us: power on delay time (us)
+ * @power_off_delay_us: power off delay time (us)
+ * @swap_axis: whether swaw x y axis
+ * @panel_max_id: max supported fingers
+ * @panel_max_x/y/w/p: resolution and size
+ * @panel_max_key: max supported keys
+ * @pannel_key_map: key map
+ * @fw_name: name of the firmware image
+ */
+struct goodix_ts_board_data {
+	const char *avdd_name;
+	struct gpio_desc *reset_gpiod;
+	struct gpio_desc *irq_gpiod;
+	int irq;
+	unsigned int  irq_flags;
+
+	unsigned int power_on_delay_us;
+	unsigned int power_off_delay_us;
+
+	unsigned int swap_axis;
+	unsigned int panel_max_id; /*max touch id*/
+	unsigned int panel_max_x;
+	unsigned int panel_max_y;
+	unsigned int panel_max_w; /*major and minor*/
+	unsigned int panel_max_key;
+	unsigned int panel_key_map[GOODIX_MAX_KEY];
+
+	const char *fw_name;
+	bool esd_default_on;
+};
+
+/*
+ * struct goodix_ts_config - chip config data
+ * @initialized: whether intialized
+ * @name: name of this config
+ * @lock: mutex
+ * @reg_base: register base of config data
+ * @length: bytes of the config
+ * @delay: delay time after sending config
+ * @data: config data buffer
+ */
+struct goodix_ts_config {
+	bool initialized;
+	char name[24];
+	struct mutex lock;
+	unsigned int reg_base;
+	unsigned int length;
+	unsigned int delay; /*ms*/
+	unsigned char data[GOODIX_CFG_MAX_SIZE];
+};
+
+/*
+ * struct goodix_ts_cmd - command package
+ * @initialized: whether initialized
+ * @cmd_reg: command register
+ * @length: command length in bytes
+ * @cmds: command data
+ */
+#pragma pack(4)
+struct goodix_ts_cmd {
+	u32 initialized;
+	u32 cmd_reg;
+	u32 length;
+	u8 cmds[3];
+};
+#pragma pack()
+
+/* interrupt event type */
+enum ts_event_type {
+	EVENT_INVALID,
+	EVENT_TOUCH,
+	EVENT_REQUEST,
+};
+
+/* requset event type */
+enum ts_request_type {
+	REQUEST_INVALID,
+	REQUEST_CONFIG,
+	REQUEST_BAKREF,
+	REQUEST_RESET,
+	REQUEST_MAINCLK,
+};
+
+/* notifier event */
+
+enum ts_notify_event {
+	NOTIFY_FWUPDATE_START,
+	NOTIFY_FWUPDATE_END,
+	NOTIFY_SUSPEND,
+	NOTIFY_RESUME,
+};
+
+/* coordinate package */
+struct goodix_ts_coords {
+	int id;
+	unsigned int x, y, w, p;
+};
+
+/* touch event data */
+struct goodix_touch_data {
+	/* finger */
+	int touch_num;
+	struct goodix_ts_coords coords[GOODIX_MAX_TOUCH];
+	/* key */
+	u16 key_value;
+};
+
+/* request event data */
+struct goodix_request_data {
+	enum ts_request_type request_type;
+};
+
+/*
+ * struct goodix_ts_event - touch event struct
+ * @event_type: touch event type, touch data or
+ *	request event
+ * @event_data: event data
+ */
+struct goodix_ts_event {
+	enum ts_event_type event_type;
+	union {
+		struct goodix_touch_data touch_data;
+		struct goodix_request_data request_data;
+	} event_data;
+};
+
+/*
+ * struct goodix_ts_version - firmware version
+ * @valid: whether these infomation is valid
+ * @pid: product id string
+ * @vid: firmware version code
+ * @cid: customer id code
+ * @sensor_id: sendor id
+ */
+struct goodix_ts_version {
+	bool valid;
+	char pid[5];
+	u16 vid;
+	u8 cid;
+	u8 sensor_id;
+};
+
+/*
+ * struct goodix_ts_device - ts device data
+ * @name: device name
+ * @version: reserved
+ * @bus_type: i2c or spi
+ * @board_data: board data obtained from dts
+ * @normal_cfg: normal config data
+ * @highsense_cfg: high sense config data
+ * @hw_ops: hardware operations
+ * @chip_version: firmware version infomation
+ * @sleep_cmd: sleep commang
+ * @gesture_cmd: gesture command
+ * @dev: device pointer,may be a i2c or spi device
+ * @of_node: device node
+ */
+struct goodix_ts_device {
+	char *name;
+	int version;
+	int bus_type;
+
+	struct goodix_ts_board_data *board_data;
+	struct goodix_ts_config *normal_cfg;
+	struct goodix_ts_config *highsense_cfg;
+	const struct goodix_ts_hw_ops *hw_ops;
+
+	struct goodix_ts_version chip_version;
+	struct goodix_ts_cmd sleep_cmd;
+	struct goodix_ts_cmd gesture_cmd;
+
+	struct device *dev;
+};
+
+/*
+ * struct goodix_ts_hw_ops -  hardware opeartions
+ * @init: hardware initialization
+ * @reset: hardware reset
+ * @read: read data from touch device
+ * @write: write data to touch device
+ * @send_cmd: send command to touch device
+ * @send_config: send configuration data
+ * @read_version: read firmware version
+ * @event_handler: touch event handler
+ * @suspend: put touch device into low power mode
+ * @resume: put touch device into working mode
+ */
+struct goodix_ts_hw_ops {
+
+	int (*init)(struct goodix_ts_device *dev);
+	void (*reset)(struct goodix_ts_device *dev);
+	int (*read)(struct goodix_ts_device *dev, unsigned int addr,
+			 unsigned char *data, unsigned int len);
+	int (*write)(struct goodix_ts_device *dev, unsigned int addr,
+			unsigned char *data, unsigned int len);
+	int (*send_cmd)(struct goodix_ts_device *dev,
+			struct goodix_ts_cmd  *cmd);
+	int (*send_config)(struct goodix_ts_device *dev,
+			struct goodix_ts_config *config);
+	int (*read_version)(struct goodix_ts_device *dev,
+			struct goodix_ts_version *version);
+	int (*event_handler)(struct goodix_ts_device *dev,
+			struct goodix_ts_event *ts_event);
+	int (*check_hw)(struct goodix_ts_device *dev);
+	int (*suspend)(struct goodix_ts_device *dev);
+	int (*resume)(struct goodix_ts_device *dev);
+};
+
+/*
+ * struct goodix_ts_esd - esd protector structure
+ * @esd_work: esd delayed work
+ * @esd_on: true - turn on esd protection, false - turn
+ *  off esd protection
+ * @esd_mutex: protect @esd_on flag
+ */
+struct goodix_ts_esd {
+	struct delayed_work esd_work;
+	struct mutex esd_mutex;
+	struct notifier_block esd_notifier;
+	struct goodix_ts_core *ts_core;
+	bool esd_on;
+};
+
+/*
+ * struct godix_ts_core - core layer data struct
+ * @pdev: core layer platform device
+ * @ts_dev: hardware layer touch device
+ * @input_dev: input device
+ * @avdd: analog regulator
+ * @pinctrl: pinctrl handler
+ * @pin_sta_active: active/normal pin state
+ * @pin_sta_suspend: suspend/sleep pin state
+ * @ts_event: touch event data struct
+ * @power_on: power on/off flag
+ * @irq: irq number
+ * @irq_enabled: irq enabled/disabled flag
+ * @suspended: suspend/resume flag
+ * @hw_err: indicate that hw_ops->init() failed
+ * @ts_notifier: generic notifier
+ * @ts_esd: esd protector structure
+ * @fb_notifier: framebuffer notifier
+ * @early_suspend: early suspend
+ */
+struct goodix_ts_core {
+	struct platform_device *pdev;
+	struct goodix_ts_device *ts_dev;
+	struct input_dev *input_dev;
+
+	struct regulator *avdd;
+	struct goodix_ts_event ts_event;
+	int power_on;
+	int irq;
+	size_t irq_trig_cnt;
+
+	atomic_t irq_enabled;
+	atomic_t suspended;
+	bool hw_err;
+
+	struct notifier_block ts_notifier;
+	struct goodix_ts_esd ts_esd;
+
+#ifdef CONFIG_FB
+	struct notifier_block fb_notifier;
+#endif
+};
+
+/* external module structures */
+enum goodix_ext_priority {
+	EXTMOD_PRIO_RESERVED = 0,
+	EXTMOD_PRIO_FWUPDATE,
+	EXTMOD_PRIO_GESTURE,
+	EXTMOD_PRIO_HOTKNOT,
+	EXTMOD_PRIO_DBGTOOL,
+	EXTMOD_PRIO_DEFAULT,
+};
+
+struct goodix_ext_module;
+/* external module's operations callback */
+struct goodix_ext_module_funcs {
+	int (*init)(struct goodix_ts_core *core_data,
+			struct goodix_ext_module *module);
+	int (*exit)(struct goodix_ts_core *core_data,
+			struct goodix_ext_module *module);
+
+	int (*before_reset)(struct goodix_ts_core *core_data,
+			struct goodix_ext_module *module);
+	int (*after_reset)(struct goodix_ts_core *core_data,
+			struct goodix_ext_module *module);
+
+	int (*before_suspend)(struct goodix_ts_core *core_data,
+			struct goodix_ext_module *module);
+	int (*after_suspend)(struct goodix_ts_core *core_data,
+			struct goodix_ext_module *module);
+
+	int (*before_resume)(struct goodix_ts_core *core_data,
+			struct goodix_ext_module *module);
+	int (*after_resume)(struct goodix_ts_core *core_data,
+			struct goodix_ext_module *module);
+
+	int (*irq_event)(struct goodix_ts_core *core_data,
+			struct goodix_ext_module *module);
+};
+
+/*
+ * struct goodix_ext_module - external module struct
+ * @list: list used to link into modules manager
+ * @name: name of external module
+ * @priority: module priority vlaue, zero is invalid
+ * @funcs: operations callback
+ * @priv_data: private data region
+ * @kobj: kobject
+ * @work: used to queue one work to do registration
+ */
+struct goodix_ext_module {
+	struct list_head list;
+	char *name;
+	enum goodix_ext_priority priority;
+	const struct goodix_ext_module_funcs *funcs;
+	void *priv_data;
+	struct kobject kobj;
+	struct work_struct work;
+};
+
+/*
+ * struct goodix_ext_attribute - exteranl attribute struct
+ * @attr: attribute
+ * @show: show interface of external attribute
+ * @store: store interface of external attribute
+ */
+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);
+};
+
+/* external attrs helper macro */
+#define __EXTMOD_ATTR(_name, _mode, _show, _store)	{	\
+	.attr = {.name = __stringify(_name), .mode = _mode },	\
+	.show   = _show,	\
+	.store  = _store,	\
+}
+
+/* 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)
+
+/*
+ * get board data pointer
+ */
+static inline struct goodix_ts_board_data *board_data(
+		struct goodix_ts_core *core)
+{
+	return core->ts_dev->board_data;
+}
+
+/*
+ * get touch hardware operations pointer
+ */
+static inline const struct goodix_ts_hw_ops *ts_hw_ops(
+		struct goodix_ts_core *core)
+{
+	return core->ts_dev->hw_ops;
+}
+
+/*
+ * checksum helper functions
+ * checksum can be u8/le16/be16/le32/be32 format
+ * NOTE: the caller shoule be responsible for the
+ * legality of @data and @size parameters, so be
+ * careful when call these functions.
+ */
+static inline u8 checksum_u8(u8 *data, u32 size)
+{
+	u8 checksum = 0;
+	u32 i;
+
+	for (i = 0; i < size; i++)
+		checksum += data[i];
+	return checksum;
+}
+
+static inline u16 checksum_le16(u8 *data, u32 size)
+{
+	u16 checksum = 0;
+	u32 i;
+
+	for (i = 0; i < size; i += 2)
+		checksum += le16_to_cpup((__le16 *)(data + i));
+	return checksum;
+}
+
+static inline u16 checksum_be16(u8 *data, u32 size)
+{
+	u16 checksum = 0;
+	u32 i;
+
+	for (i = 0; i < size; i += 2)
+		checksum += be16_to_cpup((__be16 *)(data + i));
+	return checksum;
+}
+
+static inline u32 checksum_le32(u8 *data, u32 size)
+{
+	u32 checksum = 0;
+	u32 i;
+
+	for (i = 0; i < size; i += 4)
+		checksum += le32_to_cpup((__le32 *)(data + i));
+	return checksum;
+}
+
+static inline u32 checksum_be32(u8 *data, u32 size)
+{
+	u32 checksum = 0;
+	u32 i;
+
+	for (i = 0; i < size; i += 4)
+		checksum += be32_to_cpup((__be32 *)(data + i));
+	return checksum;
+}
+
+/*
+ * define event action
+ * EVT_xxx macros are used in opeartions callback
+ * defined in @goodix_ext_module_funcs to control
+ * the behaviors of event such as suspend/resume/
+ * irq_event.
+ *
+ * generally there are two types of behaviors:
+ *	1. you want the flow of this event be canceled,
+ *	in this condition, you should return EVT_CANCEL_XXX
+ *	in the operations callback.
+ *		e.g. the firmware update module is updating
+ *		the firmware, you want to cancel suspend flow,
+ *		so you need to return EVT_CANCEL_SUSPEND in
+ *		suspend callback function.
+ *	2. you want the flow of this event continue, in
+ *	this condition, you should return EVT_HANDLED in
+ *	the callback function.
+ */
+#define EVT_HANDLED			0
+#define EVT_CONTINUE			0
+#define EVT_CANCEL			1
+#define EVT_CANCEL_IRQEVT		1
+#define EVT_CANCEL_SUSPEND		1
+#define EVT_CANCEL_RESUME		1
+#define EVT_CANCEL_RESET		1
+
+/*
+ * errno define
+ * Note:
+ *	1. bus read/write functions defined in hardware
+ *	  layer code(e.g. goodix_xxx_i2c.c) *must* return
+ *	  -EBUS if failed to transfer data on bus.
+ */
+#define EBUS					1000
+#define ETIMEOUT				1001
+#define ECHKSUM					1002
+#define EMEMCMP					1003
+
+/**
+ * goodix_register_ext_module - interface for external module
+ * to register into touch core modules structure
+ *
+ * @module: pointer to external module to be register
+ * return: 0 ok, <0 failed
+ */
+int goodix_register_ext_module(struct goodix_ext_module *module);
+
+/**
+ * goodix_unregister_ext_module - interface for external module
+ * to unregister external modules
+ *
+ * @module: pointer to external module
+ * return: 0 ok, <0 failed
+ */
+int goodix_unregister_ext_module(struct goodix_ext_module *module);
+
+/**
+ * goodix_ts_irq_enable - Enable/Disable a irq
+
+ * @core_data: pointer to touch core data
+ * enable: enable or disable irq
+ * return: 0 ok, <0 failed
+ */
+int goodix_ts_irq_enable(struct goodix_ts_core *core_data, bool enable);
+
+struct kobj_type *goodix_get_default_ktype(void);
+
+/**
+ * goodix_ts_blocking_notify - notify clients of certain events
+ *	see enum ts_notify_event in goodix_ts_core.h
+ */
+int goodix_ts_blocking_notify(enum ts_notify_event evt, void *v);
+
+#endif
diff --git a/drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_tools.c b/drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_tools.c
new file mode 100755
index 0000000..b0dd121
--- /dev/null
+++ b/drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_tools.c
@@ -0,0 +1,542 @@
+/*
+ * Goodix GTx5 Touchscreen Dirver
+ *
+ * Copyright (C) 2015 - 2016 Goodix, Inc.
+ * Authors:  Wang Yafei <wangyafei@goodix.com>
+ *
+ * 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/module.h>
+#include <linux/compat.h>
+#include <linux/kernel.h>
+#include <linux/atomic.h>
+#include <linux/miscdevice.h>
+#include <linux/slab.h>
+#include <linux/uaccess.h>
+#include <linux/fs.h>
+#include <linux/list.h>
+#include <linux/ioctl.h>
+#include <linux/wait.h>
+#include "goodix_ts_core.h"
+
+#define GOODIX_TOOLS_NAME		"gtp_tools"
+#define GOODIX_TS_IOC_MAGIC		'G'
+#define NEGLECT_SIZE_MASK		(~(_IOC_SIZEMASK << _IOC_SIZESHIFT))
+
+#define GTP_IRQ_ENABLE	_IO(GOODIX_TS_IOC_MAGIC, 0)
+#define GTP_DEV_RESET	_IO(GOODIX_TS_IOC_MAGIC, 1)
+#define GTP_SEND_COMMAND (_IOW(GOODIX_TS_IOC_MAGIC, 2, u8) & NEGLECT_SIZE_MASK)
+#define GTP_SEND_CONFIG	(_IOW(GOODIX_TS_IOC_MAGIC, 3, u8) & NEGLECT_SIZE_MASK)
+#define GTP_ASYNC_READ	(_IOR(GOODIX_TS_IOC_MAGIC, 4, u8) & NEGLECT_SIZE_MASK)
+#define GTP_SYNC_READ	(_IOR(GOODIX_TS_IOC_MAGIC, 5, u8) & NEGLECT_SIZE_MASK)
+#define GTP_ASYNC_WRITE	(_IOW(GOODIX_TS_IOC_MAGIC, 6, u8) & NEGLECT_SIZE_MASK)
+
+#define GOODIX_TS_IOC_MAXNR		6
+
+#define IRQ_FALG	(0x01 << 2)
+
+#define I2C_MSG_HEAD_LEN	20
+#define MAX_DATA_LEN	4096
+#define TS_REG_COORDS_BASE	0x824E
+/*
+ * struct goodix_tools_data - goodix tools data message used in sync read
+ * @data: The buffer into which data is written
+ * @reg_addr: Slave device register start address to start read data
+ * @length: Number of data bytes in @data being read from slave device
+ * @filled: When buffer @data be filled will set this flag with 1, outhrwise 0
+ * @list_head:Eonnet every goodix_tools_data struct into a list
+ */
+
+struct goodix_tools_data {
+	u32 reg_addr;
+	u32 length;
+	u8 *data;
+	bool filled;
+	struct list_head list;
+};
+
+
+/*
+ * struct goodix_tools_dev - goodix tools device struct
+ * @ts_core: The core data struct of ts driver
+ * @ops_mode: represent device work mode
+ * @rawdiffcmd: Set slave device into rawdata mode
+ * @normalcmd: Set slave device into normal mode
+ * @wq: Wait queue struct use in synchronous data read
+ * @mutex: Protect goodix_tools_dev
+ * @ref_count: reference count
+ * @ref_mutex: Protect ref_count
+ */
+struct goodix_tools_dev {
+	struct goodix_ts_core *ts_core;
+	struct list_head head;
+	unsigned int ops_mode;
+	struct goodix_ts_cmd rawdiffcmd, normalcmd;
+	wait_queue_head_t wq;
+	struct mutex mutex;
+	int ref_count;
+	struct mutex ref_mutex;
+	struct goodix_ext_module module;
+} *goodix_tools_dev;
+
+static int goodix_tools_open(struct inode *inode, struct file *filp);
+static int goodix_tools_release(struct inode *inode, struct file *filp);
+static long goodix_tools_ioctl(struct file *filp, unsigned int cmd,
+					unsigned long arg);
+#ifdef CONFIG_COMPAT
+static long goodix_tools_compat_ioctl(struct file *file, unsigned int cmd,
+				unsigned long arg);
+#endif
+
+static const struct file_operations goodix_tools_fops = {
+	.owner		= THIS_MODULE,
+	.open		= goodix_tools_open,
+	.release	= goodix_tools_release,
+	.unlocked_ioctl	= goodix_tools_ioctl,
+#ifdef CONFIG_COMPAT
+	.compat_ioctl = goodix_tools_compat_ioctl,
+#endif
+};
+
+static struct miscdevice goodix_tools_miscdev = {
+	.minor	= MISC_DYNAMIC_MINOR,
+	.name	= GOODIX_TOOLS_NAME,
+	.fops	= &goodix_tools_fops,
+};
+/* read data from i2c asynchronous,
+ * success return bytes read, else return <= 0
+ */
+static int async_read(struct goodix_tools_dev *dev, void __user *arg)
+{
+	u8 *databuf = NULL;
+	int ret = 0;
+	u32 reg_addr, length;
+	u8 i2c_msg_head[I2C_MSG_HEAD_LEN];
+	struct goodix_ts_device *ts_dev = dev->ts_core->ts_dev;
+	const struct goodix_ts_hw_ops *hw_ops = ts_dev->hw_ops;
+
+	ret = copy_from_user(&i2c_msg_head, arg, I2C_MSG_HEAD_LEN);
+	if (ret)
+		return ret;
+
+	reg_addr = le32_to_cpup((__le32 *)&i2c_msg_head[0]);
+	length = le32_to_cpup((__le32 *)&i2c_msg_head[4]);
+	if (length > MAX_DATA_LEN)
+		length = MAX_DATA_LEN;
+
+	databuf = kzalloc(length, GFP_KERNEL);
+	if (!databuf)
+		return -ENOMEM;
+
+	if (!hw_ops->read(ts_dev, reg_addr, databuf, length)) {
+		if (copy_to_user((u8 *)arg + I2C_MSG_HEAD_LEN,
+					databuf, length))
+			ret = -EFAULT;
+		else
+			ret = length;
+	} else {
+		ret = -EBUSY;
+	}
+
+	kfree(databuf);
+	return ret;
+}
+
+/* read data from i2c synchronous,
+ * success return bytes read, else return <= 0
+ */
+static int sync_read(struct goodix_tools_dev *dev, void __user *arg)
+{
+	int ret = 0;
+	u8 i2c_msg_head[I2C_MSG_HEAD_LEN];
+	struct goodix_tools_data tools_data;
+
+	ret = copy_from_user(&i2c_msg_head, arg, I2C_MSG_HEAD_LEN);
+	if (ret)
+		return ret;
+
+	tools_data.reg_addr = le32_to_cpup((__le32 *)&i2c_msg_head[0]);
+	tools_data.length = le32_to_cpup((__le32 *)&i2c_msg_head[4]);
+	tools_data.filled = 0;
+	if (tools_data.length > MAX_DATA_LEN)
+		tools_data.length = MAX_DATA_LEN;
+
+	tools_data.data = kzalloc(tools_data.length, GFP_KERNEL);
+	if (!tools_data.data)
+		return -ENOMEM;
+
+	mutex_lock(&dev->mutex);
+	list_add_tail(&tools_data.list, &dev->head);
+	mutex_unlock(&dev->mutex);
+	/* wait queue will timeout after 1 seconds */
+	wait_event_interruptible_timeout(dev->wq, tools_data.filled == 1, HZ);
+
+	mutex_lock(&dev->mutex);
+	list_del(&tools_data.list);
+	mutex_unlock(&dev->mutex);
+	if (tools_data.filled == 1) {
+		if (copy_to_user((u8 *)arg + I2C_MSG_HEAD_LEN, tools_data.data,
+							tools_data.length))
+			ret = -EFAULT;
+		else
+			ret = tools_data.length;
+	} else {
+		ret = -EAGAIN;
+		dev_dbg(goodix_tools_miscdev.this_device,
+			"Wait queue timeout\n");
+	}
+
+	kfree(tools_data.data);
+	return ret;
+}
+
+/* write data to i2c asynchronous,
+ * success return bytes write, else return <= 0
+ */
+static int async_write(struct goodix_tools_dev *dev, void __user *arg)
+{
+	u8 *databuf;
+	int ret = 0;
+	u32 reg_addr, length;
+	u8 i2c_msg_head[I2C_MSG_HEAD_LEN];
+	struct goodix_ts_device *ts_dev = dev->ts_core->ts_dev;
+	const struct goodix_ts_hw_ops *hw_ops = ts_dev->hw_ops;
+
+	ret = copy_from_user(&i2c_msg_head, arg, I2C_MSG_HEAD_LEN);
+	if (ret)
+		return -EFAULT;
+
+	reg_addr = le32_to_cpup((__le32 *)&i2c_msg_head[0]);
+	length = le32_to_cpup((__le32 *)&i2c_msg_head[4]);
+	if (length > MAX_DATA_LEN)
+		length = MAX_DATA_LEN;
+
+	databuf = kzalloc(length, GFP_KERNEL);
+	if (!databuf)
+		return -ENOMEM;
+
+	ret = copy_from_user(databuf, (u8 *)arg + I2C_MSG_HEAD_LEN, length);
+	if (ret) {
+		ret = -EFAULT;
+		goto err_out;
+	}
+
+	if (hw_ops->write(ts_dev, reg_addr, databuf, length))
+		ret = -EBUSY;
+	else
+		ret = length;
+
+err_out:
+	kfree(databuf);
+	return ret;
+}
+
+static int init_cfg_data(struct goodix_ts_config *cfg, void __user *arg)
+{
+	int ret = 0;
+	u32 reg_addr, length;
+	u8 i2c_msg_head[I2C_MSG_HEAD_LEN];
+
+	cfg->initialized = 0;
+	mutex_init(&cfg->lock);
+	ret = copy_from_user(&i2c_msg_head, arg, I2C_MSG_HEAD_LEN);
+	if (ret)
+		return -EFAULT;
+
+	reg_addr = le32_to_cpup((__le32 *)&i2c_msg_head[0]);
+	length = le32_to_cpup((__le32 *)&i2c_msg_head[4]);
+	if (length > MAX_DATA_LEN)
+		length = MAX_DATA_LEN;
+
+	ret = copy_from_user(cfg->data, (u8 *)arg + I2C_MSG_HEAD_LEN, length);
+	if (ret) {
+		ret = -EFAULT;
+		dev_dbg(goodix_tools_miscdev.this_device,
+			"Copy data from user failed\n");
+		goto err_out;
+	}
+	cfg->reg_base = reg_addr;
+	cfg->length = length;
+	strlcpy(cfg->name, "tools-send-cfg", sizeof(cfg->name));
+	cfg->delay = 50;
+	cfg->initialized = true;
+	return 0;
+
+err_out:
+	return ret;
+}
+/**
+ * goodix_tools_ioctl - ioctl implementation
+ *
+ * @filp: Pointer to file opened
+ * @cmd: Ioctl opertion command
+ * @arg: Command data
+ * Returns >=0 - succeed, else failed
+ */
+static long goodix_tools_ioctl(struct file *filp, unsigned int cmd,
+					unsigned long arg)
+{
+	int ret = 0;
+	struct goodix_tools_dev *dev = filp->private_data;
+	struct goodix_ts_device *ts_dev;
+	const struct goodix_ts_hw_ops *hw_ops;
+	struct goodix_ts_cmd temp_cmd;
+	struct goodix_ts_config *temp_cfg;
+
+	if (dev->ts_core == NULL) {
+		dev_err(goodix_tools_miscdev.this_device,
+			"Tools module not register\n");
+		return -EINVAL;
+	}
+	ts_dev = dev->ts_core->ts_dev;
+	hw_ops = ts_dev->hw_ops;
+
+	if (_IOC_TYPE(cmd) != GOODIX_TS_IOC_MAGIC)
+		return -ENOTTY;
+	if (_IOC_NR(cmd) > GOODIX_TS_IOC_MAXNR)
+		return -ENOTTY;
+
+
+	switch (cmd & NEGLECT_SIZE_MASK) {
+	case GTP_IRQ_ENABLE:
+		if (arg == 1) {
+			goodix_ts_irq_enable(dev->ts_core, true);
+			mutex_lock(&dev->mutex);
+			dev->ops_mode |= IRQ_FALG;
+			mutex_unlock(&dev->mutex);
+			dev_dbg(goodix_tools_miscdev.this_device,
+				"IRQ enabled\n");
+		} else if (arg == 0) {
+			goodix_ts_irq_enable(dev->ts_core, false);
+			mutex_lock(&dev->mutex);
+			dev->ops_mode &= ~IRQ_FALG;
+			mutex_unlock(&dev->mutex);
+			dev_dbg(goodix_tools_miscdev.this_device,
+				"IRQ disabled\n");
+		} else {
+			dev_dbg(goodix_tools_miscdev.this_device,
+				"Irq already set with, arg = %ld\n", arg);
+		}
+		ret = 0;
+		break;
+	case GTP_DEV_RESET:
+		hw_ops->reset(ts_dev);
+		break;
+	case GTP_SEND_COMMAND:
+		ret = copy_from_user(&temp_cmd, (void __user *)arg,
+					sizeof(struct goodix_ts_cmd));
+		if (ret) {
+			ret = -EINVAL;
+			goto err_out;
+		}
+
+		ret = hw_ops->send_cmd(ts_dev, &temp_cmd);
+		if (ret) {
+			dev_warn(goodix_tools_miscdev.this_device,
+				"Send command failed\n");
+			ret = -EAGAIN;
+		}
+	break;
+	case GTP_SEND_CONFIG:
+		temp_cfg = kzalloc(sizeof(struct goodix_ts_config), GFP_KERNEL);
+		if (!temp_cfg) {
+			ret = -ENOMEM;
+			goto err_out;
+		}
+		ret = init_cfg_data(temp_cfg, (void __user *)arg);
+
+		if (!ret) {
+			ret = hw_ops->send_config(ts_dev, temp_cfg);
+			if (ret) {
+				dev_warn(goodix_tools_miscdev.this_device,
+					"Failed send config\n");
+				ret = -EAGAIN;
+			}
+		}
+		kfree(temp_cfg);
+	break;
+	case GTP_ASYNC_READ:
+		ret = async_read(dev, (void __user *)arg);
+		if (ret < 0)
+			dev_warn(goodix_tools_miscdev.this_device,
+				"Async data read failed");
+	break;
+	case GTP_SYNC_READ:
+		if (filp->f_flags & O_NONBLOCK) {
+			dev_dbg(goodix_tools_miscdev.this_device,
+				"Goodix tools now worked in sync_bus mode\n");
+			ret = -EAGAIN;
+			goto err_out;
+		}
+		ret = sync_read(dev, (void __user *)arg);
+		if (ret < 0)
+			dev_warn(goodix_tools_miscdev.this_device,
+				"Sync data read failed\n");
+	break;
+	case GTP_ASYNC_WRITE:
+		ret = async_write(dev, (void __user *)arg);
+		if (ret < 0)
+			dev_warn(goodix_tools_miscdev.this_device,
+				"Async data write failed\n");
+	break;
+	default:
+		dev_info(goodix_tools_miscdev.this_device, "Invalid cmd\n");
+		ret = -ENOTTY;
+		break;
+	}
+
+err_out:
+	return ret;
+}
+
+#ifdef CONFIG_COMPAT
+static long goodix_tools_compat_ioctl(struct file *file, unsigned int cmd,
+				unsigned long arg)
+{
+	if (!file->f_op || !file->f_op->unlocked_ioctl)
+		return -ENOTTY;
+
+	return goodix_tools_ioctl(file, cmd, (unsigned long)compat_ptr(arg));
+}
+#endif
+
+static int goodix_tools_open(struct inode *inode, struct file *filp)
+{
+	int ret = 0;
+
+	filp->private_data = goodix_tools_dev;
+
+	mutex_lock(&goodix_tools_dev->ref_mutex);
+
+	/* Only the first time open device need to register module */
+	if (goodix_tools_dev->ref_count == 0)
+		ret = goodix_register_ext_module(&goodix_tools_dev->module);
+	if (!ret)
+		goodix_tools_dev->ref_count++;
+
+	mutex_unlock(&goodix_tools_dev->ref_mutex);
+	return ret;
+}
+
+static int goodix_tools_release(struct inode *inode, struct file *filp)
+{
+	int ret = 0;
+
+	mutex_lock(&goodix_tools_dev->ref_mutex);
+
+	goodix_tools_dev->ref_count--;
+	/* when the last close this dev node unregister the module */
+	if (goodix_tools_dev->ref_count == 0)
+		ret = goodix_unregister_ext_module(&goodix_tools_dev->module);
+
+	mutex_unlock(&goodix_tools_dev->ref_mutex);
+	return ret;
+}
+
+/**
+ * goodix_tools_module_irq - goodix tools Irq handle
+ * This functions is excuted when interrupt happened
+ *
+ * @core_data: pointer to touch core data
+ * @module: pointer to goodix_ext_module struct
+ * return: EVT_CONTINUE let other module handle this irq
+ */
+static int goodix_tools_module_irq(struct goodix_ts_core *core_data,
+	struct goodix_ext_module *module)
+{
+	struct goodix_tools_dev *dev = module->priv_data;
+	struct goodix_ts_device *ts_dev = dev->ts_core->ts_dev;
+	const struct goodix_ts_hw_ops *hw_ops = ts_dev->hw_ops;
+	struct goodix_tools_data *tools_data;
+	int r = 0;
+	u8 evt_sta = 0;
+
+	if (!list_empty(&dev->head)) {
+		r = hw_ops->read(ts_dev, TS_REG_COORDS_BASE, &evt_sta, 1);
+		if (r < 0 || ((evt_sta & 0x80) == 0))
+			return EVT_CONTINUE;
+
+		mutex_lock(&dev->mutex);
+		list_for_each_entry(tools_data, &dev->head, list) {
+			if (!hw_ops->read(ts_dev, tools_data->reg_addr,
+					tools_data->data, tools_data->length)) {
+				tools_data->filled = 1;
+			}
+		}
+		mutex_unlock(&dev->mutex);
+		wake_up(&dev->wq);
+	}
+	return EVT_CONTINUE;
+}
+
+static int goodix_tools_module_init(struct goodix_ts_core *core_data,
+			struct goodix_ext_module *module)
+{
+	struct goodix_tools_dev *dev = module->priv_data;
+
+	if (core_data) {
+		dev->ts_core = core_data;
+		return 0;
+	} else {
+		return -ENODEV;
+	}
+}
+
+static struct goodix_ext_module_funcs goodix_tools_module_funcs = {
+	.irq_event = goodix_tools_module_irq,
+	.init = goodix_tools_module_init,
+};
+
+/**
+ * goodix_tools_init - init goodix tools device and register a miscdevice
+ *
+ * return: 0 success, else failed
+ */
+static int __init goodix_tools_init(void)
+{
+	int ret;
+
+	goodix_tools_dev = kzalloc(sizeof(struct goodix_tools_dev), GFP_KERNEL);
+	if (!goodix_tools_dev)
+		return -ENOMEM;
+
+	INIT_LIST_HEAD(&goodix_tools_dev->head);
+	goodix_tools_dev->ops_mode = 0;
+	goodix_tools_dev->ops_mode |= IRQ_FALG;
+	init_waitqueue_head(&goodix_tools_dev->wq);
+	mutex_init(&goodix_tools_dev->mutex);
+	goodix_tools_dev->ref_count = 0;
+	mutex_init(&goodix_tools_dev->ref_mutex);
+
+	goodix_tools_dev->module.funcs = &goodix_tools_module_funcs;
+	goodix_tools_dev->module.name = GOODIX_TOOLS_NAME;
+	goodix_tools_dev->module.priv_data = goodix_tools_dev;
+	goodix_tools_dev->module.priority = EXTMOD_PRIO_DBGTOOL;
+
+	ret = misc_register(&goodix_tools_miscdev);
+
+	return ret;
+}
+
+static void __exit goodix_tools_exit(void)
+{
+	misc_deregister(&goodix_tools_miscdev);
+	kfree(goodix_tools_dev);
+}
+
+module_init(goodix_tools_init);
+module_exit(goodix_tools_exit);
+
+MODULE_DESCRIPTION("Goodix tools Module");
+MODULE_AUTHOR("Goodix, Inc.");
+MODULE_LICENSE("GPL v2");
-- 
2.7.4

[PATCH] Input: fix platform_no_drv_owner.cocci warnings

[kbuild test robot]

drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_core.c:1335:3-8: No need to set .owner here. The core will do it.

 Remove .owner field if calls are used which set it automatically

Generated by: scripts/coccinelle/api/platform_no_drv_owner.cocci

CC: Wang Yafei <wangyafei@goodix.com>
Signed-off-by: Fengguang Wu <fengguang.wu@intel.com>
---

 goodix_ts_core.c |    1 -
 1 file changed, 1 deletion(-)

--- a/drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_core.c
+++ b/drivers/input/touchscreen/goodix-ts-sunrise/goodix_ts_core.c
@@ -1332,7 +1332,6 @@ MODULE_DEVICE_TABLE(platform, ts_core_id
 static struct platform_driver goodix_ts_driver = {
 	.driver = {
 		.name = GOODIX_CORE_DRIVER_NAME,
-		.owner = THIS_MODULE,
 		.pm = &dev_pm_ops,
 	},
 	.probe = goodix_ts_probe,

[PATCH] Input: fix platform_no_drv_owner.cocci warnings

[kbuild test robot]

drivers/input/touchscreen/goodix-ts-sunrise/goodix_gtx5_i2c.c:872:3-8: No need to set .owner here. The core will do it.

 Remove .owner field if calls are used which set it automatically

Generated by: scripts/coccinelle/api/platform_no_drv_owner.cocci

CC: Wang Yafei <wangyafei@goodix.com>
Signed-off-by: Fengguang Wu <fengguang.wu@intel.com>
---

 goodix_gtx5_i2c.c |    1 -
 1 file changed, 1 deletion(-)

--- a/drivers/input/touchscreen/goodix-ts-sunrise/goodix_gtx5_i2c.c
+++ b/drivers/input/touchscreen/goodix-ts-sunrise/goodix_gtx5_i2c.c
@@ -869,7 +869,6 @@ MODULE_DEVICE_TABLE(i2c, gtx5_id_table);
 static struct i2c_driver goodix_i2c_driver = {
 	.driver = {
 		.name = TS_DRIVER_NAME,
-		.owner = THIS_MODULE,
 		.of_match_table = of_match_ptr(gtx5_of_matchs),
 	},
 	.probe = goodix_i2c_probe,

Re: [PATCH 1/2] Input: Add driver for Cypress Generation 5 touchscreen

[kbuild test robot]

Hi Mylène,

[auto build test WARNING on input/next]
[also build test WARNING on v4.12-rc3 next-20170529]
[if your patch is applied to the wrong git tree, please drop us a note to help improve the system]

url:    https://github.com/0day-ci/linux/commits/Myl-ne-Josserand/Input-Add-Cypress-Gen5-Touchscreen-driver/20170529-230006
base:   https://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git next


coccinelle warnings: (new ones prefixed by >>)

>> drivers/input/touchscreen/cyttsp5.c:1162:3-8: No need to set .owner here. The core will do it.

Please review and possibly fold the followup patch.

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[PATCH 1/2] Input: Add driver for Cypress Generation 5 touchscreen

[Mylène Josserand]

This is the basic driver for the Cypress TrueTouch Gen5 touchscreen
controllers. This driver supports only the I2C bus but it uses regmap
so SPI support could be added later.
The touchscreen can retrieve some defined zone that are handled as
buttons (according to the hardware). That is why it handles
button and multitouch events.

Signed-off-by: Mylène Josserand <mylene.josserand@free-electrons.com>
---
 drivers/input/touchscreen/Kconfig   |   15 +
 drivers/input/touchscreen/Makefile  |    1 +
 drivers/input/touchscreen/cyttsp5.c | 1174 +++++++++++++++++++++++++++++++++++
 3 files changed, 1190 insertions(+)
 create mode 100644 drivers/input/touchscreen/cyttsp5.c

diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index cf26ca49ae6d..8e9e25cd0249 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -238,6 +238,21 @@ config TOUCHSCREEN_CYTTSP4_SPI
 	  To compile this driver as a module, choose M here: the
 	  module will be called cyttsp4_spi.
 
+config TOUCHSCREEN_CYTTSP5
+	tristate "Cypress TrueTouch Gen5 Touchscreen Driver"
+	depends on OF
+	select REGMAP_I2C
+	help
+	  Driver for Parade TrueTouch Standard Product
+	  Generation 5 touchscreen controllers.
+	  I2C bus interface support only.
+
+	  Say Y here if you have a Cypress Gen5 touchscreen.
+	  If unsure, say N.
+
+	  To compile this driver as a module, choose M here: the
+	  module will be called cyttsp5.
+
 config TOUCHSCREEN_DA9034
 	tristate "Touchscreen support for Dialog Semiconductor DA9034"
 	depends on PMIC_DA903X
diff --git a/drivers/input/touchscreen/Makefile b/drivers/input/touchscreen/Makefile
index 18e476948e44..a9ac134d8b7b 100644
--- a/drivers/input/touchscreen/Makefile
+++ b/drivers/input/touchscreen/Makefile
@@ -25,6 +25,7 @@ obj-$(CONFIG_TOUCHSCREEN_CYTTSP_SPI)	+= cyttsp_spi.o
 obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_CORE)	+= cyttsp4_core.o
 obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_I2C)	+= cyttsp4_i2c.o cyttsp_i2c_common.o
 obj-$(CONFIG_TOUCHSCREEN_CYTTSP4_SPI)	+= cyttsp4_spi.o
+obj-$(CONFIG_TOUCHSCREEN_CYTTSP5)	+= cyttsp5.o
 obj-$(CONFIG_TOUCHSCREEN_DA9034)	+= da9034-ts.o
 obj-$(CONFIG_TOUCHSCREEN_DA9052)	+= da9052_tsi.o
 obj-$(CONFIG_TOUCHSCREEN_DYNAPRO)	+= dynapro.o
diff --git a/drivers/input/touchscreen/cyttsp5.c b/drivers/input/touchscreen/cyttsp5.c
new file mode 100644
index 000000000000..d472d6ed83dc
--- /dev/null
+++ b/drivers/input/touchscreen/cyttsp5.c
@@ -0,0 +1,1174 @@
+/*
+ * Parade TrueTouch(TM) Standard Product V5 Module.
+ * For use with Parade touchscreen controllers.
+ *
+ * Copyright (C) 2015 Parade Technologies
+ * Copyright (C) 2012-2015 Cypress Semiconductor
+ * Copyright (C) 2017 Free Electrons
+ *
+ * Author: Mylène Josserand <mylene.josserand@free-electrons.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * version 2, and only version 2, 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.
+ *
+ */
+
+#include <asm/unaligned.h>
+#include <linux/delay.h>
+#include <linux/device.h>
+#include <linux/gpio.h>
+#include <linux/input/mt.h>
+#include <linux/input/touchscreen.h>
+#include <linux/interrupt.h>
+#include <linux/i2c.h>
+#include <linux/module.h>
+#include <linux/of_device.h>
+#include <linux/regmap.h>
+
+#define CYTTSP5_NAME				"cyttsp5"
+#define CY_I2C_DATA_SIZE			(2 * 256)
+#define HID_VERSION				0x0100
+#define CY_MAX_INPUT				512
+#define CYTTSP5_PREALLOCATED_CMD_BUFFER	32
+#define CY_BITS_PER_BTN			1
+#define CY_NUM_BTN_EVENT_ID			((1 << CY_BITS_PER_BTN) - 1)
+
+#define MAX_AREA				255
+#define HID_OUTPUT_BL_SOP			0x1
+#define HID_OUTPUT_BL_EOP			0x17
+#define HID_OUTPUT_BL_LAUNCH_APP		0x3B
+#define HID_OUTPUT_BL_LAUNCH_APP_SIZE		11
+#define HID_OUTPUT_GET_SYSINFO			0x2
+#define HID_OUTPUT_GET_SYSINFO_SIZE		5
+
+#define HID_DESC_REG				0x1
+#define HID_OUTPUT_REG				0x4
+
+#define REPORT_ID_TOUCH			0x1
+#define REPORT_ID_BTN				0x3
+#define REPORT_SIZE_5				5
+#define REPORT_SIZE_8				8
+#define REPORT_SIZE_16				16
+
+/* Touch reports offsets */
+/* Header offsets */
+#define TOUCH_REPORT_DESC_HDR_CONTACTCOUNT	16
+/* Record offsets */
+#define TOUCH_REPORT_DESC_CONTACTID		8
+#define TOUCH_REPORT_DESC_X			16
+#define TOUCH_REPORT_DESC_Y			32
+#define TOUCH_REPORT_DESC_P			48
+#define TOUCH_REPORT_DESC_MAJ			56
+#define TOUCH_REPORT_DESC_MIN			64
+
+/* HID */
+#define HID_TOUCH_REPORT_ID			0x1
+#define HID_BTN_REPORT_ID			0x3
+#define HID_APP_RESPONSE_REPORT_ID		0x1F
+#define HID_APP_OUTPUT_REPORT_ID		0x2F
+#define HID_BL_RESPONSE_REPORT_ID		0x30
+#define HID_BL_OUTPUT_REPORT_ID		0x40
+
+#define HID_OUTPUT_RESPONSE_REPORT_OFFSET	2
+#define HID_OUTPUT_RESPONSE_CMD_OFFSET		4
+#define HID_OUTPUT_RESPONSE_CMD_MASK		0x7F
+
+#define HID_SYSINFO_SENSING_OFFSET		33
+#define HID_SYSINFO_BTN_OFFSET			48
+#define HID_SYSINFO_BTN_MASK			0xFF
+#define HID_SYSINFO_MAX_BTN			8
+
+/*  Timeout in ms */
+#define CY_HID_OUTPUT_TIMEOUT			200
+#define CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT	3000
+#define CY_HID_GET_HID_DESCRIPTOR_TIMEOUT	4000
+
+/* maximum number of concurrent tracks */
+#define TOUCH_REPORT_SIZE			10
+#define TOUCH_INPUT_HEADER_SIZE		7
+#define BTN_REPORT_SIZE			9
+#define BTN_INPUT_HEADER_SIZE			5
+
+/* All usage pages for Touch Report */
+#define TOUCH_REPORT_USAGE_PG_X		0x00010030
+#define TOUCH_REPORT_USAGE_PG_Y		0x00010031
+#define TOUCH_REPORT_USAGE_PG_P		0x000D0030
+#define TOUCH_REPORT_USAGE_PG_CONTACTID	0x000D0051
+#define TOUCH_REPORT_USAGE_PG_CONTACTCOUNT	0x000D0054
+#define TOUCH_REPORT_USAGE_PG_MAJ		0xFF010062
+#define TOUCH_REPORT_USAGE_PG_MIN		0xFF010063
+#define TOUCH_COL_USAGE_PG			0x000D0022
+
+/* helpers */
+#define IS_TMO(t)				((t) == 0)
+#define HI_BYTE(x)				(u8)(((x) >> 8) & 0xFF)
+#define LOW_BYTE(x)				(u8)((x) & 0xFF)
+
+/* System Information interface definitions */
+struct cyttsp5_sensing_conf_data_dev {
+	u8 electrodes_x;
+	u8 electrodes_y;
+	__le16 len_x;
+	__le16 len_y;
+	__le16 res_x;
+	__le16 res_y;
+	__le16 max_z;
+	u8 origin_x;
+	u8 origin_y;
+	u8 btn;
+	u8 scan_mode;
+	u8 max_num_of_tch_per_refresh_cycle;
+} __packed;
+
+struct cyttsp5_sensing_conf_data {
+	u16 res_x;
+	u16 res_y;
+	u16 max_z;
+	u16 len_x;
+	u16 len_y;
+	u8 origin_x;
+	u8 origin_y;
+	u8 max_tch;
+};
+
+enum cyttsp5_tch_abs {	/* for ordering within the extracted touch data array */
+	CY_TCH_X,	/* X */
+	CY_TCH_Y,	/* Y */
+	CY_TCH_P,	/* P (Z) */
+	CY_TCH_T,	/* TOUCH ID */
+	CY_TCH_MAJ,	/* TOUCH_MAJOR */
+	CY_TCH_MIN,	/* TOUCH_MINOR */
+	CY_TCH_NUM_ABS,
+};
+
+struct cyttsp5_tch_abs_params {
+	size_t ofs;	/* abs byte offset */
+	size_t size;	/* size in bits */
+	size_t min;	/* min value */
+	size_t max;	/* max value */
+	size_t bofs;	/* bit offset */
+};
+
+struct cyttsp5_touch {
+	int hdr;
+	int abs[CY_TCH_NUM_ABS];
+};
+
+struct cyttsp5_btn {
+	bool enabled;
+	int key_code;
+};
+
+struct cyttsp5_sysinfo {
+	struct cyttsp5_sensing_conf_data sensing_conf_data;
+	int num_btns;
+	struct cyttsp5_btn *btn;
+	struct cyttsp5_tch_abs_params tch_hdr;
+	struct cyttsp5_tch_abs_params tch_abs[CY_TCH_NUM_ABS];
+	u8 *xy_mode;
+	u8 *xy_data;
+};
+
+struct cyttsp5_hid_desc {
+	__le16 hid_desc_len;
+	u8 packet_id;
+	u8 reserved_byte;
+	__le16 bcd_version;
+	__le16 report_desc_len;
+	__le16 report_desc_register;
+	__le16 input_register;
+	__le16 max_input_len;
+	__le16 output_register;
+	__le16 max_output_len;
+	__le16 command_register;
+	__le16 data_register;
+	__le16 vendor_id;
+	__le16 product_id;
+	__le16 version_id;
+	u8 reserved[4];
+} __packed;
+
+struct cyttsp5 {
+	struct device *dev;
+	struct mutex system_lock;
+	struct mutex btn_lock;
+	struct mutex mt_lock;
+	wait_queue_head_t wait_q;
+	int irq;
+	struct cyttsp5_sysinfo sysinfo;
+	int hid_cmd_state;
+	struct cyttsp5_hid_desc hid_desc;
+	u8 cmd_buf[CYTTSP5_PREALLOCATED_CMD_BUFFER];
+	u8 input_buf[CY_MAX_INPUT];
+	u8 response_buf[CY_MAX_INPUT];
+	struct gpio_desc *reset_gpio;
+	struct input_dev *input;
+	char phys[NAME_MAX];
+	int num_prv_rec;
+	struct regmap *regmap;
+};
+
+static int cyttsp5_read(struct cyttsp5 *ts, u8 *buf, u32 max)
+{
+	int rc;
+	u32 size;
+
+	if (!buf)
+		return -EINVAL;
+
+	/* Read the frame to retrieve the size */
+	rc = regmap_bulk_read(ts->regmap, 0, buf, 2);
+	if (rc < 0)
+		return rc;
+
+	size = get_unaligned_le16(&buf[0]);
+	if (!size || size == 2)
+		return 0;
+
+	if (size > max)
+		return -EINVAL;
+
+	/* Get the real value */
+	return regmap_bulk_read(ts->regmap, 0, buf, size);
+}
+
+static int cyttsp5_write(struct cyttsp5 *ts, unsigned int reg, u8 *data,
+			 size_t size)
+{
+	u8 cmd[size + 1];
+
+	/* High bytes of register address needed as first byte of cmd */
+	cmd[0] = HI_BYTE(reg);
+	/* Copy the rest of the data */
+	memcpy(&cmd[1], data, size);
+
+	return regmap_bulk_write(ts->regmap, LOW_BYTE(reg), cmd, size + 1);
+}
+
+static void cyttsp5_final_sync(struct input_dev *input, int max_slots,
+			       unsigned long *ids)
+{
+	int t;
+
+	for (t = 0; t < max_slots; t++) {
+		if (test_bit(t, ids))
+			continue;
+		input_mt_slot(input, t);
+		input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
+	}
+
+	input_sync(input);
+}
+
+static void cyttsp5_report_slot_liftoff(struct cyttsp5 *ts, int max_slots)
+{
+	int t;
+
+	if (ts->num_prv_rec == 0)
+		return;
+
+	for (t = 0; t < max_slots; t++) {
+		input_mt_slot(ts->input, t);
+		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, false);
+	}
+}
+
+static void cyttsp5_mt_lift_all(struct cyttsp5 *ts)
+{
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int max = si->tch_abs[CY_TCH_T].max;
+
+	if (ts->num_prv_rec != 0) {
+		cyttsp5_report_slot_liftoff(ts, max);
+		input_sync(ts->input);
+		ts->num_prv_rec = 0;
+	}
+}
+
+static void cyttsp5_get_touch_axis(int *axis, int size, int max, u8 *xy_data,
+				   int bofs)
+{
+	int nbyte;
+	int next;
+
+	for (nbyte = 0, *axis = 0, next = 0; nbyte < size; nbyte++) {
+		*axis = *axis + ((xy_data[next] >> bofs) << (nbyte * 8));
+		next++;
+	}
+
+	*axis &= max - 1;
+}
+
+static void cyttsp5_get_touch_record(struct cyttsp5 *ts,
+				     struct cyttsp5_touch *touch, u8 *xy_data)
+{
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	enum cyttsp5_tch_abs abs;
+
+	for (abs = CY_TCH_X; abs < CY_TCH_NUM_ABS; abs++) {
+		cyttsp5_get_touch_axis(&touch->abs[abs],
+				       si->tch_abs[abs].size,
+				       si->tch_abs[abs].max,
+				       xy_data + si->tch_abs[abs].ofs,
+				       si->tch_abs[abs].bofs);
+	}
+}
+
+static void cyttsp5_mt_process_touch(struct cyttsp5 *ts,
+				     struct cyttsp5_touch *touch)
+{
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int tmp;
+
+	tmp = touch->abs[CY_TCH_X];
+	touch->abs[CY_TCH_X] = touch->abs[CY_TCH_Y];
+	touch->abs[CY_TCH_Y] = tmp;
+
+	/* Convert MAJOR/MINOR from mm to resolution */
+	tmp = touch->abs[CY_TCH_MAJ] * 100 * si->sensing_conf_data.res_x;
+	touch->abs[CY_TCH_MAJ] = tmp / si->sensing_conf_data.len_x;
+	tmp = touch->abs[CY_TCH_MIN] * 100 * si->sensing_conf_data.res_x;
+	touch->abs[CY_TCH_MIN] = tmp / si->sensing_conf_data.len_x;
+}
+
+static void cyttsp5_get_mt_touches(struct cyttsp5 *ts,
+				   struct cyttsp5_touch *tch, int num_cur_tch)
+{
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int i, t = 0;
+	DECLARE_BITMAP(ids, si->tch_abs[CY_TCH_T].max);
+	u8 *tch_addr;
+
+	bitmap_zero(ids, si->tch_abs[CY_TCH_T].max);
+	memset(tch->abs, 0, sizeof(tch->abs));
+
+	for (i = 0; i < num_cur_tch; i++) {
+		tch_addr = si->xy_data + (i * TOUCH_REPORT_SIZE);
+		cyttsp5_get_touch_record(ts, tch, tch_addr);
+
+		/* Process touch */
+		cyttsp5_mt_process_touch(ts, tch);
+
+		t = tch->abs[CY_TCH_T];
+		input_mt_slot(ts->input, t);
+		input_mt_report_slot_state(ts->input, MT_TOOL_FINGER, true);
+		__set_bit(t, ids);
+
+		/* position and pressure fields */
+		input_report_abs(ts->input, ABS_MT_POSITION_X, tch->abs[CY_TCH_X]);
+		input_report_abs(ts->input, ABS_MT_POSITION_Y, tch->abs[CY_TCH_Y]);
+		input_report_abs(ts->input, ABS_MT_PRESSURE, tch->abs[CY_TCH_P]);
+
+		/* Get the extended touch fields */
+		input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR, tch->abs[CY_TCH_MAJ]);
+		input_report_abs(ts->input, ABS_MT_TOUCH_MINOR, tch->abs[CY_TCH_MIN]);
+	}
+
+	cyttsp5_final_sync(ts->input, si->tch_abs[CY_TCH_T].max, ids);
+
+	ts->num_prv_rec = num_cur_tch;
+}
+
+/* read xy_data for all current touches */
+static int cyttsp5_xy_worker(struct cyttsp5 *ts)
+{
+	struct device *dev = ts->dev;
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int max_tch = si->sensing_conf_data.max_tch;
+	struct cyttsp5_touch tch;
+	u8 num_cur_tch;
+
+	cyttsp5_get_touch_axis(&tch.hdr, si->tch_hdr.size,
+			       si->tch_hdr.max,
+			       si->xy_mode + 3 + si->tch_hdr.ofs,
+			       si->tch_hdr.bofs);
+
+	num_cur_tch = tch.hdr;
+	if (num_cur_tch > max_tch) {
+		dev_err(dev, "%s: Num touch err detected (n=%d)\n",
+			__func__, num_cur_tch);
+		num_cur_tch = max_tch;
+	}
+
+	if (num_cur_tch == 0 && ts->num_prv_rec == 0)
+		return 0;
+
+	/* extract xy_data for all currently reported touches */
+	if (num_cur_tch)
+		cyttsp5_get_mt_touches(ts, &tch, num_cur_tch);
+	else
+		cyttsp5_mt_lift_all(ts);
+
+	return 0;
+}
+
+static int cyttsp5_mt_attention(struct device *dev)
+{
+	struct cyttsp5 *ts = dev_get_drvdata(dev);
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int rc;
+
+	if (si->xy_mode[2] != HID_TOUCH_REPORT_ID)
+		return 0;
+
+	/* core handles handshake */
+	mutex_lock(&ts->mt_lock);
+	rc = cyttsp5_xy_worker(ts);
+	mutex_unlock(&ts->mt_lock);
+	if (rc < 0)
+		dev_err(dev, "%s: xy_worker error r=%d\n", __func__, rc);
+
+	return rc;
+}
+
+static int cyttsp5_setup_input_device(struct device *dev)
+{
+	struct cyttsp5 *ts = dev_get_drvdata(dev);
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int max_x, max_y, max_p;
+	int max_x_tmp, max_y_tmp;
+	int rc;
+
+	__set_bit(EV_ABS, ts->input->evbit);
+	__set_bit(EV_REL, ts->input->evbit);
+	__set_bit(EV_KEY, ts->input->evbit);
+
+	max_x_tmp = si->sensing_conf_data.res_x;
+	max_y_tmp = si->sensing_conf_data.res_y;
+	max_x = max_y_tmp - 1;
+	max_y = max_x_tmp - 1;
+	max_p = si->sensing_conf_data.max_z;
+
+	input_mt_init_slots(ts->input, si->tch_abs[CY_TCH_T].max, 0);
+
+	__set_bit(ABS_MT_POSITION_X, ts->input->absbit);
+	__set_bit(ABS_MT_POSITION_Y, ts->input->absbit);
+	__set_bit(ABS_MT_PRESSURE, ts->input->absbit);
+
+	input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, max_x, 0, 0);
+	input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, max_y, 0, 0);
+	input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, max_p, 0, 0);
+
+	input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, MAX_AREA, 0, 0);
+	input_set_abs_params(ts->input, ABS_MT_TOUCH_MINOR, 0, MAX_AREA, 0, 0);
+
+	rc = input_register_device(ts->input);
+	if (rc < 0)
+		dev_err(dev, "%s: Error, failed register input device r=%d\n",
+			__func__, rc);
+
+	return rc;
+}
+
+static int cyttsp5_parse_dt_key_code(struct device *dev)
+{
+	struct cyttsp5 *ts = dev_get_drvdata(dev);
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	struct device_node *np, *pp;
+	int rc, i;
+
+	np = dev->of_node;
+	if (!np)
+		return -EINVAL;
+
+	if (si->num_btns) {
+		si->btn = devm_kzalloc(dev,
+				       si->num_btns * sizeof(struct cyttsp5_btn),
+				       GFP_KERNEL);
+		if (!si->btn)
+			return -ENOMEM;
+
+		/* Initialized the button to RESERVED */
+		for (i = 0; i < si->num_btns; i++) {
+			struct cyttsp5_btn *btns = &si->btn[i];
+			btns->key_code = KEY_RESERVED;
+			btns->enabled = true;
+		}
+	}
+
+	i = 0;
+	for_each_child_of_node(np, pp) {
+		struct cyttsp5_btn *btns = &si->btn[i];
+
+		rc = of_property_read_u32(pp, "linux,code", &btns->key_code);
+		if (rc) {
+			dev_err(dev, "%s: Inval linux,code prop\n", pp->name);
+			return -EINVAL;
+		}
+		btns->enabled = true;
+
+		i++;
+	}
+
+	return i;
+}
+
+static int cyttsp5_btn_attention(struct device *dev)
+{
+	struct cyttsp5 *ts = dev_get_drvdata(dev);
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int cur_btn;
+	int cur_btn_state;
+
+	if (si->xy_mode[2] != HID_BTN_REPORT_ID)
+		return 0;
+
+	/* core handles handshake */
+	mutex_lock(&ts->btn_lock);
+
+	/* extract button press/release touch information */
+	if (si->num_btns > 0) {
+		for (cur_btn = 0; cur_btn < si->num_btns; cur_btn++) {
+			/* Get current button state */
+			cur_btn_state = (si->xy_data[0] >> (cur_btn * CY_BITS_PER_BTN))
+				& CY_NUM_BTN_EVENT_ID;
+
+			if (!si->btn[cur_btn].enabled)
+				continue;
+
+			input_report_key(ts->input, si->btn[cur_btn].key_code,
+					 cur_btn_state);
+			input_sync(ts->input);
+		}
+	}
+
+	mutex_unlock(&ts->btn_lock);
+
+	return 0;
+}
+
+static const u16 crc_table[16] = {
+	0x0000, 0x1021, 0x2042, 0x3063,
+	0x4084, 0x50a5, 0x60c6, 0x70e7,
+	0x8108, 0x9129, 0xa14a, 0xb16b,
+	0xc18c, 0xd1ad, 0xe1ce, 0xf1ef,
+};
+
+static u16 cyttsp5_compute_crc(u8 *buf, u32 size)
+{
+	u16 remainder = 0xFFFF;
+	u16 xor_mask = 0x0000;
+	u32 index;
+	u32 byte_value;
+	u32 table_index;
+	u32 crc_bit_width = sizeof(u16) * 8;
+
+	/* Divide the message by polynomial, via the table. */
+	for (index = 0; index < size; index++) {
+		byte_value = buf[index];
+		table_index = ((byte_value >> 4) & 0x0F)
+			^ (remainder >> (crc_bit_width - 4));
+		remainder = crc_table[table_index] ^ (remainder << 4);
+		table_index = (byte_value & 0x0F)
+			^ (remainder >> (crc_bit_width - 4));
+		remainder = crc_table[table_index] ^ (remainder << 4);
+	}
+
+	/* Perform the final remainder CRC. */
+	return remainder ^ xor_mask;
+}
+
+static int cyttsp5_validate_cmd_response(struct cyttsp5 *ts, u8 code)
+{
+	u16 size, crc;
+	u8 status, offset;
+	int command_code;
+
+	size = get_unaligned_le16(&ts->response_buf[0]);
+
+	if (!size)
+		return 0;
+
+	offset = ts->response_buf[HID_OUTPUT_RESPONSE_REPORT_OFFSET];
+
+	if (offset == HID_BL_RESPONSE_REPORT_ID) {
+		if (ts->response_buf[4] != HID_OUTPUT_BL_SOP) {
+			dev_err(ts->dev, "%s: HID output response, wrong SOP\n",
+				__func__);
+			return -EPROTO;
+		}
+
+		if (ts->response_buf[size - 1] != HID_OUTPUT_BL_EOP) {
+			dev_err(ts->dev, "%s: HID output response, wrong EOP\n",
+				__func__);
+			return -EPROTO;
+		}
+
+		crc = cyttsp5_compute_crc(&ts->response_buf[4], size - 7);
+		if (ts->response_buf[size - 3] != LOW_BYTE(crc)
+		    || ts->response_buf[size - 2] != HI_BYTE(crc)) {
+			dev_err(ts->dev, "%s: HID output response, wrong CRC 0x%X\n",
+				__func__, crc);
+			return -EPROTO;
+		}
+
+		status = ts->response_buf[5];
+		if (status) {
+			dev_err(ts->dev, "%s: HID output response, ERROR:%d\n",
+				__func__, status);
+			return -EPROTO;
+		}
+	}
+
+	if (offset == HID_APP_RESPONSE_REPORT_ID) {
+		command_code = ts->response_buf[HID_OUTPUT_RESPONSE_CMD_OFFSET]
+			& HID_OUTPUT_RESPONSE_CMD_MASK;
+		if (command_code != code) {
+			dev_err(ts->dev,
+				"%s: HID output response, wrong command_code:%X\n",
+				__func__, command_code);
+			return -EPROTO;
+		}
+	}
+
+	return 0;
+}
+
+static void cyttsp5_si_get_btn_data(struct cyttsp5 *ts)
+{
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+	int i;
+	int num_btns = 0;
+	unsigned int btns = ts->response_buf[HID_SYSINFO_BTN_OFFSET]
+		& HID_SYSINFO_BTN_MASK;
+
+	for (i = 0; i < HID_SYSINFO_MAX_BTN; i++) {
+		if (btns & (1 << i))
+			num_btns++;
+	}
+	si->num_btns = num_btns;
+}
+
+static int cyttsp5_get_sysinfo_regs(struct cyttsp5 *ts)
+{
+	struct cyttsp5_sensing_conf_data *scd = &ts->sysinfo.sensing_conf_data;
+	struct cyttsp5_sensing_conf_data_dev *scd_dev =
+		(struct cyttsp5_sensing_conf_data_dev *)
+		&ts->response_buf[HID_SYSINFO_SENSING_OFFSET];
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+
+	cyttsp5_si_get_btn_data(ts);
+
+	scd->max_tch = scd_dev->max_num_of_tch_per_refresh_cycle;
+	scd->res_x = get_unaligned_le16(&scd_dev->res_x);
+	scd->res_y = get_unaligned_le16(&scd_dev->res_y);
+	scd->max_z = get_unaligned_le16(&scd_dev->max_z);
+	scd->len_x = get_unaligned_le16(&scd_dev->len_x);
+	scd->len_y = get_unaligned_le16(&scd_dev->len_y);
+
+	si->xy_data = devm_kzalloc(ts->dev, scd->max_tch * TOUCH_REPORT_SIZE,
+				   GFP_KERNEL);
+	if (!si->xy_data)
+		return -ENOMEM;
+
+	si->xy_mode = devm_kzalloc(ts->dev, TOUCH_INPUT_HEADER_SIZE, GFP_KERNEL);
+	if (!si->xy_mode) {
+		devm_kfree(ts->dev, si->xy_data);
+		return -ENOMEM;
+	}
+
+	return 0;
+}
+
+static int cyttsp5_hid_output_get_sysinfo(struct cyttsp5 *ts)
+{
+	int rc, t;
+	u8 cmd[HID_OUTPUT_GET_SYSINFO_SIZE];
+
+	mutex_lock(&ts->system_lock);
+	ts->hid_cmd_state = HID_OUTPUT_GET_SYSINFO + 1;
+	mutex_unlock(&ts->system_lock);
+
+	/* HI bytes of Output register address */
+	cmd[0] = LOW_BYTE(HID_OUTPUT_GET_SYSINFO_SIZE);
+	cmd[1] = HI_BYTE(HID_OUTPUT_GET_SYSINFO_SIZE);
+	cmd[2] = HID_APP_OUTPUT_REPORT_ID;
+	cmd[3] = 0x0; /* Reserved */
+	cmd[4] = HID_OUTPUT_GET_SYSINFO;
+
+	rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
+			   HID_OUTPUT_GET_SYSINFO_SIZE);
+	if (rc) {
+		dev_err(ts->dev, "%s: Failed to write command %d",
+			__func__, rc);
+		goto error;
+	}
+
+	t = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == 0),
+			       msecs_to_jiffies(CY_HID_OUTPUT_GET_SYSINFO_TIMEOUT));
+	if (IS_TMO(t)) {
+		dev_err(ts->dev, "%s: HID output cmd execution timed out\n",
+			__func__);
+		rc = -ETIME;
+		goto error;
+	}
+
+	rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_GET_SYSINFO);
+	goto exit;
+
+error:
+	mutex_lock(&ts->system_lock);
+	ts->hid_cmd_state = 0;
+	mutex_unlock(&ts->system_lock);
+	return rc;
+exit:
+	rc = cyttsp5_get_sysinfo_regs(ts);
+
+	return rc;
+}
+
+static int cyttsp5_hid_output_bl_launch_app(struct cyttsp5 *ts)
+{
+	int rc, t;
+	u8 cmd[HID_OUTPUT_BL_LAUNCH_APP];
+	u16 crc;
+
+	mutex_lock(&ts->system_lock);
+	ts->hid_cmd_state = HID_OUTPUT_BL_LAUNCH_APP + 1;
+	mutex_unlock(&ts->system_lock);
+
+	cmd[0] = LOW_BYTE(HID_OUTPUT_BL_LAUNCH_APP_SIZE);
+	cmd[1] = HI_BYTE(HID_OUTPUT_BL_LAUNCH_APP_SIZE);
+	cmd[2] = HID_BL_OUTPUT_REPORT_ID;
+	cmd[3] = 0x0; /* Reserved */
+	cmd[4] = HID_OUTPUT_BL_SOP;
+	cmd[5] = HID_OUTPUT_BL_LAUNCH_APP;
+	cmd[6] = 0x0; /* Low bytes of data */
+	cmd[7] = 0x0; /* Hi bytes of data */
+	crc = cyttsp5_compute_crc(&cmd[4], 4);
+	cmd[8] = LOW_BYTE(crc);
+	cmd[9] = HI_BYTE(crc);
+	cmd[10] = HID_OUTPUT_BL_EOP;
+
+	rc = cyttsp5_write(ts, HID_OUTPUT_REG, cmd,
+			   HID_OUTPUT_BL_LAUNCH_APP_SIZE);
+	if (rc) {
+		dev_err(ts->dev, "%s: Failed to write command %d",
+			__func__, rc);
+		goto error;
+	}
+
+	t = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == 0),
+			       msecs_to_jiffies(CY_HID_OUTPUT_TIMEOUT));
+	if (IS_TMO(t)) {
+		dev_err(ts->dev, "%s: HID output cmd execution timed out\n",
+			__func__);
+		rc = -ETIME;
+		goto error;
+	}
+
+	rc = cyttsp5_validate_cmd_response(ts, HID_OUTPUT_BL_LAUNCH_APP);
+	goto exit;
+
+error:
+	mutex_lock(&ts->system_lock);
+	ts->hid_cmd_state = 0;
+	mutex_unlock(&ts->system_lock);
+exit:
+	return rc;
+}
+
+static int cyttsp5_get_hid_descriptor(struct cyttsp5 *ts,
+				      struct cyttsp5_hid_desc *desc)
+{
+	struct device *dev = ts->dev;
+	__le16 hid_desc_register = HID_DESC_REG;
+	int rc;
+	int t;
+	u8 cmd[2];
+
+	/* Read HID descriptor length and version */
+	mutex_lock(&ts->system_lock);
+	ts->hid_cmd_state = 1;
+	mutex_unlock(&ts->system_lock);
+
+	/* Set HID descriptor register */
+	memcpy(cmd, &hid_desc_register, sizeof(hid_desc_register));
+
+	regmap_write(ts->regmap, HID_DESC_REG, cmd[0]);
+	rc = regmap_write(ts->regmap, HID_DESC_REG, cmd[1]);
+	if (rc < 0) {
+		dev_err(dev, "%s: failed to get HID descriptor, rc=%d\n",
+			__func__, rc);
+		goto error;
+	}
+
+	t = wait_event_timeout(ts->wait_q, (ts->hid_cmd_state == 0),
+			       msecs_to_jiffies(CY_HID_GET_HID_DESCRIPTOR_TIMEOUT));
+	if (IS_TMO(t)) {
+		dev_err(ts->dev, "%s: HID get descriptor timed out\n",
+			__func__);
+		rc = -ETIME;
+		goto error;
+	}
+
+	memcpy((u8 *)desc, ts->response_buf, sizeof(struct cyttsp5_hid_desc));
+
+	/* Check HID descriptor length and version */
+	if (le16_to_cpu(desc->hid_desc_len) != sizeof(*desc) ||
+	    le16_to_cpu(desc->bcd_version) != HID_VERSION) {
+		dev_err(dev, "%s: Unsupported HID version\n", __func__);
+		return -ENODEV;
+	}
+
+	goto exit;
+
+error:
+	mutex_lock(&ts->system_lock);
+	ts->hid_cmd_state = 0;
+	mutex_unlock(&ts->system_lock);
+exit:
+	return rc;
+}
+
+static int fill_tch_abs(struct cyttsp5_tch_abs_params *tch_abs, int report_size,
+			int offset)
+{
+	tch_abs->ofs = offset / 8;
+	tch_abs->size = report_size / 8;
+	if (report_size % 8)
+		tch_abs->size += 1;
+	tch_abs->min = 0;
+	tch_abs->max = 1 << report_size;
+	tch_abs->bofs = offset - (tch_abs->ofs << 3);
+
+	return 0;
+}
+
+static int move_button_data(struct cyttsp5 *ts, struct cyttsp5_sysinfo *si)
+{
+	memcpy(si->xy_mode, ts->input_buf, BTN_INPUT_HEADER_SIZE);
+	memcpy(si->xy_data, &ts->input_buf[BTN_INPUT_HEADER_SIZE],
+	       BTN_REPORT_SIZE);
+
+	return 0;
+}
+
+static int move_touch_data(struct cyttsp5 *ts, struct cyttsp5_sysinfo *si)
+{
+	int max_tch = si->sensing_conf_data.max_tch;
+	int num_cur_tch;
+	int length;
+	struct cyttsp5_tch_abs_params *tch = &si->tch_hdr;
+
+	memcpy(si->xy_mode, ts->input_buf, TOUCH_INPUT_HEADER_SIZE);
+
+	cyttsp5_get_touch_axis(&num_cur_tch, tch->size,
+			       tch->max, si->xy_mode + 3 + tch->ofs, tch->bofs);
+	if (unlikely(num_cur_tch > max_tch))
+		num_cur_tch = max_tch;
+
+	length = num_cur_tch * TOUCH_REPORT_SIZE;
+
+	memcpy(si->xy_data, &ts->input_buf[TOUCH_INPUT_HEADER_SIZE], length);
+	return 0;
+}
+
+static irqreturn_t cyttsp5_handle_irq(int irq, void *handle)
+{
+	struct cyttsp5 *ts = handle;
+	int report_id;
+	int size;
+	int rc;
+
+	rc = cyttsp5_read(ts, ts->input_buf, CY_MAX_INPUT);
+	if (!rc) {
+		size = get_unaligned_le16(&ts->input_buf[0]);
+
+		/* check reset */
+		if (size == 0) {
+			memcpy(ts->response_buf, ts->input_buf, 2);
+
+			ts->hid_cmd_state = 0;
+			wake_up(&ts->wait_q);
+			mutex_unlock(&ts->system_lock);
+			return IRQ_HANDLED;
+		}
+
+		report_id = ts->input_buf[2];
+
+		if (report_id == HID_TOUCH_REPORT_ID) {
+			move_touch_data(ts, &ts->sysinfo);
+			cyttsp5_mt_attention(ts->dev);
+		} else if (report_id == HID_BTN_REPORT_ID) {
+			move_button_data(ts, &ts->sysinfo);
+			cyttsp5_btn_attention(ts->dev);
+		} else {
+			/* It is not an input but a command response */
+			memcpy(ts->response_buf, ts->input_buf, size);
+
+			mutex_lock(&ts->system_lock);
+			ts->hid_cmd_state = 0;
+			mutex_unlock(&ts->system_lock);
+			wake_up(&ts->wait_q);
+		}
+	}
+
+	return IRQ_HANDLED;
+}
+
+static int cyttsp5_deassert_int(struct cyttsp5 *ts)
+{
+	u16 size;
+	u8 buf[2];
+	int rc;
+
+	rc = regmap_bulk_read(ts->regmap, 0, buf, 2);
+	if (rc < 0)
+		return rc;
+
+	size = get_unaligned_le16(&buf[0]);
+	if (size == 2 || size == 0)
+		return 0;
+
+	return -EINVAL;
+}
+
+static int cyttsp5_fill_all_touch(struct cyttsp5 *ts)
+{
+	struct cyttsp5_sysinfo *si = &ts->sysinfo;
+
+	fill_tch_abs(&si->tch_abs[CY_TCH_X], REPORT_SIZE_16,
+		     TOUCH_REPORT_DESC_X);
+	fill_tch_abs(&si->tch_abs[CY_TCH_Y], REPORT_SIZE_16,
+		     TOUCH_REPORT_DESC_Y);
+	fill_tch_abs(&si->tch_abs[CY_TCH_P], REPORT_SIZE_8,
+		     TOUCH_REPORT_DESC_P);
+	fill_tch_abs(&si->tch_abs[CY_TCH_T], REPORT_SIZE_5,
+		     TOUCH_REPORT_DESC_CONTACTID);
+	fill_tch_abs(&si->tch_hdr, REPORT_SIZE_5,
+		     TOUCH_REPORT_DESC_HDR_CONTACTCOUNT);
+	fill_tch_abs(&si->tch_abs[CY_TCH_MAJ], REPORT_SIZE_8,
+		     TOUCH_REPORT_DESC_MAJ);
+	fill_tch_abs(&si->tch_abs[CY_TCH_MIN], REPORT_SIZE_8,
+		     TOUCH_REPORT_DESC_MIN);
+
+	return 0;
+}
+
+static int cyttsp5_startup(struct cyttsp5 *ts)
+{
+	int rc;
+
+	rc = cyttsp5_deassert_int(ts);
+	if (rc) {
+		dev_err(ts->dev, "%s: Error on deassert int r=%d\n",
+			__func__, rc);
+		return -ENODEV;
+	}
+
+	/*
+	 * Launch the application as the device starts in bootloader mode
+	 * because of a power-on-reset
+	 */
+	rc = cyttsp5_hid_output_bl_launch_app(ts);
+	if (rc < 0) {
+		dev_err(ts->dev, "%s: Error on launch app r=%d\n",
+			__func__, rc);
+		goto exit;
+	}
+
+	rc = cyttsp5_get_hid_descriptor(ts, &ts->hid_desc);
+	if (rc < 0) {
+		dev_err(ts->dev, "%s: Error on getting HID descriptor r=%d\n",
+			__func__, rc);
+		goto exit;
+	}
+
+	rc = cyttsp5_fill_all_touch(ts);
+	if (rc < 0) {
+		dev_err(ts->dev, "%s: Error on getting report descriptor r=%d\n",
+			__func__, rc);
+		goto exit;
+	}
+
+	rc = cyttsp5_hid_output_get_sysinfo(ts);
+	if (rc) {
+		dev_err(ts->dev, "%s: Error on getting sysinfo r=%d\n",
+			__func__, rc);
+		goto exit;
+	}
+
+exit:
+
+	return rc;
+}
+
+static const struct of_device_id cyttsp5_of_match[] = {
+	{ .compatible = "cypress,cyttsp5", },
+	{ }
+};
+MODULE_DEVICE_TABLE(of, cyttsp5_of_match);
+
+static const struct i2c_device_id cyttsp5_i2c_id[] = {
+	{ CYTTSP5_NAME, 0, },
+	{ }
+};
+MODULE_DEVICE_TABLE(i2c, cyttsp5_i2c_id);
+
+static int cyttsp5_probe(struct device *dev, struct regmap *regmap, int irq,
+			 const char *name)
+{
+	struct cyttsp5 *ts;
+	struct cyttsp5_sysinfo *si;
+	int rc = 0, i;
+
+	ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
+	if (!ts) {
+		rc = -ENOMEM;
+		goto error_alloc_data;
+	}
+
+	/* Initialize device info */
+	ts->regmap = regmap;
+	ts->dev = dev;
+	si = &ts->sysinfo;
+	dev_set_drvdata(dev, ts);
+
+	/* Initialize mutexes and spinlocks */
+	mutex_init(&ts->system_lock);
+	mutex_init(&ts->mt_lock);
+	mutex_init(&ts->btn_lock);
+
+	/* Initialize wait queue */
+	init_waitqueue_head(&ts->wait_q);
+
+	/* Call platform init function */
+	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_HIGH);
+	if (IS_ERR(ts->reset_gpio)) {
+		rc = PTR_ERR(ts->reset_gpio);
+		dev_err(dev, "Failed to request reset gpio, error %d\n", rc);
+		return rc;
+	}
+
+	/* Need a delay to have device up */
+	msleep(20);
+
+	ts->irq = irq;
+	rc = devm_request_threaded_irq(dev, ts->irq, NULL, cyttsp5_handle_irq,
+				       IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
+				       name, ts);
+	if (rc) {
+		dev_err(dev, "unable to request IRQ\n");
+		goto error_setup_irq;
+	}
+
+	rc = cyttsp5_startup(ts);
+	if (rc) {
+		dev_err(ts->dev, "%s: Fail initial startup r=%d\n",
+			__func__, rc);
+		goto error_startup;
+	}
+
+	rc = cyttsp5_parse_dt_key_code(dev);
+	if (rc < 0) {
+		dev_err(ts->dev, "%s: Error while parsing dts\n", __func__);
+		goto error_startup;
+	}
+
+	ts->input = input_allocate_device();
+	if (!ts->input) {
+		dev_err(dev, "%s: Error, failed to allocate input device\n",
+			__func__);
+		rc = -ENODEV;
+		goto error_startup;
+	}
+
+	ts->input->name = "cyttsp5";
+	scnprintf(ts->phys, sizeof(ts->phys), "%s/input%d", dev_name(dev), 0);
+	ts->input->phys = ts->phys;
+	ts->input->dev.parent = ts->dev;
+	input_set_drvdata(ts->input, ts);
+
+	touchscreen_parse_properties(ts->input, true, NULL);
+
+	if (si) {
+		__set_bit(EV_KEY, ts->input->evbit);
+		for (i = 0; i < si->num_btns; i++)
+			__set_bit(si->btn[i].key_code, ts->input->keybit);
+
+		rc = cyttsp5_setup_input_device(dev);
+		if (rc)
+			goto error_init_input;
+	}
+
+	return 0;
+
+error_init_input:
+	input_free_device(ts->input);
+error_startup:
+error_setup_irq:
+	dev_set_drvdata(dev, NULL);
+error_alloc_data:
+	dev_err(dev, "%s failed.\n", __func__);
+	if (dev->of_node)
+		of_node_put(dev->of_node);
+
+	return rc;
+}
+
+static int cyttsp5_i2c_probe(struct i2c_client *client,
+			     const struct i2c_device_id *id)
+{
+	struct regmap *regmap;
+	static const struct regmap_config config = {
+		.reg_bits = 8,
+		.val_bits = 8,
+	};
+
+	regmap = devm_regmap_init_i2c(client, &config);
+	if (IS_ERR(regmap)) {
+		dev_err(&client->dev, "%s: regmap allocation failed: %ld\n",
+			__func__, PTR_ERR(regmap));
+		return PTR_ERR(regmap);
+	}
+
+	return cyttsp5_probe(&client->dev, regmap, client->irq, client->name);
+}
+
+static int cyttsp5_remove(struct device *dev)
+{
+	const struct of_device_id *match;
+	struct cyttsp5 *ts = dev_get_drvdata(dev);
+
+	input_unregister_device(ts->input);
+
+	dev_set_drvdata(dev, NULL);
+
+	match = of_match_device(of_match_ptr(cyttsp5_of_match), dev);
+	if (match && dev->of_node)
+		of_node_put(dev->of_node);
+
+	return 0;
+}
+
+static int cyttsp5_i2c_remove(struct i2c_client *client)
+{
+	struct device *dev = &client->dev;
+
+	return cyttsp5_remove(dev);
+}
+
+static struct i2c_driver cyttsp5_i2c_driver = {
+	.driver = {
+		.name = CYTTSP5_NAME,
+		.owner = THIS_MODULE,
+		.of_match_table = cyttsp5_of_match,
+	},
+	.probe = cyttsp5_i2c_probe,
+	.remove = cyttsp5_i2c_remove,
+	.id_table = cyttsp5_i2c_id,
+};
+
+module_i2c_driver(cyttsp5_i2c_driver);
+
+MODULE_LICENSE("GPL");
+MODULE_DESCRIPTION("Touchscreen driver for Cypress TrueTouch Gen 5 Product");
+MODULE_AUTHOR("Mylène Josserand <mylene.josserand@free-electrons.com>");
-- 
2.11.0

[PATCH] Input: fix platform_no_drv_owner.cocci warnings

[kbuild test robot]

drivers/input/touchscreen/cyttsp5.c:1162:3-8: No need to set .owner here. The core will do it.

 Remove .owner field if calls are used which set it automatically

Generated by: scripts/coccinelle/api/platform_no_drv_owner.cocci

CC: Mylène Josserand <mylene.josserand@free-electrons.com>
Signed-off-by: Fengguang Wu <fengguang.wu@intel.com>
---

 cyttsp5.c |    1 -
 1 file changed, 1 deletion(-)

--- a/drivers/input/touchscreen/cyttsp5.c
+++ b/drivers/input/touchscreen/cyttsp5.c
@@ -1159,7 +1159,6 @@ static int cyttsp5_i2c_remove(struct i2c
 static struct i2c_driver cyttsp5_i2c_driver = {
 	.driver = {
 		.name = CYTTSP5_NAME,
-		.owner = THIS_MODULE,
 		.of_match_table = cyttsp5_of_match,
 	},
 	.probe = cyttsp5_i2c_probe,

[input:next 1341/1344] drivers/input/touchscreen/ft6236.c:316:3-8: No need to set .owner here. The core will do it.

[kbuild test robot]

tree:   https://git.kernel.org/pub/scm/linux/kernel/git/dtor/input.git next
head:   c65cf815653ec64e73d40819806c2d1aed91681e
commit: 92deea1350f9fa97a841d45cd1f8228d5e8aa667 [1341/1344] Input: add support for FocalTech FT6236 touchscreen controller


coccinelle warnings: (new ones prefixed by >>)

>> drivers/input/touchscreen/ft6236.c:316:3-8: No need to set .owner here. The core will do it.

Please review and possibly fold the followup patch.

---
0-DAY kernel test infrastructure                Open Source Technology Center
https://lists.01.org/pipermail/kbuild-all                   Intel Corporation

[PATCH] Input: fix platform_no_drv_owner.cocci warnings

[kbuild test robot]

drivers/input/touchscreen/ft6236.c:316:3-8: No need to set .owner here. The core will do it.

 Remove .owner field if calls are used which set it automatically

Generated by: scripts/coccinelle/api/platform_no_drv_owner.cocci

CC: Noralf Trønnes <noralf@tronnes.org>
Signed-off-by: Fengguang Wu <fengguang.wu@intel.com>
---

 ft6236.c |    1 -
 1 file changed, 1 deletion(-)

--- a/drivers/input/touchscreen/ft6236.c
+++ b/drivers/input/touchscreen/ft6236.c
@@ -313,7 +313,6 @@ MODULE_DEVICE_TABLE(i2c, ft6236_id);
 static struct i2c_driver ft6236_driver = {
 	.driver = {
 		.name = "ft6236",
-		.owner = THIS_MODULE,
 		.of_match_table = of_match_ptr(ft6236_of_match),
 	},
 	.probe = ft6236_probe,

Re: [PATCH] Input: fix platform_no_drv_owner.cocci warnings

[Dmitry Torokhov]

On Tue, Oct 06, 2015 at 09:35:31AM +0800, kbuild test robot wrote:
> drivers/input/touchscreen/ft6236.c:316:3-8: No need to set .owner here. The core will do it.
> 
>  Remove .owner field if calls are used which set it automatically
> 
> Generated by: scripts/coccinelle/api/platform_no_drv_owner.cocci
> 
> CC: Noralf Trønnes <noralf@tronnes.org>
> Signed-off-by: Fengguang Wu <fengguang.wu@intel.com>

Applied, thank you.

> ---
> 
>  ft6236.c |    1 -
>  1 file changed, 1 deletion(-)
> 
> --- a/drivers/input/touchscreen/ft6236.c
> +++ b/drivers/input/touchscreen/ft6236.c
> @@ -313,7 +313,6 @@ MODULE_DEVICE_TABLE(i2c, ft6236_id);
>  static struct i2c_driver ft6236_driver = {
>  	.driver = {
>  		.name = "ft6236",
> -		.owner = THIS_MODULE,
>  		.of_match_table = of_match_ptr(ft6236_of_match),
>  	},
>  	.probe = ft6236_probe,

-- 
Dmitry
--
To unsubscribe from this list: send the line "unsubscribe linux-input" in
the body of a message to majordomo@vger.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html