1
2
3
4
5
6
7
8
9
10
11
12
13
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
33
34
35
36
37
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
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
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
72#define DATA_VALID BIT(16)
73
74
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
143
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
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
220 val = (PONBG | PON | PVSTC(4) | ONE_SHOT | ZMEASURE_EN);
221 tsc_write(ts, tscm, val);
222
223
224 val &= ~(AFERST);
225 tsc_write(ts, tscm, val);
226
227
228 tsc_write(ts, bwcm, 0);
229
230
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};
381
382static int __init tsc_init(void)
383{
384 return platform_driver_register(&tsc_driver);
385}
386
387static void __exit tsc_exit(void)
388{
389 platform_driver_unregister(&tsc_driver);
390}
391
392module_init(tsc_init);
393module_exit(tsc_exit);
394
395MODULE_AUTHOR("Cyril Chemparathy");
396MODULE_DESCRIPTION("TNETV107X Touchscreen Driver");
397MODULE_ALIAS("platform:tnetv107x-ts");
398MODULE_LICENSE("GPL");
399
