2 * Touchscreen driver for UCB1x00-based touchscreens
4 * Copyright (C) 2001 Russell King, All Rights Reserved.
5 * Copyright (C) 2005 Pavel Machek
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.
11 * 21-Jan-2002 <jco@ict.es> :
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.
20 #include <linux/config.h>
21 #include <linux/module.h>
22 #include <linux/moduleparam.h>
23 #include <linux/init.h>
24 #include <linux/smp.h>
25 #include <linux/smp_lock.h>
26 #include <linux/sched.h>
27 #include <linux/completion.h>
28 #include <linux/delay.h>
29 #include <linux/string.h>
30 #include <linux/input.h>
31 #include <linux/device.h>
32 #include <linux/suspend.h>
33 #include <linux/slab.h>
34 #include <linux/kthread.h>
35 #include <linux/delay.h>
38 #include <asm/semaphore.h>
39 #include <asm/arch/collie.h>
40 #include <asm/mach-types.h>
46 struct input_dev
*idev
;
49 wait_queue_head_t irq_wait
;
50 struct task_struct
*rtask
;
54 unsigned int restart
:1;
55 unsigned int adcsync
:1;
60 static inline void ucb1x00_ts_evt_add(struct ucb1x00_ts
*ts
, u16 pressure
, u16 x
, u16 y
)
62 input_report_abs(ts
->idev
, ABS_X
, x
);
63 input_report_abs(ts
->idev
, ABS_Y
, y
);
64 input_report_abs(ts
->idev
, ABS_PRESSURE
, pressure
);
68 static inline void ucb1x00_ts_event_release(struct ucb1x00_ts
*ts
)
70 input_report_abs(ts
->idev
, ABS_PRESSURE
, 0);
75 * Switch to interrupt mode.
77 static inline void ucb1x00_ts_mode_int(struct ucb1x00_ts
*ts
)
79 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
80 UCB_TS_CR_TSMX_POW
| UCB_TS_CR_TSPX_POW
|
81 UCB_TS_CR_TSMY_GND
| UCB_TS_CR_TSPY_GND
|
86 * Switch to pressure mode, and read pressure. We don't need to wait
87 * here, since both plates are being driven.
89 static inline unsigned int ucb1x00_ts_read_pressure(struct ucb1x00_ts
*ts
)
91 if (machine_is_collie()) {
92 ucb1x00_io_write(ts
->ucb
, COLLIE_TC35143_GPIO_TBL_CHK
, 0);
93 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
94 UCB_TS_CR_TSPX_POW
| UCB_TS_CR_TSMX_POW
|
95 UCB_TS_CR_MODE_POS
| UCB_TS_CR_BIAS_ENA
);
99 return ucb1x00_adc_read(ts
->ucb
, UCB_ADC_INP_AD2
, ts
->adcsync
);
101 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
102 UCB_TS_CR_TSMX_POW
| UCB_TS_CR_TSPX_POW
|
103 UCB_TS_CR_TSMY_GND
| UCB_TS_CR_TSPY_GND
|
104 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
106 return ucb1x00_adc_read(ts
->ucb
, UCB_ADC_INP_TSPY
, ts
->adcsync
);
111 * Switch to X position mode and measure Y plate. We switch the plate
112 * configuration in pressure mode, then switch to position mode. This
113 * gives a faster response time. Even so, we need to wait about 55us
114 * for things to stabilise.
116 static inline unsigned int ucb1x00_ts_read_xpos(struct ucb1x00_ts
*ts
)
118 if (machine_is_collie())
119 ucb1x00_io_write(ts
->ucb
, 0, COLLIE_TC35143_GPIO_TBL_CHK
);
121 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
122 UCB_TS_CR_TSMX_GND
| UCB_TS_CR_TSPX_POW
|
123 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
124 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
125 UCB_TS_CR_TSMX_GND
| UCB_TS_CR_TSPX_POW
|
126 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
128 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
129 UCB_TS_CR_TSMX_GND
| UCB_TS_CR_TSPX_POW
|
130 UCB_TS_CR_MODE_POS
| UCB_TS_CR_BIAS_ENA
);
134 return ucb1x00_adc_read(ts
->ucb
, UCB_ADC_INP_TSPY
, ts
->adcsync
);
138 * Switch to Y position mode and measure X plate. We switch the plate
139 * configuration in pressure mode, then switch to position mode. This
140 * gives a faster response time. Even so, we need to wait about 55us
141 * for things to stabilise.
143 static inline unsigned int ucb1x00_ts_read_ypos(struct ucb1x00_ts
*ts
)
145 if (machine_is_collie())
146 ucb1x00_io_write(ts
->ucb
, 0, COLLIE_TC35143_GPIO_TBL_CHK
);
148 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
149 UCB_TS_CR_TSMY_GND
| UCB_TS_CR_TSPY_POW
|
150 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
151 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
152 UCB_TS_CR_TSMY_GND
| UCB_TS_CR_TSPY_POW
|
153 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
156 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
157 UCB_TS_CR_TSMY_GND
| UCB_TS_CR_TSPY_POW
|
158 UCB_TS_CR_MODE_POS
| UCB_TS_CR_BIAS_ENA
);
162 return ucb1x00_adc_read(ts
->ucb
, UCB_ADC_INP_TSPX
, ts
->adcsync
);
166 * Switch to X plate resistance mode. Set MX to ground, PX to
167 * supply. Measure current.
169 static inline unsigned int ucb1x00_ts_read_xres(struct ucb1x00_ts
*ts
)
171 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
172 UCB_TS_CR_TSMX_GND
| UCB_TS_CR_TSPX_POW
|
173 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
174 return ucb1x00_adc_read(ts
->ucb
, 0, ts
->adcsync
);
178 * Switch to Y plate resistance mode. Set MY to ground, PY to
179 * supply. Measure current.
181 static inline unsigned int ucb1x00_ts_read_yres(struct ucb1x00_ts
*ts
)
183 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
184 UCB_TS_CR_TSMY_GND
| UCB_TS_CR_TSPY_POW
|
185 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
186 return ucb1x00_adc_read(ts
->ucb
, 0, ts
->adcsync
);
189 static inline int ucb1x00_ts_pen_down(struct ucb1x00_ts
*ts
)
191 unsigned int val
= ucb1x00_reg_read(ts
->ucb
, UCB_TS_CR
);
192 if (machine_is_collie())
193 return (!(val
& (UCB_TS_CR_TSPX_LOW
)));
195 return (val
& (UCB_TS_CR_TSPX_LOW
| UCB_TS_CR_TSMX_LOW
));
199 * This is a RT kernel thread that handles the ADC accesses
200 * (mainly so we can use semaphores in the UCB1200 core code
201 * to serialise accesses to the ADC).
203 static int ucb1x00_thread(void *_ts
)
205 struct ucb1x00_ts
*ts
= _ts
;
206 struct task_struct
*tsk
= current
;
207 DECLARE_WAITQUEUE(wait
, tsk
);
211 * We could run as a real-time thread. However, thus far
212 * this doesn't seem to be necessary.
214 // tsk->policy = SCHED_FIFO;
215 // tsk->rt_priority = 1;
219 add_wait_queue(&ts
->irq_wait
, &wait
);
220 while (!kthread_should_stop()) {
221 unsigned int x
, y
, p
;
226 ucb1x00_adc_enable(ts
->ucb
);
228 x
= ucb1x00_ts_read_xpos(ts
);
229 y
= ucb1x00_ts_read_ypos(ts
);
230 p
= ucb1x00_ts_read_pressure(ts
);
233 * Switch back to interrupt mode.
235 ucb1x00_ts_mode_int(ts
);
236 ucb1x00_adc_disable(ts
->ucb
);
240 ucb1x00_enable(ts
->ucb
);
243 if (ucb1x00_ts_pen_down(ts
)) {
244 set_task_state(tsk
, TASK_INTERRUPTIBLE
);
246 ucb1x00_enable_irq(ts
->ucb
, UCB_IRQ_TSPX
, machine_is_collie() ? UCB_RISING
: UCB_FALLING
);
247 ucb1x00_disable(ts
->ucb
);
250 * If we spat out a valid sample set last time,
251 * spit out a "pen off" sample here.
254 ucb1x00_ts_event_release(ts
);
258 timeout
= MAX_SCHEDULE_TIMEOUT
;
260 ucb1x00_disable(ts
->ucb
);
263 * Filtering is policy. Policy belongs in user
264 * space. We therefore leave it to user space
265 * to do any filtering they please.
268 ucb1x00_ts_evt_add(ts
, p
, x
, y
);
272 set_task_state(tsk
, TASK_INTERRUPTIBLE
);
278 schedule_timeout(timeout
);
281 remove_wait_queue(&ts
->irq_wait
, &wait
);
288 * We only detect touch screen _touches_ with this interrupt
289 * handler, and even then we just schedule our task.
291 static void ucb1x00_ts_irq(int idx
, void *id
)
293 struct ucb1x00_ts
*ts
= id
;
294 ucb1x00_disable_irq(ts
->ucb
, UCB_IRQ_TSPX
, UCB_FALLING
);
295 wake_up(&ts
->irq_wait
);
298 static int ucb1x00_ts_open(struct input_dev
*idev
)
300 struct ucb1x00_ts
*ts
= (struct ucb1x00_ts
*)idev
;
305 init_waitqueue_head(&ts
->irq_wait
);
306 ret
= ucb1x00_hook_irq(ts
->ucb
, UCB_IRQ_TSPX
, ucb1x00_ts_irq
, ts
);
311 * If we do this at all, we should allow the user to
312 * measure and read the X and Y resistance at any time.
314 ucb1x00_adc_enable(ts
->ucb
);
315 ts
->x_res
= ucb1x00_ts_read_xres(ts
);
316 ts
->y_res
= ucb1x00_ts_read_yres(ts
);
317 ucb1x00_adc_disable(ts
->ucb
);
319 ts
->rtask
= kthread_run(ucb1x00_thread
, ts
, "ktsd");
320 if (!IS_ERR(ts
->rtask
)) {
323 ucb1x00_free_irq(ts
->ucb
, UCB_IRQ_TSPX
, ts
);
333 * Release touchscreen resources. Disable IRQs.
335 static void ucb1x00_ts_close(struct input_dev
*idev
)
337 struct ucb1x00_ts
*ts
= (struct ucb1x00_ts
*)idev
;
340 kthread_stop(ts
->rtask
);
342 ucb1x00_enable(ts
->ucb
);
343 ucb1x00_free_irq(ts
->ucb
, UCB_IRQ_TSPX
, ts
);
344 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
, 0);
345 ucb1x00_disable(ts
->ucb
);
349 static int ucb1x00_ts_resume(struct ucb1x00_dev
*dev
)
351 struct ucb1x00_ts
*ts
= dev
->priv
;
353 if (ts
->rtask
!= NULL
) {
355 * Restart the TS thread to ensure the
356 * TS interrupt mode is set up again
360 wake_up(&ts
->irq_wait
);
365 #define ucb1x00_ts_resume NULL
372 static int ucb1x00_ts_add(struct ucb1x00_dev
*dev
)
374 struct ucb1x00_ts
*ts
;
376 ts
= kzalloc(sizeof(struct ucb1x00_ts
), GFP_KERNEL
);
380 ts
->idev
= input_allocate_device();
387 ts
->adcsync
= adcsync
? UCB_SYNC
: UCB_NOSYNC
;
389 ts
->idev
->name
= "Touchscreen panel";
390 ts
->idev
->id
.product
= ts
->ucb
->id
;
391 ts
->idev
->open
= ucb1x00_ts_open
;
392 ts
->idev
->close
= ucb1x00_ts_close
;
394 __set_bit(EV_ABS
, ts
->idev
->evbit
);
395 __set_bit(ABS_X
, ts
->idev
->absbit
);
396 __set_bit(ABS_Y
, ts
->idev
->absbit
);
397 __set_bit(ABS_PRESSURE
, ts
->idev
->absbit
);
399 input_register_device(ts
->idev
);
406 static void ucb1x00_ts_remove(struct ucb1x00_dev
*dev
)
408 struct ucb1x00_ts
*ts
= dev
->priv
;
410 input_unregister_device(ts
->idev
);
414 static struct ucb1x00_driver ucb1x00_ts_driver
= {
415 .add
= ucb1x00_ts_add
,
416 .remove
= ucb1x00_ts_remove
,
417 .resume
= ucb1x00_ts_resume
,
420 static int __init
ucb1x00_ts_init(void)
422 return ucb1x00_register_driver(&ucb1x00_ts_driver
);
425 static void __exit
ucb1x00_ts_exit(void)
427 ucb1x00_unregister_driver(&ucb1x00_ts_driver
);
430 module_param(adcsync
, int, 0444);
431 module_init(ucb1x00_ts_init
);
432 module_exit(ucb1x00_ts_exit
);
434 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
435 MODULE_DESCRIPTION("UCB1x00 touchscreen driver");
436 MODULE_LICENSE("GPL");