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/module.h>
21 #include <linux/moduleparam.h>
22 #include <linux/init.h>
23 #include <linux/smp.h>
24 #include <linux/sched.h>
25 #include <linux/completion.h>
26 #include <linux/delay.h>
27 #include <linux/string.h>
28 #include <linux/input.h>
29 #include <linux/device.h>
30 #include <linux/freezer.h>
31 #include <linux/slab.h>
32 #include <linux/kthread.h>
35 #include <asm/semaphore.h>
36 #include <asm/arch/collie.h>
37 #include <asm/mach-types.h>
43 struct input_dev
*idev
;
46 wait_queue_head_t irq_wait
;
47 struct task_struct
*rtask
;
51 unsigned int restart
:1;
52 unsigned int adcsync
:1;
57 static inline void ucb1x00_ts_evt_add(struct ucb1x00_ts
*ts
, u16 pressure
, u16 x
, u16 y
)
59 struct input_dev
*idev
= ts
->idev
;
61 input_report_abs(idev
, ABS_X
, x
);
62 input_report_abs(idev
, ABS_Y
, y
);
63 input_report_abs(idev
, ABS_PRESSURE
, pressure
);
67 static inline void ucb1x00_ts_event_release(struct ucb1x00_ts
*ts
)
69 struct input_dev
*idev
= ts
->idev
;
71 input_report_abs(idev
, ABS_PRESSURE
, 0);
76 * Switch to interrupt mode.
78 static inline void ucb1x00_ts_mode_int(struct ucb1x00_ts
*ts
)
80 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
81 UCB_TS_CR_TSMX_POW
| UCB_TS_CR_TSPX_POW
|
82 UCB_TS_CR_TSMY_GND
| UCB_TS_CR_TSPY_GND
|
87 * Switch to pressure mode, and read pressure. We don't need to wait
88 * here, since both plates are being driven.
90 static inline unsigned int ucb1x00_ts_read_pressure(struct ucb1x00_ts
*ts
)
92 if (machine_is_collie()) {
93 ucb1x00_io_write(ts
->ucb
, COLLIE_TC35143_GPIO_TBL_CHK
, 0);
94 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
95 UCB_TS_CR_TSPX_POW
| UCB_TS_CR_TSMX_POW
|
96 UCB_TS_CR_MODE_POS
| UCB_TS_CR_BIAS_ENA
);
100 return ucb1x00_adc_read(ts
->ucb
, UCB_ADC_INP_AD2
, ts
->adcsync
);
102 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
103 UCB_TS_CR_TSMX_POW
| UCB_TS_CR_TSPX_POW
|
104 UCB_TS_CR_TSMY_GND
| UCB_TS_CR_TSPY_GND
|
105 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
107 return ucb1x00_adc_read(ts
->ucb
, UCB_ADC_INP_TSPY
, ts
->adcsync
);
112 * Switch to X position mode and measure Y plate. We switch the plate
113 * configuration in pressure mode, then switch to position mode. This
114 * gives a faster response time. Even so, we need to wait about 55us
115 * for things to stabilise.
117 static inline unsigned int ucb1x00_ts_read_xpos(struct ucb1x00_ts
*ts
)
119 if (machine_is_collie())
120 ucb1x00_io_write(ts
->ucb
, 0, COLLIE_TC35143_GPIO_TBL_CHK
);
122 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
123 UCB_TS_CR_TSMX_GND
| UCB_TS_CR_TSPX_POW
|
124 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
125 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
126 UCB_TS_CR_TSMX_GND
| UCB_TS_CR_TSPX_POW
|
127 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
129 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
130 UCB_TS_CR_TSMX_GND
| UCB_TS_CR_TSPX_POW
|
131 UCB_TS_CR_MODE_POS
| UCB_TS_CR_BIAS_ENA
);
135 return ucb1x00_adc_read(ts
->ucb
, UCB_ADC_INP_TSPY
, ts
->adcsync
);
139 * Switch to Y position mode and measure X plate. We switch the plate
140 * configuration in pressure mode, then switch to position mode. This
141 * gives a faster response time. Even so, we need to wait about 55us
142 * for things to stabilise.
144 static inline unsigned int ucb1x00_ts_read_ypos(struct ucb1x00_ts
*ts
)
146 if (machine_is_collie())
147 ucb1x00_io_write(ts
->ucb
, 0, COLLIE_TC35143_GPIO_TBL_CHK
);
149 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
150 UCB_TS_CR_TSMY_GND
| UCB_TS_CR_TSPY_POW
|
151 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
152 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
153 UCB_TS_CR_TSMY_GND
| UCB_TS_CR_TSPY_POW
|
154 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
157 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
158 UCB_TS_CR_TSMY_GND
| UCB_TS_CR_TSPY_POW
|
159 UCB_TS_CR_MODE_POS
| UCB_TS_CR_BIAS_ENA
);
163 return ucb1x00_adc_read(ts
->ucb
, UCB_ADC_INP_TSPX
, ts
->adcsync
);
167 * Switch to X plate resistance mode. Set MX to ground, PX to
168 * supply. Measure current.
170 static inline unsigned int ucb1x00_ts_read_xres(struct ucb1x00_ts
*ts
)
172 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
173 UCB_TS_CR_TSMX_GND
| UCB_TS_CR_TSPX_POW
|
174 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
175 return ucb1x00_adc_read(ts
->ucb
, 0, ts
->adcsync
);
179 * Switch to Y plate resistance mode. Set MY to ground, PY to
180 * supply. Measure current.
182 static inline unsigned int ucb1x00_ts_read_yres(struct ucb1x00_ts
*ts
)
184 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
,
185 UCB_TS_CR_TSMY_GND
| UCB_TS_CR_TSPY_POW
|
186 UCB_TS_CR_MODE_PRES
| UCB_TS_CR_BIAS_ENA
);
187 return ucb1x00_adc_read(ts
->ucb
, 0, ts
->adcsync
);
190 static inline int ucb1x00_ts_pen_down(struct ucb1x00_ts
*ts
)
192 unsigned int val
= ucb1x00_reg_read(ts
->ucb
, UCB_TS_CR
);
194 if (machine_is_collie())
195 return (!(val
& (UCB_TS_CR_TSPX_LOW
)));
197 return (val
& (UCB_TS_CR_TSPX_LOW
| UCB_TS_CR_TSMX_LOW
));
201 * This is a RT kernel thread that handles the ADC accesses
202 * (mainly so we can use semaphores in the UCB1200 core code
203 * to serialise accesses to the ADC).
205 static int ucb1x00_thread(void *_ts
)
207 struct ucb1x00_ts
*ts
= _ts
;
208 struct task_struct
*tsk
= current
;
209 DECLARE_WAITQUEUE(wait
, tsk
);
212 add_wait_queue(&ts
->irq_wait
, &wait
);
213 while (!kthread_should_stop()) {
214 unsigned int x
, y
, p
;
219 ucb1x00_adc_enable(ts
->ucb
);
221 x
= ucb1x00_ts_read_xpos(ts
);
222 y
= ucb1x00_ts_read_ypos(ts
);
223 p
= ucb1x00_ts_read_pressure(ts
);
226 * Switch back to interrupt mode.
228 ucb1x00_ts_mode_int(ts
);
229 ucb1x00_adc_disable(ts
->ucb
);
233 ucb1x00_enable(ts
->ucb
);
236 if (ucb1x00_ts_pen_down(ts
)) {
237 set_task_state(tsk
, TASK_INTERRUPTIBLE
);
239 ucb1x00_enable_irq(ts
->ucb
, UCB_IRQ_TSPX
, machine_is_collie() ? UCB_RISING
: UCB_FALLING
);
240 ucb1x00_disable(ts
->ucb
);
243 * If we spat out a valid sample set last time,
244 * spit out a "pen off" sample here.
247 ucb1x00_ts_event_release(ts
);
251 timeout
= MAX_SCHEDULE_TIMEOUT
;
253 ucb1x00_disable(ts
->ucb
);
256 * Filtering is policy. Policy belongs in user
257 * space. We therefore leave it to user space
258 * to do any filtering they please.
261 ucb1x00_ts_evt_add(ts
, p
, x
, y
);
265 set_task_state(tsk
, TASK_INTERRUPTIBLE
);
271 schedule_timeout(timeout
);
274 remove_wait_queue(&ts
->irq_wait
, &wait
);
281 * We only detect touch screen _touches_ with this interrupt
282 * handler, and even then we just schedule our task.
284 static void ucb1x00_ts_irq(int idx
, void *id
)
286 struct ucb1x00_ts
*ts
= id
;
288 ucb1x00_disable_irq(ts
->ucb
, UCB_IRQ_TSPX
, UCB_FALLING
);
289 wake_up(&ts
->irq_wait
);
292 static int ucb1x00_ts_open(struct input_dev
*idev
)
294 struct ucb1x00_ts
*ts
= input_get_drvdata(idev
);
299 init_waitqueue_head(&ts
->irq_wait
);
300 ret
= ucb1x00_hook_irq(ts
->ucb
, UCB_IRQ_TSPX
, ucb1x00_ts_irq
, ts
);
305 * If we do this at all, we should allow the user to
306 * measure and read the X and Y resistance at any time.
308 ucb1x00_adc_enable(ts
->ucb
);
309 ts
->x_res
= ucb1x00_ts_read_xres(ts
);
310 ts
->y_res
= ucb1x00_ts_read_yres(ts
);
311 ucb1x00_adc_disable(ts
->ucb
);
313 ts
->rtask
= kthread_run(ucb1x00_thread
, ts
, "ktsd");
314 if (!IS_ERR(ts
->rtask
)) {
317 ucb1x00_free_irq(ts
->ucb
, UCB_IRQ_TSPX
, ts
);
327 * Release touchscreen resources. Disable IRQs.
329 static void ucb1x00_ts_close(struct input_dev
*idev
)
331 struct ucb1x00_ts
*ts
= input_get_drvdata(idev
);
334 kthread_stop(ts
->rtask
);
336 ucb1x00_enable(ts
->ucb
);
337 ucb1x00_free_irq(ts
->ucb
, UCB_IRQ_TSPX
, ts
);
338 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
, 0);
339 ucb1x00_disable(ts
->ucb
);
343 static int ucb1x00_ts_resume(struct ucb1x00_dev
*dev
)
345 struct ucb1x00_ts
*ts
= dev
->priv
;
347 if (ts
->rtask
!= NULL
) {
349 * Restart the TS thread to ensure the
350 * TS interrupt mode is set up again
354 wake_up(&ts
->irq_wait
);
359 #define ucb1x00_ts_resume NULL
366 static int ucb1x00_ts_add(struct ucb1x00_dev
*dev
)
368 struct ucb1x00_ts
*ts
;
369 struct input_dev
*idev
;
372 ts
= kzalloc(sizeof(struct ucb1x00_ts
), GFP_KERNEL
);
373 idev
= input_allocate_device();
381 ts
->adcsync
= adcsync
? UCB_SYNC
: UCB_NOSYNC
;
383 idev
->name
= "Touchscreen panel";
384 idev
->id
.product
= ts
->ucb
->id
;
385 idev
->open
= ucb1x00_ts_open
;
386 idev
->close
= ucb1x00_ts_close
;
388 __set_bit(EV_ABS
, idev
->evbit
);
389 __set_bit(ABS_X
, idev
->absbit
);
390 __set_bit(ABS_Y
, idev
->absbit
);
391 __set_bit(ABS_PRESSURE
, idev
->absbit
);
393 input_set_drvdata(idev
, ts
);
395 err
= input_register_device(idev
);
404 input_free_device(idev
);
409 static void ucb1x00_ts_remove(struct ucb1x00_dev
*dev
)
411 struct ucb1x00_ts
*ts
= dev
->priv
;
413 input_unregister_device(ts
->idev
);
417 static struct ucb1x00_driver ucb1x00_ts_driver
= {
418 .add
= ucb1x00_ts_add
,
419 .remove
= ucb1x00_ts_remove
,
420 .resume
= ucb1x00_ts_resume
,
423 static int __init
ucb1x00_ts_init(void)
425 return ucb1x00_register_driver(&ucb1x00_ts_driver
);
428 static void __exit
ucb1x00_ts_exit(void)
430 ucb1x00_unregister_driver(&ucb1x00_ts_driver
);
433 module_param(adcsync
, int, 0444);
434 module_init(ucb1x00_ts_init
);
435 module_exit(ucb1x00_ts_exit
);
437 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>");
438 MODULE_DESCRIPTION("UCB1x00 touchscreen driver");
439 MODULE_LICENSE("GPL");