lists.openwall.net   lists  /  announce  owl-users  owl-dev  john-users  john-dev  passwdqc-users  yescrypt  popa3d-users  /  oss-security  kernel-hardening  musl  sabotage  tlsify  passwords  /  crypt-dev  xvendor  /  Bugtraq  Full-Disclosure  linux-kernel  linux-netdev  linux-ext4  linux-hardening  linux-cve-announce  PHC 
Open Source and information security mailing list archives
 
Hash Suite: Windows password security audit tool. GUI, reports in PDF.
[<prev] [next>] [<thread-prev] [thread-next>] [day] [month] [year] [list]
Date:	Mon, 15 Dec 2014 06:10:49 -0800
From:	Jeremiah Mahler <jmmahler@...il.com>
To:	Dudley Du <dudley.dulixin@...il.com>
Cc:	dmitry.torokhov@...il.com, rydberg@...omail.se, bleung@...gle.com,
	linux-input@...r.kernel.org, linux-kernel@...r.kernel.org
Subject: Re: [PATCH v15 02/12] input: cyapa: add gen5 trackpad device basic
 functions support

Dudley,

On Mon, Dec 15, 2014 at 02:23:13PM +0800, Dudley Du wrote:
> Based on the cyapa core, add the gen5 trackpad device's basic functions
> supported, so gen5 trackpad device can work with kernel input system.
> And also based on the state parse interface, the cyapa driver can
> automatically determine the attached is gen3 or gen5 protocol trackpad
> device, then set the correct protocol to work with the attached
> trackpad device.
> TEST=test on Chromebooks.
> 
> Signed-off-by: Dudley Du <dudley.dulixin@...il.com>
> ---
>  drivers/input/mouse/Makefile     |    2 +-
>  drivers/input/mouse/cyapa.c      |   13 +
>  drivers/input/mouse/cyapa.h      |    1 +
>  drivers/input/mouse/cyapa_gen5.c | 1660 ++++++++++++++++++++++++++++++++++++++
>  4 files changed, 1675 insertions(+), 1 deletion(-)
>  create mode 100644 drivers/input/mouse/cyapa_gen5.c
> 
> diff --git a/drivers/input/mouse/Makefile b/drivers/input/mouse/Makefile
> index 8bd950d..8a9c98e 100644
> --- a/drivers/input/mouse/Makefile
> +++ b/drivers/input/mouse/Makefile
> @@ -24,7 +24,7 @@ obj-$(CONFIG_MOUSE_SYNAPTICS_I2C)	+= synaptics_i2c.o
>  obj-$(CONFIG_MOUSE_SYNAPTICS_USB)	+= synaptics_usb.o
>  obj-$(CONFIG_MOUSE_VSXXXAA)		+= vsxxxaa.o
>  
> -cyapatp-objs := cyapa.o cyapa_gen3.o
> +cyapatp-objs := cyapa.o cyapa_gen3.o cyapa_gen5.o
>  psmouse-objs := psmouse-base.o synaptics.o focaltech.o
>  
>  psmouse-$(CONFIG_MOUSE_PS2_ALPS)	+= alps.o
> diff --git a/drivers/input/mouse/cyapa.c b/drivers/input/mouse/cyapa.c
> index ae1df15..d4560a3 100644
> --- a/drivers/input/mouse/cyapa.c
> +++ b/drivers/input/mouse/cyapa.c
> @@ -157,6 +157,14 @@ static int cyapa_get_state(struct cyapa *cyapa)
>  			if (!error)
>  				goto out_detected;
>  		}
> +		if ((cyapa->gen == CYAPA_GEN_UNKNOWN ||
> +				cyapa->gen == CYAPA_GEN5) &&
> +			!smbus && even_addr) {
> +			error = cyapa_gen5_ops.state_parse(cyapa,
> +					status, BL_STATUS_SIZE);
> +			if (!error)
> +				goto out_detected;
> +		}
>  
>  		/*
>  		 * Write 0x00 0x00 to trackpad device to force update its
> @@ -240,6 +248,9 @@ static int cyapa_check_is_operational(struct cyapa *cyapa)
>  		return error;
>  
>  	switch (cyapa->gen) {
> +	case CYAPA_GEN5:
> +		cyapa->ops = &cyapa_gen5_ops;
> +		break;
>  	case CYAPA_GEN3:
>  		cyapa->ops = &cyapa_gen3_ops;
>  		break;
> @@ -476,6 +487,8 @@ static int cyapa_initialize(struct cyapa *cyapa)
>  
>  	if (cyapa_gen3_ops.initialize)
>  		error = cyapa_gen3_ops.initialize(cyapa);
> +	if (!error && cyapa_gen5_ops.initialize)
> +		error = cyapa_gen5_ops.initialize(cyapa);
>  	if (error)
>  		return error;
>  
> diff --git a/drivers/input/mouse/cyapa.h b/drivers/input/mouse/cyapa.h
> index 709ad47..d7d4f11 100644
> --- a/drivers/input/mouse/cyapa.h
> +++ b/drivers/input/mouse/cyapa.h
> @@ -312,5 +312,6 @@ u16 cyapa_pwr_cmd_to_sleep_time(u8 pwr_mode);
>  
>  extern const char product_id[];
>  extern const struct cyapa_dev_ops cyapa_gen3_ops;
> +extern const struct cyapa_dev_ops cyapa_gen5_ops;
>  
>  #endif
> diff --git a/drivers/input/mouse/cyapa_gen5.c b/drivers/input/mouse/cyapa_gen5.c
> new file mode 100644
> index 0000000..1ac264d
> --- /dev/null
> +++ b/drivers/input/mouse/cyapa_gen5.c
> @@ -0,0 +1,1660 @@
> +/*
> + * Cypress APA trackpad with I2C interface
> + *
> + * Author: Dudley Du <dudl@...ress.com>
> + *
> + * Copyright (C) 2014 Cypress Semiconductor, Inc.
> + *
> + * This file is subject to the terms and conditions of the GNU General Public
> + * License.  See the file COPYING in the main directory of this archive for
> + * more details.
> + */
> +
> +#include <linux/delay.h>
> +#include <linux/i2c.h>
> +#include <linux/input.h>
> +#include <linux/input/mt.h>
> +#include <linux/mutex.h>
> +#include <linux/completion.h>
> +#include <linux/slab.h>
> +#include <linux/unaligned/access_ok.h>
> +#include "cyapa.h"
> +
> +
> +/* Macro of Gen5 */
> +#define RECORD_EVENT_NONE        0
> +#define RECORD_EVENT_TOUCHDOWN	 1
> +#define RECORD_EVENT_DISPLACE    2
> +#define RECORD_EVENT_LIFTOFF     3
> +
> +#define CYAPA_TSG_FLASH_MAP_BLOCK_SIZE      0x80
> +#define CYAPA_TSG_IMG_FW_HDR_SIZE           13
> +#define CYAPA_TSG_FW_ROW_SIZE               (CYAPA_TSG_FLASH_MAP_BLOCK_SIZE)
> +#define CYAPA_TSG_IMG_START_ROW_NUM         0x002e
> +#define CYAPA_TSG_IMG_END_ROW_NUM           0x01fe
> +#define CYAPA_TSG_IMG_APP_INTEGRITY_ROW_NUM 0x01ff
> +#define CYAPA_TSG_IMG_MAX_RECORDS           (CYAPA_TSG_IMG_END_ROW_NUM - \
> +				CYAPA_TSG_IMG_START_ROW_NUM + 1 + 1)
> +#define CYAPA_TSG_IMG_READ_SIZE             (CYAPA_TSG_FLASH_MAP_BLOCK_SIZE / 2)
> +#define CYAPA_TSG_START_OF_APPLICATION      0x1700
> +#define CYAPA_TSG_APP_INTEGRITY_SIZE        60
> +#define CYAPA_TSG_FLASH_MAP_METADATA_SIZE   60
> +#define CYAPA_TSG_BL_KEY_SIZE               8
> +
> +/* Macro definitions for Gen5 trackpad device. */
> +#define GEN5_TOUCH_REPORT_HEAD_SIZE     7
> +#define GEN5_TOUCH_REPORT_MAX_SIZE      127
> +#define GEN5_BTN_REPORT_HEAD_SIZE       6
> +#define GEN5_BTN_REPORT_MAX_SIZE        14
> +#define GEN5_WAKEUP_EVENT_SIZE          4
> +#define GEN5_RAW_DATA_HEAD_SIZE         24
> +
> +#define GEN5_BL_CMD_REPORT_ID           0x40
> +#define GEN5_BL_RESP_REPORT_ID          0x30
> +#define GEN5_APP_CMD_REPORT_ID          0x2f
> +#define GEN5_APP_RESP_REPORT_ID         0x1f
> +
> +#define GEN5_APP_DEEP_SLEEP_REPORT_ID   0xf0
> +#define GEN5_DEEP_SLEEP_RESP_LENGTH     5
> +
> +#define GEN5_PARAMETER_ACT_INTERVL_ID        0x4d
> +#define GEN5_PARAMETER_ACT_INTERVL_SIZE      1
> +#define GEN5_PARAMETER_ACT_LFT_INTERVL_ID    0x4f
> +#define GEN5_PARAMETER_ACT_LFT_INTERVL_SIZE  2
> +#define GEN5_PARAMETER_LP_INTRVL_ID          0x4c
> +#define GEN5_PARAMETER_LP_INTRVL_SIZE        2
> +
> +#define GEN5_PARAMETER_DISABLE_PIP_REPORT    0x08
> +
> +#define GEN5_POWER_STATE_ACTIVE              0x01
> +#define GEN5_POWER_STATE_LOOK_FOR_TOUCH      0x02
> +#define GEN5_POWER_STATE_READY               0x03
> +#define GEN5_POWER_STATE_IDLE                0x04
> +#define GEN5_POWER_STATE_BTN_ONLY            0x05
> +#define GEN5_POWER_STATE_OFF                 0x06
> +
> +#define GEN5_DEEP_SLEEP_STATE_MASK  0x03
> +#define GEN5_DEEP_SLEEP_STATE_ON    0x00
> +#define GEN5_DEEP_SLEEP_STATE_OFF   0x01
> +
> +#define GEN5_DEEP_SLEEP_OPCODE      0x08
> +#define GEN5_DEEP_SLEEP_OPCODE_MASK 0x0f
> +
> +#define GEN5_POWER_READY_MAX_INTRVL_TIME  50   /* Unit: ms */
> +#define GEN5_POWER_IDLE_MAX_INTRVL_TIME   250  /* Unit: ms */
> +
> +#define GEN5_CMD_REPORT_ID_OFFSET       4
> +
> +#define GEN5_RESP_REPORT_ID_OFFSET      2
> +#define GEN5_RESP_RSVD_OFFSET           3
> +#define     GEN5_RESP_RSVD_KEY          0x00
> +#define GEN5_RESP_BL_SOP_OFFSET         4
> +#define     GEN5_SOP_KEY                0x01  /* Start of Packet */
> +#define     GEN5_EOP_KEY                0x17  /* End of Packet */
> +#define GEN5_RESP_APP_CMD_OFFSET        4
> +#define     GET_GEN5_CMD_CODE(reg)      ((reg) & 0x7f)
> +
> +#define VALID_CMD_RESP_HEADER(resp, cmd)				    \
> +	(((resp)[GEN5_RESP_REPORT_ID_OFFSET] == GEN5_APP_RESP_REPORT_ID) && \
> +	((resp)[GEN5_RESP_RSVD_OFFSET] == GEN5_RESP_RSVD_KEY) &&	    \
> +	(GET_GEN5_CMD_CODE((resp)[GEN5_RESP_APP_CMD_OFFSET]) == (cmd)))
> +
> +#define GEN5_MIN_BL_CMD_LENGTH           13
> +#define GEN5_MIN_BL_RESP_LENGTH          11
> +#define GEN5_MIN_APP_CMD_LENGTH          7
> +#define GEN5_MIN_APP_RESP_LENGTH         5
> +#define GEN5_UNSUPPORTED_CMD_RESP_LENGTH 6
> +
> +#define GEN5_RESP_LENGTH_OFFSET  0x00
> +#define GEN5_RESP_LENGTH_SIZE    2
> +
> +#define GEN5_HID_DESCRIPTOR_SIZE      32
> +#define GEN5_BL_HID_REPORT_ID         0xff
> +#define GEN5_APP_HID_REPORT_ID        0xf7
> +#define GEN5_BL_MAX_OUTPUT_LENGTH     0x0100
> +#define GEN5_APP_MAX_OUTPUT_LENGTH    0x00fe
> +
> +#define GEN5_BL_REPORT_DESCRIPTOR_SIZE            0x1d
> +#define GEN5_BL_REPORT_DESCRIPTOR_ID              0xfe
> +#define GEN5_APP_REPORT_DESCRIPTOR_SIZE           0xee
> +#define GEN5_APP_CONTRACT_REPORT_DESCRIPTOR_SIZE  0xfa
> +#define GEN5_APP_REPORT_DESCRIPTOR_ID             0xf6
> +
> +#define GEN5_TOUCH_REPORT_ID         0x01
> +#define GEN5_BTN_REPORT_ID           0x03
> +#define GEN5_WAKEUP_EVENT_REPORT_ID  0x04
> +#define GEN5_OLD_PUSH_BTN_REPORT_ID  0x05
> +#define GEN5_PUSH_BTN_REPORT_ID      0x06
> +
> +#define GEN5_CMD_COMPLETE_SUCCESS(status) ((status) == 0x00)
> +
> +#define GEN5_BL_INITIATE_RESP_LEN            11
> +#define GEN5_BL_FAIL_EXIT_RESP_LEN           11
> +#define GEN5_BL_FAIL_EXIT_STATUS_CODE        0x0c
> +#define GEN5_BL_VERIFY_INTEGRITY_RESP_LEN    12
> +#define GEN5_BL_INTEGRITY_CHEKC_PASS         0x00
> +#define GEN5_BL_BLOCK_WRITE_RESP_LEN         11
> +#define GEN5_BL_READ_APP_INFO_RESP_LEN       31
> +#define GEN5_CMD_CALIBRATE                   0x28
> +#define CYAPA_SENSING_MODE_MUTUAL_CAP_FINE   0x00
> +#define CYAPA_SENSING_MODE_SELF_CAP          0x02
> +
> +#define GEN5_CMD_RETRIEVE_DATA_STRUCTURE     0x24
> +#define GEN5_RETRIEVE_MUTUAL_PWC_DATA        0x00
> +#define GEN5_RETRIEVE_SELF_CAP_PWC_DATA      0x01
> +
> +#define GEN5_RETRIEVE_DATA_ELEMENT_SIZE_MASK 0x07
> +
> +#define GEN5_CMD_EXECUTE_PANEL_SCAN          0x2a
> +#define GEN5_CMD_RETRIEVE_PANEL_SCAN         0x2b
> +#define GEN5_PANEL_SCAN_MUTUAL_RAW_DATA      0x00
> +#define GEN5_PANEL_SCAN_MUTUAL_BASELINE      0x01
> +#define GEN5_PANEL_SCAN_MUTUAL_DIFFCOUNT     0x02
> +#define GEN5_PANEL_SCAN_SELF_RAW_DATA        0x03
> +#define GEN5_PANEL_SCAN_SELF_BASELINE        0x04
> +#define GEN5_PANEL_SCAN_SELF_DIFFCOUNT       0x05
> +
> +#define GEN5_PWC_DATA_ELEMENT_SIZE_MASK      0x07
> +
> +#define	GEN5_NUMBER_OF_TOUCH_OFFSET  5
> +#define GEN5_NUMBER_OF_TOUCH_MASK    0x1f
> +#define GEN5_BUTTONS_OFFSET          5
> +#define GEN5_BUTTONS_MASK            0x0f
> +#define GEN5_GET_EVENT_ID(reg)       (((reg) >> 5) & 0x03)
> +#define GEN5_GET_TOUCH_ID(reg)       ((reg) & 0x1f)
> +
> +#define GEN5_PRODUCT_FAMILY_MASK        0xf000
> +#define GEN5_PRODUCT_FAMILY_TRACKPAD    0x1000
> +
> +#define TSG_INVALID_CMD   0xff
> +
> +struct cyapa_gen5_touch_record {
> +	/*
> +	 * Bit 7 - 3: reserved
> +	 * Bit 2 - 0: touch type;
> +	 *            0 : standard finger;
> +	 *            1 - 15 : reserved.
> +	 */
> +	u8 touch_type;
> +
> +	/*
> +	 * Bit 7: indicates touch liftoff status.
> +	 *		0 : touch is currently on the panel.
> +	 *		1 : touch record indicates a liftoff.
> +	 * Bit 6 - 5: indicates an event associated with this touch instance
> +	 *		0 : no event
> +	 *		1 : touchdown
> +	 *		2 : significant displacement (> active distance)
> +	 *		3 : liftoff (record reports last known coordinates)
> +	 * Bit 4 - 0: An arbitrary ID tag associated with a finger
> +	 *		to allow tracking a touch as it moves around the panel.
> +	 */
> +	u8 touch_tip_event_id;
> +
> +	/* Bit 7 - 0 of X-axis corrinate of the touch in pixel. */
                               coordinate

                              and more below...
> +	u8 x_lo;
> +
> +	/* Bit 15 - 8 of X-axis corrinate of the touch in pixel. */
> +	u8 x_hi;
> +
> +	/* Bit 7 - 0 of Y-axis corrinate of the touch in pixel. */
> +	u8 y_lo;
> +
> +	/* Bit 15 - 8 of Y-axis corrinate of the touch in pixel. */
> +	u8 y_hi;
> +
> +	/* Touch intensity in counts, pressure value. */
> +	u8 z;
> +
> +	/*
> +	 * The length of the major axis of the ellipse of contact between
> +	 * the finger and the panel (ABS_MT_TOUCH_MAJOR).
> +	 */
> +	u8 major_axis_len;
> +
> +	/*
> +	 * The length of the minor axis of the ellipse of contact between
> +	 * the finger and the panel (ABS_MT_TOUCH_MINOR).
> +	 */
> +	u8 minor_axis_len;
> +
> +	/*
> +	 * The length of the major axis of the approaching tool.
> +	 * (ABS_MT_WIDTH_MAJOR)
> +	 */
> +	u8 major_tool_len;
> +
> +	/*
> +	 * The length of the minor axis of the approaching tool.
> +	 * (ABS_MT_WIDTH_MINOR)
> +	 */
> +	u8 minor_tool_len;
> +
> +	/*
> +	 * The angle between the panel vertical axis and
> +	 * the major axis of the contact ellipse. This value is an 8-bit
> +	 * signed integer. The range is -127 to +127 (corresponding to
> +	 * -90 degree and +90 degree respectively).
> +	 * The positive direction is clockwise from the vertical axis.
> +	 * If the ellipse of contact degenerates into a circle,
> +	 * orientation is reported as 0.
> +	 */
> +	u8 orientation;
> +} __packed;
> +
> +struct cyapa_gen5_report_data {
> +	u8 report_head[GEN5_TOUCH_REPORT_HEAD_SIZE];
> +	struct cyapa_gen5_touch_record touch_records[10];
> +} __packed;
> +
> +struct cyapa_tsg_bin_image_data_record {
> +	u8 flash_array_id;
> +	__be16 row_number;
> +	/* The number of bytes of flash data contained in this record. */
> +	__be16 record_len;
> +	/* The flash program data. */
> +	u8 record_data[CYAPA_TSG_FW_ROW_SIZE];
> +} __packed;
> +
> +struct cyapa_tsg_bin_image {
> +	struct cyapa_tsg_bin_image_head image_head;
> +	struct cyapa_tsg_bin_image_data_record records[0];
> +} __packed;
> +
> +/* Variables to record latest gen5 trackpad power states. */
> +#define GEN5_DEV_SET_PWR_STATE(cyapa, s)	((cyapa)->dev_pwr_mode = (s))
> +#define GEN5_DEV_GET_PWR_STATE(cyapa)		((cyapa)->dev_pwr_mode)
> +#define GEN5_DEV_SET_SLEEP_TIME(cyapa, t)	((cyapa)->dev_sleep_time = (t))
> +#define GEN5_DEV_GET_SLEEP_TIME(cyapa)		((cyapa)->dev_sleep_time)
> +#define GEN5_DEV_UNINIT_SLEEP_TIME(cyapa)	\
> +		(((cyapa)->dev_sleep_time) == UNINIT_SLEEP_TIME)
> +
> +
> +static int cyapa_gen5_initialize(struct cyapa *cyapa)
> +{
> +	struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
> +
> +	init_completion(&gen5_pip->cmd_ready);
> +	atomic_set(&gen5_pip->cmd_issued, 0);
> +	mutex_init(&gen5_pip->cmd_lock);
> +
> +	gen5_pip->resp_sort_func = NULL;
> +	gen5_pip->in_progress_cmd = TSG_INVALID_CMD;
> +	gen5_pip->resp_data = NULL;
> +	gen5_pip->resp_len = NULL;
> +
> +	cyapa->dev_pwr_mode = UNINIT_PWR_MODE;
> +	cyapa->dev_sleep_time = UNINIT_SLEEP_TIME;
> +
> +	return 0;
> +}
> +
> +/* Return negative errno, or else the number of bytes read. */
> +static ssize_t cyapa_i2c_pip_read(struct cyapa *cyapa, u8 *buf, size_t size)
> +{
> +	int ret;
> +
> +	if (size == 0)
> +		return 0;
> +
> +	if (!buf || size > CYAPA_REG_MAP_SIZE)
> +		return -EINVAL;
> +
> +	ret = i2c_master_recv(cyapa->client, buf, size);
> +
> +	if (ret != size)
> +		return (ret < 0) ? ret : -EIO;
> +
> +	return size;
> +}
> +
> +/**
> + * Return a negative errno code else zero on success.
> + */
> +static ssize_t cyapa_i2c_pip_write(struct cyapa *cyapa, u8 *buf, size_t size)
> +{
> +	int ret;
> +
> +	if (!buf || !size)
> +		return -EINVAL;
> +
> +	ret = i2c_master_send(cyapa->client, buf, size);
> +
> +	if (ret != size)
> +		return (ret < 0) ? ret : -EIO;
> +
> +	return 0;
> +}
> +
> +/**
> + * This function is aimed to dump all not read data in Gen5 trackpad
> + * before send any command, otherwise, the interrupt line will be blocked.
> + */
> +static int cyapa_empty_pip_output_data(struct cyapa *cyapa,
> +		u8 *buf, int *len, cb_sort func)
> +{
> +	struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
> +	int length;
> +	int report_count;
> +	int empty_count;
> +	int buf_len;
> +	int error;
> +
> +	buf_len = 0;
> +	if (len) {
> +		buf_len = (*len < CYAPA_REG_MAP_SIZE) ?
> +				*len : CYAPA_REG_MAP_SIZE;
> +		*len = 0;
> +	}
> +
> +	report_count = 8;  /* max 7 pending data before command response data */
> +	empty_count = 0;
> +	do {
> +		/*
> +		 * Depnding on testing in cyapa driver, there are max 5 "02 00"
                   Depending

> +		 * packets between two valid buffered data report in firmware.
> +		 * So in order to dump all buffered data out and
> +		 * make interrupt line release for reassert again,
> +		 * we must set the empty_count check value bigger than 5 to
> +		 * make it work. Otherwise, in some situation,
> +		 * the interrupt line may unable to reactive again,
> +		 * which will cause trackpad device unable to
> +		 * report data any more.
> +		 * for example, it may happen in EFT and ESD testing.
> +		 */
> +		if (empty_count > 5)
> +			return 0;
> +
> +		error = cyapa_i2c_pip_read(cyapa, gen5_pip->empty_buf,
> +				GEN5_RESP_LENGTH_SIZE);
> +		if (error < 0)
> +			return error;
> +
> +		length = get_unaligned_le16(gen5_pip->empty_buf);
> +		if (length == GEN5_RESP_LENGTH_SIZE) {
> +			empty_count++;
> +			continue;
> +		} else if (length > CYAPA_REG_MAP_SIZE) {
> +			/* Should not happen */
> +			return -EINVAL;
> +		} else if (length == 0) {
> +			/* Application or bootloader launch data polled out. */
> +			length = GEN5_RESP_LENGTH_SIZE;
> +			if (buf && buf_len && func &&
> +				func(cyapa, gen5_pip->empty_buf, length)) {
> +				length = min(buf_len, length);
> +				memcpy(buf, gen5_pip->empty_buf, length);
> +				*len = length;
> +				/* Response found, success. */
> +				return 0;
> +			}
> +			continue;
> +		}
> +
> +		error = cyapa_i2c_pip_read(cyapa, gen5_pip->empty_buf, length);
> +		if (error < 0)
> +			return error;
> +
> +		report_count--;
> +		empty_count = 0;
> +		length = get_unaligned_le16(gen5_pip->empty_buf);
> +		if (length <= GEN5_RESP_LENGTH_SIZE) {
> +			empty_count++;
> +		} else if (buf && buf_len && func &&
> +			func(cyapa, gen5_pip->empty_buf, length)) {
> +			length = min(buf_len, length);
> +			memcpy(buf, gen5_pip->empty_buf, length);
> +			*len = length;
> +			/* Response found, success. */
> +			return 0;
> +		}
> +
> +		error = -EINVAL;
> +	} while (report_count);
> +
> +	return error;
> +}
> +
> +static int cyapa_do_i2c_pip_cmd_irq_sync(
> +		struct cyapa *cyapa,
> +		u8 *cmd, size_t cmd_len,
> +		unsigned long timeout)
> +{
> +	int error;
> +	struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
> +
> +	/* Wait for interrupt to set ready completion */
> +	init_completion(&gen5_pip->cmd_ready);
> +
> +	atomic_inc(&gen5_pip->cmd_issued);
> +	error = cyapa_i2c_pip_write(cyapa, cmd, cmd_len);
> +	if (error) {
> +		atomic_dec(&gen5_pip->cmd_issued);
> +		return (error < 0) ? error : -EIO;
> +	}
> +
> +	/* Wait for interrupt to indicate command is completed. */
> +	timeout = wait_for_completion_timeout(&gen5_pip->cmd_ready,
> +				msecs_to_jiffies(timeout));
> +	if (timeout == 0) {
> +		atomic_dec(&gen5_pip->cmd_issued);
> +		return -ETIMEDOUT;
> +	}
> +
> +	return 0;
> +}
> +
> +static int cyapa_do_i2c_pip_cmd_polling(
> +		struct cyapa *cyapa,
> +		u8 *cmd, size_t cmd_len,
> +		u8 *resp_data, int *resp_len,
> +		unsigned long timeout,
> +		cb_sort func)
> +{
> +	int error;
> +	int tries;
> +	int length;
> +	struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
> +
> +	atomic_inc(&gen5_pip->cmd_issued);
> +	error = cyapa_i2c_pip_write(cyapa, cmd, cmd_len);
> +	if (error) {
> +		atomic_dec(&gen5_pip->cmd_issued);
> +		return error < 0 ? error : -EIO;
> +	}
> +
> +	tries = timeout / 5;
> +	length = resp_len ? *resp_len : 0;
> +	if (resp_data && resp_len && length != 0 && func) {
> +		do {
> +			usleep_range(3000, 5000);
> +			*resp_len = length;
> +			error = cyapa_empty_pip_output_data(cyapa,
> +					resp_data, resp_len, func);
> +			if (error || *resp_len == 0)
> +				continue;
> +			else
> +				break;
> +		} while (--tries > 0);
> +		if ((error || *resp_len == 0) || tries <= 0)
> +			error = error ? error : -ETIMEDOUT;
> +	}
> +
> +	atomic_dec(&gen5_pip->cmd_issued);
> +	return error;
> +}
> +
> +static int cyapa_i2c_pip_cmd_irq_sync(
> +		struct cyapa *cyapa,
> +		u8 *cmd, int cmd_len,
> +		u8 *resp_data, int *resp_len,
> +		unsigned long timeout,
> +		cb_sort func,
> +		bool irq_mode)
> +{
> +	int error;
> +	struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
> +
> +	if (!cmd || !cmd_len)
> +		return -EINVAL;
> +
> +	/* Commands must be serialized. */
> +	error = mutex_lock_interruptible(&gen5_pip->cmd_lock);
> +	if (error)
> +		return error;
> +
> +	gen5_pip->resp_sort_func = func;
> +	gen5_pip->resp_data = resp_data;
> +	gen5_pip->resp_len = resp_len;
> +
> +	if (cmd_len >= GEN5_MIN_APP_CMD_LENGTH &&
> +			cmd[4] == GEN5_APP_CMD_REPORT_ID) {
> +		/* Application command */
> +		gen5_pip->in_progress_cmd = cmd[6] & 0x7f;
> +	} else if (cmd_len >= GEN5_MIN_BL_CMD_LENGTH &&
> +			cmd[4] == GEN5_BL_CMD_REPORT_ID) {
> +		/* Bootloader command */
> +		gen5_pip->in_progress_cmd = cmd[7];
> +	}
> +
> +	/* Send command data, wait and read output response data's length. */
> +	if (irq_mode) {
> +		gen5_pip->is_irq_mode = true;
> +		error = cyapa_do_i2c_pip_cmd_irq_sync(cyapa, cmd, cmd_len,
> +							timeout);
> +		if (error == -ETIMEDOUT && resp_data &&
> +				resp_len && *resp_len != 0 && func) {
> +			/*
> +			 * For some old version, there was no interrupt for
> +			 * the command response data, so need to poll here
> +			 * to try to get the response data.
> +			 */
> +			error = cyapa_empty_pip_output_data(cyapa,
> +					resp_data, resp_len, func);
> +			if (error || *resp_len == 0)
> +				error = error ? error : -ETIMEDOUT;
> +		}
> +	} else {
> +		gen5_pip->is_irq_mode = false;
> +		error = cyapa_do_i2c_pip_cmd_polling(cyapa, cmd, cmd_len,
> +				resp_data, resp_len, timeout, func);
> +	}
> +
> +	gen5_pip->resp_sort_func = NULL;
> +	gen5_pip->resp_data = NULL;
> +	gen5_pip->resp_len = NULL;
> +	gen5_pip->in_progress_cmd = TSG_INVALID_CMD;
> +
> +	mutex_unlock(&gen5_pip->cmd_lock);
> +	return error;
> +}
> +
> +static bool cyapa_gen5_sort_tsg_pip_bl_resp_data(struct cyapa *cyapa,
> +		u8 *data, int len)
> +{
> +	if (!data || len < GEN5_MIN_BL_RESP_LENGTH)
> +		return false;
> +
> +	/* Bootloader input report id 30h */
> +	if (data[GEN5_RESP_REPORT_ID_OFFSET] == GEN5_BL_RESP_REPORT_ID &&
> +			data[GEN5_RESP_RSVD_OFFSET] == GEN5_RESP_RSVD_KEY &&
> +			data[GEN5_RESP_BL_SOP_OFFSET] == GEN5_SOP_KEY)
> +		return true;
> +
> +	return false;
> +}
> +
> +static bool cyapa_gen5_sort_tsg_pip_app_resp_data(struct cyapa *cyapa,
> +		u8 *data, int len)
> +{
> +	int resp_len;
> +	struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
> +
> +	if (!data || len < GEN5_MIN_APP_RESP_LENGTH)
> +		return false;
> +
> +	if (data[GEN5_RESP_REPORT_ID_OFFSET] == GEN5_APP_RESP_REPORT_ID &&
> +			data[GEN5_RESP_RSVD_OFFSET] == GEN5_RESP_RSVD_KEY) {
> +		resp_len = get_unaligned_le16(&data[GEN5_RESP_LENGTH_OFFSET]);
> +		if (GET_GEN5_CMD_CODE(data[GEN5_RESP_APP_CMD_OFFSET]) == 0x00 &&
> +			resp_len == GEN5_UNSUPPORTED_CMD_RESP_LENGTH &&
> +			data[5] == gen5_pip->in_progress_cmd) {
> +			/* Unsupported command code */
> +			return false;
> +		} else if (GET_GEN5_CMD_CODE(data[GEN5_RESP_APP_CMD_OFFSET]) ==
> +				gen5_pip->in_progress_cmd) {
> +			/* Correct command response received */
> +			return true;
> +		}
> +	}
> +
> +	return false;
> +}
> +
> +static bool cyapa_gen5_sort_application_launch_data(struct cyapa *cyapa,
> +		u8 *buf, int len)
> +{
> +	if (buf == NULL || len < GEN5_RESP_LENGTH_SIZE)
> +		return false;
> +
> +	/*
> +	 * After reset or power on, trackpad device always sets to 0x00 0x00
> +	 * to indicate a reset or power on event.
> +	 */
> +	if (buf[0] == 0 && buf[1] == 0)
> +		return true;
> +
> +	return false;
> +}
> +
> +static bool cyapa_gen5_sort_hid_descriptor_data(struct cyapa *cyapa,
> +		u8 *buf, int len)
> +{
> +	int resp_len;
> +	int max_output_len;
> +
> +	/* Check hid descriptor. */
> +	if (len != GEN5_HID_DESCRIPTOR_SIZE)
> +		return false;
> +
> +	resp_len = get_unaligned_le16(&buf[GEN5_RESP_LENGTH_OFFSET]);
> +	max_output_len = get_unaligned_le16(&buf[16]);
> +	if (resp_len == GEN5_HID_DESCRIPTOR_SIZE) {
> +		if (buf[GEN5_RESP_REPORT_ID_OFFSET] == GEN5_BL_HID_REPORT_ID &&
> +				max_output_len == GEN5_BL_MAX_OUTPUT_LENGTH) {
> +			/* BL mode HID Descriptor */
> +			return true;
> +		} else if (buf[2] == GEN5_APP_HID_REPORT_ID &&
> +				max_output_len == GEN5_APP_MAX_OUTPUT_LENGTH) {
> +			/* APP mode HID Descriptor */
> +			return true;
> +		}
> +	}
> +
> +	return false;
> +}
> +
> +static bool cyapa_gen5_sort_deep_sleep_data(struct cyapa *cyapa,
> +		u8 *buf, int len)
> +{
> +	if (len == GEN5_DEEP_SLEEP_RESP_LENGTH &&
> +		buf[GEN5_RESP_REPORT_ID_OFFSET] ==
> +			GEN5_APP_DEEP_SLEEP_REPORT_ID &&
> +		(buf[4] & GEN5_DEEP_SLEEP_OPCODE_MASK) ==
> +			GEN5_DEEP_SLEEP_OPCODE)
> +		return true;
> +	return false;
> +}
> +
> +static int gen5_idle_state_parse(struct cyapa *cyapa)
> +{
> +	int ret;
> +	int error;
> +	int length;
> +	u8 cmd[2];
> +	u8 resp_data[GEN5_HID_DESCRIPTOR_SIZE];
> +	int max_output_len;
> +
> +	/*
> +	 * Dump all buffered data firstly for the situation
> +	 * when the trackpad is just power on the cyapa go here.
> +	 */
> +	cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL);
> +
> +	memset(resp_data, 0, sizeof(resp_data));
> +	ret = cyapa_i2c_pip_read(cyapa, resp_data, 3);
> +	if (ret != 3)
> +		return ret < 0 ? ret : -EIO;
> +
> +	length = get_unaligned_le16(&resp_data[GEN5_RESP_LENGTH_OFFSET]);
> +	if (length == GEN5_RESP_LENGTH_SIZE) {
> +		/* Normal state of Gen5 with no data to respose */
> +		cyapa->gen = CYAPA_GEN5;
> +
> +		cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL);
> +
> +		/* Read description from trackpad device */
> +		cmd[0] = 0x01;
> +		cmd[1] = 0x00;
> +		length = GEN5_HID_DESCRIPTOR_SIZE;
> +		error = cyapa_i2c_pip_cmd_irq_sync(cyapa,
> +				cmd, GEN5_RESP_LENGTH_SIZE,
> +				resp_data, &length,
> +				300,
> +				cyapa_gen5_sort_hid_descriptor_data,
> +				false);
> +		if (error)
> +			return error;
> +
> +		length = get_unaligned_le16(
> +				&resp_data[GEN5_RESP_LENGTH_OFFSET]);
> +		max_output_len = get_unaligned_le16(&resp_data[16]);
> +		if ((length == GEN5_HID_DESCRIPTOR_SIZE ||
> +				length == GEN5_RESP_LENGTH_SIZE) &&
> +			(resp_data[GEN5_RESP_REPORT_ID_OFFSET] ==
> +				GEN5_BL_HID_REPORT_ID) &&
> +			max_output_len == GEN5_BL_MAX_OUTPUT_LENGTH) {
> +			/* BL mode HID Description read */
> +			cyapa->state = CYAPA_STATE_GEN5_BL;
> +		} else if ((length == GEN5_HID_DESCRIPTOR_SIZE ||
> +				length == GEN5_RESP_LENGTH_SIZE) &&
> +			(resp_data[GEN5_RESP_REPORT_ID_OFFSET] ==
> +				GEN5_APP_HID_REPORT_ID) &&
> +			max_output_len == GEN5_APP_MAX_OUTPUT_LENGTH) {
> +			/* APP mode HID Description read */
> +			cyapa->state = CYAPA_STATE_GEN5_APP;
> +		} else {
> +			/* Should not happen!!! */
> +			cyapa->state = CYAPA_STATE_NO_DEVICE;
> +		}
> +	}
> +
> +	return 0;
> +}
> +
> +static int gen5_hid_description_header_parse(struct cyapa *cyapa, u8 *reg_data)
> +{
> +	int ret;
> +	int length;
> +	u8 resp_data[32];
> +	int max_output_len;
> +
> +	/* 0x20 0x00 0xF7 is Gen5 Application HID Description Header;
> +	 * 0x20 0x00 0xFF is Gen5 Booloader HID Description Header.
> +	 *
> +	 * Must read HID Description content through out,
> +	 * otherwise Gen5 trackpad cannot response next command
> +	 * or report any touch or button data.
> +	 */
> +	ret = cyapa_i2c_pip_read(cyapa, resp_data,
> +			GEN5_HID_DESCRIPTOR_SIZE);
> +	if (ret != GEN5_HID_DESCRIPTOR_SIZE)
> +		return ret < 0 ? ret : -EIO;
> +	length = get_unaligned_le16(&resp_data[GEN5_RESP_LENGTH_OFFSET]);
> +	max_output_len = get_unaligned_le16(&resp_data[16]);
> +	if (length == GEN5_RESP_LENGTH_SIZE) {
> +		if (reg_data[GEN5_RESP_REPORT_ID_OFFSET] ==
> +				GEN5_BL_HID_REPORT_ID) {
> +			/*
> +			 * BL mode HID Description has been previously
> +			 * read out.
> +			 */
> +			cyapa->gen = CYAPA_GEN5;
> +			cyapa->state = CYAPA_STATE_GEN5_BL;
> +		} else {
> +			/*
> +			 * APP mode HID Description has been previously
> +			 * read out.
> +			 */
> +			cyapa->gen = CYAPA_GEN5;
> +			cyapa->state = CYAPA_STATE_GEN5_APP;
> +		}
> +	} else if (length == GEN5_HID_DESCRIPTOR_SIZE &&
> +			resp_data[2] == GEN5_BL_HID_REPORT_ID &&
> +			max_output_len == GEN5_BL_MAX_OUTPUT_LENGTH) {
> +		/* BL mode HID Description read. */
> +		cyapa->gen = CYAPA_GEN5;
> +		cyapa->state = CYAPA_STATE_GEN5_BL;
> +	} else if (length == GEN5_HID_DESCRIPTOR_SIZE &&
> +			(resp_data[GEN5_RESP_REPORT_ID_OFFSET] ==
> +				GEN5_APP_HID_REPORT_ID) &&
> +			max_output_len == GEN5_APP_MAX_OUTPUT_LENGTH) {
> +		/* APP mode HID Description read. */
> +		cyapa->gen = CYAPA_GEN5;
> +		cyapa->state = CYAPA_STATE_GEN5_APP;
> +	} else {
> +		/* Should not happen!!! */
> +		cyapa->state = CYAPA_STATE_NO_DEVICE;
> +	}
> +
> +	return 0;
> +}
> +
> +static int gen5_report_data_header_parse(struct cyapa *cyapa, u8 *reg_data)
> +{
> +	int length;
> +
> +	length = get_unaligned_le16(&reg_data[GEN5_RESP_LENGTH_OFFSET]);
> +	switch (reg_data[GEN5_RESP_REPORT_ID_OFFSET]) {
> +	case GEN5_TOUCH_REPORT_ID:
> +		if (length < GEN5_TOUCH_REPORT_HEAD_SIZE ||
> +			length > GEN5_TOUCH_REPORT_MAX_SIZE)
> +			return -EINVAL;
> +		break;
> +	case GEN5_BTN_REPORT_ID:
> +	case GEN5_OLD_PUSH_BTN_REPORT_ID:
> +	case GEN5_PUSH_BTN_REPORT_ID:
> +		if (length < GEN5_BTN_REPORT_HEAD_SIZE ||
> +			length > GEN5_BTN_REPORT_MAX_SIZE)
> +			return -EINVAL;
> +		break;
> +	case GEN5_WAKEUP_EVENT_REPORT_ID:
> +		if (length != GEN5_WAKEUP_EVENT_SIZE)
> +			return -EINVAL;
> +		break;
> +	default:
> +		return -EINVAL;
> +	}
> +
> +	cyapa->gen = CYAPA_GEN5;
> +	cyapa->state = CYAPA_STATE_GEN5_APP;
> +	return 0;
> +}
> +
> +static int gen5_cmd_resp_header_parse(struct cyapa *cyapa, u8 *reg_data)
> +{
> +	int ret;
> +	int length;
> +	struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
> +
> +	/*
> +	 * Must read report data through out,
> +	 * otherwise Gen5 trackpad cannot response next command
> +	 * or report any touch or button data.
> +	 */
> +	length = get_unaligned_le16(&reg_data[GEN5_RESP_LENGTH_OFFSET]);
> +	ret = cyapa_i2c_pip_read(cyapa, gen5_pip->empty_buf, length);
> +	if (ret != length)
> +		return ret < 0 ? ret : -EIO;
> +
> +	if (length == GEN5_RESP_LENGTH_SIZE) {
> +		/* Previous command has read the data through out. */
> +		if (reg_data[GEN5_RESP_REPORT_ID_OFFSET] ==
> +				GEN5_BL_RESP_REPORT_ID) {
> +			/* Gen5 BL command response data detected */
> +			cyapa->gen = CYAPA_GEN5;
> +			cyapa->state = CYAPA_STATE_GEN5_BL;
> +		} else {
> +			/* Gen5 APP command response data detected */
> +			cyapa->gen = CYAPA_GEN5;
> +			cyapa->state = CYAPA_STATE_GEN5_APP;
> +		}
> +	} else if ((gen5_pip->empty_buf[GEN5_RESP_REPORT_ID_OFFSET] ==
> +				GEN5_BL_RESP_REPORT_ID) &&
> +			(gen5_pip->empty_buf[GEN5_RESP_RSVD_OFFSET] ==
> +				GEN5_RESP_RSVD_KEY) &&
> +			(gen5_pip->empty_buf[GEN5_RESP_BL_SOP_OFFSET] ==
> +				GEN5_SOP_KEY) &&
> +			(gen5_pip->empty_buf[length - 1] ==
> +				GEN5_EOP_KEY)) {
> +		/* Gen5 BL command response data detected */
> +		cyapa->gen = CYAPA_GEN5;
> +		cyapa->state = CYAPA_STATE_GEN5_BL;
> +	} else if (gen5_pip->empty_buf[GEN5_RESP_REPORT_ID_OFFSET] ==
> +				GEN5_APP_RESP_REPORT_ID &&
> +			gen5_pip->empty_buf[GEN5_RESP_RSVD_OFFSET] ==
> +				GEN5_RESP_RSVD_KEY) {
> +		/* Gen5 APP command response data detected */
> +		cyapa->gen = CYAPA_GEN5;
> +		cyapa->state = CYAPA_STATE_GEN5_APP;
> +	} else {
> +		/* Should not happen!!! */
> +		cyapa->state = CYAPA_STATE_NO_DEVICE;
> +	}
> +
> +	return 0;
> +}
> +
> +static int cyapa_gen5_state_parse(struct cyapa *cyapa, u8 *reg_data, int len)
> +{
> +	int length;
> +
> +	if (!reg_data || len < 3)
> +		return -EINVAL;
> +
> +	cyapa->state = CYAPA_STATE_NO_DEVICE;
> +
> +	/* Parse based on Gen5 characteristic registers and bits */
> +	length = get_unaligned_le16(&reg_data[GEN5_RESP_LENGTH_OFFSET]);
> +	if (length == 0 || length == GEN5_RESP_LENGTH_SIZE) {
> +		gen5_idle_state_parse(cyapa);
> +	} else if (length == GEN5_HID_DESCRIPTOR_SIZE &&
> +			(reg_data[2] == GEN5_BL_HID_REPORT_ID ||
> +				reg_data[2] == GEN5_APP_HID_REPORT_ID)) {
> +		gen5_hid_description_header_parse(cyapa, reg_data);
> +	} else if ((length == GEN5_APP_REPORT_DESCRIPTOR_SIZE ||
> +			length == GEN5_APP_CONTRACT_REPORT_DESCRIPTOR_SIZE) &&
> +			reg_data[2] == GEN5_APP_REPORT_DESCRIPTOR_ID) {
> +		/* 0xEE 0x00 0xF6 is Gen5 APP Report Description header. */
> +		cyapa->gen = CYAPA_GEN5;
> +		cyapa->state = CYAPA_STATE_GEN5_APP;
> +	} else if (length == GEN5_BL_REPORT_DESCRIPTOR_SIZE &&
> +			reg_data[2] == GEN5_BL_REPORT_DESCRIPTOR_ID) {
> +		/* 0x1D 0x00 0xFE is Gen5 BL Report Descriptior header. */
> +		cyapa->gen = CYAPA_GEN5;
> +		cyapa->state = CYAPA_STATE_GEN5_BL;
> +	} else if (reg_data[2] == GEN5_TOUCH_REPORT_ID ||
> +			reg_data[2] == GEN5_BTN_REPORT_ID ||
> +			reg_data[2] == GEN5_OLD_PUSH_BTN_REPORT_ID ||
> +			reg_data[2] == GEN5_PUSH_BTN_REPORT_ID ||
> +			reg_data[2] == GEN5_WAKEUP_EVENT_REPORT_ID) {
> +		gen5_report_data_header_parse(cyapa, reg_data);
> +	} else if (reg_data[2] == GEN5_BL_RESP_REPORT_ID ||
> +			reg_data[2] == GEN5_APP_RESP_REPORT_ID) {
> +		gen5_cmd_resp_header_parse(cyapa, reg_data);
> +	}
> +
> +	if (cyapa->gen == CYAPA_GEN5) {
> +		/*
> +		 * Must read the content (e.g.: Report Description and so on)
> +		 * from trackpad device through out. Otherwise,
> +		 * Gen5 trackpad cannot response to next command or
> +		 * report any touch or button data later.
> +		 */
> +		cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL);
> +
> +		if (cyapa->state == CYAPA_STATE_GEN5_APP ||
> +			cyapa->state == CYAPA_STATE_GEN5_BL)
> +			return 0;
> +	}
> +
> +	return -EAGAIN;
> +}
> +
> +bool cyapa_gen5_sort_bl_exit_data(struct cyapa *cyapa, u8 *buf, int len)
> +{
> +	if (buf == NULL || len < GEN5_RESP_LENGTH_SIZE)
> +		return false;
> +
> +	if (buf[0] == 0 && buf[1] == 0)
> +		return true;
> +
> +	/* Exit bootloader failed for some reason. */
> +	if (len == GEN5_BL_FAIL_EXIT_RESP_LEN &&
> +			buf[GEN5_RESP_REPORT_ID_OFFSET] ==
> +				GEN5_BL_RESP_REPORT_ID &&
> +			buf[GEN5_RESP_RSVD_OFFSET] == GEN5_RESP_RSVD_KEY &&
> +			buf[GEN5_RESP_BL_SOP_OFFSET] == GEN5_SOP_KEY &&
> +			buf[10] == GEN5_EOP_KEY)
> +		return true;
> +
> +	return false;
> +}
> +
> +static int cyapa_gen5_bl_exit(struct cyapa *cyapa)
> +{
> +	int error;
> +	u8 resp_data[11];
> +	int resp_len;
> +	u8 bl_gen5_bl_exit[] = { 0x04, 0x00,
> +		0x0B, 0x00, 0x40, 0x00, 0x01, 0x3b, 0x00, 0x00,
> +		0x20, 0xc7, 0x17
> +	};
> +
> +	resp_len = sizeof(resp_data);
> +	error = cyapa_i2c_pip_cmd_irq_sync(cyapa,
> +			bl_gen5_bl_exit, sizeof(bl_gen5_bl_exit),
> +			resp_data, &resp_len,
> +			5000, cyapa_gen5_sort_bl_exit_data, false);
> +	if (error)
> +		return error;
> +
> +	if (resp_len == GEN5_BL_FAIL_EXIT_RESP_LEN ||
> +			resp_data[GEN5_RESP_REPORT_ID_OFFSET] ==
> +				GEN5_BL_RESP_REPORT_ID)
> +		return -EAGAIN;
> +
> +	if (resp_data[0] == 0x00 && resp_data[1] == 0x00)
> +		return 0;
> +
> +	return -ENODEV;
> +}
> +
> +static int cyapa_gen5_change_power_state(struct cyapa *cyapa, u8 power_state)
> +{
> +	u8 cmd[8] = { 0x04, 0x00, 0x06, 0x00, 0x2f, 0x00, 0x08, 0x01 };
> +	u8 resp_data[6];
> +	int resp_len;
> +	int error;
> +
> +	cmd[7] = power_state;
> +	resp_len = sizeof(resp_data);
> +	error = cyapa_i2c_pip_cmd_irq_sync(cyapa, cmd, sizeof(cmd),
> +			resp_data, &resp_len,
> +			500, cyapa_gen5_sort_tsg_pip_app_resp_data, false);
> +	if (error || !VALID_CMD_RESP_HEADER(resp_data, 0x08) ||
> +			!GEN5_CMD_COMPLETE_SUCCESS(resp_data[5]))
> +		return error < 0 ? error : -EINVAL;
> +
> +	return 0;
> +}
> +
> +static int cyapa_gen5_set_interval_time(struct cyapa *cyapa,
> +		u8 parameter_id, u16 interval_time)
> +{
> +	u8 cmd[13];
> +	int cmd_len;
> +	u8 resp_data[7];
> +	int resp_len;
> +	u8 parameter_size;
> +	int error;
> +
> +	switch (parameter_id) {
> +	case GEN5_PARAMETER_ACT_INTERVL_ID:
> +		parameter_size = GEN5_PARAMETER_ACT_INTERVL_SIZE;
> +		break;
> +	case GEN5_PARAMETER_ACT_LFT_INTERVL_ID:
> +		parameter_size = GEN5_PARAMETER_ACT_LFT_INTERVL_SIZE;
> +		break;
> +	case GEN5_PARAMETER_LP_INTRVL_ID:
> +		parameter_size = GEN5_PARAMETER_LP_INTRVL_SIZE;
> +		break;
> +	default:
> +		return -EINVAL;
> +	}
> +	cmd_len = 7 + parameter_size;  /* Not incuding 2 bytes address */
> +	cmd[0] = 0x04;
> +	cmd[1] = 0x00;
> +	put_unaligned_le16(cmd_len, &cmd[2]);
> +	cmd[4] = 0x2f;
> +	cmd[5] = 0x00;
> +	cmd[6] = 0x06; /* Set parameter command code */
> +	cmd[7] = parameter_id;
> +	cmd[8] = parameter_size;
> +	put_unaligned_le16(interval_time, &cmd[9]);
> +	resp_len = sizeof(resp_data);
> +	error = cyapa_i2c_pip_cmd_irq_sync(cyapa, cmd, cmd_len + 2,
> +			resp_data, &resp_len,
> +			500, cyapa_gen5_sort_tsg_pip_app_resp_data, false);
> +	if (error || !VALID_CMD_RESP_HEADER(resp_data, 0x06) ||
> +			resp_data[5] != parameter_id ||
> +			resp_data[6] != parameter_size)
> +		return error < 0 ? error : -EINVAL;
> +
> +	return 0;
> +}
> +
> +static int cyapa_gen5_get_interval_time(struct cyapa *cyapa,
> +		u8 parameter_id, u16 *interval_time)
> +{
> +	u8 cmd[8];
> +	u8 resp_data[11];
> +	int resp_len;
> +	u8 parameter_size;
> +	u16 mask, i;
> +	int error;
> +
> +	*interval_time = 0;
> +	switch (parameter_id) {
> +	case GEN5_PARAMETER_ACT_INTERVL_ID:
> +		parameter_size = GEN5_PARAMETER_ACT_INTERVL_SIZE;
> +		break;
> +	case GEN5_PARAMETER_ACT_LFT_INTERVL_ID:
> +		parameter_size = GEN5_PARAMETER_ACT_LFT_INTERVL_SIZE;
> +		break;
> +	case GEN5_PARAMETER_LP_INTRVL_ID:
> +		parameter_size = GEN5_PARAMETER_LP_INTRVL_SIZE;
> +		break;
> +	default:
> +		return -EINVAL;
> +	}
> +
> +	cmd[0] = 0x04;
> +	cmd[1] = 0x00;
> +	cmd[2] = 0x06;
> +	cmd[3] = 0x00;
> +	cmd[4] = 0x2f;
> +	cmd[5] = 0x00;
> +	cmd[6] = 0x05; /* Get parameter command code */
> +	cmd[7] = parameter_id;
> +	resp_len = sizeof(resp_data);
> +	error = cyapa_i2c_pip_cmd_irq_sync(cyapa, cmd, sizeof(cmd),
> +			resp_data, &resp_len,
> +			500, cyapa_gen5_sort_tsg_pip_app_resp_data, false);
> +	if (error || !VALID_CMD_RESP_HEADER(resp_data, 0x05) ||
> +			resp_data[5] != parameter_id ||
> +			resp_data[6] == 0)
> +		return error < 0 ? error : -EINVAL;
> +
> +	mask = 0;
> +	for (i = 0; i < parameter_size; i++)
> +		mask |= (0xff << (i * 8));
> +	*interval_time = get_unaligned_le16(&resp_data[7]) & mask;
> +
> +	return 0;
> +}
> +
> +static int cyapa_gen5_disable_pip_report(struct cyapa *cyapa)
> +{
> +	u8 cmd[10];
> +	u8 resp_data[7];
> +	int resp_len;
> +	int error;
> +
> +	cmd[0] = 0x04;
> +	cmd[1] = 0x00;
> +	put_unaligned_le16(8, &cmd[2]);
> +	cmd[4] = 0x2f;
> +	cmd[5] = 0x00;
> +	cmd[6] = 0x06; /* Set parameter command code */
> +	cmd[7] = GEN5_PARAMETER_DISABLE_PIP_REPORT;
> +	cmd[8] = 0x01;
> +	cmd[9] = 0x01;
> +	resp_len = sizeof(resp_data);
> +	error = cyapa_i2c_pip_cmd_irq_sync(cyapa, cmd, 10,
> +			resp_data, &resp_len,
> +			500, cyapa_gen5_sort_tsg_pip_app_resp_data, false);
> +	if (error || !VALID_CMD_RESP_HEADER(resp_data, 0x06) ||
> +			resp_data[5] != GEN5_PARAMETER_DISABLE_PIP_REPORT ||
> +			resp_data[6] != 0x01)
> +		return error < 0 ? error : -EINVAL;
> +
> +	return 0;
> +}
> +
> +static int cyapa_gen5_deep_sleep(struct cyapa *cyapa, u8 state)
> +{
> +	u8 cmd[4] = { 0x05, 0x00, 0x00, 0x08};
> +	u8 resp_data[5];
> +	int resp_len;
> +	int error;
> +
> +	cmd[0] = 0x05;
> +	cmd[1] = 0x00;
> +	cmd[2] = state & GEN5_DEEP_SLEEP_STATE_MASK;
> +	cmd[3] = 0x08;
> +	resp_len = sizeof(resp_data);
> +	error = cyapa_i2c_pip_cmd_irq_sync(cyapa, cmd, sizeof(cmd),
> +			resp_data, &resp_len,
> +			500, cyapa_gen5_sort_deep_sleep_data, false);
> +	if (error || ((resp_data[3] & GEN5_DEEP_SLEEP_STATE_MASK) != state))
> +		return -EINVAL;
> +
> +	return 0;
> +}
> +
> +static int cyapa_gen5_set_power_mode(struct cyapa *cyapa,
> +		u8 power_mode, u16 sleep_time)
> +{
> +	struct device *dev = &cyapa->client->dev;
> +	u8 power_state;
> +	int error;
> +
> +	if (cyapa->state != CYAPA_STATE_GEN5_APP)
> +		return 0;
> +
> +	/* Dump all the report data before do power mode commmands. */
> +	cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL);
> +
> +	if (GEN5_DEV_GET_PWR_STATE(cyapa) == UNINIT_PWR_MODE) {
> +		/*
> +		 * Assume TP in deep sleep mode when driver is loaded,
> +		 * avoid driver unload and reload command IO issue caused by TP
> +		 * has been set into deep sleep mode when unloading.
> +		 */
> +		GEN5_DEV_SET_PWR_STATE(cyapa, PWR_MODE_OFF);
> +	}
> +
> +	if (GEN5_DEV_UNINIT_SLEEP_TIME(cyapa) &&
> +			GEN5_DEV_GET_PWR_STATE(cyapa) != PWR_MODE_OFF)
> +		if (cyapa_gen5_get_interval_time(cyapa,
> +				GEN5_PARAMETER_LP_INTRVL_ID,
> +				&cyapa->dev_sleep_time) != 0)
> +			GEN5_DEV_SET_SLEEP_TIME(cyapa, UNINIT_SLEEP_TIME);
> +
> +	if (GEN5_DEV_GET_PWR_STATE(cyapa) == power_mode) {
> +		if (power_mode == PWR_MODE_OFF ||
> +			power_mode == PWR_MODE_FULL_ACTIVE ||
> +			power_mode == PWR_MODE_BTN_ONLY ||
> +			GEN5_DEV_GET_SLEEP_TIME(cyapa) == sleep_time) {
> +			/* Has in correct power mode state, early return. */
> +			return 0;
> +		}
> +	}
> +
> +	if (power_mode == PWR_MODE_OFF) {
> +		error = cyapa_gen5_deep_sleep(cyapa, GEN5_DEEP_SLEEP_STATE_OFF);
> +		if (error) {
> +			dev_err(dev, "enter deep sleep fail: %d\n", error);
> +			return error;
> +		}
> +
> +		GEN5_DEV_SET_PWR_STATE(cyapa, PWR_MODE_OFF);
> +		return 0;
> +	}
> +
> +	/*
> +	 * When trackpad in power off mode, it cannot change to other power
> +	 * state directly, must be wake up from sleep firstly, then
> +	 * continue to do next power sate change.
> +	 */
> +	if (GEN5_DEV_GET_PWR_STATE(cyapa) == PWR_MODE_OFF) {
> +		error = cyapa_gen5_deep_sleep(cyapa, GEN5_DEEP_SLEEP_STATE_ON);
> +		if (error) {
> +			dev_err(dev, "deep sleep wake fail: %d\n", error);
> +			return error;
> +		}
> +	}
> +
> +	if (power_mode == PWR_MODE_FULL_ACTIVE) {
> +		error = cyapa_gen5_change_power_state(cyapa,
> +				GEN5_POWER_STATE_ACTIVE);
> +		if (error) {
> +			dev_err(dev, "change to active fail: %d\n", error);
> +			return error;
> +		}
> +
> +		GEN5_DEV_SET_PWR_STATE(cyapa, PWR_MODE_FULL_ACTIVE);
> +	} else if (power_mode == PWR_MODE_BTN_ONLY) {
> +		error = cyapa_gen5_change_power_state(cyapa,
> +				GEN5_POWER_STATE_BTN_ONLY);
> +		if (error) {
> +			dev_err(dev, "fail to button only mode: %d\n", error);
> +			return error;
> +		}
> +
> +		GEN5_DEV_SET_PWR_STATE(cyapa, PWR_MODE_BTN_ONLY);
> +	} else {
> +		/*
> +		 * Continue to change power mode even failed to set
> +		 * interval time, it won't affect the power mode change.
> +		 * except the sleep interval time is not correct.
> +		 */
> +		if (GEN5_DEV_UNINIT_SLEEP_TIME(cyapa) ||
> +				sleep_time != GEN5_DEV_GET_SLEEP_TIME(cyapa))
> +			if (cyapa_gen5_set_interval_time(cyapa,
> +					GEN5_PARAMETER_LP_INTRVL_ID,
> +					sleep_time) == 0)
> +				GEN5_DEV_SET_SLEEP_TIME(cyapa, sleep_time);
> +
> +		if (sleep_time <= GEN5_POWER_READY_MAX_INTRVL_TIME)
> +			power_state = GEN5_POWER_STATE_READY;
> +		else
> +			power_state = GEN5_POWER_STATE_IDLE;
> +		error = cyapa_gen5_change_power_state(cyapa, power_state);
> +		if (error) {
> +			dev_err(dev, "set power state to 0x%02x failed: %d\n",
> +				power_state, error);
> +			return error;
> +		}
> +
> +		/*
> +		 * Disable pip report for a little time, firmware will
> +		 * re-enable it automatically. It's used to fix the issue
> +		 * that trackpad unable to report signal to wake system up
> +		 * in the special situation that system is in suspending, and
> +		 * at the same time, user touch trackpad to wake system up.
> +		 * This function can avoid the data to be buffured when system
> +		 * is suspending which may cause interrput line unable to be
> +		 * asserted again.
> +		 */
> +		cyapa_empty_pip_output_data(cyapa, NULL, NULL, NULL);
> +		cyapa_gen5_disable_pip_report(cyapa);
> +
> +		GEN5_DEV_SET_PWR_STATE(cyapa,
> +			cyapa_sleep_time_to_pwr_cmd(sleep_time));
> +	}
> +
> +	return 0;
> +}
> +
> +static bool cyapa_gen5_sort_system_info_data(struct cyapa *cyapa,
> +		u8 *buf, int len)
> +{
> +	/* Check the report id and command code */
> +	if (VALID_CMD_RESP_HEADER(buf, 0x02))
> +		return true;
> +
> +	return false;
> +}
> +
> +static int cyapa_gen5_bl_query_data(struct cyapa *cyapa)
> +{
> +	u8 cmd[16];
> +	int cmd_len;
> +	u8 resp_data[GEN5_BL_READ_APP_INFO_RESP_LEN];
> +	int resp_len;
> +	int error;
> +
> +	/* Read application information. */
> +	cmd[0] = 0x04;
> +	cmd[1] = 0x00;
> +	cmd[2] = 0x0b;
> +	cmd[3] = 0x00;
> +	cmd[4] = 0x40;
> +	cmd[5] = 0x00;
> +	cmd[6] = GEN5_SOP_KEY;
> +	cmd[7] = 0x3c;  /* Read application information command code */
> +	cmd[8] = 0x00;
> +	cmd[9] = 0x00;
> +	cmd[10] = 0xb0;
> +	cmd[11] = 0x42;
> +	cmd[12] = GEN5_EOP_KEY;
> +	cmd_len = 13;
> +	resp_len = GEN5_BL_READ_APP_INFO_RESP_LEN;
> +	error = cyapa_i2c_pip_cmd_irq_sync(cyapa,
> +			cmd, cmd_len,
> +			resp_data, &resp_len,
> +			500, cyapa_gen5_sort_tsg_pip_bl_resp_data, false);
> +	if (error || resp_len != GEN5_BL_READ_APP_INFO_RESP_LEN ||
> +		!GEN5_CMD_COMPLETE_SUCCESS(resp_data[5]))
> +		return error ? error : -EIO;
> +
> +	memcpy(&cyapa->product_id[0], &resp_data[8], 5);
> +	cyapa->product_id[5] = '-';
> +	memcpy(&cyapa->product_id[6], &resp_data[13], 6);
> +	cyapa->product_id[12] = '-';
> +	memcpy(&cyapa->product_id[13], &resp_data[19], 2);
> +	cyapa->product_id[15] = '\0';
> +
> +	cyapa->fw_maj_ver = resp_data[22];
> +	cyapa->fw_min_ver = resp_data[23];
> +
> +	return 0;
> +}
> +
> +static int cyapa_gen5_get_query_data(struct cyapa *cyapa)
> +{
> +	u8 resp_data[71];
> +	int resp_len;
> +	u8 get_system_information[] = {
> +		0x04, 0x00, 0x05, 0x00, 0x2f, 0x00, 0x02
> +	};
> +	u16 product_family;
> +	int error;
> +
> +	resp_len = sizeof(resp_data);
> +	error = cyapa_i2c_pip_cmd_irq_sync(cyapa,
> +			get_system_information, sizeof(get_system_information),
> +			resp_data, &resp_len,
> +			2000, cyapa_gen5_sort_system_info_data, false);
> +	if (error || resp_len < sizeof(resp_data))
> +		return error ? error : -EIO;
> +
> +	product_family = get_unaligned_le16(&resp_data[7]);
> +	if ((product_family & GEN5_PRODUCT_FAMILY_MASK) !=
> +		GEN5_PRODUCT_FAMILY_TRACKPAD)
> +		return -EINVAL;
> +
> +	cyapa->fw_maj_ver = resp_data[15];
> +	cyapa->fw_min_ver = resp_data[16];
> +
> +	cyapa->electrodes_x = resp_data[52];
> +	cyapa->electrodes_y = resp_data[53];
> +
> +	cyapa->physical_size_x =  get_unaligned_le16(&resp_data[54]) / 100;
> +	cyapa->physical_size_y = get_unaligned_le16(&resp_data[56]) / 100;
> +
> +	cyapa->max_abs_x = get_unaligned_le16(&resp_data[58]);
> +	cyapa->max_abs_y = get_unaligned_le16(&resp_data[60]);
> +
> +	cyapa->max_z = get_unaligned_le16(&resp_data[62]);
> +
> +	cyapa->x_origin = resp_data[64] & 0x01;
> +	cyapa->y_origin = resp_data[65] & 0x01;
> +
> +	cyapa->btn_capability = (resp_data[70] << 3) & CAPABILITY_BTN_MASK;
> +
> +	memcpy(&cyapa->product_id[0], &resp_data[33], 5);
> +	cyapa->product_id[5] = '-';
> +	memcpy(&cyapa->product_id[6], &resp_data[38], 6);
> +	cyapa->product_id[12] = '-';
> +	memcpy(&cyapa->product_id[13], &resp_data[44], 2);
> +	cyapa->product_id[15] = '\0';
> +
> +	if (!cyapa->electrodes_x || !cyapa->electrodes_y ||
> +		!cyapa->physical_size_x || !cyapa->physical_size_y ||
> +		!cyapa->max_abs_x || !cyapa->max_abs_y || !cyapa->max_z)
> +		return -EINVAL;
> +
> +	return 0;
> +}
> +
> +static int cyapa_gen5_do_operational_check(struct cyapa *cyapa)
> +{
> +	struct device *dev = &cyapa->client->dev;
> +	int error;
> +
> +	if (cyapa->gen != CYAPA_GEN5)
> +		return -ENODEV;
> +
> +	switch (cyapa->state) {
> +	case CYAPA_STATE_GEN5_BL:
> +		error = cyapa_gen5_bl_exit(cyapa);
> +		if (error) {
> +			/* Rry to update trackpad product information. */
> +			cyapa_gen5_bl_query_data(cyapa);
> +			goto out;
> +		}
> +
> +		cyapa->state = CYAPA_STATE_GEN5_APP;
> +
> +	case CYAPA_STATE_GEN5_APP:
> +		/*
> +		 * If trackpad device in deep sleep mode,
> +		 * the app command will fail.
> +		 * So always try to reset trackpad device to full active when
> +		 * the device state is requeried.
> +		 */
> +		error = cyapa_gen5_set_power_mode(cyapa,
> +				PWR_MODE_FULL_ACTIVE, 0);
> +		if (error)
> +			dev_warn(dev, "%s: failed to set power active mode.\n",
> +				__func__);
> +
> +		/* Get trackpad product information. */
> +		error = cyapa_gen5_get_query_data(cyapa);
> +		if (error)
> +			goto out;
> +		/* Only support product ID starting with CYTRA */
> +		if (memcmp(cyapa->product_id, product_id,
> +				strlen(product_id)) != 0) {
> +			dev_err(dev, "%s: unknown product ID (%s)\n",
> +				__func__, cyapa->product_id);
> +			error = -EINVAL;
> +		}
> +		break;
> +	default:
> +		error = -EINVAL;
> +	}
> +
> +out:
> +	return error;
> +}
> +
> +/*
> + * Return false, do not continue process
> + * Return true, continue process.
> + */
> +static bool cyapa_gen5_irq_cmd_handler(struct cyapa *cyapa)
> +{
> +	int length;
> +	struct cyapa_gen5_cmd_states *gen5_pip = &cyapa->cmd_states.gen5;
> +
> +	if (atomic_read(&gen5_pip->cmd_issued)) {
> +		/* Polling command response data. */
> +		if (gen5_pip->is_irq_mode == false)
> +			return false;
> +
> +		/*
> +		 * Read out all none command response data.
> +		 * these output data may caused by user put finger on
> +		 * trackpad when host waiting the command response.
> +		 */
> +		cyapa_i2c_pip_read(cyapa, gen5_pip->irq_cmd_buf,
> +			GEN5_RESP_LENGTH_SIZE);
> +		length = get_unaligned_le16(gen5_pip->irq_cmd_buf);
> +		length = (length <= GEN5_RESP_LENGTH_SIZE) ?
> +				GEN5_RESP_LENGTH_SIZE : length;
> +		if (length > GEN5_RESP_LENGTH_SIZE)
> +			cyapa_i2c_pip_read(cyapa,
> +				gen5_pip->irq_cmd_buf, length);
> +
> +		if (!(gen5_pip->resp_sort_func &&
> +			gen5_pip->resp_sort_func(cyapa,
> +				gen5_pip->irq_cmd_buf, length))) {
> +			/*
> +			 * Cover the Gen5 V1 firmware issue.
> +			 * The issue is there is no interrut will be
> +			 * asserted to notityf host to read a command
> +			 * data out when always has finger touch on
> +			 * trackpad during the command is issued to
> +			 * trackad device.
> +			 * This issue has the scenario is that,
> +			 * user always has his fingers touched on
> +			 * trackpad device when booting/rebooting
> +			 * their chrome book.
> +			 */
> +			length = *gen5_pip->resp_len;
> +			cyapa_empty_pip_output_data(cyapa,
> +					gen5_pip->resp_data,
> +					&length,
> +					gen5_pip->resp_sort_func);
> +			if (gen5_pip->resp_len && length != 0) {
> +				*gen5_pip->resp_len = length;
> +				atomic_dec(&gen5_pip->cmd_issued);
> +				complete(&gen5_pip->cmd_ready);
> +			}
> +			return false;
> +		}
> +
> +		if (gen5_pip->resp_data && gen5_pip->resp_len) {
> +			*gen5_pip->resp_len = (*gen5_pip->resp_len < length) ?
> +				*gen5_pip->resp_len : length;
> +			memcpy(gen5_pip->resp_data, gen5_pip->irq_cmd_buf,
> +				*gen5_pip->resp_len);
> +		}
> +		atomic_dec(&gen5_pip->cmd_issued);
> +		complete(&gen5_pip->cmd_ready);
> +		return false;
> +	}
> +
> +	return true;
> +}
> +
> +static void cyapa_gen5_report_buttons(struct cyapa *cyapa,
> +		const struct cyapa_gen5_report_data *report_data)
> +{
> +	struct input_dev *input = cyapa->input;
> +	u8 buttons = report_data->report_head[GEN5_BUTTONS_OFFSET];
> +
> +	buttons = (buttons << CAPABILITY_BTN_SHIFT) & CAPABILITY_BTN_MASK;
> +
> +	if (cyapa->btn_capability & CAPABILITY_LEFT_BTN_MASK) {
> +		input_report_key(input, BTN_LEFT,
> +			!!(buttons & CAPABILITY_LEFT_BTN_MASK));
> +	}
> +	if (cyapa->btn_capability & CAPABILITY_MIDDLE_BTN_MASK) {
> +		input_report_key(input, BTN_MIDDLE,
> +			!!(buttons & CAPABILITY_MIDDLE_BTN_MASK));
> +	}
> +	if (cyapa->btn_capability & CAPABILITY_RIGHT_BTN_MASK) {
> +		input_report_key(input, BTN_RIGHT,
> +			!!(buttons & CAPABILITY_RIGHT_BTN_MASK));
> +	}
> +
> +	input_sync(input);
> +}
> +
> +static void cyapa_gen5_report_slot_data(struct cyapa *cyapa,
> +		const struct cyapa_gen5_touch_record *touch)
> +{
> +	struct input_dev *input = cyapa->input;
> +	u8 event_id = GEN5_GET_EVENT_ID(touch->touch_tip_event_id);
> +	int slot = GEN5_GET_TOUCH_ID(touch->touch_tip_event_id);
> +	int x, y;
> +
> +	if (event_id == RECORD_EVENT_LIFTOFF)
> +		return;
> +
> +	input_mt_slot(input, slot);
> +	input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
> +	x = (touch->x_hi << 8) | touch->x_lo;
> +	if (cyapa->x_origin)
> +		x = cyapa->max_abs_x - x;
> +	input_report_abs(input, ABS_MT_POSITION_X, x);
> +	y = (touch->y_hi << 8) | touch->y_lo;
> +	if (cyapa->y_origin)
> +		y = cyapa->max_abs_y - y;
> +	input_report_abs(input, ABS_MT_POSITION_Y, y);
> +	input_report_abs(input, ABS_MT_PRESSURE,
> +		touch->z);
> +	input_report_abs(input, ABS_MT_TOUCH_MAJOR,
> +		touch->major_axis_len);
> +	input_report_abs(input, ABS_MT_TOUCH_MINOR,
> +		touch->minor_axis_len);
> +
> +	input_report_abs(input, ABS_MT_WIDTH_MAJOR,
> +		touch->major_tool_len);
> +	input_report_abs(input, ABS_MT_WIDTH_MINOR,
> +		touch->minor_tool_len);
> +
> +	input_report_abs(input, ABS_MT_ORIENTATION,
> +		touch->orientation);
> +}
> +
> +static void cyapa_gen5_report_touches(struct cyapa *cyapa,
> +		const struct cyapa_gen5_report_data *report_data)
> +{
> +	struct input_dev *input = cyapa->input;
> +	unsigned int touch_num;
> +	int i;
> +
> +	touch_num = report_data->report_head[GEN5_NUMBER_OF_TOUCH_OFFSET] &
> +			GEN5_NUMBER_OF_TOUCH_MASK;
> +
> +	for (i = 0; i < touch_num; i++)
> +		cyapa_gen5_report_slot_data(cyapa,
> +			&report_data->touch_records[i]);
> +
> +	input_mt_sync_frame(input);
> +	input_sync(input);
> +}
> +
> +static int cyapa_gen5_irq_handler(struct cyapa *cyapa)
> +{
> +	struct device *dev = &cyapa->client->dev;
> +	struct cyapa_gen5_report_data report_data;
> +	int ret;
> +	u8 report_id;
> +	unsigned int report_len;
> +
> +	if (cyapa->gen != CYAPA_GEN5 ||
> +		cyapa->state != CYAPA_STATE_GEN5_APP) {
> +		dev_err(dev, "invalid device state, gen=%d, state=0x%02x\n",
> +			cyapa->gen, cyapa->state);
> +		return -EINVAL;
> +	}
> +
> +	ret = cyapa_i2c_pip_read(cyapa, (u8 *)&report_data,
> +			GEN5_RESP_LENGTH_SIZE);
> +	if (ret != GEN5_RESP_LENGTH_SIZE) {
> +		dev_err(dev, "failed to read length bytes, (%d)\n", ret);
> +		return -EINVAL;
> +	}
> +
> +	report_len = get_unaligned_le16(
> +			&report_data.report_head[GEN5_RESP_LENGTH_OFFSET]);
> +	if (report_len < GEN5_RESP_LENGTH_SIZE) {
> +		/* Invliad length or internal reset happened. */
> +		dev_err(dev, "invalid report_len=%d. bytes: %02x %02x\n",
> +			report_len, report_data.report_head[0],
> +			report_data.report_head[1]);
> +		return -EINVAL;
> +	}
> +
> +	/* Idle, no data for report. */
> +	if (report_len == GEN5_RESP_LENGTH_SIZE)
> +		return 0;
> +
> +	ret = cyapa_i2c_pip_read(cyapa, (u8 *)&report_data, report_len);
> +	if (ret != report_len) {
> +		dev_err(dev, "failed to read %d bytes report data, (%d)\n",
> +			report_len, ret);
> +		return -EINVAL;
> +	}
> +
> +	report_id = report_data.report_head[GEN5_RESP_REPORT_ID_OFFSET];
> +	if (report_id == GEN5_WAKEUP_EVENT_REPORT_ID &&
> +			report_len == GEN5_WAKEUP_EVENT_SIZE) {
> +		/*
> +		 * Device wake event from deep sleep mode for touch.
> +		 * This interrupt event is used to wake system up.
> +		 */
> +		return 0;
> +	} else if (report_id != GEN5_TOUCH_REPORT_ID &&
> +			report_id != GEN5_BTN_REPORT_ID &&
> +			report_id != GEN5_OLD_PUSH_BTN_REPORT_ID &&
> +			report_id != GEN5_PUSH_BTN_REPORT_ID) {
> +		/* Running in BL mode or unknown response data read. */
> +		dev_err(dev, "invalid report_id=0x%02x\n", report_id);
> +		return -EINVAL;
> +	}
> +
> +	if (report_id == GEN5_TOUCH_REPORT_ID &&
> +		(report_len < GEN5_TOUCH_REPORT_HEAD_SIZE ||
> +			report_len > GEN5_TOUCH_REPORT_MAX_SIZE)) {
> +		/* Invalid report data length for finger packet. */
> +		dev_err(dev, "invalid touch packet length=%d\n", report_len);
> +		return 0;
> +	}
> +
> +	if ((report_id == GEN5_BTN_REPORT_ID ||
> +			report_id == GEN5_OLD_PUSH_BTN_REPORT_ID ||
> +			report_id == GEN5_PUSH_BTN_REPORT_ID) &&
> +		(report_len < GEN5_BTN_REPORT_HEAD_SIZE ||
> +			report_len > GEN5_BTN_REPORT_MAX_SIZE)) {
> +		/* Invalid report data length of button packet. */
> +		dev_err(dev, "invalid button packet length=%d\n", report_len);
> +		return 0;
> +	}
> +
> +	if (report_id == GEN5_TOUCH_REPORT_ID)
> +		cyapa_gen5_report_touches(cyapa, &report_data);
> +	else
> +		cyapa_gen5_report_buttons(cyapa, &report_data);
> +
> +	return 0;
> +}
> +
> +const struct cyapa_dev_ops cyapa_gen5_ops = {
> +	.initialize = cyapa_gen5_initialize,
> +
> +	.state_parse = cyapa_gen5_state_parse,
> +	.operational_check = cyapa_gen5_do_operational_check,
> +
> +	.irq_handler = cyapa_gen5_irq_handler,
> +	.irq_cmd_handler = cyapa_gen5_irq_cmd_handler,
> +	.sort_empty_output_data = cyapa_empty_pip_output_data,
> +	.set_power_mode = cyapa_gen5_set_power_mode,
> +};
> -- 
> 1.9.1
> 
> --
> To unsubscribe from this list: send the line "unsubscribe linux-input" in
> the body of a message to majordomo@...r.kernel.org
> More majordomo info at  http://vger.kernel.org/majordomo-info.html

-- 
- Jeremiah Mahler
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@...r.kernel.org
More majordomo info at  http://vger.kernel.org/majordomo-info.html
Please read the FAQ at  http://www.tux.org/lkml/

Powered by blists - more mailing lists