[linux-2.6-block.git] / drivers / input / touchscreen / cyttsp_core.c

/*
 * Core Source for:
 * Cypress TrueTouch(TM) Standard Product (TTSP) touchscreen drivers.
 * For use with Cypress Txx3xx parts.
 * Supported parts include:
 * CY8CTST341
 * CY8CTMA340
 *
 * Copyright (C) 2009, 2010, 2011 Cypress Semiconductor, Inc.
 * Copyright (C) 2012 Javier Martinez Canillas <javier@dowhile0.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.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 * Contact Cypress Semiconductor at www.cypress.com <kev@cypress.com>
 *
 */

#include <linux/delay.h>
#include <linux/input.h>
#include <linux/input/mt.h>
#include <linux/input/touchscreen.h>
#include <linux/gpio.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/property.h>
#include <linux/gpio/consumer.h>

#include "cyttsp_core.h"

/* Bootloader number of command keys */
#define CY_NUM_BL_KEYS		8

/* helpers */
#define GET_NUM_TOUCHES(x)		((x) & 0x0F)
#define IS_LARGE_AREA(x)		(((x) & 0x10) >> 4)
#define IS_BAD_PKT(x)			((x) & 0x20)
#define IS_VALID_APP(x)			((x) & 0x01)
#define IS_OPERATIONAL_ERR(x)		((x) & 0x3F)
#define GET_HSTMODE(reg)		(((reg) & 0x70) >> 4)
#define GET_BOOTLOADERMODE(reg)		(((reg) & 0x10) >> 4)

#define CY_REG_BASE			0x00
#define CY_REG_ACT_DIST			0x1E
#define CY_REG_ACT_INTRVL		0x1D
#define CY_REG_TCH_TMOUT		(CY_REG_ACT_INTRVL + 1)
#define CY_REG_LP_INTRVL		(CY_REG_TCH_TMOUT + 1)
#define CY_MAXZ				255
#define CY_DELAY_DFLT			20 /* ms */
#define CY_DELAY_MAX			500
#define CY_ACT_DIST_DFLT		0xF8
#define CY_ACT_DIST_MASK		0x0F
#define CY_HNDSHK_BIT			0x80
/* device mode bits */
#define CY_OPERATE_MODE			0x00
#define CY_SYSINFO_MODE			0x10
/* power mode select bits */
#define CY_SOFT_RESET_MODE		0x01 /* return to Bootloader mode */
#define CY_DEEP_SLEEP_MODE		0x02
#define CY_LOW_POWER_MODE		0x04

/* Slots management */
#define CY_MAX_FINGER			4
#define CY_MAX_ID			16

static const u8 bl_command[] = {
	0x00,			/* file offset */
	0xFF,			/* command */
	0xA5,			/* exit bootloader command */
	0, 1, 2, 3, 4, 5, 6, 7	/* default keys */
};

static int ttsp_read_block_data(struct cyttsp *ts, u8 command,
				u8 length, void *buf)
{
	int error;
	int tries;

	for (tries = 0; tries < CY_NUM_RETRY; tries++) {
		error = ts->bus_ops->read(ts->dev, ts->xfer_buf, command,
				length, buf);
		if (!error)
			return 0;

		msleep(CY_DELAY_DFLT);
	}

	return -EIO;
}

static int ttsp_write_block_data(struct cyttsp *ts, u8 command,
				 u8 length, void *buf)
{
	int error;
	int tries;

	for (tries = 0; tries < CY_NUM_RETRY; tries++) {
		error = ts->bus_ops->write(ts->dev, ts->xfer_buf, command,
				length, buf);
		if (!error)
			return 0;

		msleep(CY_DELAY_DFLT);
	}

	return -EIO;
}

static int ttsp_send_command(struct cyttsp *ts, u8 cmd)
{
	return ttsp_write_block_data(ts, CY_REG_BASE, sizeof(cmd), &cmd);
}

static int cyttsp_handshake(struct cyttsp *ts)
{
	if (ts->use_hndshk)
		return ttsp_send_command(ts,
				ts->xy_data.hst_mode ^ CY_HNDSHK_BIT);

	return 0;
}

static int cyttsp_load_bl_regs(struct cyttsp *ts)
{
	memset(&ts->bl_data, 0, sizeof(ts->bl_data));
	ts->bl_data.bl_status = 0x10;

	return ttsp_read_block_data(ts, CY_REG_BASE,
				    sizeof(ts->bl_data), &ts->bl_data);
}

static int cyttsp_exit_bl_mode(struct cyttsp *ts)
{
	int error;
	u8 bl_cmd[sizeof(bl_command)];

	memcpy(bl_cmd, bl_command, sizeof(bl_command));
	if (ts->bl_keys)
		memcpy(&bl_cmd[sizeof(bl_command) - CY_NUM_BL_KEYS],
			ts->bl_keys, CY_NUM_BL_KEYS);

	error = ttsp_write_block_data(ts, CY_REG_BASE,
				      sizeof(bl_cmd), bl_cmd);
	if (error)
		return error;

	/* wait for TTSP Device to complete the operation */
	msleep(CY_DELAY_DFLT);

	error = cyttsp_load_bl_regs(ts);
	if (error)
		return error;

	if (GET_BOOTLOADERMODE(ts->bl_data.bl_status))
		return -EIO;

	return 0;
}

static int cyttsp_set_operational_mode(struct cyttsp *ts)
{
	int error;

	error = ttsp_send_command(ts, CY_OPERATE_MODE);
	if (error)
		return error;

	/* wait for TTSP Device to complete switch to Operational mode */
	error = ttsp_read_block_data(ts, CY_REG_BASE,
				     sizeof(ts->xy_data), &ts->xy_data);
	if (error)
		return error;

	error = cyttsp_handshake(ts);
	if (error)
		return error;

	return ts->xy_data.act_dist == CY_ACT_DIST_DFLT ? -EIO : 0;
}

static int cyttsp_set_sysinfo_mode(struct cyttsp *ts)
{
	int error;

	memset(&ts->sysinfo_data, 0, sizeof(ts->sysinfo_data));

	/* switch to sysinfo mode */
	error = ttsp_send_command(ts, CY_SYSINFO_MODE);
	if (error)
		return error;

	/* read sysinfo registers */
	msleep(CY_DELAY_DFLT);
	error = ttsp_read_block_data(ts, CY_REG_BASE, sizeof(ts->sysinfo_data),
				      &ts->sysinfo_data);
	if (error)
		return error;

	error = cyttsp_handshake(ts);
	if (error)
		return error;

	if (!ts->sysinfo_data.tts_verh && !ts->sysinfo_data.tts_verl)
		return -EIO;

	return 0;
}

static int cyttsp_set_sysinfo_regs(struct cyttsp *ts)
{
	int retval = 0;

	if (ts->act_intrvl != CY_ACT_INTRVL_DFLT ||
	    ts->tch_tmout != CY_TCH_TMOUT_DFLT ||
	    ts->lp_intrvl != CY_LP_INTRVL_DFLT) {

		u8 intrvl_ray[] = {
			ts->act_intrvl,
			ts->tch_tmout,
			ts->lp_intrvl
		};

		/* set intrvl registers */
		retval = ttsp_write_block_data(ts, CY_REG_ACT_INTRVL,
					sizeof(intrvl_ray), intrvl_ray);
		msleep(CY_DELAY_DFLT);
	}

	return retval;
}

static void cyttsp_hard_reset(struct cyttsp *ts)
{
	if (ts->reset_gpio) {
		gpiod_set_value_cansleep(ts->reset_gpio, 1);
		msleep(CY_DELAY_DFLT);
		gpiod_set_value_cansleep(ts->reset_gpio, 0);
		msleep(CY_DELAY_DFLT);
	}
}

static int cyttsp_soft_reset(struct cyttsp *ts)
{
	unsigned long timeout;
	int retval;

	/* wait for interrupt to set ready completion */
	reinit_completion(&ts->bl_ready);
	ts->state = CY_BL_STATE;

	enable_irq(ts->irq);

	retval = ttsp_send_command(ts, CY_SOFT_RESET_MODE);
	if (retval)
		goto out;

	timeout = wait_for_completion_timeout(&ts->bl_ready,
			msecs_to_jiffies(CY_DELAY_DFLT * CY_DELAY_MAX));
	retval = timeout ? 0 : -EIO;

out:
	ts->state = CY_IDLE_STATE;
	disable_irq(ts->irq);
	return retval;
}

static int cyttsp_act_dist_setup(struct cyttsp *ts)
{
	u8 act_dist_setup = ts->act_dist;

	/* Init gesture; active distance setup */
	return ttsp_write_block_data(ts, CY_REG_ACT_DIST,
				sizeof(act_dist_setup), &act_dist_setup);
}

static void cyttsp_extract_track_ids(struct cyttsp_xydata *xy_data, int *ids)
{
	ids[0] = xy_data->touch12_id >> 4;
	ids[1] = xy_data->touch12_id & 0xF;
	ids[2] = xy_data->touch34_id >> 4;
	ids[3] = xy_data->touch34_id & 0xF;
}

static const struct cyttsp_tch *cyttsp_get_tch(struct cyttsp_xydata *xy_data,
					       int idx)
{
	switch (idx) {
	case 0:
		return &xy_data->tch1;
	case 1:
		return &xy_data->tch2;
	case 2:
		return &xy_data->tch3;
	case 3:
		return &xy_data->tch4;
	default:
		return NULL;
	}
}

static void cyttsp_report_tchdata(struct cyttsp *ts)
{
	struct cyttsp_xydata *xy_data = &ts->xy_data;
	struct input_dev *input = ts->input;
	int num_tch = GET_NUM_TOUCHES(xy_data->tt_stat);
	const struct cyttsp_tch *tch;
	int ids[CY_MAX_ID];
	int i;
	DECLARE_BITMAP(used, CY_MAX_ID);

	if (IS_LARGE_AREA(xy_data->tt_stat) == 1) {
		/* terminate all active tracks */
		num_tch = 0;
		dev_dbg(ts->dev, "%s: Large area detected\n", __func__);
	} else if (num_tch > CY_MAX_FINGER) {
		/* terminate all active tracks */
		num_tch = 0;
		dev_dbg(ts->dev, "%s: Num touch error detected\n", __func__);
	} else if (IS_BAD_PKT(xy_data->tt_mode)) {
		/* terminate all active tracks */
		num_tch = 0;
		dev_dbg(ts->dev, "%s: Invalid buffer detected\n", __func__);
	}

	cyttsp_extract_track_ids(xy_data, ids);

	bitmap_zero(used, CY_MAX_ID);

	for (i = 0; i < num_tch; i++) {
		tch = cyttsp_get_tch(xy_data, i);

		input_mt_slot(input, ids[i]);
		input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
		input_report_abs(input, ABS_MT_POSITION_X, be16_to_cpu(tch->x));
		input_report_abs(input, ABS_MT_POSITION_Y, be16_to_cpu(tch->y));
		input_report_abs(input, ABS_MT_TOUCH_MAJOR, tch->z);

		__set_bit(ids[i], used);
	}

	for (i = 0; i < CY_MAX_ID; i++) {
		if (test_bit(i, used))
			continue;

		input_mt_slot(input, i);
		input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
	}

	input_sync(input);
}

static irqreturn_t cyttsp_irq(int irq, void *handle)
{
	struct cyttsp *ts = handle;
	int error;

	if (unlikely(ts->state == CY_BL_STATE)) {
		complete(&ts->bl_ready);
		goto out;
	}

	/* Get touch data from CYTTSP device */
	error = ttsp_read_block_data(ts, CY_REG_BASE,
				 sizeof(struct cyttsp_xydata), &ts->xy_data);
	if (error)
		goto out;

	/* provide flow control handshake */
	error = cyttsp_handshake(ts);
	if (error)
		goto out;

	if (unlikely(ts->state == CY_IDLE_STATE))
		goto out;

	if (GET_BOOTLOADERMODE(ts->xy_data.tt_mode)) {
		/*
		 * TTSP device has reset back to bootloader mode.
		 * Restore to operational mode.
		 */
		error = cyttsp_exit_bl_mode(ts);
		if (error) {
			dev_err(ts->dev,
				"Could not return to operational mode, err: %d\n",
				error);
			ts->state = CY_IDLE_STATE;
		}
	} else {
		cyttsp_report_tchdata(ts);
	}

out:
	return IRQ_HANDLED;
}

static int cyttsp_power_on(struct cyttsp *ts)
{
	int error;

	error = cyttsp_soft_reset(ts);
	if (error)
		return error;

	error = cyttsp_load_bl_regs(ts);
	if (error)
		return error;

	if (GET_BOOTLOADERMODE(ts->bl_data.bl_status) &&
	    IS_VALID_APP(ts->bl_data.bl_status)) {
		error = cyttsp_exit_bl_mode(ts);
		if (error)
			return error;
	}

	if (GET_HSTMODE(ts->bl_data.bl_file) != CY_OPERATE_MODE ||
	    IS_OPERATIONAL_ERR(ts->bl_data.bl_status)) {
		return -ENODEV;
	}

	error = cyttsp_set_sysinfo_mode(ts);
	if (error)
		return error;

	error = cyttsp_set_sysinfo_regs(ts);
	if (error)
		return error;

	error = cyttsp_set_operational_mode(ts);
	if (error)
		return error;

	/* init active distance */
	error = cyttsp_act_dist_setup(ts);
	if (error)
		return error;

	ts->state = CY_ACTIVE_STATE;

	return 0;
}

static int cyttsp_enable(struct cyttsp *ts)
{
	int error;

	/*
	 * The device firmware can wake on an I2C or SPI memory slave
	 * address match. So just reading a register is sufficient to
	 * wake up the device. The first read attempt will fail but it
	 * will wake it up making the second read attempt successful.
	 */
	error = ttsp_read_block_data(ts, CY_REG_BASE,
				     sizeof(ts->xy_data), &ts->xy_data);
	if (error)
		return error;

	if (GET_HSTMODE(ts->xy_data.hst_mode))
		return -EIO;

	enable_irq(ts->irq);

	return 0;
}

static int cyttsp_disable(struct cyttsp *ts)
{
	int error;

	error = ttsp_send_command(ts, CY_LOW_POWER_MODE);
	if (error)
		return error;

	disable_irq(ts->irq);

	return 0;
}

static int __maybe_unused cyttsp_suspend(struct device *dev)
{
	struct cyttsp *ts = dev_get_drvdata(dev);
	int retval = 0;

	mutex_lock(&ts->input->mutex);

	if (ts->input->users) {
		retval = cyttsp_disable(ts);
		if (retval == 0)
			ts->suspended = true;
	}

	mutex_unlock(&ts->input->mutex);

	return retval;
}

static int __maybe_unused cyttsp_resume(struct device *dev)
{
	struct cyttsp *ts = dev_get_drvdata(dev);

	mutex_lock(&ts->input->mutex);

	if (ts->input->users)
		cyttsp_enable(ts);

	ts->suspended = false;

	mutex_unlock(&ts->input->mutex);

	return 0;
}

SIMPLE_DEV_PM_OPS(cyttsp_pm_ops, cyttsp_suspend, cyttsp_resume);
EXPORT_SYMBOL_GPL(cyttsp_pm_ops);

static int cyttsp_open(struct input_dev *dev)
{
	struct cyttsp *ts = input_get_drvdata(dev);
	int retval = 0;

	if (!ts->suspended)
		retval = cyttsp_enable(ts);

	return retval;
}

static void cyttsp_close(struct input_dev *dev)
{
	struct cyttsp *ts = input_get_drvdata(dev);

	if (!ts->suspended)
		cyttsp_disable(ts);
}

static int cyttsp_parse_properties(struct cyttsp *ts)
{
	struct device *dev = ts->dev;
	u32 dt_value;
	int ret;

	ts->bl_keys = devm_kzalloc(dev, CY_NUM_BL_KEYS, GFP_KERNEL);
	if (!ts->bl_keys)
		return -ENOMEM;

	/* Set some default values */
	ts->use_hndshk = false;
	ts->act_dist = CY_ACT_DIST_DFLT;
	ts->act_intrvl = CY_ACT_INTRVL_DFLT;
	ts->tch_tmout = CY_TCH_TMOUT_DFLT;
	ts->lp_intrvl = CY_LP_INTRVL_DFLT;

	ret = device_property_read_u8_array(dev, "bootloader-key",
					    ts->bl_keys, CY_NUM_BL_KEYS);
	if (ret) {
		dev_err(dev,
			"bootloader-key property could not be retrieved\n");
		return ret;
	}

	ts->use_hndshk = device_property_present(dev, "use-handshake");

	if (!device_property_read_u32(dev, "active-distance", &dt_value)) {
		if (dt_value > 15) {
			dev_err(dev, "active-distance (%u) must be [0-15]\n",
				dt_value);
			return -EINVAL;
		}
		ts->act_dist &= ~CY_ACT_DIST_MASK;
		ts->act_dist |= dt_value;
	}

	if (!device_property_read_u32(dev, "active-interval-ms", &dt_value)) {
		if (dt_value > 255) {
			dev_err(dev, "active-interval-ms (%u) must be [0-255]\n",
				dt_value);
			return -EINVAL;
		}
		ts->act_intrvl = dt_value;
	}

	if (!device_property_read_u32(dev, "lowpower-interval-ms", &dt_value)) {
		if (dt_value > 2550) {
			dev_err(dev, "lowpower-interval-ms (%u) must be [0-2550]\n",
				dt_value);
			return -EINVAL;
		}
		/* Register value is expressed in 0.01s / bit */
		ts->lp_intrvl = dt_value / 10;
	}

	if (!device_property_read_u32(dev, "touch-timeout-ms", &dt_value)) {
		if (dt_value > 2550) {
			dev_err(dev, "touch-timeout-ms (%u) must be [0-2550]\n",
				dt_value);
			return -EINVAL;
		}
		/* Register value is expressed in 0.01s / bit */
		ts->tch_tmout = dt_value / 10;
	}

	return 0;
}

struct cyttsp *cyttsp_probe(const struct cyttsp_bus_ops *bus_ops,
			    struct device *dev, int irq, size_t xfer_buf_size)
{
	struct cyttsp *ts;
	struct input_dev *input_dev;
	int error;

	ts = devm_kzalloc(dev, sizeof(*ts) + xfer_buf_size, GFP_KERNEL);
	if (!ts)
		return ERR_PTR(-ENOMEM);

	input_dev = devm_input_allocate_device(dev);
	if (!input_dev)
		return ERR_PTR(-ENOMEM);

	ts->dev = dev;
	ts->input = input_dev;
	ts->bus_ops = bus_ops;
	ts->irq = irq;

	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
	if (IS_ERR(ts->reset_gpio)) {
		error = PTR_ERR(ts->reset_gpio);
		dev_err(dev, "Failed to request reset gpio, error %d\n", error);
		return ERR_PTR(error);
	}

	error = cyttsp_parse_properties(ts);
	if (error)
		return ERR_PTR(error);

	init_completion(&ts->bl_ready);
	snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));

	input_dev->name = "Cypress TTSP TouchScreen";
	input_dev->phys = ts->phys;
	input_dev->id.bustype = bus_ops->bustype;
	input_dev->dev.parent = ts->dev;

	input_dev->open = cyttsp_open;
	input_dev->close = cyttsp_close;

	input_set_drvdata(input_dev, ts);

	input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X);
	input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y);
	touchscreen_parse_properties(input_dev, true, NULL);

	error = input_mt_init_slots(input_dev, CY_MAX_ID, 0);
	if (error) {
		dev_err(dev, "Unable to init MT slots.\n");
		return ERR_PTR(error);
	}

	error = devm_request_threaded_irq(dev, ts->irq, NULL, cyttsp_irq,
					  IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
					  "cyttsp", ts);
	if (error) {
		dev_err(ts->dev, "failed to request IRQ %d, err: %d\n",
			ts->irq, error);
		return ERR_PTR(error);
	}

	disable_irq(ts->irq);

	cyttsp_hard_reset(ts);

	error = cyttsp_power_on(ts);
	if (error)
		return ERR_PTR(error);

	error = input_register_device(input_dev);
	if (error) {
		dev_err(ts->dev, "failed to register input device: %d\n",
			error);
		return ERR_PTR(error);
	}

	return ts;
}
EXPORT_SYMBOL_GPL(cyttsp_probe);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard touchscreen driver core");
MODULE_AUTHOR("Cypress");
Commit	Line	Data
4065d1e7 JMC	1	/*
	2	* Core Source for:
	3	* Cypress TrueTouch(TM) Standard Product (TTSP) touchscreen drivers.
	4	* For use with Cypress Txx3xx parts.
	5	* Supported parts include:
	6	* CY8CTST341
	7	* CY8CTMA340
	8	*
	9	* Copyright (C) 2009, 2010, 2011 Cypress Semiconductor, Inc.
	10	* Copyright (C) 2012 Javier Martinez Canillas <javier@dowhile0.org>
	11	*
	12	* This program is free software; you can redistribute it and/or
	13	* modify it under the terms of the GNU General Public License
	14	* version 2, and only version 2, as published by the
	15	* Free Software Foundation.
	16	*
	17	* This program is distributed in the hope that it will be useful,
	18	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	* GNU General Public License for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License along
	23	* with this program; if not, write to the Free Software Foundation, Inc.,
	24	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
	25	*
	26	* Contact Cypress Semiconductor at www.cypress.com <kev@cypress.com>
	27	*
	28	*/
	29
	30	#include <linux/delay.h>
	31	#include <linux/input.h>
	32	#include <linux/input/mt.h>
707b61bb	33	#include <linux/input/touchscreen.h>
4065d1e7 JMC	34	#include <linux/gpio.h>
	35	#include <linux/interrupt.h>
	36	#include <linux/slab.h>
707b61bb OS	37	#include <linux/property.h>
707b61bb OS	38	#include <linux/gpio/consumer.h>
4065d1e7 JMC	39
	40	#include "cyttsp_core.h"
	41
	42	/* Bootloader number of command keys */
	43	#define CY_NUM_BL_KEYS 8
	44
	45	/* helpers */
	46	#define GET_NUM_TOUCHES(x) ((x) & 0x0F)
	47	#define IS_LARGE_AREA(x) (((x) & 0x10) >> 4)
	48	#define IS_BAD_PKT(x) ((x) & 0x20)
	49	#define IS_VALID_APP(x) ((x) & 0x01)
	50	#define IS_OPERATIONAL_ERR(x) ((x) & 0x3F)
	51	#define GET_HSTMODE(reg) (((reg) & 0x70) >> 4)
	52	#define GET_BOOTLOADERMODE(reg) (((reg) & 0x10) >> 4)
	53
	54	#define CY_REG_BASE 0x00
	55	#define CY_REG_ACT_DIST 0x1E
	56	#define CY_REG_ACT_INTRVL 0x1D
	57	#define CY_REG_TCH_TMOUT (CY_REG_ACT_INTRVL + 1)
	58	#define CY_REG_LP_INTRVL (CY_REG_TCH_TMOUT + 1)
	59	#define CY_MAXZ 255
	60	#define CY_DELAY_DFLT 20 /* ms */
	61	#define CY_DELAY_MAX 500
	62	#define CY_ACT_DIST_DFLT 0xF8
707b61bb	63	#define CY_ACT_DIST_MASK 0x0F
4065d1e7 JMC	64	#define CY_HNDSHK_BIT 0x80
	65	/* device mode bits */
	66	#define CY_OPERATE_MODE 0x00
	67	#define CY_SYSINFO_MODE 0x10
	68	/* power mode select bits */
	69	#define CY_SOFT_RESET_MODE 0x01 /* return to Bootloader mode */
	70	#define CY_DEEP_SLEEP_MODE 0x02
	71	#define CY_LOW_POWER_MODE 0x04
	72
	73	/* Slots management */
	74	#define CY_MAX_FINGER 4
	75	#define CY_MAX_ID 16
	76
	77	static const u8 bl_command[] = {
	78	0x00, /* file offset */
	79	0xFF, /* command */
	80	0xA5, /* exit bootloader command */
	81	0, 1, 2, 3, 4, 5, 6, 7 /* default keys */
	82	};
	83
	84	static int ttsp_read_block_data(struct cyttsp *ts, u8 command,
	85	u8 length, void *buf)
	86	{
	87	int error;
	88	int tries;
	89
	90	for (tries = 0; tries < CY_NUM_RETRY; tries++) {
9664877e FY	91	error = ts->bus_ops->read(ts->dev, ts->xfer_buf, command,
9664877e FY	92	length, buf);
4065d1e7 JMC	93	if (!error)
	94	return 0;
	95
	96	msleep(CY_DELAY_DFLT);
	97	}
	98
	99	return -EIO;
	100	}
	101
	102	static int ttsp_write_block_data(struct cyttsp *ts, u8 command,
	103	u8 length, void *buf)
	104	{
	105	int error;
	106	int tries;
	107
	108	for (tries = 0; tries < CY_NUM_RETRY; tries++) {
9664877e FY	109	error = ts->bus_ops->write(ts->dev, ts->xfer_buf, command,
9664877e FY	110	length, buf);
4065d1e7 JMC	111	if (!error)
	112	return 0;
	113
	114	msleep(CY_DELAY_DFLT);
	115	}
	116
	117	return -EIO;
	118	}
	119
	120	static int ttsp_send_command(struct cyttsp *ts, u8 cmd)
	121	{
	122	return ttsp_write_block_data(ts, CY_REG_BASE, sizeof(cmd), &cmd);
	123	}
	124
fbd5e77e FY	125	static int cyttsp_handshake(struct cyttsp *ts)
fbd5e77e FY	126	{
707b61bb	127	if (ts->use_hndshk)
fbd5e77e FY	128	return ttsp_send_command(ts,
	129	ts->xy_data.hst_mode ^ CY_HNDSHK_BIT);
	130
	131	return 0;
	132	}
	133
4065d1e7 JMC	134	static int cyttsp_load_bl_regs(struct cyttsp *ts)
	135	{
	136	memset(&ts->bl_data, 0, sizeof(ts->bl_data));
	137	ts->bl_data.bl_status = 0x10;
	138
	139	return ttsp_read_block_data(ts, CY_REG_BASE,
	140	sizeof(ts->bl_data), &ts->bl_data);
	141	}
	142
	143	static int cyttsp_exit_bl_mode(struct cyttsp *ts)
	144	{
	145	int error;
	146	u8 bl_cmd[sizeof(bl_command)];
	147
	148	memcpy(bl_cmd, bl_command, sizeof(bl_command));
707b61bb	149	if (ts->bl_keys)
4065d1e7	150	memcpy(&bl_cmd[sizeof(bl_command) - CY_NUM_BL_KEYS],
707b61bb	151	ts->bl_keys, CY_NUM_BL_KEYS);
4065d1e7 JMC	152
	153	error = ttsp_write_block_data(ts, CY_REG_BASE,
	154	sizeof(bl_cmd), bl_cmd);
	155	if (error)
	156	return error;
	157
	158	/* wait for TTSP Device to complete the operation */
	159	msleep(CY_DELAY_DFLT);
	160
	161	error = cyttsp_load_bl_regs(ts);
	162	if (error)
	163	return error;
	164
	165	if (GET_BOOTLOADERMODE(ts->bl_data.bl_status))
	166	return -EIO;
	167
	168	return 0;
	169	}
	170
	171	static int cyttsp_set_operational_mode(struct cyttsp *ts)
	172	{
	173	int error;
	174
	175	error = ttsp_send_command(ts, CY_OPERATE_MODE);
	176	if (error)
	177	return error;
	178
	179	/* wait for TTSP Device to complete switch to Operational mode */
	180	error = ttsp_read_block_data(ts, CY_REG_BASE,
	181	sizeof(ts->xy_data), &ts->xy_data);
	182	if (error)
	183	return error;
	184
fbd5e77e FY	185	error = cyttsp_handshake(ts);
	186	if (error)
	187	return error;
	188
4065d1e7 JMC	189	return ts->xy_data.act_dist == CY_ACT_DIST_DFLT ? -EIO : 0;
	190	}
	191
	192	static int cyttsp_set_sysinfo_mode(struct cyttsp *ts)
	193	{
	194	int error;
	195
	196	memset(&ts->sysinfo_data, 0, sizeof(ts->sysinfo_data));
	197
	198	/* switch to sysinfo mode */
	199	error = ttsp_send_command(ts, CY_SYSINFO_MODE);
	200	if (error)
	201	return error;
	202
	203	/* read sysinfo registers */
	204	msleep(CY_DELAY_DFLT);
	205	error = ttsp_read_block_data(ts, CY_REG_BASE, sizeof(ts->sysinfo_data),
	206	&ts->sysinfo_data);
	207	if (error)
	208	return error;
	209
fbd5e77e FY	210	error = cyttsp_handshake(ts);
	211	if (error)
	212	return error;
	213
4065d1e7 JMC	214	if (!ts->sysinfo_data.tts_verh && !ts->sysinfo_data.tts_verl)
	215	return -EIO;
	216
	217	return 0;
	218	}
	219
	220	static int cyttsp_set_sysinfo_regs(struct cyttsp *ts)
	221	{
	222	int retval = 0;
	223
707b61bb OS	224	if (ts->act_intrvl != CY_ACT_INTRVL_DFLT \|\|
	225	ts->tch_tmout != CY_TCH_TMOUT_DFLT \|\|
	226	ts->lp_intrvl != CY_LP_INTRVL_DFLT) {
4065d1e7 JMC	227
4065d1e7 JMC	228	u8 intrvl_ray[] = {
707b61bb OS	229	ts->act_intrvl,
	230	ts->tch_tmout,
	231	ts->lp_intrvl
4065d1e7 JMC	232	};
	233
	234	/* set intrvl registers */
	235	retval = ttsp_write_block_data(ts, CY_REG_ACT_INTRVL,
	236	sizeof(intrvl_ray), intrvl_ray);
	237	msleep(CY_DELAY_DFLT);
	238	}
	239
	240	return retval;
	241	}
	242
8fb81d20 OS	243	static void cyttsp_hard_reset(struct cyttsp *ts)
	244	{
	245	if (ts->reset_gpio) {
	246	gpiod_set_value_cansleep(ts->reset_gpio, 1);
	247	msleep(CY_DELAY_DFLT);
	248	gpiod_set_value_cansleep(ts->reset_gpio, 0);
	249	msleep(CY_DELAY_DFLT);
	250	}
	251	}
	252
4065d1e7 JMC	253	static int cyttsp_soft_reset(struct cyttsp *ts)
	254	{
	255	unsigned long timeout;
	256	int retval;
	257
	258	/* wait for interrupt to set ready completion */
16735d02	259	reinit_completion(&ts->bl_ready);
4065d1e7 JMC	260	ts->state = CY_BL_STATE;
	261
	262	enable_irq(ts->irq);
	263
	264	retval = ttsp_send_command(ts, CY_SOFT_RESET_MODE);
	265	if (retval)
	266	goto out;
	267
	268	timeout = wait_for_completion_timeout(&ts->bl_ready,
	269	msecs_to_jiffies(CY_DELAY_DFLT * CY_DELAY_MAX));
	270	retval = timeout ? 0 : -EIO;
	271
	272	out:
	273	ts->state = CY_IDLE_STATE;
	274	disable_irq(ts->irq);
	275	return retval;
	276	}
	277
	278	static int cyttsp_act_dist_setup(struct cyttsp *ts)
	279	{
707b61bb	280	u8 act_dist_setup = ts->act_dist;
4065d1e7 JMC	281
	282	/* Init gesture; active distance setup */
	283	return ttsp_write_block_data(ts, CY_REG_ACT_DIST,
	284	sizeof(act_dist_setup), &act_dist_setup);
	285	}
	286
	287	static void cyttsp_extract_track_ids(struct cyttsp_xydata xy_data, int ids)
	288	{
	289	ids[0] = xy_data->touch12_id >> 4;
	290	ids[1] = xy_data->touch12_id & 0xF;
	291	ids[2] = xy_data->touch34_id >> 4;
	292	ids[3] = xy_data->touch34_id & 0xF;
	293	}
	294
	295	static const struct cyttsp_tch cyttsp_get_tch(struct cyttsp_xydata xy_data,
	296	int idx)
	297	{
	298	switch (idx) {
	299	case 0:
	300	return &xy_data->tch1;
	301	case 1:
	302	return &xy_data->tch2;
	303	case 2:
	304	return &xy_data->tch3;
	305	case 3:
	306	return &xy_data->tch4;
	307	default:
	308	return NULL;
	309	}
	310	}
	311
	312	static void cyttsp_report_tchdata(struct cyttsp *ts)
	313	{
	314	struct cyttsp_xydata *xy_data = &ts->xy_data;
	315	struct input_dev *input = ts->input;
	316	int num_tch = GET_NUM_TOUCHES(xy_data->tt_stat);
	317	const struct cyttsp_tch *tch;
	318	int ids[CY_MAX_ID];
	319	int i;
	320	DECLARE_BITMAP(used, CY_MAX_ID);
	321
	322	if (IS_LARGE_AREA(xy_data->tt_stat) == 1) {
	323	/* terminate all active tracks */
	324	num_tch = 0;
	325	dev_dbg(ts->dev, "%s: Large area detected\n", __func__);
	326	} else if (num_tch > CY_MAX_FINGER) {
	327	/* terminate all active tracks */
	328	num_tch = 0;
	329	dev_dbg(ts->dev, "%s: Num touch error detected\n", __func__);
	330	} else if (IS_BAD_PKT(xy_data->tt_mode)) {
	331	/* terminate all active tracks */
	332	num_tch = 0;
	333	dev_dbg(ts->dev, "%s: Invalid buffer detected\n", __func__);
	334	}
	335
	336	cyttsp_extract_track_ids(xy_data, ids);
	337
	338	bitmap_zero(used, CY_MAX_ID);
	339
	340	for (i = 0; i < num_tch; i++) {
	341	tch = cyttsp_get_tch(xy_data, i);
	342
	343	input_mt_slot(input, ids[i]);
	344	input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
345	input_report_abs(input, ABS_MT_POSITION_X, be16_to_cpu(tch->x));
346	input_report_abs(input, ABS_MT_POSITION_Y, be16_to_cpu(tch->y));
347	input_report_abs(input, ABS_MT_TOUCH_MAJOR, tch->z);
348
349	__set_bit(ids[i], used);
350	}
351
352	for (i = 0; i < CY_MAX_ID; i++) {
353	if (test_bit(i, used))
354	continue;
355
356	input_mt_slot(input, i);
357	input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
358	}
359
360	input_sync(input);
361	}
362
363	static irqreturn_t cyttsp_irq(int irq, void *handle)
364	{
365	struct cyttsp *ts = handle;
366	int error;
367
368	if (unlikely(ts->state == CY_BL_STATE)) {
369	complete(&ts->bl_ready);
370	goto out;
371	}
372
373	/* Get touch data from CYTTSP device */
374	error = ttsp_read_block_data(ts, CY_REG_BASE,
375	sizeof(struct cyttsp_xydata), &ts->xy_data);
376	if (error)
377	goto out;
378
379	/* provide flow control handshake */
fbd5e77e FY	380	error = cyttsp_handshake(ts);
	381	if (error)
	382	goto out;
4065d1e7 JMC	383
	384	if (unlikely(ts->state == CY_IDLE_STATE))
	385	goto out;
	386
	387	if (GET_BOOTLOADERMODE(ts->xy_data.tt_mode)) {
	388	/*
	389	* TTSP device has reset back to bootloader mode.
	390	* Restore to operational mode.
	391	*/
	392	error = cyttsp_exit_bl_mode(ts);
	393	if (error) {
	394	dev_err(ts->dev,
	395	"Could not return to operational mode, err: %d\n",
	396	error);
	397	ts->state = CY_IDLE_STATE;
	398	}
	399	} else {
	400	cyttsp_report_tchdata(ts);
	401	}
	402
	403	out:
	404	return IRQ_HANDLED;
	405	}
	406
	407	static int cyttsp_power_on(struct cyttsp *ts)
	408	{
	409	int error;
	410
	411	error = cyttsp_soft_reset(ts);
	412	if (error)
	413	return error;
	414
	415	error = cyttsp_load_bl_regs(ts);
	416	if (error)
	417	return error;
	418
	419	if (GET_BOOTLOADERMODE(ts->bl_data.bl_status) &&
	420	IS_VALID_APP(ts->bl_data.bl_status)) {
	421	error = cyttsp_exit_bl_mode(ts);
	422	if (error)
	423	return error;
	424	}
	425
	426	if (GET_HSTMODE(ts->bl_data.bl_file) != CY_OPERATE_MODE \|\|
	427	IS_OPERATIONAL_ERR(ts->bl_data.bl_status)) {
	428	return -ENODEV;
	429	}
	430
	431	error = cyttsp_set_sysinfo_mode(ts);
	432	if (error)
	433	return error;
	434
	435	error = cyttsp_set_sysinfo_regs(ts);
	436	if (error)
	437	return error;
	438
	439	error = cyttsp_set_operational_mode(ts);
	440	if (error)
	441	return error;
	442
	443	/* init active distance */
	444	error = cyttsp_act_dist_setup(ts);
	445	if (error)
	446	return error;
447
448	ts->state = CY_ACTIVE_STATE;
449
450	return 0;
451	}
452
453	static int cyttsp_enable(struct cyttsp *ts)
454	{
455	int error;
456
457	/*
458	* The device firmware can wake on an I2C or SPI memory slave
459	* address match. So just reading a register is sufficient to
460	* wake up the device. The first read attempt will fail but it
461	* will wake it up making the second read attempt successful.
462	*/
463	error = ttsp_read_block_data(ts, CY_REG_BASE,
464	sizeof(ts->xy_data), &ts->xy_data);
465	if (error)
466	return error;
467
468	if (GET_HSTMODE(ts->xy_data.hst_mode))
469	return -EIO;
470
471	enable_irq(ts->irq);
472
473	return 0;
474	}
475
476	static int cyttsp_disable(struct cyttsp *ts)
477	{
478	int error;
479
480	error = ttsp_send_command(ts, CY_LOW_POWER_MODE);
481	if (error)
482	return error;
483
484	disable_irq(ts->irq);
485
486	return 0;
487	}
488
02b6a58b	489	static int __maybe_unused cyttsp_suspend(struct device *dev)
4065d1e7 JMC	490	{
	491	struct cyttsp *ts = dev_get_drvdata(dev);
	492	int retval = 0;
	493
	494	mutex_lock(&ts->input->mutex);
	495
	496	if (ts->input->users) {
	497	retval = cyttsp_disable(ts);
	498	if (retval == 0)
	499	ts->suspended = true;
	500	}
	501
	502	mutex_unlock(&ts->input->mutex);
	503
	504	return retval;
	505	}
	506
02b6a58b	507	static int __maybe_unused cyttsp_resume(struct device *dev)
4065d1e7 JMC	508	{
	509	struct cyttsp *ts = dev_get_drvdata(dev);
	510
	511	mutex_lock(&ts->input->mutex);
	512
	513	if (ts->input->users)
	514	cyttsp_enable(ts);
	515
	516	ts->suspended = false;
	517
	518	mutex_unlock(&ts->input->mutex);
	519
	520	return 0;
	521	}
	522
4065d1e7 JMC	523	SIMPLE_DEV_PM_OPS(cyttsp_pm_ops, cyttsp_suspend, cyttsp_resume);
	524	EXPORT_SYMBOL_GPL(cyttsp_pm_ops);
	525
	526	static int cyttsp_open(struct input_dev *dev)
	527	{
	528	struct cyttsp *ts = input_get_drvdata(dev);
	529	int retval = 0;
	530
	531	if (!ts->suspended)
	532	retval = cyttsp_enable(ts);
	533
	534	return retval;
	535	}
	536
	537	static void cyttsp_close(struct input_dev *dev)
	538	{
	539	struct cyttsp *ts = input_get_drvdata(dev);
	540
	541	if (!ts->suspended)
	542	cyttsp_disable(ts);
	543	}
	544
707b61bb	545	static int cyttsp_parse_properties(struct cyttsp *ts)
e4cf92ba	546	{
707b61bb OS	547	struct device *dev = ts->dev;
	548	u32 dt_value;
	549	int ret;
	550
	551	ts->bl_keys = devm_kzalloc(dev, CY_NUM_BL_KEYS, GFP_KERNEL);
	552	if (!ts->bl_keys)
	553	return -ENOMEM;
	554
	555	/* Set some default values */
	556	ts->use_hndshk = false;
	557	ts->act_dist = CY_ACT_DIST_DFLT;
	558	ts->act_intrvl = CY_ACT_INTRVL_DFLT;
	559	ts->tch_tmout = CY_TCH_TMOUT_DFLT;
	560	ts->lp_intrvl = CY_LP_INTRVL_DFLT;
	561
	562	ret = device_property_read_u8_array(dev, "bootloader-key",
	563	ts->bl_keys, CY_NUM_BL_KEYS);
	564	if (ret) {
	565	dev_err(dev,
	566	"bootloader-key property could not be retrieved\n");
	567	return ret;
	568	}
	569
	570	ts->use_hndshk = device_property_present(dev, "use-handshake");
	571
	572	if (!device_property_read_u32(dev, "active-distance", &dt_value)) {
	573	if (dt_value > 15) {
	574	dev_err(dev, "active-distance (%u) must be [0-15]\n",
	575	dt_value);
	576	return -EINVAL;
	577	}
	578	ts->act_dist &= ~CY_ACT_DIST_MASK;
	579	ts->act_dist \|= dt_value;
	580	}
	581
	582	if (!device_property_read_u32(dev, "active-interval-ms", &dt_value)) {
	583	if (dt_value > 255) {
	584	dev_err(dev, "active-interval-ms (%u) must be [0-255]\n",
	585	dt_value);
	586	return -EINVAL;
	587	}
	588	ts->act_intrvl = dt_value;
	589	}
e4cf92ba	590
707b61bb OS	591	if (!device_property_read_u32(dev, "lowpower-interval-ms", &dt_value)) {
	592	if (dt_value > 2550) {
	593	dev_err(dev, "lowpower-interval-ms (%u) must be [0-2550]\n",
	594	dt_value);
	595	return -EINVAL;
	596	}
	597	/* Register value is expressed in 0.01s / bit */
	598	ts->lp_intrvl = dt_value / 10;
	599	}
	600
	601	if (!device_property_read_u32(dev, "touch-timeout-ms", &dt_value)) {
	602	if (dt_value > 2550) {
	603	dev_err(dev, "touch-timeout-ms (%u) must be [0-2550]\n",
	604	dt_value);
	605	return -EINVAL;
	606	}
	607	/* Register value is expressed in 0.01s / bit */
	608	ts->tch_tmout = dt_value / 10;
	609	}
	610
	611	return 0;
e4cf92ba OS	612	}
e4cf92ba OS	613
4065d1e7 JMC	614	struct cyttsp cyttsp_probe(const struct cyttsp_bus_ops bus_ops,
	615	struct device *dev, int irq, size_t xfer_buf_size)
	616	{
4065d1e7 JMC	617	struct cyttsp *ts;
	618	struct input_dev *input_dev;
	619	int error;
	620
e4cf92ba OS	621	ts = devm_kzalloc(dev, sizeof(*ts) + xfer_buf_size, GFP_KERNEL);
	622	if (!ts)
	623	return ERR_PTR(-ENOMEM);
	624
	625	input_dev = devm_input_allocate_device(dev);
	626	if (!input_dev)
	627	return ERR_PTR(-ENOMEM);
4065d1e7 JMC	628
	629	ts->dev = dev;
	630	ts->input = input_dev;
4065d1e7 JMC	631	ts->bus_ops = bus_ops;
	632	ts->irq = irq;
	633
707b61bb OS	634	ts->reset_gpio = devm_gpiod_get_optional(dev, "reset", GPIOD_OUT_LOW);
	635	if (IS_ERR(ts->reset_gpio)) {
	636	error = PTR_ERR(ts->reset_gpio);
	637	dev_err(dev, "Failed to request reset gpio, error %d\n", error);
e4cf92ba OS	638	return ERR_PTR(error);
	639	}
	640
707b61bb OS	641	error = cyttsp_parse_properties(ts);
	642	if (error)
	643	return ERR_PTR(error);
	644
	645	init_completion(&ts->bl_ready);
	646	snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
4065d1e7	647
707b61bb	648	input_dev->name = "Cypress TTSP TouchScreen";
4065d1e7 JMC	649	input_dev->phys = ts->phys;
	650	input_dev->id.bustype = bus_ops->bustype;
	651	input_dev->dev.parent = ts->dev;
	652
	653	input_dev->open = cyttsp_open;
	654	input_dev->close = cyttsp_close;
	655
	656	input_set_drvdata(input_dev, ts);
	657
707b61bb OS	658	input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_X);
707b61bb OS	659	input_set_capability(input_dev, EV_ABS, ABS_MT_POSITION_Y);
ed7c9870	660	touchscreen_parse_properties(input_dev, true, NULL);
4065d1e7	661
69a12402 OS	662	error = input_mt_init_slots(input_dev, CY_MAX_ID, 0);
	663	if (error) {
	664	dev_err(dev, "Unable to init MT slots.\n");
	665	return ERR_PTR(error);
	666	}
4065d1e7	667
e4cf92ba OS	668	error = devm_request_threaded_irq(dev, ts->irq, NULL, cyttsp_irq,
e4cf92ba OS	669	IRQF_TRIGGER_FALLING \| IRQF_ONESHOT,
707b61bb	670	"cyttsp", ts);
4065d1e7 JMC	671	if (error) {
	672	dev_err(ts->dev, "failed to request IRQ %d, err: %d\n",
	673	ts->irq, error);
e4cf92ba	674	return ERR_PTR(error);
4065d1e7 JMC	675	}
	676
	677	disable_irq(ts->irq);
	678
8fb81d20 OS	679	cyttsp_hard_reset(ts);
8fb81d20 OS	680
4065d1e7 JMC	681	error = cyttsp_power_on(ts);
4065d1e7 JMC	682	if (error)
e4cf92ba	683	return ERR_PTR(error);
4065d1e7 JMC	684
	685	error = input_register_device(input_dev);
	686	if (error) {
	687	dev_err(ts->dev, "failed to register input device: %d\n",
	688	error);
e4cf92ba	689	return ERR_PTR(error);
4065d1e7 JMC	690	}
	691
	692	return ts;
4065d1e7 JMC	693	}
	694	EXPORT_SYMBOL_GPL(cyttsp_probe);
	695
4065d1e7 JMC	696	MODULE_LICENSE("GPL");
	697	MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard touchscreen driver core");
	698	MODULE_AUTHOR("Cypress");