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
16#include <linux/module.h>
17#include <linux/kernel.h>
18#include <linux/err.h>
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 */
45struct 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
82struct sample {
83	int x, y, p;
84};
85
86struct 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
99static 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
128static 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
169static 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);
194out:
195	spin_unlock(&ts->lock);
196	return IRQ_HANDLED;
197}
198
199static 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
236static 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
246static 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);
294	if (IS_ERR(ts->clk)) {
295		dev_err(dev, "cannot claim device clock\n");
296		error = PTR_ERR(ts->clk);
297		goto error_clk;
298	}
299
300	error = request_threaded_irq(ts->tsc_irq, NULL, tsc_irq, 0,
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
343error_reg:
344	input_free_device(ts->input_dev);
345error_input:
346	free_irq(ts->tsc_irq, ts);
347error_irq:
348	clk_put(ts->clk);
349error_clk:
350	iounmap(ts->regs);
351error_map:
352	release_mem_region(ts->res->start, resource_size(ts->res));
353error_res:
354	platform_set_drvdata(pdev, NULL);
355	kfree(ts);
356
357	return error;
358}
359
360static 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
375static 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};
381module_platform_driver(tsc_driver);
382
383MODULE_AUTHOR("Cyril Chemparathy");
384MODULE_DESCRIPTION("TNETV107X Touchscreen Driver");
385MODULE_ALIAS("platform:tnetv107x-ts");
386MODULE_LICENSE("GPL");
387