[deliverable/linux.git] / drivers / input / touchscreen / auo-pixcir-ts.c

/*
 * Driver for AUO in-cell touchscreens
 *
 * Copyright (c) 2011 Heiko Stuebner <heiko@sntech.de>
 *
 * loosely based on auo_touch.c from Dell Streak vendor-kernel
 *
 * Copyright (c) 2008 QUALCOMM Incorporated.
 * Copyright (c) 2008 QUALCOMM USA, INC.
 *
 *
 * This software is licensed under the terms of the GNU General Public
 * License version 2, as published by the Free Software Foundation, and
 * may be copied, distributed, and modified under those terms.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/input.h>
#include <linux/jiffies.h>
#include <linux/i2c.h>
#include <linux/mutex.h>
#include <linux/delay.h>
#include <linux/gpio.h>
#include <linux/input/auo-pixcir-ts.h>
#include <linux/of.h>
#include <linux/of_gpio.h>

/*
 * Coordinate calculation:
 * X1 = X1_LSB + X1_MSB*256
 * Y1 = Y1_LSB + Y1_MSB*256
 * X2 = X2_LSB + X2_MSB*256
 * Y2 = Y2_LSB + Y2_MSB*256
 */
#define AUO_PIXCIR_REG_X1_LSB		0x00
#define AUO_PIXCIR_REG_X1_MSB		0x01
#define AUO_PIXCIR_REG_Y1_LSB		0x02
#define AUO_PIXCIR_REG_Y1_MSB		0x03
#define AUO_PIXCIR_REG_X2_LSB		0x04
#define AUO_PIXCIR_REG_X2_MSB		0x05
#define AUO_PIXCIR_REG_Y2_LSB		0x06
#define AUO_PIXCIR_REG_Y2_MSB		0x07

#define AUO_PIXCIR_REG_STRENGTH		0x0d
#define AUO_PIXCIR_REG_STRENGTH_X1_LSB	0x0e
#define AUO_PIXCIR_REG_STRENGTH_X1_MSB	0x0f

#define AUO_PIXCIR_REG_RAW_DATA_X	0x2b
#define AUO_PIXCIR_REG_RAW_DATA_Y	0x4f

#define AUO_PIXCIR_REG_X_SENSITIVITY	0x6f
#define AUO_PIXCIR_REG_Y_SENSITIVITY	0x70
#define AUO_PIXCIR_REG_INT_SETTING	0x71
#define AUO_PIXCIR_REG_INT_WIDTH	0x72
#define AUO_PIXCIR_REG_POWER_MODE	0x73

#define AUO_PIXCIR_REG_VERSION		0x77
#define AUO_PIXCIR_REG_CALIBRATE	0x78

#define AUO_PIXCIR_REG_TOUCHAREA_X1	0x1e
#define AUO_PIXCIR_REG_TOUCHAREA_Y1	0x1f
#define AUO_PIXCIR_REG_TOUCHAREA_X2	0x20
#define AUO_PIXCIR_REG_TOUCHAREA_Y2	0x21

#define AUO_PIXCIR_REG_EEPROM_CALIB_X	0x42
#define AUO_PIXCIR_REG_EEPROM_CALIB_Y	0xad

#define AUO_PIXCIR_INT_TPNUM_MASK	0xe0
#define AUO_PIXCIR_INT_TPNUM_SHIFT	5
#define AUO_PIXCIR_INT_RELEASE		(1 << 4)
#define AUO_PIXCIR_INT_ENABLE		(1 << 3)
#define AUO_PIXCIR_INT_POL_HIGH		(1 << 2)
#define AUO_PIXCIR_INT_MODE_MASK	0x03

/*
 * Power modes:
 * active:	scan speed 60Hz
 * sleep:	scan speed 10Hz can be auto-activated, wakeup on 1st touch
 * deep sleep:	scan speed 1Hz can only be entered or left manually.
 */
#define AUO_PIXCIR_POWER_ACTIVE		0x00
#define AUO_PIXCIR_POWER_SLEEP		0x01
#define AUO_PIXCIR_POWER_DEEP_SLEEP	0x02
#define AUO_PIXCIR_POWER_MASK		0x03

#define AUO_PIXCIR_POWER_ALLOW_SLEEP	(1 << 2)
#define AUO_PIXCIR_POWER_IDLE_TIME(ms)	((ms & 0xf) << 4)

#define AUO_PIXCIR_CALIBRATE		0x03

#define AUO_PIXCIR_EEPROM_CALIB_X_LEN	62
#define AUO_PIXCIR_EEPROM_CALIB_Y_LEN	36

#define AUO_PIXCIR_RAW_DATA_X_LEN	18
#define AUO_PIXCIR_RAW_DATA_Y_LEN	11

#define AUO_PIXCIR_STRENGTH_ENABLE	(1 << 0)

/* Touchscreen absolute values */
#define AUO_PIXCIR_REPORT_POINTS	2
#define AUO_PIXCIR_MAX_AREA		0xff
#define AUO_PIXCIR_PENUP_TIMEOUT_MS	10

struct auo_pixcir_ts {
	struct i2c_client	*client;
	struct input_dev	*input;
	const struct auo_pixcir_ts_platdata *pdata;
	char			phys[32];

	/* special handling for touch_indicate interupt mode */
	bool			touch_ind_mode;

	wait_queue_head_t	wait;
	bool			stopped;
};

struct auo_point_t {
	int	coord_x;
	int	coord_y;
	int	area_major;
	int	area_minor;
	int	orientation;
};

static int auo_pixcir_collect_data(struct auo_pixcir_ts *ts,
				   struct auo_point_t *point)
{
	struct i2c_client *client = ts->client;
	const struct auo_pixcir_ts_platdata *pdata = ts->pdata;
	uint8_t raw_coord[8];
	uint8_t raw_area[4];
	int i, ret;

	/* touch coordinates */
	ret = i2c_smbus_read_i2c_block_data(client, AUO_PIXCIR_REG_X1_LSB,
					    8, raw_coord);
	if (ret < 0) {
		dev_err(&client->dev, "failed to read coordinate, %d\n", ret);
		return ret;
	}

	/* touch area */
	ret = i2c_smbus_read_i2c_block_data(client, AUO_PIXCIR_REG_TOUCHAREA_X1,
					    4, raw_area);
	if (ret < 0) {
		dev_err(&client->dev, "could not read touch area, %d\n", ret);
		return ret;
	}

	for (i = 0; i < AUO_PIXCIR_REPORT_POINTS; i++) {
		point[i].coord_x =
			raw_coord[4 * i + 1] << 8 | raw_coord[4 * i];
		point[i].coord_y =
			raw_coord[4 * i + 3] << 8 | raw_coord[4 * i + 2];

		if (point[i].coord_x > pdata->x_max ||
		    point[i].coord_y > pdata->y_max) {
			dev_warn(&client->dev, "coordinates (%d,%d) invalid\n",
				point[i].coord_x, point[i].coord_y);
			point[i].coord_x = point[i].coord_y = 0;
		}

		/* determine touch major, minor and orientation */
		point[i].area_major = max(raw_area[2 * i], raw_area[2 * i + 1]);
		point[i].area_minor = min(raw_area[2 * i], raw_area[2 * i + 1]);
		point[i].orientation = raw_area[2 * i] > raw_area[2 * i + 1];
	}

	return 0;
}

static irqreturn_t auo_pixcir_interrupt(int irq, void *dev_id)
{
	struct auo_pixcir_ts *ts = dev_id;
	const struct auo_pixcir_ts_platdata *pdata = ts->pdata;
	struct auo_point_t point[AUO_PIXCIR_REPORT_POINTS];
	int i;
	int ret;
	int fingers = 0;
	int abs = -1;

	while (!ts->stopped) {

		/* check for up event in touch touch_ind_mode */
		if (ts->touch_ind_mode) {
			if (gpio_get_value(pdata->gpio_int) == 0) {
				input_mt_sync(ts->input);
				input_report_key(ts->input, BTN_TOUCH, 0);
				input_sync(ts->input);
				break;
			}
		}

		ret = auo_pixcir_collect_data(ts, point);
		if (ret < 0) {
			/* we want to loop only in touch_ind_mode */
			if (!ts->touch_ind_mode)
				break;

			wait_event_timeout(ts->wait, ts->stopped,
				msecs_to_jiffies(AUO_PIXCIR_PENUP_TIMEOUT_MS));
			continue;
		}

		for (i = 0; i < AUO_PIXCIR_REPORT_POINTS; i++) {
			if (point[i].coord_x > 0 || point[i].coord_y > 0) {
				input_report_abs(ts->input, ABS_MT_POSITION_X,
						 point[i].coord_x);
				input_report_abs(ts->input, ABS_MT_POSITION_Y,
						 point[i].coord_y);
				input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR,
						 point[i].area_major);
				input_report_abs(ts->input, ABS_MT_TOUCH_MINOR,
						 point[i].area_minor);
				input_report_abs(ts->input, ABS_MT_ORIENTATION,
						 point[i].orientation);
				input_mt_sync(ts->input);

				/* use first finger as source for singletouch */
				if (fingers == 0)
					abs = i;

				/* number of touch points could also be queried
				 * via i2c but would require an additional call
				 */
				fingers++;
			}
		}

		input_report_key(ts->input, BTN_TOUCH, fingers > 0);

		if (abs > -1) {
			input_report_abs(ts->input, ABS_X, point[abs].coord_x);
			input_report_abs(ts->input, ABS_Y, point[abs].coord_y);
		}

		input_sync(ts->input);

		/* we want to loop only in touch_ind_mode */
		if (!ts->touch_ind_mode)
			break;

		wait_event_timeout(ts->wait, ts->stopped,
				 msecs_to_jiffies(AUO_PIXCIR_PENUP_TIMEOUT_MS));
	}

	return IRQ_HANDLED;
}

/*
 * Set the power mode of the device.
 * Valid modes are
 * - AUO_PIXCIR_POWER_ACTIVE
 * - AUO_PIXCIR_POWER_SLEEP - automatically left on first touch
 * - AUO_PIXCIR_POWER_DEEP_SLEEP
 */
static int auo_pixcir_power_mode(struct auo_pixcir_ts *ts, int mode)
{
	struct i2c_client *client = ts->client;
	int ret;

	ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_POWER_MODE);
	if (ret < 0) {
		dev_err(&client->dev, "unable to read reg %Xh, %d\n",
			AUO_PIXCIR_REG_POWER_MODE, ret);
		return ret;
	}

	ret &= ~AUO_PIXCIR_POWER_MASK;
	ret |= mode;

	ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_POWER_MODE, ret);
	if (ret) {
		dev_err(&client->dev, "unable to write reg %Xh, %d\n",
			AUO_PIXCIR_REG_POWER_MODE, ret);
		return ret;
	}

	return 0;
}

static int auo_pixcir_int_config(struct auo_pixcir_ts *ts,
					   int int_setting)
{
	struct i2c_client *client = ts->client;
	const struct auo_pixcir_ts_platdata *pdata = ts->pdata;
	int ret;

	ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_INT_SETTING);
	if (ret < 0) {
		dev_err(&client->dev, "unable to read reg %Xh, %d\n",
			AUO_PIXCIR_REG_INT_SETTING, ret);
		return ret;
	}

	ret &= ~AUO_PIXCIR_INT_MODE_MASK;
	ret |= int_setting;
	ret |= AUO_PIXCIR_INT_POL_HIGH; /* always use high for interrupts */

	ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_INT_SETTING,
					ret);
	if (ret < 0) {
		dev_err(&client->dev, "unable to write reg %Xh, %d\n",
			AUO_PIXCIR_REG_INT_SETTING, ret);
		return ret;
	}

	ts->touch_ind_mode = pdata->int_setting == AUO_PIXCIR_INT_TOUCH_IND;

	return 0;
}

/* control the generation of interrupts on the device side */
static int auo_pixcir_int_toggle(struct auo_pixcir_ts *ts, bool enable)
{
	struct i2c_client *client = ts->client;
	int ret;

	ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_INT_SETTING);
	if (ret < 0) {
		dev_err(&client->dev, "unable to read reg %Xh, %d\n",
			AUO_PIXCIR_REG_INT_SETTING, ret);
		return ret;
	}

	if (enable)
		ret |= AUO_PIXCIR_INT_ENABLE;
	else
		ret &= ~AUO_PIXCIR_INT_ENABLE;

	ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_INT_SETTING,
					ret);
	if (ret < 0) {
		dev_err(&client->dev, "unable to write reg %Xh, %d\n",
			AUO_PIXCIR_REG_INT_SETTING, ret);
		return ret;
	}

	return 0;
}

static int auo_pixcir_start(struct auo_pixcir_ts *ts)
{
	struct i2c_client *client = ts->client;
	int ret;

	ret = auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_ACTIVE);
	if (ret < 0) {
		dev_err(&client->dev, "could not set power mode, %d\n",
			ret);
		return ret;
	}

	ts->stopped = false;
	mb();
	enable_irq(client->irq);

	ret = auo_pixcir_int_toggle(ts, 1);
	if (ret < 0) {
		dev_err(&client->dev, "could not enable interrupt, %d\n",
			ret);
		disable_irq(client->irq);
		return ret;
	}

	return 0;
}

static int auo_pixcir_stop(struct auo_pixcir_ts *ts)
{
	struct i2c_client *client = ts->client;
	int ret;

	ret = auo_pixcir_int_toggle(ts, 0);
	if (ret < 0) {
		dev_err(&client->dev, "could not disable interrupt, %d\n",
			ret);
		return ret;
	}

	/* disable receiving of interrupts */
	disable_irq(client->irq);
	ts->stopped = true;
	mb();
	wake_up(&ts->wait);

	return auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_DEEP_SLEEP);
}

static int auo_pixcir_input_open(struct input_dev *dev)
{
	struct auo_pixcir_ts *ts = input_get_drvdata(dev);
	int ret;

	ret = auo_pixcir_start(ts);
	if (ret)
		return ret;

	return 0;
}

static void auo_pixcir_input_close(struct input_dev *dev)
{
	struct auo_pixcir_ts *ts = input_get_drvdata(dev);

	auo_pixcir_stop(ts);

	return;
}

static int __maybe_unused auo_pixcir_suspend(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct auo_pixcir_ts *ts = i2c_get_clientdata(client);
	struct input_dev *input = ts->input;
	int ret = 0;

	mutex_lock(&input->mutex);

	/* when configured as wakeup source, device should always wake system
	 * therefore start device if necessary
	 */
	if (device_may_wakeup(&client->dev)) {
		/* need to start device if not open, to be wakeup source */
		if (!input->users) {
			ret = auo_pixcir_start(ts);
			if (ret)
				goto unlock;
		}

		enable_irq_wake(client->irq);
		ret = auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_SLEEP);
	} else if (input->users) {
		ret = auo_pixcir_stop(ts);
	}

unlock:
	mutex_unlock(&input->mutex);

	return ret;
}

static int __maybe_unused auo_pixcir_resume(struct device *dev)
{
	struct i2c_client *client = to_i2c_client(dev);
	struct auo_pixcir_ts *ts = i2c_get_clientdata(client);
	struct input_dev *input = ts->input;
	int ret = 0;

	mutex_lock(&input->mutex);

	if (device_may_wakeup(&client->dev)) {
		disable_irq_wake(client->irq);

		/* need to stop device if it was not open on suspend */
		if (!input->users) {
			ret = auo_pixcir_stop(ts);
			if (ret)
				goto unlock;
		}

		/* device wakes automatically from SLEEP */
	} else if (input->users) {
		ret = auo_pixcir_start(ts);
	}

unlock:
	mutex_unlock(&input->mutex);

	return ret;
}

static SIMPLE_DEV_PM_OPS(auo_pixcir_pm_ops,
			 auo_pixcir_suspend, auo_pixcir_resume);

#ifdef CONFIG_OF
static struct auo_pixcir_ts_platdata *auo_pixcir_parse_dt(struct device *dev)
{
	struct auo_pixcir_ts_platdata *pdata;
	struct device_node *np = dev->of_node;

	if (!np)
		return ERR_PTR(-ENOENT);

	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
	if (!pdata) {
		dev_err(dev, "failed to allocate platform data\n");
		return ERR_PTR(-ENOMEM);
	}

	pdata->gpio_int = of_get_gpio(np, 0);
	if (!gpio_is_valid(pdata->gpio_int)) {
		dev_err(dev, "failed to get interrupt gpio\n");
		return ERR_PTR(-EINVAL);
	}

	pdata->gpio_rst = of_get_gpio(np, 1);
	if (!gpio_is_valid(pdata->gpio_rst)) {
		dev_err(dev, "failed to get reset gpio\n");
		return ERR_PTR(-EINVAL);
	}

	if (of_property_read_u32(np, "x-size", &pdata->x_max)) {
		dev_err(dev, "failed to get x-size property\n");
		return ERR_PTR(-EINVAL);
	}

	if (of_property_read_u32(np, "y-size", &pdata->y_max)) {
		dev_err(dev, "failed to get y-size property\n");
		return ERR_PTR(-EINVAL);
	}

	/* default to asserting the interrupt when the screen is touched */
	pdata->int_setting = AUO_PIXCIR_INT_TOUCH_IND;

	return pdata;
}
#else
static struct auo_pixcir_ts_platdata *auo_pixcir_parse_dt(struct device *dev)
{
	return ERR_PTR(-EINVAL);
}
#endif

static void auo_pixcir_reset(void *data)
{
	struct auo_pixcir_ts *ts = data;

	gpio_set_value(ts->pdata->gpio_rst, 0);
}

static int auo_pixcir_probe(struct i2c_client *client,
			    const struct i2c_device_id *id)
{
	const struct auo_pixcir_ts_platdata *pdata;
	struct auo_pixcir_ts *ts;
	struct input_dev *input_dev;
	int version;
	int error;

	pdata = dev_get_platdata(&client->dev);
	if (!pdata) {
		pdata = auo_pixcir_parse_dt(&client->dev);
		if (IS_ERR(pdata))
			return PTR_ERR(pdata);
	}

	ts = devm_kzalloc(&client->dev,
			  sizeof(struct auo_pixcir_ts), GFP_KERNEL);
	if (!ts)
		return -ENOMEM;

	input_dev = devm_input_allocate_device(&client->dev);
	if (!input_dev) {
		dev_err(&client->dev, "could not allocate input device\n");
		return -ENOMEM;
	}

	ts->pdata = pdata;
	ts->client = client;
	ts->input = input_dev;
	ts->touch_ind_mode = 0;
	ts->stopped = true;
	init_waitqueue_head(&ts->wait);

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

	input_dev->name = "AUO-Pixcir touchscreen";
	input_dev->phys = ts->phys;
	input_dev->id.bustype = BUS_I2C;

	input_dev->open = auo_pixcir_input_open;
	input_dev->close = auo_pixcir_input_close;

	__set_bit(EV_ABS, input_dev->evbit);
	__set_bit(EV_KEY, input_dev->evbit);

	__set_bit(BTN_TOUCH, input_dev->keybit);

	/* For single touch */
	input_set_abs_params(input_dev, ABS_X, 0, pdata->x_max, 0, 0);
	input_set_abs_params(input_dev, ABS_Y, 0, pdata->y_max, 0, 0);

	/* For multi touch */
	input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
			     pdata->x_max, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
			     pdata->y_max, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0,
			     AUO_PIXCIR_MAX_AREA, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0,
			     AUO_PIXCIR_MAX_AREA, 0, 0);
	input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);

	input_set_drvdata(ts->input, ts);

	error = devm_gpio_request_one(&client->dev, pdata->gpio_int,
				      GPIOF_DIR_IN, "auo_pixcir_ts_int");
	if (error) {
		dev_err(&client->dev, "request of gpio %d failed, %d\n",
			pdata->gpio_int, error);
		return error;
	}

	error = devm_gpio_request_one(&client->dev, pdata->gpio_rst,
				      GPIOF_DIR_OUT | GPIOF_INIT_HIGH,
				      "auo_pixcir_ts_rst");
	if (error) {
		dev_err(&client->dev, "request of gpio %d failed, %d\n",
			pdata->gpio_rst, error);
		return error;
	}

	error = devm_add_action(&client->dev, auo_pixcir_reset, ts);
	if (error) {
		auo_pixcir_reset(ts);
		dev_err(&client->dev, "failed to register reset action, %d\n",
			error);
		return error;
	}

	msleep(200);

	version = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_VERSION);
	if (version < 0) {
		error = version;
		return error;
	}

	dev_info(&client->dev, "firmware version 0x%X\n", version);

	error = auo_pixcir_int_config(ts, pdata->int_setting);
	if (error)
		return error;

	error = devm_request_threaded_irq(&client->dev, client->irq,
					  NULL, auo_pixcir_interrupt,
					  IRQF_TRIGGER_RISING | IRQF_ONESHOT,
					  input_dev->name, ts);
	if (error) {
		dev_err(&client->dev, "irq %d requested failed, %d\n",
			client->irq, error);
		return error;
	}

	/* stop device and put it into deep sleep until it is opened */
	error = auo_pixcir_stop(ts);
	if (error)
		return error;

	error = input_register_device(input_dev);
	if (error) {
		dev_err(&client->dev, "could not register input device, %d\n",
			error);
		return error;
	}

	i2c_set_clientdata(client, ts);

	return 0;
}

static const struct i2c_device_id auo_pixcir_idtable[] = {
	{ "auo_pixcir_ts", 0 },
	{ }
};
MODULE_DEVICE_TABLE(i2c, auo_pixcir_idtable);

#ifdef CONFIG_OF
static const struct of_device_id auo_pixcir_ts_dt_idtable[] = {
	{ .compatible = "auo,auo_pixcir_ts" },
	{},
};
MODULE_DEVICE_TABLE(of, auo_pixcir_ts_dt_idtable);
#endif

static struct i2c_driver auo_pixcir_driver = {
	.driver = {
		.owner	= THIS_MODULE,
		.name	= "auo_pixcir_ts",
		.pm	= &auo_pixcir_pm_ops,
		.of_match_table	= of_match_ptr(auo_pixcir_ts_dt_idtable),
	},
	.probe		= auo_pixcir_probe,
	.id_table	= auo_pixcir_idtable,
};

module_i2c_driver(auo_pixcir_driver);

MODULE_DESCRIPTION("AUO-PIXCIR touchscreen driver");
MODULE_LICENSE("GPL v2");
MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");
Commit	Line	Data
5245db49 HS	1	/*
	2	* Driver for AUO in-cell touchscreens
	3	*
	4	* Copyright (c) 2011 Heiko Stuebner <heiko@sntech.de>
	5	*
	6	* loosely based on auo_touch.c from Dell Streak vendor-kernel
	7	*
	8	* Copyright (c) 2008 QUALCOMM Incorporated.
	9	* Copyright (c) 2008 QUALCOMM USA, INC.
	10	*
	11	*
	12	* This software is licensed under the terms of the GNU General Public
	13	* License version 2, as published by the Free Software Foundation, and
	14	* may be copied, distributed, and modified under those terms.
	15	*
	16	* This program is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	*/
	22
	23	#include <linux/kernel.h>
	24	#include <linux/module.h>
	25	#include <linux/interrupt.h>
	26	#include <linux/slab.h>
	27	#include <linux/input.h>
	28	#include <linux/jiffies.h>
	29	#include <linux/i2c.h>
	30	#include <linux/mutex.h>
	31	#include <linux/delay.h>
	32	#include <linux/gpio.h>
	33	#include <linux/input/auo-pixcir-ts.h>
7241443f HS	34	#include <linux/of.h>
7241443f HS	35	#include <linux/of_gpio.h>
5245db49 HS	36
	37	/*
	38	* Coordinate calculation:
	39	* X1 = X1_LSB + X1_MSB*256
	40	* Y1 = Y1_LSB + Y1_MSB*256
	41	* X2 = X2_LSB + X2_MSB*256
	42	* Y2 = Y2_LSB + Y2_MSB*256
	43	*/
	44	#define AUO_PIXCIR_REG_X1_LSB 0x00
	45	#define AUO_PIXCIR_REG_X1_MSB 0x01
	46	#define AUO_PIXCIR_REG_Y1_LSB 0x02
	47	#define AUO_PIXCIR_REG_Y1_MSB 0x03
	48	#define AUO_PIXCIR_REG_X2_LSB 0x04
	49	#define AUO_PIXCIR_REG_X2_MSB 0x05
	50	#define AUO_PIXCIR_REG_Y2_LSB 0x06
	51	#define AUO_PIXCIR_REG_Y2_MSB 0x07
	52
	53	#define AUO_PIXCIR_REG_STRENGTH 0x0d
	54	#define AUO_PIXCIR_REG_STRENGTH_X1_LSB 0x0e
	55	#define AUO_PIXCIR_REG_STRENGTH_X1_MSB 0x0f
	56
	57	#define AUO_PIXCIR_REG_RAW_DATA_X 0x2b
	58	#define AUO_PIXCIR_REG_RAW_DATA_Y 0x4f
	59
	60	#define AUO_PIXCIR_REG_X_SENSITIVITY 0x6f
	61	#define AUO_PIXCIR_REG_Y_SENSITIVITY 0x70
	62	#define AUO_PIXCIR_REG_INT_SETTING 0x71
	63	#define AUO_PIXCIR_REG_INT_WIDTH 0x72
	64	#define AUO_PIXCIR_REG_POWER_MODE 0x73
	65
	66	#define AUO_PIXCIR_REG_VERSION 0x77
	67	#define AUO_PIXCIR_REG_CALIBRATE 0x78
	68
	69	#define AUO_PIXCIR_REG_TOUCHAREA_X1 0x1e
	70	#define AUO_PIXCIR_REG_TOUCHAREA_Y1 0x1f
	71	#define AUO_PIXCIR_REG_TOUCHAREA_X2 0x20
	72	#define AUO_PIXCIR_REG_TOUCHAREA_Y2 0x21
	73
	74	#define AUO_PIXCIR_REG_EEPROM_CALIB_X 0x42
	75	#define AUO_PIXCIR_REG_EEPROM_CALIB_Y 0xad
	76
	77	#define AUO_PIXCIR_INT_TPNUM_MASK 0xe0
	78	#define AUO_PIXCIR_INT_TPNUM_SHIFT 5
	79	#define AUO_PIXCIR_INT_RELEASE (1 << 4)
	80	#define AUO_PIXCIR_INT_ENABLE (1 << 3)
	81	#define AUO_PIXCIR_INT_POL_HIGH (1 << 2)
	82	#define AUO_PIXCIR_INT_MODE_MASK 0x03
	83
	84	/*
	85	* Power modes:
	86	* active: scan speed 60Hz
	87	* sleep: scan speed 10Hz can be auto-activated, wakeup on 1st touch
	88	* deep sleep: scan speed 1Hz can only be entered or left manually.
	89	*/
	90	#define AUO_PIXCIR_POWER_ACTIVE 0x00
	91	#define AUO_PIXCIR_POWER_SLEEP 0x01
	92	#define AUO_PIXCIR_POWER_DEEP_SLEEP 0x02
	93	#define AUO_PIXCIR_POWER_MASK 0x03
	94
	95	#define AUO_PIXCIR_POWER_ALLOW_SLEEP (1 << 2)
	96	#define AUO_PIXCIR_POWER_IDLE_TIME(ms) ((ms & 0xf) << 4)
	97
	98	#define AUO_PIXCIR_CALIBRATE 0x03
	99
100	#define AUO_PIXCIR_EEPROM_CALIB_X_LEN 62
101	#define AUO_PIXCIR_EEPROM_CALIB_Y_LEN 36
102
103	#define AUO_PIXCIR_RAW_DATA_X_LEN 18
104	#define AUO_PIXCIR_RAW_DATA_Y_LEN 11
105
106	#define AUO_PIXCIR_STRENGTH_ENABLE (1 << 0)
107
108	/* Touchscreen absolute values */
109	#define AUO_PIXCIR_REPORT_POINTS 2
110	#define AUO_PIXCIR_MAX_AREA 0xff
111	#define AUO_PIXCIR_PENUP_TIMEOUT_MS 10
112
113	struct auo_pixcir_ts {
114	struct i2c_client *client;
115	struct input_dev *input;
38e83f7f	116	const struct auo_pixcir_ts_platdata *pdata;
5245db49 HS	117	char phys[32];
	118
	119	/* special handling for touch_indicate interupt mode */
	120	bool touch_ind_mode;
	121
	122	wait_queue_head_t wait;
	123	bool stopped;
	124	};
	125
	126	struct auo_point_t {
	127	int coord_x;
	128	int coord_y;
	129	int area_major;
	130	int area_minor;
	131	int orientation;
	132	};
	133
	134	static int auo_pixcir_collect_data(struct auo_pixcir_ts *ts,
	135	struct auo_point_t *point)
	136	{
	137	struct i2c_client *client = ts->client;
38e83f7f	138	const struct auo_pixcir_ts_platdata *pdata = ts->pdata;
5245db49 HS	139	uint8_t raw_coord[8];
	140	uint8_t raw_area[4];
	141	int i, ret;
	142
	143	/* touch coordinates */
	144	ret = i2c_smbus_read_i2c_block_data(client, AUO_PIXCIR_REG_X1_LSB,
	145	8, raw_coord);
	146	if (ret < 0) {
	147	dev_err(&client->dev, "failed to read coordinate, %d\n", ret);
	148	return ret;
	149	}
	150
	151	/* touch area */
	152	ret = i2c_smbus_read_i2c_block_data(client, AUO_PIXCIR_REG_TOUCHAREA_X1,
	153	4, raw_area);
	154	if (ret < 0) {
	155	dev_err(&client->dev, "could not read touch area, %d\n", ret);
	156	return ret;
	157	}
	158
	159	for (i = 0; i < AUO_PIXCIR_REPORT_POINTS; i++) {
	160	point[i].coord_x =
	161	raw_coord[4 * i + 1] << 8 \| raw_coord[4 * i];
	162	point[i].coord_y =
	163	raw_coord[4 * i + 3] << 8 \| raw_coord[4 * i + 2];
	164
	165	if (point[i].coord_x > pdata->x_max \|\|
	166	point[i].coord_y > pdata->y_max) {
	167	dev_warn(&client->dev, "coordinates (%d,%d) invalid\n",
	168	point[i].coord_x, point[i].coord_y);
	169	point[i].coord_x = point[i].coord_y = 0;
	170	}
	171
	172	/* determine touch major, minor and orientation */
	173	point[i].area_major = max(raw_area[2 * i], raw_area[2 * i + 1]);
	174	point[i].area_minor = min(raw_area[2 * i], raw_area[2 * i + 1]);
	175	point[i].orientation = raw_area[2 * i] > raw_area[2 * i + 1];
	176	}
	177
	178	return 0;
	179	}
	180
	181	static irqreturn_t auo_pixcir_interrupt(int irq, void *dev_id)
	182	{
	183	struct auo_pixcir_ts *ts = dev_id;
38e83f7f	184	const struct auo_pixcir_ts_platdata *pdata = ts->pdata;
5245db49 HS	185	struct auo_point_t point[AUO_PIXCIR_REPORT_POINTS];
	186	int i;
	187	int ret;
	188	int fingers = 0;
	189	int abs = -1;
	190
	191	while (!ts->stopped) {
	192
	193	/* check for up event in touch touch_ind_mode */
	194	if (ts->touch_ind_mode) {
	195	if (gpio_get_value(pdata->gpio_int) == 0) {
	196	input_mt_sync(ts->input);
	197	input_report_key(ts->input, BTN_TOUCH, 0);
	198	input_sync(ts->input);
	199	break;
	200	}
	201	}
	202
	203	ret = auo_pixcir_collect_data(ts, point);
	204	if (ret < 0) {
	205	/* we want to loop only in touch_ind_mode */
	206	if (!ts->touch_ind_mode)
	207	break;
	208
	209	wait_event_timeout(ts->wait, ts->stopped,
	210	msecs_to_jiffies(AUO_PIXCIR_PENUP_TIMEOUT_MS));
	211	continue;
	212	}
	213
	214	for (i = 0; i < AUO_PIXCIR_REPORT_POINTS; i++) {
	215	if (point[i].coord_x > 0 \|\| point[i].coord_y > 0) {
	216	input_report_abs(ts->input, ABS_MT_POSITION_X,
	217	point[i].coord_x);
	218	input_report_abs(ts->input, ABS_MT_POSITION_Y,
	219	point[i].coord_y);
	220	input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR,
	221	point[i].area_major);
	222	input_report_abs(ts->input, ABS_MT_TOUCH_MINOR,
	223	point[i].area_minor);
	224	input_report_abs(ts->input, ABS_MT_ORIENTATION,
	225	point[i].orientation);
	226	input_mt_sync(ts->input);
	227
	228	/* use first finger as source for singletouch */
	229	if (fingers == 0)
	230	abs = i;
	231
	232	/* number of touch points could also be queried
	233	* via i2c but would require an additional call
	234	*/
	235	fingers++;
	236	}
	237	}
	238
	239	input_report_key(ts->input, BTN_TOUCH, fingers > 0);
	240
	241	if (abs > -1) {
	242	input_report_abs(ts->input, ABS_X, point[abs].coord_x);
	243	input_report_abs(ts->input, ABS_Y, point[abs].coord_y);
	244	}
	245
	246	input_sync(ts->input);
	247
	248	/* we want to loop only in touch_ind_mode */
249	if (!ts->touch_ind_mode)
250	break;
251
252	wait_event_timeout(ts->wait, ts->stopped,
253	msecs_to_jiffies(AUO_PIXCIR_PENUP_TIMEOUT_MS));
254	}
255
256	return IRQ_HANDLED;
257	}
258
259	/*
260	* Set the power mode of the device.
261	* Valid modes are
262	* - AUO_PIXCIR_POWER_ACTIVE
263	* - AUO_PIXCIR_POWER_SLEEP - automatically left on first touch
264	* - AUO_PIXCIR_POWER_DEEP_SLEEP
265	*/
266	static int auo_pixcir_power_mode(struct auo_pixcir_ts *ts, int mode)
267	{
268	struct i2c_client *client = ts->client;
269	int ret;
270
271	ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_POWER_MODE);
272	if (ret < 0) {
273	dev_err(&client->dev, "unable to read reg %Xh, %d\n",
274	AUO_PIXCIR_REG_POWER_MODE, ret);
275	return ret;
276	}
277
278	ret &= ~AUO_PIXCIR_POWER_MASK;
279	ret \|= mode;
280
281	ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_POWER_MODE, ret);
282	if (ret) {
283	dev_err(&client->dev, "unable to write reg %Xh, %d\n",
284	AUO_PIXCIR_REG_POWER_MODE, ret);
285	return ret;
286	}
287
288	return 0;
289	}
290
5298cc4c	291	static int auo_pixcir_int_config(struct auo_pixcir_ts *ts,
5245db49 HS	292	int int_setting)
	293	{
	294	struct i2c_client *client = ts->client;
38e83f7f	295	const struct auo_pixcir_ts_platdata *pdata = ts->pdata;
5245db49 HS	296	int ret;
	297
	298	ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_INT_SETTING);
	299	if (ret < 0) {
	300	dev_err(&client->dev, "unable to read reg %Xh, %d\n",
	301	AUO_PIXCIR_REG_INT_SETTING, ret);
	302	return ret;
	303	}
	304
	305	ret &= ~AUO_PIXCIR_INT_MODE_MASK;
	306	ret \|= int_setting;
	307	ret \|= AUO_PIXCIR_INT_POL_HIGH; /* always use high for interrupts */
	308
	309	ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_INT_SETTING,
	310	ret);
	311	if (ret < 0) {
	312	dev_err(&client->dev, "unable to write reg %Xh, %d\n",
	313	AUO_PIXCIR_REG_INT_SETTING, ret);
	314	return ret;
	315	}
	316
	317	ts->touch_ind_mode = pdata->int_setting == AUO_PIXCIR_INT_TOUCH_IND;
	318
	319	return 0;
	320	}
	321
	322	/* control the generation of interrupts on the device side */
	323	static int auo_pixcir_int_toggle(struct auo_pixcir_ts *ts, bool enable)
	324	{
	325	struct i2c_client *client = ts->client;
	326	int ret;
	327
	328	ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_INT_SETTING);
	329	if (ret < 0) {
	330	dev_err(&client->dev, "unable to read reg %Xh, %d\n",
	331	AUO_PIXCIR_REG_INT_SETTING, ret);
	332	return ret;
	333	}
	334
	335	if (enable)
	336	ret \|= AUO_PIXCIR_INT_ENABLE;
	337	else
	338	ret &= ~AUO_PIXCIR_INT_ENABLE;
	339
	340	ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_INT_SETTING,
	341	ret);
	342	if (ret < 0) {
	343	dev_err(&client->dev, "unable to write reg %Xh, %d\n",
	344	AUO_PIXCIR_REG_INT_SETTING, ret);
	345	return ret;
	346	}
	347
	348	return 0;
	349	}
	350
	351	static int auo_pixcir_start(struct auo_pixcir_ts *ts)
	352	{
	353	struct i2c_client *client = ts->client;
	354	int ret;
	355
	356	ret = auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_ACTIVE);
	357	if (ret < 0) {
	358	dev_err(&client->dev, "could not set power mode, %d\n",
	359	ret);
360	return ret;
361	}
362
363	ts->stopped = false;
364	mb();
365	enable_irq(client->irq);
366
367	ret = auo_pixcir_int_toggle(ts, 1);
368	if (ret < 0) {
369	dev_err(&client->dev, "could not enable interrupt, %d\n",
370	ret);
371	disable_irq(client->irq);
372	return ret;
373	}
374
375	return 0;
376	}
377
378	static int auo_pixcir_stop(struct auo_pixcir_ts *ts)
379	{
380	struct i2c_client *client = ts->client;
381	int ret;
382
383	ret = auo_pixcir_int_toggle(ts, 0);
384	if (ret < 0) {
385	dev_err(&client->dev, "could not disable interrupt, %d\n",
386	ret);
387	return ret;
388	}
389
390	/* disable receiving of interrupts */
391	disable_irq(client->irq);
392	ts->stopped = true;
393	mb();
394	wake_up(&ts->wait);
395
396	return auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_DEEP_SLEEP);
397	}
398
399	static int auo_pixcir_input_open(struct input_dev *dev)
400	{
401	struct auo_pixcir_ts *ts = input_get_drvdata(dev);
402	int ret;
403
404	ret = auo_pixcir_start(ts);
405	if (ret)
406	return ret;
407
408	return 0;
409	}
410
411	static void auo_pixcir_input_close(struct input_dev *dev)
412	{
413	struct auo_pixcir_ts *ts = input_get_drvdata(dev);
414
415	auo_pixcir_stop(ts);
416
417	return;
418	}
419
02b6a58b	420	static int __maybe_unused auo_pixcir_suspend(struct device *dev)
5245db49 HS	421	{
	422	struct i2c_client *client = to_i2c_client(dev);
	423	struct auo_pixcir_ts *ts = i2c_get_clientdata(client);
	424	struct input_dev *input = ts->input;
	425	int ret = 0;
	426
	427	mutex_lock(&input->mutex);
	428
	429	/* when configured as wakeup source, device should always wake system
	430	* therefore start device if necessary
	431	*/
	432	if (device_may_wakeup(&client->dev)) {
	433	/* need to start device if not open, to be wakeup source */
	434	if (!input->users) {
	435	ret = auo_pixcir_start(ts);
	436	if (ret)
	437	goto unlock;
	438	}
	439
	440	enable_irq_wake(client->irq);
	441	ret = auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_SLEEP);
	442	} else if (input->users) {
	443	ret = auo_pixcir_stop(ts);
	444	}
	445
	446	unlock:
	447	mutex_unlock(&input->mutex);
	448
	449	return ret;
	450	}
	451
02b6a58b	452	static int __maybe_unused auo_pixcir_resume(struct device *dev)
5245db49 HS	453	{
	454	struct i2c_client *client = to_i2c_client(dev);
	455	struct auo_pixcir_ts *ts = i2c_get_clientdata(client);
	456	struct input_dev *input = ts->input;
	457	int ret = 0;
	458
	459	mutex_lock(&input->mutex);
	460
	461	if (device_may_wakeup(&client->dev)) {
	462	disable_irq_wake(client->irq);
	463
	464	/* need to stop device if it was not open on suspend */
	465	if (!input->users) {
	466	ret = auo_pixcir_stop(ts);
	467	if (ret)
	468	goto unlock;
	469	}
	470
	471	/* device wakes automatically from SLEEP */
	472	} else if (input->users) {
	473	ret = auo_pixcir_start(ts);
	474	}
	475
	476	unlock:
	477	mutex_unlock(&input->mutex);
	478
	479	return ret;
	480	}
5245db49	481
7241443f HS	482	static SIMPLE_DEV_PM_OPS(auo_pixcir_pm_ops,
	483	auo_pixcir_suspend, auo_pixcir_resume);
	484
	485	#ifdef CONFIG_OF
	486	static struct auo_pixcir_ts_platdata auo_pixcir_parse_dt(struct device dev)
	487	{
	488	struct auo_pixcir_ts_platdata *pdata;
	489	struct device_node *np = dev->of_node;
	490
	491	if (!np)
	492	return ERR_PTR(-ENOENT);
	493
	494	pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
	495	if (!pdata) {
	496	dev_err(dev, "failed to allocate platform data\n");
	497	return ERR_PTR(-ENOMEM);
	498	}
	499
	500	pdata->gpio_int = of_get_gpio(np, 0);
	501	if (!gpio_is_valid(pdata->gpio_int)) {
	502	dev_err(dev, "failed to get interrupt gpio\n");
	503	return ERR_PTR(-EINVAL);
	504	}
	505
	506	pdata->gpio_rst = of_get_gpio(np, 1);
	507	if (!gpio_is_valid(pdata->gpio_rst)) {
	508	dev_err(dev, "failed to get reset gpio\n");
	509	return ERR_PTR(-EINVAL);
	510	}
	511
	512	if (of_property_read_u32(np, "x-size", &pdata->x_max)) {
	513	dev_err(dev, "failed to get x-size property\n");
	514	return ERR_PTR(-EINVAL);
	515	}
	516
	517	if (of_property_read_u32(np, "y-size", &pdata->y_max)) {
	518	dev_err(dev, "failed to get y-size property\n");
	519	return ERR_PTR(-EINVAL);
	520	}
	521
	522	/* default to asserting the interrupt when the screen is touched */
	523	pdata->int_setting = AUO_PIXCIR_INT_TOUCH_IND;
	524
	525	return pdata;
	526	}
	527	#else
	528	static struct auo_pixcir_ts_platdata auo_pixcir_parse_dt(struct device dev)
	529	{
	530	return ERR_PTR(-EINVAL);
	531	}
	532	#endif
5245db49	533
bfc29e95 DT	534	static void auo_pixcir_reset(void *data)
	535	{
	536	struct auo_pixcir_ts *ts = data;
	537
	538	gpio_set_value(ts->pdata->gpio_rst, 0);
	539	}
	540
5298cc4c	541	static int auo_pixcir_probe(struct i2c_client *client,
bfc29e95	542	const struct i2c_device_id *id)
5245db49	543	{
7241443f	544	const struct auo_pixcir_ts_platdata *pdata;
5245db49 HS	545	struct auo_pixcir_ts *ts;
5245db49 HS	546	struct input_dev *input_dev;
bfc29e95 DT	547	int version;
bfc29e95 DT	548	int error;
5245db49	549
7241443f HS	550	pdata = dev_get_platdata(&client->dev);
	551	if (!pdata) {
	552	pdata = auo_pixcir_parse_dt(&client->dev);
	553	if (IS_ERR(pdata))
	554	return PTR_ERR(pdata);
	555	}
5245db49	556
bfc29e95 DT	557	ts = devm_kzalloc(&client->dev,
bfc29e95 DT	558	sizeof(struct auo_pixcir_ts), GFP_KERNEL);
5245db49 HS	559	if (!ts)
	560	return -ENOMEM;
	561
bfc29e95 DT	562	input_dev = devm_input_allocate_device(&client->dev);
	563	if (!input_dev) {
	564	dev_err(&client->dev, "could not allocate input device\n");
	565	return -ENOMEM;
27cef8b4 HS	566	}
27cef8b4 HS	567
38e83f7f	568	ts->pdata = pdata;
5245db49	569	ts->client = client;
bfc29e95	570	ts->input = input_dev;
5245db49	571	ts->touch_ind_mode = 0;
bfc29e95	572	ts->stopped = true;
5245db49 HS	573	init_waitqueue_head(&ts->wait);
	574
	575	snprintf(ts->phys, sizeof(ts->phys),
	576	"%s/input0", dev_name(&client->dev));
	577
5245db49 HS	578	input_dev->name = "AUO-Pixcir touchscreen";
	579	input_dev->phys = ts->phys;
	580	input_dev->id.bustype = BUS_I2C;
5245db49 HS	581
	582	input_dev->open = auo_pixcir_input_open;
	583	input_dev->close = auo_pixcir_input_close;
	584
	585	__set_bit(EV_ABS, input_dev->evbit);
	586	__set_bit(EV_KEY, input_dev->evbit);
	587
	588	__set_bit(BTN_TOUCH, input_dev->keybit);
	589
	590	/* For single touch */
	591	input_set_abs_params(input_dev, ABS_X, 0, pdata->x_max, 0, 0);
	592	input_set_abs_params(input_dev, ABS_Y, 0, pdata->y_max, 0, 0);
	593
	594	/* For multi touch */
	595	input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
	596	pdata->x_max, 0, 0);
	597	input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
	598	pdata->y_max, 0, 0);
	599	input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0,
	600	AUO_PIXCIR_MAX_AREA, 0, 0);
	601	input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0,
	602	AUO_PIXCIR_MAX_AREA, 0, 0);
	603	input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
	604
5245db49	605	input_set_drvdata(ts->input, ts);
5245db49	606
bfc29e95 DT	607	error = devm_gpio_request_one(&client->dev, pdata->gpio_int,
	608	GPIOF_DIR_IN, "auo_pixcir_ts_int");
	609	if (error) {
	610	dev_err(&client->dev, "request of gpio %d failed, %d\n",
	611	pdata->gpio_int, error);
	612	return error;
5245db49 HS	613	}
5245db49 HS	614
bfc29e95 DT	615	error = devm_gpio_request_one(&client->dev, pdata->gpio_rst,
	616	GPIOF_DIR_OUT \| GPIOF_INIT_HIGH,
	617	"auo_pixcir_ts_rst");
	618	if (error) {
	619	dev_err(&client->dev, "request of gpio %d failed, %d\n",
	620	pdata->gpio_rst, error);
	621	return error;
5245db49 HS	622	}
5245db49 HS	623
bfc29e95 DT	624	error = devm_add_action(&client->dev, auo_pixcir_reset, ts);
	625	if (error) {
	626	auo_pixcir_reset(ts);
	627	dev_err(&client->dev, "failed to register reset action, %d\n",
	628	error);
	629	return error;
	630	}
5245db49	631
bfc29e95	632	msleep(200);
5245db49	633
bfc29e95 DT	634	version = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_VERSION);
	635	if (version < 0) {
	636	error = version;
	637	return error;
	638	}
5245db49	639
bfc29e95	640	dev_info(&client->dev, "firmware version 0x%X\n", version);
5245db49	641
bfc29e95 DT	642	error = auo_pixcir_int_config(ts, pdata->int_setting);
	643	if (error)
	644	return error;
5245db49	645
bfc29e95 DT	646	error = devm_request_threaded_irq(&client->dev, client->irq,
	647	NULL, auo_pixcir_interrupt,
	648	IRQF_TRIGGER_RISING \| IRQF_ONESHOT,
	649	input_dev->name, ts);
	650	if (error) {
	651	dev_err(&client->dev, "irq %d requested failed, %d\n",
	652	client->irq, error);
	653	return error;
	654	}
5245db49	655
bfc29e95 DT	656	/* stop device and put it into deep sleep until it is opened */
	657	error = auo_pixcir_stop(ts);
	658	if (error)
	659	return error;
	660
	661	error = input_register_device(input_dev);
	662	if (error) {
	663	dev_err(&client->dev, "could not register input device, %d\n",
	664	error);
	665	return error;
	666	}
5245db49	667
bfc29e95	668	i2c_set_clientdata(client, ts);
5245db49 HS	669
	670	return 0;
	671	}
	672
	673	static const struct i2c_device_id auo_pixcir_idtable[] = {
	674	{ "auo_pixcir_ts", 0 },
	675	{ }
	676	};
	677	MODULE_DEVICE_TABLE(i2c, auo_pixcir_idtable);
	678
7241443f	679	#ifdef CONFIG_OF
69f8cafd	680	static const struct of_device_id auo_pixcir_ts_dt_idtable[] = {
7241443f HS	681	{ .compatible = "auo,auo_pixcir_ts" },
	682	{},
	683	};
	684	MODULE_DEVICE_TABLE(of, auo_pixcir_ts_dt_idtable);
	685	#endif
	686
5245db49 HS	687	static struct i2c_driver auo_pixcir_driver = {
	688	.driver = {
	689	.owner = THIS_MODULE,
	690	.name = "auo_pixcir_ts",
	691	.pm = &auo_pixcir_pm_ops,
7241443f	692	.of_match_table = of_match_ptr(auo_pixcir_ts_dt_idtable),
5245db49 HS	693	},
5245db49 HS	694	.probe = auo_pixcir_probe,
5245db49 HS	695	.id_table = auo_pixcir_idtable,
	696	};
	697
4a533835	698	module_i2c_driver(auo_pixcir_driver);
5245db49 HS	699
	700	MODULE_DESCRIPTION("AUO-PIXCIR touchscreen driver");
	701	MODULE_LICENSE("GPL v2");
	702	MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");