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 struct input_dev
*idev
= ts
->idev
;
63 input_report_abs(idev
, ABS_X
, x
);
64 input_report_abs(idev
, ABS_Y
, y
);
65 input_report_abs(idev
, ABS_PRESSURE
, pressure
);
69 static inline void ucb1x00_ts_event_release(struct ucb1x00_ts
*ts
)
71 struct input_dev
*idev
= ts
->idev
;
72 input_report_abs(idev
, ABS_PRESSURE
, 0);
77 * Switch to interrupt mode.
79 static inline void ucb1x00_ts_mode_int(struct ucb1x00_ts
*ts
)
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
|
88 * Switch to pressure mode, and read pressure. We don't need to wait
89 * here, since both plates are being driven.
91 static inline unsigned int ucb1x00_ts_read_pressure(struct ucb1x00_ts
*ts
)
93 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
);
101 return ucb1x00_adc_read(ts
->ucb
, UCB_ADC_INP_AD2
, ts
->adcsync
);
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
);
108 return ucb1x00_adc_read(ts
->ucb
, UCB_ADC_INP_TSPY
, ts
->adcsync
);
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.
118 static inline unsigned int ucb1x00_ts_read_xpos(struct ucb1x00_ts
*ts
)
120 if (machine_is_collie())
121 ucb1x00_io_write(ts
->ucb
, 0, COLLIE_TC35143_GPIO_TBL_CHK
);
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
);
130 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
);
136 return ucb1x00_adc_read(ts
->ucb
, UCB_ADC_INP_TSPY
, ts
->adcsync
);
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.
145 static inline unsigned int ucb1x00_ts_read_ypos(struct ucb1x00_ts
*ts
)
147 if (machine_is_collie())
148 ucb1x00_io_write(ts
->ucb
, 0, COLLIE_TC35143_GPIO_TBL_CHK
);
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
);
158 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
);
164 return ucb1x00_adc_read(ts
->ucb
, UCB_ADC_INP_TSPX
, ts
->adcsync
);
168 * Switch to X plate resistance mode. Set MX to ground, PX to
169 * supply. Measure current.
171 static inline unsigned int ucb1x00_ts_read_xres(struct ucb1x00_ts
*ts
)
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
);
180 * Switch to Y plate resistance mode. Set MY to ground, PY to
181 * supply. Measure current.
183 static inline unsigned int ucb1x00_ts_read_yres(struct ucb1x00_ts
*ts
)
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
);
191 static inline int ucb1x00_ts_pen_down(struct ucb1x00_ts
*ts
)
193 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
);
213 * We could run as a real-time thread. However, thus far
214 * this doesn't seem to be necessary.
216 // tsk->policy = SCHED_FIFO;
217 // tsk->rt_priority = 1;
221 add_wait_queue(&ts
->irq_wait
, &wait
);
222 while (!kthread_should_stop()) {
223 unsigned int x
, y
, p
;
228 ucb1x00_adc_enable(ts
->ucb
);
230 x
= ucb1x00_ts_read_xpos(ts
);
231 y
= ucb1x00_ts_read_ypos(ts
);
232 p
= ucb1x00_ts_read_pressure(ts
);
235 * Switch back to interrupt mode.
237 ucb1x00_ts_mode_int(ts
);
238 ucb1x00_adc_disable(ts
->ucb
);
242 ucb1x00_enable(ts
->ucb
);
245 if (ucb1x00_ts_pen_down(ts
)) {
246 set_task_state(tsk
, TASK_INTERRUPTIBLE
);
248 ucb1x00_enable_irq(ts
->ucb
, UCB_IRQ_TSPX
, machine_is_collie() ? UCB_RISING
: UCB_FALLING
);
249 ucb1x00_disable(ts
->ucb
);
252 * If we spat out a valid sample set last time,
253 * spit out a "pen off" sample here.
256 ucb1x00_ts_event_release(ts
);
260 timeout
= MAX_SCHEDULE_TIMEOUT
;
262 ucb1x00_disable(ts
->ucb
);
265 * Filtering is policy. Policy belongs in user
266 * space. We therefore leave it to user space
267 * to do any filtering they please.
270 ucb1x00_ts_evt_add(ts
, p
, x
, y
);
274 set_task_state(tsk
, TASK_INTERRUPTIBLE
);
280 schedule_timeout(timeout
);
283 remove_wait_queue(&ts
->irq_wait
, &wait
);
290 * We only detect touch screen _touches_ with this interrupt
291 * handler, and even then we just schedule our task.
293 static void ucb1x00_ts_irq(int idx
, void *id
)
295 struct ucb1x00_ts
*ts
= id
;
296 ucb1x00_disable_irq(ts
->ucb
, UCB_IRQ_TSPX
, UCB_FALLING
);
297 wake_up(&ts
->irq_wait
);
300 static int ucb1x00_ts_open(struct input_dev
*idev
)
302 struct ucb1x00_ts
*ts
= idev
->private;
307 init_waitqueue_head(&ts
->irq_wait
);
308 ret
= ucb1x00_hook_irq(ts
->ucb
, UCB_IRQ_TSPX
, ucb1x00_ts_irq
, ts
);
313 * If we do this at all, we should allow the user to
314 * measure and read the X and Y resistance at any time.
316 ucb1x00_adc_enable(ts
->ucb
);
317 ts
->x_res
= ucb1x00_ts_read_xres(ts
);
318 ts
->y_res
= ucb1x00_ts_read_yres(ts
);
319 ucb1x00_adc_disable(ts
->ucb
);
321 ts
->rtask
= kthread_run(ucb1x00_thread
, ts
, "ktsd");
322 if (!IS_ERR(ts
->rtask
)) {
325 ucb1x00_free_irq(ts
->ucb
, UCB_IRQ_TSPX
, ts
);
335 * Release touchscreen resources. Disable IRQs.
337 static void ucb1x00_ts_close(struct input_dev
*idev
)
339 struct ucb1x00_ts
*ts
= idev
->private;
342 kthread_stop(ts
->rtask
);
344 ucb1x00_enable(ts
->ucb
);
345 ucb1x00_free_irq(ts
->ucb
, UCB_IRQ_TSPX
, ts
);
346 ucb1x00_reg_write(ts
->ucb
, UCB_TS_CR
, 0);
347 ucb1x00_disable(ts
->ucb
);
351 static int ucb1x00_ts_resume(struct ucb1x00_dev
*dev
)
353 struct ucb1x00_ts
*ts
= dev
->priv
;
355 if (ts
->rtask
!= NULL
) {
357 * Restart the TS thread to ensure the
358 * TS interrupt mode is set up again
362 wake_up(&ts
->irq_wait
);
367 #define ucb1x00_ts_resume NULL
374 static int ucb1x00_ts_add(struct ucb1x00_dev
*dev
)
376 struct ucb1x00_ts
*ts
;
378 ts
= kzalloc(sizeof(struct ucb1x00_ts
), GFP_KERNEL
);
382 ts
->idev
= input_allocate_device();
389 ts
->adcsync
= adcsync
? UCB_SYNC
: UCB_NOSYNC
;
391 ts
->idev
->private = ts
;
392 ts
->idev
->name
= "Touchscreen panel";
393 ts
->idev
->id
.product
= ts
->ucb
->id
;
394 ts
->idev
->open
= ucb1x00_ts_open
;
395 ts
->idev
->close
= ucb1x00_ts_close
;
397 __set_bit(EV_ABS
, ts
->idev
->evbit
);
398 __set_bit(ABS_X
, ts
->idev
->absbit
);
399 __set_bit(ABS_Y
, ts
->idev
->absbit
);
400 __set_bit(ABS_PRESSURE
, ts
->idev
->absbit
);
402 input_register_device(ts
->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");