blob: ce1a48108210d38f645d34caa1273ad4d0acd60d [file] [log] [blame]
Russell Kingacb45432005-09-11 10:26:57 +01001/*
Pavel Machek54377752005-09-11 10:28:00 +01002 * Touchscreen driver for UCB1x00-based touchscreens
Russell Kingacb45432005-09-11 10:26:57 +01003 *
4 * Copyright (C) 2001 Russell King, All Rights Reserved.
Pavel Machek54377752005-09-11 10:28:00 +01005 * Copyright (C) 2005 Pavel Machek
Russell Kingacb45432005-09-11 10:26:57 +01006 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
10 *
11 * 21-Jan-2002 <jco@ict.es> :
12 *
13 * Added support for synchronous A/D mode. This mode is useful to
14 * avoid noise induced in the touchpanel by the LCD, provided that
15 * the UCB1x00 has a valid LCD sync signal routed to its ADCSYNC pin.
16 * It is important to note that the signal connected to the ADCSYNC
17 * pin should provide pulses even when the LCD is blanked, otherwise
18 * a pen touch needed to unblank the LCD will never be read.
19 */
Russell Kingacb45432005-09-11 10:26:57 +010020#include <linux/module.h>
21#include <linux/moduleparam.h>
22#include <linux/init.h>
23#include <linux/smp.h>
24#include <linux/smp_lock.h>
25#include <linux/sched.h>
26#include <linux/completion.h>
27#include <linux/delay.h>
28#include <linux/string.h>
29#include <linux/input.h>
30#include <linux/device.h>
Nigel Cunningham7dfb7102006-12-06 20:34:23 -080031#include <linux/freezer.h>
Russell Kingacb45432005-09-11 10:26:57 +010032#include <linux/slab.h>
Pavel Machek54377752005-09-11 10:28:00 +010033#include <linux/kthread.h>
Russell Kingacb45432005-09-11 10:26:57 +010034
35#include <asm/dma.h>
36#include <asm/semaphore.h>
Pavel Machek17532982005-10-30 23:38:01 +000037#include <asm/arch/collie.h>
38#include <asm/mach-types.h>
Russell Kingacb45432005-09-11 10:26:57 +010039
40#include "ucb1x00.h"
41
42
43struct ucb1x00_ts {
Dmitry Torokhovbd622662005-09-15 02:01:48 -050044 struct input_dev *idev;
Russell Kingacb45432005-09-11 10:26:57 +010045 struct ucb1x00 *ucb;
46
47 wait_queue_head_t irq_wait;
Russell Kingacb45432005-09-11 10:26:57 +010048 struct task_struct *rtask;
Russell Kingacb45432005-09-11 10:26:57 +010049 u16 x_res;
50 u16 y_res;
51
Russell King6b9ea422005-09-24 10:24:37 +010052 unsigned int restart:1;
53 unsigned int adcsync:1;
Russell Kingacb45432005-09-11 10:26:57 +010054};
55
56static int adcsync;
57
58static inline void ucb1x00_ts_evt_add(struct ucb1x00_ts *ts, u16 pressure, u16 x, u16 y)
59{
Nicolas Pitre1393c3e2005-12-12 00:37:36 -080060 struct input_dev *idev = ts->idev;
Dmitry Torokhov08c67d22006-09-29 01:59:52 -070061
Nicolas Pitre1393c3e2005-12-12 00:37:36 -080062 input_report_abs(idev, ABS_X, x);
63 input_report_abs(idev, ABS_Y, y);
64 input_report_abs(idev, ABS_PRESSURE, pressure);
65 input_sync(idev);
Russell Kingacb45432005-09-11 10:26:57 +010066}
67
68static inline void ucb1x00_ts_event_release(struct ucb1x00_ts *ts)
69{
Nicolas Pitre1393c3e2005-12-12 00:37:36 -080070 struct input_dev *idev = ts->idev;
Dmitry Torokhov08c67d22006-09-29 01:59:52 -070071
Nicolas Pitre1393c3e2005-12-12 00:37:36 -080072 input_report_abs(idev, ABS_PRESSURE, 0);
73 input_sync(idev);
Russell Kingacb45432005-09-11 10:26:57 +010074}
75
76/*
77 * Switch to interrupt mode.
78 */
79static inline void ucb1x00_ts_mode_int(struct ucb1x00_ts *ts)
80{
81 ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
82 UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW |
83 UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND |
84 UCB_TS_CR_MODE_INT);
85}
86
87/*
88 * Switch to pressure mode, and read pressure. We don't need to wait
89 * here, since both plates are being driven.
90 */
91static inline unsigned int ucb1x00_ts_read_pressure(struct ucb1x00_ts *ts)
92{
Pavel Machek17532982005-10-30 23:38:01 +000093 if (machine_is_collie()) {
94 ucb1x00_io_write(ts->ucb, COLLIE_TC35143_GPIO_TBL_CHK, 0);
95 ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
96 UCB_TS_CR_TSPX_POW | UCB_TS_CR_TSMX_POW |
97 UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA);
Russell Kingacb45432005-09-11 10:26:57 +010098
Pavel Machek17532982005-10-30 23:38:01 +000099 udelay(55);
100
101 return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_AD2, ts->adcsync);
102 } else {
103 ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
104 UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW |
105 UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND |
106 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
107
108 return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync);
109 }
Russell Kingacb45432005-09-11 10:26:57 +0100110}
111
112/*
113 * Switch to X position mode and measure Y plate. We switch the plate
114 * configuration in pressure mode, then switch to position mode. This
115 * gives a faster response time. Even so, we need to wait about 55us
116 * for things to stabilise.
117 */
118static inline unsigned int ucb1x00_ts_read_xpos(struct ucb1x00_ts *ts)
119{
Pavel Machek17532982005-10-30 23:38:01 +0000120 if (machine_is_collie())
121 ucb1x00_io_write(ts->ucb, 0, COLLIE_TC35143_GPIO_TBL_CHK);
122 else {
123 ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
124 UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
125 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
126 ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
127 UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
128 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
129 }
Russell Kingacb45432005-09-11 10:26:57 +0100130 ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
131 UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
132 UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA);
133
134 udelay(55);
135
136 return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync);
137}
138
139/*
140 * Switch to Y position mode and measure X plate. We switch the plate
141 * configuration in pressure mode, then switch to position mode. This
142 * gives a faster response time. Even so, we need to wait about 55us
143 * for things to stabilise.
144 */
145static inline unsigned int ucb1x00_ts_read_ypos(struct ucb1x00_ts *ts)
146{
Pavel Machek17532982005-10-30 23:38:01 +0000147 if (machine_is_collie())
148 ucb1x00_io_write(ts->ucb, 0, COLLIE_TC35143_GPIO_TBL_CHK);
149 else {
150 ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
151 UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
152 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
153 ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
154 UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
155 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
156 }
157
Russell Kingacb45432005-09-11 10:26:57 +0100158 ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
159 UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
160 UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA);
161
162 udelay(55);
163
164 return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPX, ts->adcsync);
165}
166
167/*
168 * Switch to X plate resistance mode. Set MX to ground, PX to
169 * supply. Measure current.
170 */
171static inline unsigned int ucb1x00_ts_read_xres(struct ucb1x00_ts *ts)
172{
173 ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
174 UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW |
175 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
176 return ucb1x00_adc_read(ts->ucb, 0, ts->adcsync);
177}
178
179/*
180 * Switch to Y plate resistance mode. Set MY to ground, PY to
181 * supply. Measure current.
182 */
183static inline unsigned int ucb1x00_ts_read_yres(struct ucb1x00_ts *ts)
184{
185 ucb1x00_reg_write(ts->ucb, UCB_TS_CR,
186 UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW |
187 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA);
188 return ucb1x00_adc_read(ts->ucb, 0, ts->adcsync);
189}
190
Pavel Machek17532982005-10-30 23:38:01 +0000191static inline int ucb1x00_ts_pen_down(struct ucb1x00_ts *ts)
192{
193 unsigned int val = ucb1x00_reg_read(ts->ucb, UCB_TS_CR);
Dmitry Torokhov08c67d22006-09-29 01:59:52 -0700194
Pavel Machek17532982005-10-30 23:38:01 +0000195 if (machine_is_collie())
196 return (!(val & (UCB_TS_CR_TSPX_LOW)));
197 else
198 return (val & (UCB_TS_CR_TSPX_LOW | UCB_TS_CR_TSMX_LOW));
199}
200
Russell Kingacb45432005-09-11 10:26:57 +0100201/*
202 * This is a RT kernel thread that handles the ADC accesses
203 * (mainly so we can use semaphores in the UCB1200 core code
204 * to serialise accesses to the ADC).
205 */
206static int ucb1x00_thread(void *_ts)
207{
208 struct ucb1x00_ts *ts = _ts;
209 struct task_struct *tsk = current;
210 DECLARE_WAITQUEUE(wait, tsk);
211 int valid;
212
Russell Kingacb45432005-09-11 10:26:57 +0100213 /*
214 * We could run as a real-time thread. However, thus far
215 * this doesn't seem to be necessary.
216 */
217// tsk->policy = SCHED_FIFO;
218// tsk->rt_priority = 1;
219
Russell Kingacb45432005-09-11 10:26:57 +0100220 valid = 0;
221
222 add_wait_queue(&ts->irq_wait, &wait);
Pavel Machek54377752005-09-11 10:28:00 +0100223 while (!kthread_should_stop()) {
Pavel Machek17532982005-10-30 23:38:01 +0000224 unsigned int x, y, p;
Russell Kingacb45432005-09-11 10:26:57 +0100225 signed long timeout;
226
227 ts->restart = 0;
228
229 ucb1x00_adc_enable(ts->ucb);
230
231 x = ucb1x00_ts_read_xpos(ts);
232 y = ucb1x00_ts_read_ypos(ts);
233 p = ucb1x00_ts_read_pressure(ts);
234
235 /*
236 * Switch back to interrupt mode.
237 */
238 ucb1x00_ts_mode_int(ts);
239 ucb1x00_adc_disable(ts->ucb);
240
Pavel Machek54377752005-09-11 10:28:00 +0100241 msleep(10);
Russell Kingacb45432005-09-11 10:26:57 +0100242
243 ucb1x00_enable(ts->ucb);
Russell Kingacb45432005-09-11 10:26:57 +0100244
Pavel Machek17532982005-10-30 23:38:01 +0000245
246 if (ucb1x00_ts_pen_down(ts)) {
Russell Kingacb45432005-09-11 10:26:57 +0100247 set_task_state(tsk, TASK_INTERRUPTIBLE);
248
Pavel Machek17532982005-10-30 23:38:01 +0000249 ucb1x00_enable_irq(ts->ucb, UCB_IRQ_TSPX, machine_is_collie() ? UCB_RISING : UCB_FALLING);
Russell Kingacb45432005-09-11 10:26:57 +0100250 ucb1x00_disable(ts->ucb);
251
252 /*
253 * If we spat out a valid sample set last time,
254 * spit out a "pen off" sample here.
255 */
256 if (valid) {
257 ucb1x00_ts_event_release(ts);
258 valid = 0;
259 }
260
261 timeout = MAX_SCHEDULE_TIMEOUT;
262 } else {
263 ucb1x00_disable(ts->ucb);
264
265 /*
266 * Filtering is policy. Policy belongs in user
267 * space. We therefore leave it to user space
268 * to do any filtering they please.
269 */
270 if (!ts->restart) {
271 ucb1x00_ts_evt_add(ts, p, x, y);
272 valid = 1;
273 }
274
275 set_task_state(tsk, TASK_INTERRUPTIBLE);
276 timeout = HZ / 100;
277 }
278
279 try_to_freeze();
280
281 schedule_timeout(timeout);
Russell Kingacb45432005-09-11 10:26:57 +0100282 }
283
284 remove_wait_queue(&ts->irq_wait, &wait);
285
286 ts->rtask = NULL;
Pavel Machek54377752005-09-11 10:28:00 +0100287 return 0;
Russell Kingacb45432005-09-11 10:26:57 +0100288}
289
290/*
291 * We only detect touch screen _touches_ with this interrupt
292 * handler, and even then we just schedule our task.
293 */
294static void ucb1x00_ts_irq(int idx, void *id)
295{
296 struct ucb1x00_ts *ts = id;
Dmitry Torokhov08c67d22006-09-29 01:59:52 -0700297
Russell Kingacb45432005-09-11 10:26:57 +0100298 ucb1x00_disable_irq(ts->ucb, UCB_IRQ_TSPX, UCB_FALLING);
299 wake_up(&ts->irq_wait);
300}
301
302static int ucb1x00_ts_open(struct input_dev *idev)
303{
Nicolas Pitre1393c3e2005-12-12 00:37:36 -0800304 struct ucb1x00_ts *ts = idev->private;
Russell Kingacb45432005-09-11 10:26:57 +0100305 int ret = 0;
306
Pavel Machek54377752005-09-11 10:28:00 +0100307 BUG_ON(ts->rtask);
Russell Kingacb45432005-09-11 10:26:57 +0100308
309 init_waitqueue_head(&ts->irq_wait);
310 ret = ucb1x00_hook_irq(ts->ucb, UCB_IRQ_TSPX, ucb1x00_ts_irq, ts);
311 if (ret < 0)
312 goto out;
313
314 /*
315 * If we do this at all, we should allow the user to
316 * measure and read the X and Y resistance at any time.
317 */
318 ucb1x00_adc_enable(ts->ucb);
319 ts->x_res = ucb1x00_ts_read_xres(ts);
320 ts->y_res = ucb1x00_ts_read_yres(ts);
321 ucb1x00_adc_disable(ts->ucb);
322
Pavel Machek54377752005-09-11 10:28:00 +0100323 ts->rtask = kthread_run(ucb1x00_thread, ts, "ktsd");
324 if (!IS_ERR(ts->rtask)) {
Russell Kingacb45432005-09-11 10:26:57 +0100325 ret = 0;
326 } else {
327 ucb1x00_free_irq(ts->ucb, UCB_IRQ_TSPX, ts);
Pavel Machek54377752005-09-11 10:28:00 +0100328 ts->rtask = NULL;
329 ret = -EFAULT;
Russell Kingacb45432005-09-11 10:26:57 +0100330 }
331
332 out:
Russell Kingacb45432005-09-11 10:26:57 +0100333 return ret;
334}
335
336/*
337 * Release touchscreen resources. Disable IRQs.
338 */
339static void ucb1x00_ts_close(struct input_dev *idev)
340{
Nicolas Pitre1393c3e2005-12-12 00:37:36 -0800341 struct ucb1x00_ts *ts = idev->private;
Russell Kingacb45432005-09-11 10:26:57 +0100342
Pavel Machek54377752005-09-11 10:28:00 +0100343 if (ts->rtask)
344 kthread_stop(ts->rtask);
Russell Kingacb45432005-09-11 10:26:57 +0100345
Pavel Machek54377752005-09-11 10:28:00 +0100346 ucb1x00_enable(ts->ucb);
347 ucb1x00_free_irq(ts->ucb, UCB_IRQ_TSPX, ts);
348 ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 0);
349 ucb1x00_disable(ts->ucb);
Russell Kingacb45432005-09-11 10:26:57 +0100350}
351
352#ifdef CONFIG_PM
353static int ucb1x00_ts_resume(struct ucb1x00_dev *dev)
354{
355 struct ucb1x00_ts *ts = dev->priv;
356
357 if (ts->rtask != NULL) {
358 /*
359 * Restart the TS thread to ensure the
360 * TS interrupt mode is set up again
361 * after sleep.
362 */
363 ts->restart = 1;
364 wake_up(&ts->irq_wait);
365 }
366 return 0;
367}
368#else
369#define ucb1x00_ts_resume NULL
370#endif
371
372
373/*
374 * Initialisation.
375 */
376static int ucb1x00_ts_add(struct ucb1x00_dev *dev)
377{
378 struct ucb1x00_ts *ts;
Dmitry Torokhov08c67d22006-09-29 01:59:52 -0700379 struct input_dev *idev;
380 int err;
Russell Kingacb45432005-09-11 10:26:57 +0100381
Dmitry Torokhovbd622662005-09-15 02:01:48 -0500382 ts = kzalloc(sizeof(struct ucb1x00_ts), GFP_KERNEL);
Dmitry Torokhov08c67d22006-09-29 01:59:52 -0700383 idev = input_allocate_device();
384 if (!ts || !idev) {
385 err = -ENOMEM;
386 goto fail;
Dmitry Torokhovbd622662005-09-15 02:01:48 -0500387 }
Russell Kingacb45432005-09-11 10:26:57 +0100388
389 ts->ucb = dev->ucb;
Dmitry Torokhov08c67d22006-09-29 01:59:52 -0700390 ts->idev = idev;
Russell Kingacb45432005-09-11 10:26:57 +0100391 ts->adcsync = adcsync ? UCB_SYNC : UCB_NOSYNC;
Russell Kingacb45432005-09-11 10:26:57 +0100392
Dmitry Torokhov08c67d22006-09-29 01:59:52 -0700393 idev->private = ts;
394 idev->name = "Touchscreen panel";
395 idev->id.product = ts->ucb->id;
396 idev->open = ucb1x00_ts_open;
397 idev->close = ucb1x00_ts_close;
Russell Kingacb45432005-09-11 10:26:57 +0100398
Dmitry Torokhov08c67d22006-09-29 01:59:52 -0700399 __set_bit(EV_ABS, idev->evbit);
400 __set_bit(ABS_X, idev->absbit);
401 __set_bit(ABS_Y, idev->absbit);
402 __set_bit(ABS_PRESSURE, idev->absbit);
Russell Kingacb45432005-09-11 10:26:57 +0100403
Dmitry Torokhov08c67d22006-09-29 01:59:52 -0700404 err = input_register_device(idev);
405 if (err)
406 goto fail;
Russell Kingacb45432005-09-11 10:26:57 +0100407
408 dev->priv = ts;
409
410 return 0;
Dmitry Torokhov08c67d22006-09-29 01:59:52 -0700411
412 fail:
413 input_free_device(idev);
414 kfree(ts);
415 return err;
Russell Kingacb45432005-09-11 10:26:57 +0100416}
417
418static void ucb1x00_ts_remove(struct ucb1x00_dev *dev)
419{
420 struct ucb1x00_ts *ts = dev->priv;
Dmitry Torokhovbd622662005-09-15 02:01:48 -0500421
422 input_unregister_device(ts->idev);
Russell Kingacb45432005-09-11 10:26:57 +0100423 kfree(ts);
424}
425
426static struct ucb1x00_driver ucb1x00_ts_driver = {
427 .add = ucb1x00_ts_add,
428 .remove = ucb1x00_ts_remove,
429 .resume = ucb1x00_ts_resume,
430};
431
432static int __init ucb1x00_ts_init(void)
433{
434 return ucb1x00_register_driver(&ucb1x00_ts_driver);
435}
436
437static void __exit ucb1x00_ts_exit(void)
438{
439 ucb1x00_unregister_driver(&ucb1x00_ts_driver);
440}
441
442module_param(adcsync, int, 0444);
443module_init(ucb1x00_ts_init);
444module_exit(ucb1x00_ts_exit);
445
446MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
447MODULE_DESCRIPTION("UCB1x00 touchscreen driver");
448MODULE_LICENSE("GPL");