[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / input / touchscreen / tnetv107x-ts.c

/*
 * Texas Instruments TNETV107X Touchscreen Driver
 *
 * Copyright (C) 2010 Texas Instruments
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation version 2.
 *
 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
 * kind, whether express or implied; without even the implied warranty
 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/err.h>
#include <linux/errno.h>
#include <linux/input.h>
#include <linux/platform_device.h>
#include <linux/interrupt.h>
#include <linux/slab.h>
#include <linux/delay.h>
#include <linux/ctype.h>
#include <linux/io.h>
#include <linux/clk.h>

#include <mach/tnetv107x.h>

#define TSC_PENUP_POLL		(HZ / 5)
#define IDLE_TIMEOUT		100 /* msec */

/*
 * The first and last samples of a touch interval are usually garbage and need
 * to be filtered out with these devices.  The following definitions control
 * the number of samples skipped.
 */
#define TSC_HEAD_SKIP		1
#define TSC_TAIL_SKIP		1
#define TSC_SKIP		(TSC_HEAD_SKIP + TSC_TAIL_SKIP + 1)
#define TSC_SAMPLES		(TSC_SKIP + 1)

/* Register Offsets */
struct tsc_regs {
	u32	rev;
	u32	tscm;
	u32	bwcm;
	u32	swc;
	u32	adcchnl;
	u32	adcdata;
	u32	chval[4];
};

/* TSC Mode Configuration Register (tscm) bits */
#define WMODE		BIT(0)
#define TSKIND		BIT(1)
#define ZMEASURE_EN	BIT(2)
#define IDLE		BIT(3)
#define TSC_EN		BIT(4)
#define STOP		BIT(5)
#define ONE_SHOT	BIT(6)
#define SINGLE		BIT(7)
#define AVG		BIT(8)
#define AVGNUM(x)	(((x) & 0x03) <<  9)
#define PVSTC(x)	(((x) & 0x07) << 11)
#define PON		BIT(14)
#define PONBG		BIT(15)
#define AFERST		BIT(16)

/* ADC DATA Capture Register bits */
#define DATA_VALID	BIT(16)

/* Register Access Macros */
#define tsc_read(ts, reg)		__raw_readl(&(ts)->regs->reg)
#define tsc_write(ts, reg, val)		__raw_writel(val, &(ts)->regs->reg);
#define tsc_set_bits(ts, reg, val)	\
	tsc_write(ts, reg, tsc_read(ts, reg) | (val))
#define tsc_clr_bits(ts, reg, val)	\
	tsc_write(ts, reg, tsc_read(ts, reg) & ~(val))

struct sample {
	int x, y, p;
};

struct tsc_data {
	struct input_dev		*input_dev;
	struct resource			*res;
	struct tsc_regs __iomem		*regs;
	struct timer_list		timer;
	spinlock_t			lock;
	struct clk			*clk;
	struct device			*dev;
	int				sample_count;
	struct sample			samples[TSC_SAMPLES];
	int				tsc_irq;
};

static int tsc_read_sample(struct tsc_data *ts, struct sample* sample)
{
	int	x, y, z1, z2, t, p = 0;
	u32	val;

	val = tsc_read(ts, chval[0]);
	if (val & DATA_VALID)
		x = val & 0xffff;
	else
		return -EINVAL;

	y  = tsc_read(ts, chval[1]) & 0xffff;
	z1 = tsc_read(ts, chval[2]) & 0xffff;
	z2 = tsc_read(ts, chval[3]) & 0xffff;

	if (z1) {
		t = ((600 * x) * (z2 - z1));
		p = t / (u32) (z1 << 12);
		if (p < 0)
			p = 0;
	}

	sample->x  = x;
	sample->y  = y;
	sample->p  = p;

	return 0;
}

static void tsc_poll(unsigned long data)
{
	struct tsc_data *ts = (struct tsc_data *)data;
	unsigned long flags;
	int i, val, x, y, p;

	spin_lock_irqsave(&ts->lock, flags);

	if (ts->sample_count >= TSC_SKIP) {
		input_report_abs(ts->input_dev, ABS_PRESSURE, 0);
		input_report_key(ts->input_dev, BTN_TOUCH, 0);
		input_sync(ts->input_dev);
	} else if (ts->sample_count > 0) {
		/*
		 * A touch event lasted less than our skip count.  Salvage and
		 * report anyway.
		 */
		for (i = 0, val = 0; i < ts->sample_count; i++)
			val += ts->samples[i].x;
		x = val / ts->sample_count;

		for (i = 0, val = 0; i < ts->sample_count; i++)
			val += ts->samples[i].y;
		y = val / ts->sample_count;

		for (i = 0, val = 0; i < ts->sample_count; i++)
			val += ts->samples[i].p;
		p = val / ts->sample_count;

		input_report_abs(ts->input_dev, ABS_X, x);
		input_report_abs(ts->input_dev, ABS_Y, y);
		input_report_abs(ts->input_dev, ABS_PRESSURE, p);
		input_report_key(ts->input_dev, BTN_TOUCH, 1);
		input_sync(ts->input_dev);
	}

	ts->sample_count = 0;

	spin_unlock_irqrestore(&ts->lock, flags);
}

static irqreturn_t tsc_irq(int irq, void *dev_id)
{
	struct tsc_data *ts = (struct tsc_data *)dev_id;
	struct sample *sample;
	int index;

	spin_lock(&ts->lock);

	index = ts->sample_count % TSC_SAMPLES;
	sample = &ts->samples[index];
	if (tsc_read_sample(ts, sample) < 0)
		goto out;

	if (++ts->sample_count >= TSC_SKIP) {
		index = (ts->sample_count - TSC_TAIL_SKIP - 1) % TSC_SAMPLES;
		sample = &ts->samples[index];

		input_report_abs(ts->input_dev, ABS_X, sample->x);
		input_report_abs(ts->input_dev, ABS_Y, sample->y);
		input_report_abs(ts->input_dev, ABS_PRESSURE, sample->p);
		if (ts->sample_count == TSC_SKIP)
			input_report_key(ts->input_dev, BTN_TOUCH, 1);
		input_sync(ts->input_dev);
	}
	mod_timer(&ts->timer, jiffies + TSC_PENUP_POLL);
out:
	spin_unlock(&ts->lock);
	return IRQ_HANDLED;
}

static int tsc_start(struct input_dev *dev)
{
	struct tsc_data *ts = input_get_drvdata(dev);
	unsigned long timeout = jiffies + msecs_to_jiffies(IDLE_TIMEOUT);
	u32 val;

	clk_enable(ts->clk);

	/* Go to idle mode, before any initialization */
	while (time_after(timeout, jiffies)) {
		if (tsc_read(ts, tscm) & IDLE)
			break;
	}

	if (time_before(timeout, jiffies)) {
		dev_warn(ts->dev, "timeout waiting for idle\n");
		clk_disable(ts->clk);
		return -EIO;
	}

	/* Configure TSC Control register*/
	val = (PONBG | PON | PVSTC(4) | ONE_SHOT | ZMEASURE_EN);
	tsc_write(ts, tscm, val);

	/* Bring TSC out of reset: Clear AFE reset bit */
	val &= ~(AFERST);
	tsc_write(ts, tscm, val);

	/* Configure all pins for hardware control*/
	tsc_write(ts, bwcm, 0);

	/* Finally enable the TSC */
	tsc_set_bits(ts, tscm, TSC_EN);

	return 0;
}

static void tsc_stop(struct input_dev *dev)
{
	struct tsc_data *ts = input_get_drvdata(dev);

	tsc_clr_bits(ts, tscm, TSC_EN);
	synchronize_irq(ts->tsc_irq);
	del_timer_sync(&ts->timer);
	clk_disable(ts->clk);
}

static int __devinit tsc_probe(struct platform_device *pdev)
{
	struct device *dev = &pdev->dev;
	struct tsc_data *ts;
	int error = 0;
	u32 rev = 0;

	ts = kzalloc(sizeof(struct tsc_data), GFP_KERNEL);
	if (!ts) {
		dev_err(dev, "cannot allocate device info\n");
		return -ENOMEM;
	}

	ts->dev = dev;
	spin_lock_init(&ts->lock);
	setup_timer(&ts->timer, tsc_poll, (unsigned long)ts);
	platform_set_drvdata(pdev, ts);

	ts->tsc_irq = platform_get_irq(pdev, 0);
	if (ts->tsc_irq < 0) {
		dev_err(dev, "cannot determine device interrupt\n");
		error = -ENODEV;
		goto error_res;
	}

	ts->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!ts->res) {
		dev_err(dev, "cannot determine register area\n");
		error = -ENODEV;
		goto error_res;
	}

	if (!request_mem_region(ts->res->start, resource_size(ts->res),
				pdev->name)) {
		dev_err(dev, "cannot claim register memory\n");
		ts->res = NULL;
		error = -EINVAL;
		goto error_res;
	}

	ts->regs = ioremap(ts->res->start, resource_size(ts->res));
	if (!ts->regs) {
		dev_err(dev, "cannot map register memory\n");
		error = -ENOMEM;
		goto error_map;
	}

	ts->clk = clk_get(dev, NULL);
	if (IS_ERR(ts->clk)) {
		dev_err(dev, "cannot claim device clock\n");
		error = PTR_ERR(ts->clk);
		goto error_clk;
	}

	error = request_threaded_irq(ts->tsc_irq, NULL, tsc_irq, IRQF_ONESHOT,
				     dev_name(dev), ts);
	if (error < 0) {
		dev_err(ts->dev, "Could not allocate ts irq\n");
		goto error_irq;
	}

	ts->input_dev = input_allocate_device();
	if (!ts->input_dev) {
		dev_err(dev, "cannot allocate input device\n");
		error = -ENOMEM;
		goto error_input;
	}
	input_set_drvdata(ts->input_dev, ts);

	ts->input_dev->name       = pdev->name;
	ts->input_dev->id.bustype = BUS_HOST;
	ts->input_dev->dev.parent = &pdev->dev;
	ts->input_dev->open	  = tsc_start;
	ts->input_dev->close	  = tsc_stop;

	clk_enable(ts->clk);
	rev = tsc_read(ts, rev);
	ts->input_dev->id.product = ((rev >>  8) & 0x07);
	ts->input_dev->id.version = ((rev >> 16) & 0xfff);
	clk_disable(ts->clk);

	__set_bit(EV_KEY,    ts->input_dev->evbit);
	__set_bit(EV_ABS,    ts->input_dev->evbit);
	__set_bit(BTN_TOUCH, ts->input_dev->keybit);

	input_set_abs_params(ts->input_dev, ABS_X, 0, 0xffff, 5, 0);
	input_set_abs_params(ts->input_dev, ABS_Y, 0, 0xffff, 5, 0);
	input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 4095, 128, 0);

	error = input_register_device(ts->input_dev);
	if (error < 0) {
		dev_err(dev, "failed input device registration\n");
		goto error_reg;
	}

	return 0;

error_reg:
	input_free_device(ts->input_dev);
error_input:
	free_irq(ts->tsc_irq, ts);
error_irq:
	clk_put(ts->clk);
error_clk:
	iounmap(ts->regs);
error_map:
	release_mem_region(ts->res->start, resource_size(ts->res));
error_res:
	platform_set_drvdata(pdev, NULL);
	kfree(ts);

	return error;
}

static int __devexit tsc_remove(struct platform_device *pdev)
{
	struct tsc_data *ts = platform_get_drvdata(pdev);

	input_unregister_device(ts->input_dev);
	free_irq(ts->tsc_irq, ts);
	clk_put(ts->clk);
	iounmap(ts->regs);
	release_mem_region(ts->res->start, resource_size(ts->res));
	platform_set_drvdata(pdev, NULL);
	kfree(ts);

	return 0;
}

static struct platform_driver tsc_driver = {
	.probe		= tsc_probe,
	.remove		= __devexit_p(tsc_remove),
	.driver.name	= "tnetv107x-ts",
	.driver.owner	= THIS_MODULE,
};
module_platform_driver(tsc_driver);

MODULE_AUTHOR("Cyril Chemparathy");
MODULE_DESCRIPTION("TNETV107X Touchscreen Driver");
MODULE_ALIAS("platform:tnetv107x-ts");
MODULE_LICENSE("GPL");
Commit	Line	Data
0fa6c773 CC	1	/*
	2	* Texas Instruments TNETV107X Touchscreen Driver
	3	*
	4	* Copyright (C) 2010 Texas Instruments
	5	*
	6	* This program is free software; you can redistribute it and/or
	7	* modify it under the terms of the GNU General Public License as
	8	* published by the Free Software Foundation version 2.
	9	*
	10	* This program is distributed "as is" WITHOUT ANY WARRANTY of any
	11	* kind, whether express or implied; without even the implied warranty
	12	* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	13	* GNU General Public License for more details.
	14	*/
	15
2782a351	16	#include <linux/module.h>
0fa6c773	17	#include <linux/kernel.h>
ba555461	18	#include <linux/err.h>
0fa6c773 CC	19	#include <linux/errno.h>
	20	#include <linux/input.h>
	21	#include <linux/platform_device.h>
	22	#include <linux/interrupt.h>
	23	#include <linux/slab.h>
	24	#include <linux/delay.h>
	25	#include <linux/ctype.h>
	26	#include <linux/io.h>
	27	#include <linux/clk.h>
	28
	29	#include <mach/tnetv107x.h>
	30
	31	#define TSC_PENUP_POLL (HZ / 5)
	32	#define IDLE_TIMEOUT 100 /* msec */
	33
	34	/*
	35	* The first and last samples of a touch interval are usually garbage and need
	36	* to be filtered out with these devices. The following definitions control
	37	* the number of samples skipped.
	38	*/
	39	#define TSC_HEAD_SKIP 1
	40	#define TSC_TAIL_SKIP 1
	41	#define TSC_SKIP (TSC_HEAD_SKIP + TSC_TAIL_SKIP + 1)
	42	#define TSC_SAMPLES (TSC_SKIP + 1)
	43
	44	/* Register Offsets */
	45	struct tsc_regs {
	46	u32 rev;
	47	u32 tscm;
	48	u32 bwcm;
	49	u32 swc;
	50	u32 adcchnl;
	51	u32 adcdata;
	52	u32 chval[4];
	53	};
	54
	55	/* TSC Mode Configuration Register (tscm) bits */
	56	#define WMODE BIT(0)
	57	#define TSKIND BIT(1)
	58	#define ZMEASURE_EN BIT(2)
	59	#define IDLE BIT(3)
	60	#define TSC_EN BIT(4)
	61	#define STOP BIT(5)
	62	#define ONE_SHOT BIT(6)
	63	#define SINGLE BIT(7)
	64	#define AVG BIT(8)
	65	#define AVGNUM(x) (((x) & 0x03) << 9)
	66	#define PVSTC(x) (((x) & 0x07) << 11)
	67	#define PON BIT(14)
	68	#define PONBG BIT(15)
	69	#define AFERST BIT(16)
	70
	71	/* ADC DATA Capture Register bits */
	72	#define DATA_VALID BIT(16)
	73
	74	/* Register Access Macros */
	75	#define tsc_read(ts, reg) __raw_readl(&(ts)->regs->reg)
	76	#define tsc_write(ts, reg, val) __raw_writel(val, &(ts)->regs->reg);
	77	#define tsc_set_bits(ts, reg, val) \
	78	tsc_write(ts, reg, tsc_read(ts, reg) \| (val))
	79	#define tsc_clr_bits(ts, reg, val) \
	80	tsc_write(ts, reg, tsc_read(ts, reg) & ~(val))
	81
	82	struct sample {
83	int x, y, p;
84	};
85
86	struct tsc_data {
87	struct input_dev *input_dev;
88	struct resource *res;
89	struct tsc_regs __iomem *regs;
90	struct timer_list timer;
91	spinlock_t lock;
92	struct clk *clk;
93	struct device *dev;
94	int sample_count;
95	struct sample samples[TSC_SAMPLES];
96	int tsc_irq;
97	};
98
99	static int tsc_read_sample(struct tsc_data ts, struct sample sample)
100	{
101	int x, y, z1, z2, t, p = 0;
102	u32 val;
103
104	val = tsc_read(ts, chval[0]);
105	if (val & DATA_VALID)
106	x = val & 0xffff;
107	else
108	return -EINVAL;
109
110	y = tsc_read(ts, chval[1]) & 0xffff;
111	z1 = tsc_read(ts, chval[2]) & 0xffff;
112	z2 = tsc_read(ts, chval[3]) & 0xffff;
113
114	if (z1) {
115	t = ((600 * x) * (z2 - z1));
116	p = t / (u32) (z1 << 12);
117	if (p < 0)
118	p = 0;
119	}
120
121	sample->x = x;
122	sample->y = y;
123	sample->p = p;
124
125	return 0;
126	}
127
128	static void tsc_poll(unsigned long data)
129	{
130	struct tsc_data ts = (struct tsc_data )data;
131	unsigned long flags;
132	int i, val, x, y, p;
133
134	spin_lock_irqsave(&ts->lock, flags);
135
136	if (ts->sample_count >= TSC_SKIP) {
137	input_report_abs(ts->input_dev, ABS_PRESSURE, 0);
138	input_report_key(ts->input_dev, BTN_TOUCH, 0);
139	input_sync(ts->input_dev);
140	} else if (ts->sample_count > 0) {
141	/*
142	* A touch event lasted less than our skip count. Salvage and
143	* report anyway.
144	*/
145	for (i = 0, val = 0; i < ts->sample_count; i++)
146	val += ts->samples[i].x;
147	x = val / ts->sample_count;
148
149	for (i = 0, val = 0; i < ts->sample_count; i++)
150	val += ts->samples[i].y;
151	y = val / ts->sample_count;
152
153	for (i = 0, val = 0; i < ts->sample_count; i++)
154	val += ts->samples[i].p;
155	p = val / ts->sample_count;
156
157	input_report_abs(ts->input_dev, ABS_X, x);
158	input_report_abs(ts->input_dev, ABS_Y, y);
159	input_report_abs(ts->input_dev, ABS_PRESSURE, p);
160	input_report_key(ts->input_dev, BTN_TOUCH, 1);
161	input_sync(ts->input_dev);
162	}
163
164	ts->sample_count = 0;
165
166	spin_unlock_irqrestore(&ts->lock, flags);
167	}
168
169	static irqreturn_t tsc_irq(int irq, void *dev_id)
170	{
171	struct tsc_data ts = (struct tsc_data )dev_id;
172	struct sample *sample;
173	int index;
174
175	spin_lock(&ts->lock);
176
177	index = ts->sample_count % TSC_SAMPLES;
178	sample = &ts->samples[index];
179	if (tsc_read_sample(ts, sample) < 0)
180	goto out;
181
182	if (++ts->sample_count >= TSC_SKIP) {
183	index = (ts->sample_count - TSC_TAIL_SKIP - 1) % TSC_SAMPLES;
184	sample = &ts->samples[index];
185
186	input_report_abs(ts->input_dev, ABS_X, sample->x);
187	input_report_abs(ts->input_dev, ABS_Y, sample->y);
188	input_report_abs(ts->input_dev, ABS_PRESSURE, sample->p);
189	if (ts->sample_count == TSC_SKIP)
190	input_report_key(ts->input_dev, BTN_TOUCH, 1);
191	input_sync(ts->input_dev);
192	}
193	mod_timer(&ts->timer, jiffies + TSC_PENUP_POLL);
194	out:
195	spin_unlock(&ts->lock);
196	return IRQ_HANDLED;
197	}
198
199	static int tsc_start(struct input_dev *dev)
200	{
201	struct tsc_data *ts = input_get_drvdata(dev);
202	unsigned long timeout = jiffies + msecs_to_jiffies(IDLE_TIMEOUT);
203	u32 val;
204
205	clk_enable(ts->clk);
206
207	/* Go to idle mode, before any initialization */
208	while (time_after(timeout, jiffies)) {
209	if (tsc_read(ts, tscm) & IDLE)
210	break;
211	}
212
213	if (time_before(timeout, jiffies)) {
214	dev_warn(ts->dev, "timeout waiting for idle\n");
215	clk_disable(ts->clk);
216	return -EIO;
217	}
218
219	/* Configure TSC Control register*/
220	val = (PONBG \| PON \| PVSTC(4) \| ONE_SHOT \| ZMEASURE_EN);
221	tsc_write(ts, tscm, val);
222
223	/* Bring TSC out of reset: Clear AFE reset bit */
224	val &= ~(AFERST);
225	tsc_write(ts, tscm, val);
226
227	/* Configure all pins for hardware control*/
228	tsc_write(ts, bwcm, 0);
229
230	/* Finally enable the TSC */
231	tsc_set_bits(ts, tscm, TSC_EN);
232
233	return 0;
234	}
235
236	static void tsc_stop(struct input_dev *dev)
237	{
238	struct tsc_data *ts = input_get_drvdata(dev);
239
240	tsc_clr_bits(ts, tscm, TSC_EN);
241	synchronize_irq(ts->tsc_irq);
242	del_timer_sync(&ts->timer);
243	clk_disable(ts->clk);
244	}
245
246	static int __devinit tsc_probe(struct platform_device *pdev)
247	{
248	struct device *dev = &pdev->dev;
249	struct tsc_data *ts;
250	int error = 0;
251	u32 rev = 0;
252
253	ts = kzalloc(sizeof(struct tsc_data), GFP_KERNEL);
254	if (!ts) {
255	dev_err(dev, "cannot allocate device info\n");
256	return -ENOMEM;
257	}
258
259	ts->dev = dev;
260	spin_lock_init(&ts->lock);
261	setup_timer(&ts->timer, tsc_poll, (unsigned long)ts);
262	platform_set_drvdata(pdev, ts);
263
264	ts->tsc_irq = platform_get_irq(pdev, 0);
265	if (ts->tsc_irq < 0) {
266	dev_err(dev, "cannot determine device interrupt\n");
267	error = -ENODEV;
268	goto error_res;
269	}
270
271	ts->res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
272	if (!ts->res) {
273	dev_err(dev, "cannot determine register area\n");
274	error = -ENODEV;
275	goto error_res;
276	}
277
278	if (!request_mem_region(ts->res->start, resource_size(ts->res),
279	pdev->name)) {
280	dev_err(dev, "cannot claim register memory\n");
281	ts->res = NULL;
282	error = -EINVAL;
283	goto error_res;
284	}
285
286	ts->regs = ioremap(ts->res->start, resource_size(ts->res));
287	if (!ts->regs) {
288	dev_err(dev, "cannot map register memory\n");
289	error = -ENOMEM;
290	goto error_map;
291	}
292
293	ts->clk = clk_get(dev, NULL);
ba555461	294	if (IS_ERR(ts->clk)) {
0fa6c773	295	dev_err(dev, "cannot claim device clock\n");
ba555461	296	error = PTR_ERR(ts->clk);
0fa6c773 CC	297	goto error_clk;
	298	}
	299
9b7e31bb	300	error = request_threaded_irq(ts->tsc_irq, NULL, tsc_irq, IRQF_ONESHOT,
0fa6c773 CC	301	dev_name(dev), ts);
	302	if (error < 0) {
	303	dev_err(ts->dev, "Could not allocate ts irq\n");
	304	goto error_irq;
	305	}
	306
	307	ts->input_dev = input_allocate_device();
	308	if (!ts->input_dev) {
	309	dev_err(dev, "cannot allocate input device\n");
	310	error = -ENOMEM;
	311	goto error_input;
	312	}
	313	input_set_drvdata(ts->input_dev, ts);
	314
	315	ts->input_dev->name = pdev->name;
	316	ts->input_dev->id.bustype = BUS_HOST;
	317	ts->input_dev->dev.parent = &pdev->dev;
	318	ts->input_dev->open = tsc_start;
	319	ts->input_dev->close = tsc_stop;
	320
	321	clk_enable(ts->clk);
	322	rev = tsc_read(ts, rev);
	323	ts->input_dev->id.product = ((rev >> 8) & 0x07);
	324	ts->input_dev->id.version = ((rev >> 16) & 0xfff);
	325	clk_disable(ts->clk);
	326
	327	__set_bit(EV_KEY, ts->input_dev->evbit);
	328	__set_bit(EV_ABS, ts->input_dev->evbit);
	329	__set_bit(BTN_TOUCH, ts->input_dev->keybit);
	330
	331	input_set_abs_params(ts->input_dev, ABS_X, 0, 0xffff, 5, 0);
	332	input_set_abs_params(ts->input_dev, ABS_Y, 0, 0xffff, 5, 0);
	333	input_set_abs_params(ts->input_dev, ABS_PRESSURE, 0, 4095, 128, 0);
	334
	335	error = input_register_device(ts->input_dev);
	336	if (error < 0) {
	337	dev_err(dev, "failed input device registration\n");
	338	goto error_reg;
	339	}
	340
	341	return 0;
	342
	343	error_reg:
	344	input_free_device(ts->input_dev);
	345	error_input:
	346	free_irq(ts->tsc_irq, ts);
	347	error_irq:
	348	clk_put(ts->clk);
	349	error_clk:
	350	iounmap(ts->regs);
	351	error_map:
	352	release_mem_region(ts->res->start, resource_size(ts->res));
	353	error_res:
	354	platform_set_drvdata(pdev, NULL);
	355	kfree(ts);
	356
	357	return error;
	358	}
	359
	360	static int __devexit tsc_remove(struct platform_device *pdev)
	361	{
	362	struct tsc_data *ts = platform_get_drvdata(pdev);
	363
	364	input_unregister_device(ts->input_dev);
365	free_irq(ts->tsc_irq, ts);
366	clk_put(ts->clk);
367	iounmap(ts->regs);
368	release_mem_region(ts->res->start, resource_size(ts->res));
369	platform_set_drvdata(pdev, NULL);
370	kfree(ts);
371
372	return 0;
373	}
374
375	static struct platform_driver tsc_driver = {
376	.probe = tsc_probe,
377	.remove = __devexit_p(tsc_remove),
378	.driver.name = "tnetv107x-ts",
379	.driver.owner = THIS_MODULE,
380	};
cdcc96e2	381	module_platform_driver(tsc_driver);
0fa6c773 CC	382
	383	MODULE_AUTHOR("Cyril Chemparathy");
	384	MODULE_DESCRIPTION("TNETV107X Touchscreen Driver");
6a592a7f	385	MODULE_ALIAS("platform:tnetv107x-ts");
0fa6c773	386	MODULE_LICENSE("GPL");