[deliverable/linux.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/gpio.h>
#include <linux/interrupt.h>
#include <linux/slab.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_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_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->pdata->bl_keys)
		memcpy(&bl_cmd[sizeof(bl_command) - CY_NUM_BL_KEYS],
			ts->pdata->bl_keys, sizeof(bl_command));

	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;

	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;

	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->pdata->act_intrvl != CY_ACT_INTRVL_DFLT ||
	    ts->pdata->tch_tmout != CY_TCH_TMOUT_DFLT ||
	    ts->pdata->lp_intrvl != CY_LP_INTRVL_DFLT) {

		u8 intrvl_ray[] = {
			ts->pdata->act_intrvl,
			ts->pdata->tch_tmout,
			ts->pdata->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 int cyttsp_soft_reset(struct cyttsp *ts)
{
	unsigned long timeout;
	int retval;

	/* wait for interrupt to set ready completion */
	INIT_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->pdata->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 */
	if (ts->pdata->use_hndshk) {
		error = ttsp_send_command(ts,
				ts->xy_data.hst_mode ^ CY_HNDSHK_BIT);
		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;
}

#ifdef CONFIG_PM_SLEEP
static int 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 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;
}

#endif

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);
}

struct cyttsp *cyttsp_probe(const struct cyttsp_bus_ops *bus_ops,
			    struct device *dev, int irq, size_t xfer_buf_size)
{
	const struct cyttsp_platform_data *pdata = dev->platform_data;
	struct cyttsp *ts;
	struct input_dev *input_dev;
	int error;

	if (!pdata || !pdata->name || irq <= 0) {
		error = -EINVAL;
		goto err_out;
	}

	ts = kzalloc(sizeof(*ts) + xfer_buf_size, GFP_KERNEL);
	input_dev = input_allocate_device();
	if (!ts || !input_dev) {
		error = -ENOMEM;
		goto err_free_mem;
	}

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

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

	if (pdata->init) {
		error = pdata->init();
		if (error) {
			dev_err(ts->dev, "platform init failed, err: %d\n",
				error);
			goto err_free_mem;
		}
	}

	input_dev->name = pdata->name;
	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);

	__set_bit(EV_ABS, input_dev->evbit);
	input_set_abs_params(input_dev, ABS_MT_POSITION_X,
			     0, pdata->maxx, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
			     0, pdata->maxy, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
			     0, CY_MAXZ, 0, 0);

	input_mt_init_slots(input_dev, CY_MAX_ID, 0);

	error = request_threaded_irq(ts->irq, NULL, cyttsp_irq,
				     IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
				     pdata->name, ts);
	if (error) {
		dev_err(ts->dev, "failed to request IRQ %d, err: %d\n",
			ts->irq, error);
		goto err_platform_exit;
	}

	disable_irq(ts->irq);

	error = cyttsp_power_on(ts);
	if (error)
		goto err_free_irq;

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

	return ts;

err_free_irq:
	free_irq(ts->irq, ts);
err_platform_exit:
	if (pdata->exit)
		pdata->exit();
err_free_mem:
	input_free_device(input_dev);
	kfree(ts);
err_out:
	return ERR_PTR(error);
}
EXPORT_SYMBOL_GPL(cyttsp_probe);

void cyttsp_remove(struct cyttsp *ts)
{
	free_irq(ts->irq, ts);
	input_unregister_device(ts->input);
	if (ts->pdata->exit)
		ts->pdata->exit();
	kfree(ts);
}
EXPORT_SYMBOL_GPL(cyttsp_remove);

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>
	33	#include <linux/gpio.h>
	34	#include <linux/interrupt.h>
	35	#include <linux/slab.h>
	36
	37	#include "cyttsp_core.h"
	38
	39	/* Bootloader number of command keys */
	40	#define CY_NUM_BL_KEYS 8
	41
	42	/* helpers */
	43	#define GET_NUM_TOUCHES(x) ((x) & 0x0F)
	44	#define IS_LARGE_AREA(x) (((x) & 0x10) >> 4)
	45	#define IS_BAD_PKT(x) ((x) & 0x20)
	46	#define IS_VALID_APP(x) ((x) & 0x01)
	47	#define IS_OPERATIONAL_ERR(x) ((x) & 0x3F)
	48	#define GET_HSTMODE(reg) (((reg) & 0x70) >> 4)
	49	#define GET_BOOTLOADERMODE(reg) (((reg) & 0x10) >> 4)
	50
	51	#define CY_REG_BASE 0x00
	52	#define CY_REG_ACT_DIST 0x1E
	53	#define CY_REG_ACT_INTRVL 0x1D
	54	#define CY_REG_TCH_TMOUT (CY_REG_ACT_INTRVL + 1)
	55	#define CY_REG_LP_INTRVL (CY_REG_TCH_TMOUT + 1)
	56	#define CY_MAXZ 255
	57	#define CY_DELAY_DFLT 20 /* ms */
	58	#define CY_DELAY_MAX 500
	59	#define CY_ACT_DIST_DFLT 0xF8
	60	#define CY_HNDSHK_BIT 0x80
	61	/* device mode bits */
	62	#define CY_OPERATE_MODE 0x00
	63	#define CY_SYSINFO_MODE 0x10
	64	/* power mode select bits */
65	#define CY_SOFT_RESET_MODE 0x01 /* return to Bootloader mode */
66	#define CY_DEEP_SLEEP_MODE 0x02
67	#define CY_LOW_POWER_MODE 0x04
68
69	/* Slots management */
70	#define CY_MAX_FINGER 4
71	#define CY_MAX_ID 16
72
73	static const u8 bl_command[] = {
74	0x00, /* file offset */
75	0xFF, /* command */
76	0xA5, /* exit bootloader command */
77	0, 1, 2, 3, 4, 5, 6, 7 /* default keys */
78	};
79
80	static int ttsp_read_block_data(struct cyttsp *ts, u8 command,
81	u8 length, void *buf)
82	{
83	int error;
84	int tries;
85
86	for (tries = 0; tries < CY_NUM_RETRY; tries++) {
9664877e FY	87	error = ts->bus_ops->read(ts->dev, ts->xfer_buf, command,
9664877e FY	88	length, buf);
4065d1e7 JMC	89	if (!error)
	90	return 0;
	91
	92	msleep(CY_DELAY_DFLT);
	93	}
	94
	95	return -EIO;
	96	}
	97
	98	static int ttsp_write_block_data(struct cyttsp *ts, u8 command,
	99	u8 length, void *buf)
	100	{
	101	int error;
	102	int tries;
	103
	104	for (tries = 0; tries < CY_NUM_RETRY; tries++) {
9664877e FY	105	error = ts->bus_ops->write(ts->dev, ts->xfer_buf, command,
9664877e FY	106	length, buf);
4065d1e7 JMC	107	if (!error)
	108	return 0;
	109
	110	msleep(CY_DELAY_DFLT);
	111	}
	112
	113	return -EIO;
	114	}
	115
	116	static int ttsp_send_command(struct cyttsp *ts, u8 cmd)
	117	{
	118	return ttsp_write_block_data(ts, CY_REG_BASE, sizeof(cmd), &cmd);
	119	}
	120
	121	static int cyttsp_load_bl_regs(struct cyttsp *ts)
	122	{
	123	memset(&ts->bl_data, 0, sizeof(ts->bl_data));
	124	ts->bl_data.bl_status = 0x10;
	125
	126	return ttsp_read_block_data(ts, CY_REG_BASE,
	127	sizeof(ts->bl_data), &ts->bl_data);
	128	}
	129
	130	static int cyttsp_exit_bl_mode(struct cyttsp *ts)
	131	{
	132	int error;
	133	u8 bl_cmd[sizeof(bl_command)];
	134
	135	memcpy(bl_cmd, bl_command, sizeof(bl_command));
	136	if (ts->pdata->bl_keys)
	137	memcpy(&bl_cmd[sizeof(bl_command) - CY_NUM_BL_KEYS],
	138	ts->pdata->bl_keys, sizeof(bl_command));
	139
	140	error = ttsp_write_block_data(ts, CY_REG_BASE,
	141	sizeof(bl_cmd), bl_cmd);
	142	if (error)
	143	return error;
	144
	145	/* wait for TTSP Device to complete the operation */
	146	msleep(CY_DELAY_DFLT);
	147
	148	error = cyttsp_load_bl_regs(ts);
	149	if (error)
	150	return error;
	151
	152	if (GET_BOOTLOADERMODE(ts->bl_data.bl_status))
	153	return -EIO;
	154
	155	return 0;
	156	}
	157
	158	static int cyttsp_set_operational_mode(struct cyttsp *ts)
	159	{
	160	int error;
	161
	162	error = ttsp_send_command(ts, CY_OPERATE_MODE);
	163	if (error)
	164	return error;
	165
	166	/* wait for TTSP Device to complete switch to Operational mode */
	167	error = ttsp_read_block_data(ts, CY_REG_BASE,
	168	sizeof(ts->xy_data), &ts->xy_data);
	169	if (error)
	170	return error;
171
172	return ts->xy_data.act_dist == CY_ACT_DIST_DFLT ? -EIO : 0;
173	}
174
175	static int cyttsp_set_sysinfo_mode(struct cyttsp *ts)
176	{
177	int error;
178
179	memset(&ts->sysinfo_data, 0, sizeof(ts->sysinfo_data));
180
181	/* switch to sysinfo mode */
182	error = ttsp_send_command(ts, CY_SYSINFO_MODE);
183	if (error)
184	return error;
185
186	/* read sysinfo registers */
187	msleep(CY_DELAY_DFLT);
188	error = ttsp_read_block_data(ts, CY_REG_BASE, sizeof(ts->sysinfo_data),
189	&ts->sysinfo_data);
190	if (error)
191	return error;
192
193	if (!ts->sysinfo_data.tts_verh && !ts->sysinfo_data.tts_verl)
194	return -EIO;
195
196	return 0;
197	}
198
199	static int cyttsp_set_sysinfo_regs(struct cyttsp *ts)
200	{
201	int retval = 0;
202
203	if (ts->pdata->act_intrvl != CY_ACT_INTRVL_DFLT \|\|
204	ts->pdata->tch_tmout != CY_TCH_TMOUT_DFLT \|\|
205	ts->pdata->lp_intrvl != CY_LP_INTRVL_DFLT) {
206
207	u8 intrvl_ray[] = {
208	ts->pdata->act_intrvl,
209	ts->pdata->tch_tmout,
210	ts->pdata->lp_intrvl
211	};
212
213	/* set intrvl registers */
214	retval = ttsp_write_block_data(ts, CY_REG_ACT_INTRVL,
215	sizeof(intrvl_ray), intrvl_ray);
216	msleep(CY_DELAY_DFLT);
217	}
218
219	return retval;
220	}
221
222	static int cyttsp_soft_reset(struct cyttsp *ts)
223	{
224	unsigned long timeout;
225	int retval;
226
227	/* wait for interrupt to set ready completion */
228	INIT_COMPLETION(ts->bl_ready);
229	ts->state = CY_BL_STATE;
230
231	enable_irq(ts->irq);
232
233	retval = ttsp_send_command(ts, CY_SOFT_RESET_MODE);
234	if (retval)
235	goto out;
236
237	timeout = wait_for_completion_timeout(&ts->bl_ready,
238	msecs_to_jiffies(CY_DELAY_DFLT * CY_DELAY_MAX));
239	retval = timeout ? 0 : -EIO;
240
241	out:
242	ts->state = CY_IDLE_STATE;
243	disable_irq(ts->irq);
244	return retval;
245	}
246
247	static int cyttsp_act_dist_setup(struct cyttsp *ts)
248	{
249	u8 act_dist_setup = ts->pdata->act_dist;
250
251	/* Init gesture; active distance setup */
252	return ttsp_write_block_data(ts, CY_REG_ACT_DIST,
253	sizeof(act_dist_setup), &act_dist_setup);
254	}
255
256	static void cyttsp_extract_track_ids(struct cyttsp_xydata xy_data, int ids)
257	{
258	ids[0] = xy_data->touch12_id >> 4;
259	ids[1] = xy_data->touch12_id & 0xF;
260	ids[2] = xy_data->touch34_id >> 4;
261	ids[3] = xy_data->touch34_id & 0xF;
262	}
263
264	static const struct cyttsp_tch cyttsp_get_tch(struct cyttsp_xydata xy_data,
265	int idx)
266	{
267	switch (idx) {
268	case 0:
269	return &xy_data->tch1;
270	case 1:
271	return &xy_data->tch2;
272	case 2:
273	return &xy_data->tch3;
274	case 3:
275	return &xy_data->tch4;
276	default:
277	return NULL;
278	}
279	}
280
281	static void cyttsp_report_tchdata(struct cyttsp *ts)
282	{
283	struct cyttsp_xydata *xy_data = &ts->xy_data;
284	struct input_dev *input = ts->input;
285	int num_tch = GET_NUM_TOUCHES(xy_data->tt_stat);
286	const struct cyttsp_tch *tch;
287	int ids[CY_MAX_ID];
288	int i;
289	DECLARE_BITMAP(used, CY_MAX_ID);
290
291	if (IS_LARGE_AREA(xy_data->tt_stat) == 1) {
292	/* terminate all active tracks */
293	num_tch = 0;
294	dev_dbg(ts->dev, "%s: Large area detected\n", __func__);
295	} else if (num_tch > CY_MAX_FINGER) {
296	/* terminate all active tracks */
297	num_tch = 0;
298	dev_dbg(ts->dev, "%s: Num touch error detected\n", __func__);
299	} else if (IS_BAD_PKT(xy_data->tt_mode)) {
300	/* terminate all active tracks */
301	num_tch = 0;
302	dev_dbg(ts->dev, "%s: Invalid buffer detected\n", __func__);
303	}
304
305	cyttsp_extract_track_ids(xy_data, ids);
306
307	bitmap_zero(used, CY_MAX_ID);
308
309	for (i = 0; i < num_tch; i++) {
310	tch = cyttsp_get_tch(xy_data, i);
311
312	input_mt_slot(input, ids[i]);
313	input_mt_report_slot_state(input, MT_TOOL_FINGER, true);
314	input_report_abs(input, ABS_MT_POSITION_X, be16_to_cpu(tch->x));
315	input_report_abs(input, ABS_MT_POSITION_Y, be16_to_cpu(tch->y));
316	input_report_abs(input, ABS_MT_TOUCH_MAJOR, tch->z);
317
318	__set_bit(ids[i], used);
319	}
320
321	for (i = 0; i < CY_MAX_ID; i++) {
322	if (test_bit(i, used))
323	continue;
324
325	input_mt_slot(input, i);
326	input_mt_report_slot_state(input, MT_TOOL_FINGER, false);
327	}
328
329	input_sync(input);
330	}
331
332	static irqreturn_t cyttsp_irq(int irq, void *handle)
333	{
334	struct cyttsp *ts = handle;
335	int error;
336
337	if (unlikely(ts->state == CY_BL_STATE)) {
338	complete(&ts->bl_ready);
339	goto out;
340	}
341
342	/* Get touch data from CYTTSP device */
343	error = ttsp_read_block_data(ts, CY_REG_BASE,
344	sizeof(struct cyttsp_xydata), &ts->xy_data);
345	if (error)
346	goto out;
347
348	/* provide flow control handshake */
349	if (ts->pdata->use_hndshk) {
350	error = ttsp_send_command(ts,
351	ts->xy_data.hst_mode ^ CY_HNDSHK_BIT);
352	if (error)
353	goto out;
354	}
355
356	if (unlikely(ts->state == CY_IDLE_STATE))
357	goto out;
358
359	if (GET_BOOTLOADERMODE(ts->xy_data.tt_mode)) {
360	/*
361	* TTSP device has reset back to bootloader mode.
362	* Restore to operational mode.
363	*/
364	error = cyttsp_exit_bl_mode(ts);
365	if (error) {
366	dev_err(ts->dev,
367	"Could not return to operational mode, err: %d\n",
368	error);
369	ts->state = CY_IDLE_STATE;
370	}
371	} else {
372	cyttsp_report_tchdata(ts);
373	}
374
375	out:
376	return IRQ_HANDLED;
377	}
378
379	static int cyttsp_power_on(struct cyttsp *ts)
380	{
381	int error;
382
383	error = cyttsp_soft_reset(ts);
384	if (error)
385	return error;
386
387	error = cyttsp_load_bl_regs(ts);
388	if (error)
389	return error;
390
391	if (GET_BOOTLOADERMODE(ts->bl_data.bl_status) &&
392	IS_VALID_APP(ts->bl_data.bl_status)) {
393	error = cyttsp_exit_bl_mode(ts);
394	if (error)
395	return error;
396	}
397
398	if (GET_HSTMODE(ts->bl_data.bl_file) != CY_OPERATE_MODE \|\|
399	IS_OPERATIONAL_ERR(ts->bl_data.bl_status)) {
400	return -ENODEV;
401	}
402
403	error = cyttsp_set_sysinfo_mode(ts);
404	if (error)
405	return error;
406
407	error = cyttsp_set_sysinfo_regs(ts);
408	if (error)
409	return error;
410
411	error = cyttsp_set_operational_mode(ts);
412	if (error)
413	return error;
414
415	/* init active distance */
416	error = cyttsp_act_dist_setup(ts);
417	if (error)
418	return error;
419
420	ts->state = CY_ACTIVE_STATE;
421
422	return 0;
423	}
424
425	static int cyttsp_enable(struct cyttsp *ts)
426	{
427	int error;
428
429	/*
430	* The device firmware can wake on an I2C or SPI memory slave
431	* address match. So just reading a register is sufficient to
432	* wake up the device. The first read attempt will fail but it
433	* will wake it up making the second read attempt successful.
434	*/
435	error = ttsp_read_block_data(ts, CY_REG_BASE,
436	sizeof(ts->xy_data), &ts->xy_data);
437	if (error)
438	return error;
439
440	if (GET_HSTMODE(ts->xy_data.hst_mode))
441	return -EIO;
442
443	enable_irq(ts->irq);
444
445	return 0;
446	}
447
448	static int cyttsp_disable(struct cyttsp *ts)
449	{
450	int error;
451
452	error = ttsp_send_command(ts, CY_LOW_POWER_MODE);
453	if (error)
454	return error;
455
456	disable_irq(ts->irq);
457
458	return 0;
459	}
460
461	#ifdef CONFIG_PM_SLEEP
462	static int cyttsp_suspend(struct device *dev)
463	{
464	struct cyttsp *ts = dev_get_drvdata(dev);
465	int retval = 0;
466
467	mutex_lock(&ts->input->mutex);
468
469	if (ts->input->users) {
470	retval = cyttsp_disable(ts);
471	if (retval == 0)
472	ts->suspended = true;
473	}
474
475	mutex_unlock(&ts->input->mutex);
476
477	return retval;
478	}
479
480	static int cyttsp_resume(struct device *dev)
481	{
482	struct cyttsp *ts = dev_get_drvdata(dev);
483
484	mutex_lock(&ts->input->mutex);
485
486	if (ts->input->users)
487	cyttsp_enable(ts);
488
489	ts->suspended = false;
490
491	mutex_unlock(&ts->input->mutex);
492
493	return 0;
494	}
495
496	#endif
497
498	SIMPLE_DEV_PM_OPS(cyttsp_pm_ops, cyttsp_suspend, cyttsp_resume);
499	EXPORT_SYMBOL_GPL(cyttsp_pm_ops);
500
501	static int cyttsp_open(struct input_dev *dev)
502	{
503	struct cyttsp *ts = input_get_drvdata(dev);
504	int retval = 0;
505
506	if (!ts->suspended)
507	retval = cyttsp_enable(ts);
508
509	return retval;
510	}
511
512	static void cyttsp_close(struct input_dev *dev)
513	{
514	struct cyttsp *ts = input_get_drvdata(dev);
515
516	if (!ts->suspended)
517	cyttsp_disable(ts);
518	}
519
520	struct cyttsp cyttsp_probe(const struct cyttsp_bus_ops bus_ops,
521	struct device *dev, int irq, size_t xfer_buf_size)
522	{
523	const struct cyttsp_platform_data *pdata = dev->platform_data;
524	struct cyttsp *ts;
525	struct input_dev *input_dev;
526	int error;
527
aaa60fa7	528	if (!pdata \|\| !pdata->name \|\| irq <= 0) {
4065d1e7 JMC	529	error = -EINVAL;
	530	goto err_out;
	531	}
	532
	533	ts = kzalloc(sizeof(*ts) + xfer_buf_size, GFP_KERNEL);
	534	input_dev = input_allocate_device();
	535	if (!ts \|\| !input_dev) {
	536	error = -ENOMEM;
	537	goto err_free_mem;
	538	}
	539
	540	ts->dev = dev;
	541	ts->input = input_dev;
	542	ts->pdata = dev->platform_data;
	543	ts->bus_ops = bus_ops;
	544	ts->irq = irq;
	545
	546	init_completion(&ts->bl_ready);
	547	snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
	548
	549	if (pdata->init) {
	550	error = pdata->init();
	551	if (error) {
	552	dev_err(ts->dev, "platform init failed, err: %d\n",
	553	error);
	554	goto err_free_mem;
	555	}
	556	}
	557
	558	input_dev->name = pdata->name;
	559	input_dev->phys = ts->phys;
	560	input_dev->id.bustype = bus_ops->bustype;
	561	input_dev->dev.parent = ts->dev;
	562
	563	input_dev->open = cyttsp_open;
	564	input_dev->close = cyttsp_close;
	565
	566	input_set_drvdata(input_dev, ts);
	567
	568	__set_bit(EV_ABS, input_dev->evbit);
	569	input_set_abs_params(input_dev, ABS_MT_POSITION_X,
	570	0, pdata->maxx, 0, 0);
	571	input_set_abs_params(input_dev, ABS_MT_POSITION_Y,
	572	0, pdata->maxy, 0, 0);
	573	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR,
	574	0, CY_MAXZ, 0, 0);
	575
b4adbbef	576	input_mt_init_slots(input_dev, CY_MAX_ID, 0);
4065d1e7 JMC	577
	578	error = request_threaded_irq(ts->irq, NULL, cyttsp_irq,
	579	IRQF_TRIGGER_FALLING \| IRQF_ONESHOT,
	580	pdata->name, ts);
	581	if (error) {
	582	dev_err(ts->dev, "failed to request IRQ %d, err: %d\n",
	583	ts->irq, error);
	584	goto err_platform_exit;
	585	}
	586
	587	disable_irq(ts->irq);
	588
	589	error = cyttsp_power_on(ts);
	590	if (error)
	591	goto err_free_irq;
	592
	593	error = input_register_device(input_dev);
	594	if (error) {
	595	dev_err(ts->dev, "failed to register input device: %d\n",
	596	error);
	597	goto err_free_irq;
	598	}
	599
	600	return ts;
	601
	602	err_free_irq:
	603	free_irq(ts->irq, ts);
	604	err_platform_exit:
	605	if (pdata->exit)
	606	pdata->exit();
	607	err_free_mem:
	608	input_free_device(input_dev);
	609	kfree(ts);
	610	err_out:
	611	return ERR_PTR(error);
	612	}
	613	EXPORT_SYMBOL_GPL(cyttsp_probe);
	614
	615	void cyttsp_remove(struct cyttsp *ts)
	616	{
	617	free_irq(ts->irq, ts);
	618	input_unregister_device(ts->input);
	619	if (ts->pdata->exit)
	620	ts->pdata->exit();
	621	kfree(ts);
	622	}
	623	EXPORT_SYMBOL_GPL(cyttsp_remove);
	624
	625	MODULE_LICENSE("GPL");
	626	MODULE_DESCRIPTION("Cypress TrueTouch(R) Standard touchscreen driver core");
	627	MODULE_AUTHOR("Cypress");