Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 1 | /* |
Pavel Machek | 5437775 | 2005-09-11 10:28:00 +0100 | [diff] [blame] | 2 | * Touchscreen driver for UCB1x00-based touchscreens |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 3 | * |
| 4 | * Copyright (C) 2001 Russell King, All Rights Reserved. |
Pavel Machek | 5437775 | 2005-09-11 10:28:00 +0100 | [diff] [blame] | 5 | * Copyright (C) 2005 Pavel Machek |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 6 | * |
| 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 King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 20 | #include <linux/module.h> |
| 21 | #include <linux/moduleparam.h> |
| 22 | #include <linux/init.h> |
Russell King | a336440 | 2012-01-21 14:58:28 +0000 | [diff] [blame^] | 23 | #include <linux/interrupt.h> |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 24 | #include <linux/sched.h> |
Russell King | a336440 | 2012-01-21 14:58:28 +0000 | [diff] [blame^] | 25 | #include <linux/spinlock.h> |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 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 Cunningham | 7dfb710 | 2006-12-06 20:34:23 -0800 | [diff] [blame] | 31 | #include <linux/freezer.h> |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 32 | #include <linux/slab.h> |
Pavel Machek | 5437775 | 2005-09-11 10:28:00 +0100 | [diff] [blame] | 33 | #include <linux/kthread.h> |
Thomas Kunze | c8602ed | 2009-02-10 14:54:57 +0100 | [diff] [blame] | 34 | #include <linux/mfd/ucb1x00.h> |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 35 | |
Russell King | a09e64f | 2008-08-05 16:14:15 +0100 | [diff] [blame] | 36 | #include <mach/collie.h> |
Pavel Machek | 1753298 | 2005-10-30 23:38:01 +0000 | [diff] [blame] | 37 | #include <asm/mach-types.h> |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 38 | |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 39 | |
| 40 | |
| 41 | struct ucb1x00_ts { |
Dmitry Torokhov | bd62266 | 2005-09-15 02:01:48 -0500 | [diff] [blame] | 42 | struct input_dev *idev; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 43 | struct ucb1x00 *ucb; |
| 44 | |
Russell King | a336440 | 2012-01-21 14:58:28 +0000 | [diff] [blame^] | 45 | spinlock_t irq_lock; |
| 46 | unsigned irq_disabled; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 47 | wait_queue_head_t irq_wait; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 48 | struct task_struct *rtask; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 49 | u16 x_res; |
| 50 | u16 y_res; |
| 51 | |
Russell King | 6b9ea42 | 2005-09-24 10:24:37 +0100 | [diff] [blame] | 52 | unsigned int adcsync:1; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 53 | }; |
| 54 | |
| 55 | static int adcsync; |
| 56 | |
| 57 | static inline void ucb1x00_ts_evt_add(struct ucb1x00_ts *ts, u16 pressure, u16 x, u16 y) |
| 58 | { |
Nicolas Pitre | 1393c3e | 2005-12-12 00:37:36 -0800 | [diff] [blame] | 59 | struct input_dev *idev = ts->idev; |
Dmitry Torokhov | 08c67d2 | 2006-09-29 01:59:52 -0700 | [diff] [blame] | 60 | |
Nicolas Pitre | 1393c3e | 2005-12-12 00:37:36 -0800 | [diff] [blame] | 61 | input_report_abs(idev, ABS_X, x); |
| 62 | input_report_abs(idev, ABS_Y, y); |
| 63 | input_report_abs(idev, ABS_PRESSURE, pressure); |
Jochen Friedrich | de8c8b0 | 2011-01-30 13:40:56 +0100 | [diff] [blame] | 64 | input_report_key(idev, BTN_TOUCH, 1); |
Nicolas Pitre | 1393c3e | 2005-12-12 00:37:36 -0800 | [diff] [blame] | 65 | input_sync(idev); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 66 | } |
| 67 | |
| 68 | static inline void ucb1x00_ts_event_release(struct ucb1x00_ts *ts) |
| 69 | { |
Nicolas Pitre | 1393c3e | 2005-12-12 00:37:36 -0800 | [diff] [blame] | 70 | struct input_dev *idev = ts->idev; |
Dmitry Torokhov | 08c67d2 | 2006-09-29 01:59:52 -0700 | [diff] [blame] | 71 | |
Nicolas Pitre | 1393c3e | 2005-12-12 00:37:36 -0800 | [diff] [blame] | 72 | input_report_abs(idev, ABS_PRESSURE, 0); |
Jochen Friedrich | de8c8b0 | 2011-01-30 13:40:56 +0100 | [diff] [blame] | 73 | input_report_key(idev, BTN_TOUCH, 0); |
Nicolas Pitre | 1393c3e | 2005-12-12 00:37:36 -0800 | [diff] [blame] | 74 | input_sync(idev); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 75 | } |
| 76 | |
| 77 | /* |
| 78 | * Switch to interrupt mode. |
| 79 | */ |
| 80 | static inline void ucb1x00_ts_mode_int(struct ucb1x00_ts *ts) |
| 81 | { |
| 82 | ucb1x00_reg_write(ts->ucb, UCB_TS_CR, |
| 83 | UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW | |
| 84 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND | |
| 85 | UCB_TS_CR_MODE_INT); |
| 86 | } |
| 87 | |
| 88 | /* |
| 89 | * Switch to pressure mode, and read pressure. We don't need to wait |
| 90 | * here, since both plates are being driven. |
| 91 | */ |
| 92 | static inline unsigned int ucb1x00_ts_read_pressure(struct ucb1x00_ts *ts) |
| 93 | { |
Pavel Machek | 1753298 | 2005-10-30 23:38:01 +0000 | [diff] [blame] | 94 | if (machine_is_collie()) { |
| 95 | ucb1x00_io_write(ts->ucb, COLLIE_TC35143_GPIO_TBL_CHK, 0); |
| 96 | ucb1x00_reg_write(ts->ucb, UCB_TS_CR, |
| 97 | UCB_TS_CR_TSPX_POW | UCB_TS_CR_TSMX_POW | |
| 98 | UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 99 | |
Pavel Machek | 1753298 | 2005-10-30 23:38:01 +0000 | [diff] [blame] | 100 | udelay(55); |
| 101 | |
| 102 | return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_AD2, ts->adcsync); |
| 103 | } else { |
| 104 | ucb1x00_reg_write(ts->ucb, UCB_TS_CR, |
| 105 | UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW | |
| 106 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND | |
| 107 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
| 108 | |
| 109 | return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync); |
| 110 | } |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 111 | } |
| 112 | |
| 113 | /* |
| 114 | * Switch to X position mode and measure Y plate. We switch the plate |
| 115 | * configuration in pressure mode, then switch to position mode. This |
| 116 | * gives a faster response time. Even so, we need to wait about 55us |
| 117 | * for things to stabilise. |
| 118 | */ |
| 119 | static inline unsigned int ucb1x00_ts_read_xpos(struct ucb1x00_ts *ts) |
| 120 | { |
Pavel Machek | 1753298 | 2005-10-30 23:38:01 +0000 | [diff] [blame] | 121 | if (machine_is_collie()) |
| 122 | ucb1x00_io_write(ts->ucb, 0, COLLIE_TC35143_GPIO_TBL_CHK); |
| 123 | else { |
| 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); |
| 127 | ucb1x00_reg_write(ts->ucb, UCB_TS_CR, |
| 128 | UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | |
| 129 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
| 130 | } |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 131 | ucb1x00_reg_write(ts->ucb, UCB_TS_CR, |
| 132 | UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | |
| 133 | UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA); |
| 134 | |
| 135 | udelay(55); |
| 136 | |
| 137 | return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync); |
| 138 | } |
| 139 | |
| 140 | /* |
| 141 | * Switch to Y position mode and measure X plate. We switch the plate |
| 142 | * configuration in pressure mode, then switch to position mode. This |
| 143 | * gives a faster response time. Even so, we need to wait about 55us |
| 144 | * for things to stabilise. |
| 145 | */ |
| 146 | static inline unsigned int ucb1x00_ts_read_ypos(struct ucb1x00_ts *ts) |
| 147 | { |
Pavel Machek | 1753298 | 2005-10-30 23:38:01 +0000 | [diff] [blame] | 148 | if (machine_is_collie()) |
| 149 | ucb1x00_io_write(ts->ucb, 0, COLLIE_TC35143_GPIO_TBL_CHK); |
| 150 | else { |
| 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); |
| 154 | ucb1x00_reg_write(ts->ucb, UCB_TS_CR, |
| 155 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | |
| 156 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
| 157 | } |
| 158 | |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 159 | ucb1x00_reg_write(ts->ucb, UCB_TS_CR, |
| 160 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | |
| 161 | UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA); |
| 162 | |
| 163 | udelay(55); |
| 164 | |
| 165 | return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPX, ts->adcsync); |
| 166 | } |
| 167 | |
| 168 | /* |
| 169 | * Switch to X plate resistance mode. Set MX to ground, PX to |
| 170 | * supply. Measure current. |
| 171 | */ |
| 172 | static inline unsigned int ucb1x00_ts_read_xres(struct ucb1x00_ts *ts) |
| 173 | { |
| 174 | ucb1x00_reg_write(ts->ucb, UCB_TS_CR, |
| 175 | UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | |
| 176 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
| 177 | return ucb1x00_adc_read(ts->ucb, 0, ts->adcsync); |
| 178 | } |
| 179 | |
| 180 | /* |
| 181 | * Switch to Y plate resistance mode. Set MY to ground, PY to |
| 182 | * supply. Measure current. |
| 183 | */ |
| 184 | static inline unsigned int ucb1x00_ts_read_yres(struct ucb1x00_ts *ts) |
| 185 | { |
| 186 | ucb1x00_reg_write(ts->ucb, UCB_TS_CR, |
| 187 | UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | |
| 188 | UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); |
| 189 | return ucb1x00_adc_read(ts->ucb, 0, ts->adcsync); |
| 190 | } |
| 191 | |
Pavel Machek | 1753298 | 2005-10-30 23:38:01 +0000 | [diff] [blame] | 192 | static inline int ucb1x00_ts_pen_down(struct ucb1x00_ts *ts) |
| 193 | { |
| 194 | unsigned int val = ucb1x00_reg_read(ts->ucb, UCB_TS_CR); |
Dmitry Torokhov | 08c67d2 | 2006-09-29 01:59:52 -0700 | [diff] [blame] | 195 | |
Pavel Machek | 1753298 | 2005-10-30 23:38:01 +0000 | [diff] [blame] | 196 | if (machine_is_collie()) |
| 197 | return (!(val & (UCB_TS_CR_TSPX_LOW))); |
| 198 | else |
| 199 | return (val & (UCB_TS_CR_TSPX_LOW | UCB_TS_CR_TSMX_LOW)); |
| 200 | } |
| 201 | |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 202 | /* |
| 203 | * This is a RT kernel thread that handles the ADC accesses |
| 204 | * (mainly so we can use semaphores in the UCB1200 core code |
| 205 | * to serialise accesses to the ADC). |
| 206 | */ |
| 207 | static int ucb1x00_thread(void *_ts) |
| 208 | { |
| 209 | struct ucb1x00_ts *ts = _ts; |
Robert P. J. Day | f7440b0 | 2008-04-28 02:14:24 -0700 | [diff] [blame] | 210 | DECLARE_WAITQUEUE(wait, current); |
Russell King | 0af5e4c | 2012-01-22 20:58:55 +0000 | [diff] [blame] | 211 | bool frozen, ignore = false; |
Dmitry Torokhov | 1124d5c | 2007-05-14 23:52:22 -0400 | [diff] [blame] | 212 | int valid = 0; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 213 | |
Rafael J. Wysocki | 8314418 | 2007-07-17 04:03:35 -0700 | [diff] [blame] | 214 | set_freezable(); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 215 | add_wait_queue(&ts->irq_wait, &wait); |
Russell King | 0af5e4c | 2012-01-22 20:58:55 +0000 | [diff] [blame] | 216 | while (!kthread_freezable_should_stop(&frozen)) { |
Pavel Machek | 1753298 | 2005-10-30 23:38:01 +0000 | [diff] [blame] | 217 | unsigned int x, y, p; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 218 | signed long timeout; |
| 219 | |
Russell King | 0af5e4c | 2012-01-22 20:58:55 +0000 | [diff] [blame] | 220 | if (frozen) |
| 221 | ignore = true; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 222 | |
| 223 | ucb1x00_adc_enable(ts->ucb); |
| 224 | |
| 225 | x = ucb1x00_ts_read_xpos(ts); |
| 226 | y = ucb1x00_ts_read_ypos(ts); |
| 227 | p = ucb1x00_ts_read_pressure(ts); |
| 228 | |
| 229 | /* |
| 230 | * Switch back to interrupt mode. |
| 231 | */ |
| 232 | ucb1x00_ts_mode_int(ts); |
| 233 | ucb1x00_adc_disable(ts->ucb); |
| 234 | |
Pavel Machek | 5437775 | 2005-09-11 10:28:00 +0100 | [diff] [blame] | 235 | msleep(10); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 236 | |
| 237 | ucb1x00_enable(ts->ucb); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 238 | |
Pavel Machek | 1753298 | 2005-10-30 23:38:01 +0000 | [diff] [blame] | 239 | |
| 240 | if (ucb1x00_ts_pen_down(ts)) { |
Robert P. J. Day | f7440b0 | 2008-04-28 02:14:24 -0700 | [diff] [blame] | 241 | set_current_state(TASK_INTERRUPTIBLE); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 242 | |
Russell King | a336440 | 2012-01-21 14:58:28 +0000 | [diff] [blame^] | 243 | spin_lock_irq(&ts->irq_lock); |
| 244 | if (ts->irq_disabled) { |
| 245 | ts->irq_disabled = 0; |
| 246 | enable_irq(ts->ucb->irq_base + UCB_IRQ_TSPX); |
| 247 | } |
| 248 | spin_unlock_irq(&ts->irq_lock); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 249 | ucb1x00_disable(ts->ucb); |
| 250 | |
| 251 | /* |
| 252 | * If we spat out a valid sample set last time, |
| 253 | * spit out a "pen off" sample here. |
| 254 | */ |
| 255 | if (valid) { |
| 256 | ucb1x00_ts_event_release(ts); |
| 257 | valid = 0; |
| 258 | } |
| 259 | |
| 260 | timeout = MAX_SCHEDULE_TIMEOUT; |
| 261 | } else { |
| 262 | ucb1x00_disable(ts->ucb); |
| 263 | |
| 264 | /* |
| 265 | * Filtering is policy. Policy belongs in user |
| 266 | * space. We therefore leave it to user space |
| 267 | * to do any filtering they please. |
| 268 | */ |
Russell King | 0af5e4c | 2012-01-22 20:58:55 +0000 | [diff] [blame] | 269 | if (!ignore) { |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 270 | ucb1x00_ts_evt_add(ts, p, x, y); |
| 271 | valid = 1; |
| 272 | } |
| 273 | |
Robert P. J. Day | f7440b0 | 2008-04-28 02:14:24 -0700 | [diff] [blame] | 274 | set_current_state(TASK_INTERRUPTIBLE); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 275 | timeout = HZ / 100; |
| 276 | } |
| 277 | |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 278 | schedule_timeout(timeout); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 279 | } |
| 280 | |
| 281 | remove_wait_queue(&ts->irq_wait, &wait); |
| 282 | |
| 283 | ts->rtask = NULL; |
Pavel Machek | 5437775 | 2005-09-11 10:28:00 +0100 | [diff] [blame] | 284 | return 0; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 285 | } |
| 286 | |
| 287 | /* |
| 288 | * We only detect touch screen _touches_ with this interrupt |
| 289 | * handler, and even then we just schedule our task. |
| 290 | */ |
Russell King | a336440 | 2012-01-21 14:58:28 +0000 | [diff] [blame^] | 291 | static irqreturn_t ucb1x00_ts_irq(int irq, void *id) |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 292 | { |
| 293 | struct ucb1x00_ts *ts = id; |
Dmitry Torokhov | 08c67d2 | 2006-09-29 01:59:52 -0700 | [diff] [blame] | 294 | |
Russell King | a336440 | 2012-01-21 14:58:28 +0000 | [diff] [blame^] | 295 | spin_lock(&ts->irq_lock); |
| 296 | ts->irq_disabled = 1; |
| 297 | disable_irq_nosync(ts->ucb->irq_base + UCB_IRQ_TSPX); |
| 298 | spin_unlock(&ts->irq_lock); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 299 | wake_up(&ts->irq_wait); |
Russell King | a336440 | 2012-01-21 14:58:28 +0000 | [diff] [blame^] | 300 | |
| 301 | return IRQ_HANDLED; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 302 | } |
| 303 | |
| 304 | static int ucb1x00_ts_open(struct input_dev *idev) |
| 305 | { |
Dmitry Torokhov | 26be5a5 | 2007-05-11 01:16:12 -0400 | [diff] [blame] | 306 | struct ucb1x00_ts *ts = input_get_drvdata(idev); |
Russell King | a336440 | 2012-01-21 14:58:28 +0000 | [diff] [blame^] | 307 | unsigned long flags = 0; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 308 | int ret = 0; |
| 309 | |
Pavel Machek | 5437775 | 2005-09-11 10:28:00 +0100 | [diff] [blame] | 310 | BUG_ON(ts->rtask); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 311 | |
Russell King | a336440 | 2012-01-21 14:58:28 +0000 | [diff] [blame^] | 312 | if (machine_is_collie()) |
| 313 | flags = IRQF_TRIGGER_RISING; |
| 314 | else |
| 315 | flags = IRQF_TRIGGER_FALLING; |
| 316 | |
| 317 | ts->irq_disabled = 0; |
| 318 | |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 319 | init_waitqueue_head(&ts->irq_wait); |
Russell King | a336440 | 2012-01-21 14:58:28 +0000 | [diff] [blame^] | 320 | ret = request_irq(ts->ucb->irq_base + UCB_IRQ_TSPX, ucb1x00_ts_irq, |
| 321 | flags, "ucb1x00-ts", ts); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 322 | if (ret < 0) |
| 323 | goto out; |
| 324 | |
| 325 | /* |
| 326 | * If we do this at all, we should allow the user to |
| 327 | * measure and read the X and Y resistance at any time. |
| 328 | */ |
| 329 | ucb1x00_adc_enable(ts->ucb); |
| 330 | ts->x_res = ucb1x00_ts_read_xres(ts); |
| 331 | ts->y_res = ucb1x00_ts_read_yres(ts); |
| 332 | ucb1x00_adc_disable(ts->ucb); |
| 333 | |
Pavel Machek | 5437775 | 2005-09-11 10:28:00 +0100 | [diff] [blame] | 334 | ts->rtask = kthread_run(ucb1x00_thread, ts, "ktsd"); |
| 335 | if (!IS_ERR(ts->rtask)) { |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 336 | ret = 0; |
| 337 | } else { |
Russell King | a336440 | 2012-01-21 14:58:28 +0000 | [diff] [blame^] | 338 | free_irq(ts->ucb->irq_base + UCB_IRQ_TSPX, ts); |
Pavel Machek | 5437775 | 2005-09-11 10:28:00 +0100 | [diff] [blame] | 339 | ts->rtask = NULL; |
| 340 | ret = -EFAULT; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 341 | } |
| 342 | |
| 343 | out: |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 344 | return ret; |
| 345 | } |
| 346 | |
| 347 | /* |
| 348 | * Release touchscreen resources. Disable IRQs. |
| 349 | */ |
| 350 | static void ucb1x00_ts_close(struct input_dev *idev) |
| 351 | { |
Dmitry Torokhov | 26be5a5 | 2007-05-11 01:16:12 -0400 | [diff] [blame] | 352 | struct ucb1x00_ts *ts = input_get_drvdata(idev); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 353 | |
Pavel Machek | 5437775 | 2005-09-11 10:28:00 +0100 | [diff] [blame] | 354 | if (ts->rtask) |
| 355 | kthread_stop(ts->rtask); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 356 | |
Pavel Machek | 5437775 | 2005-09-11 10:28:00 +0100 | [diff] [blame] | 357 | ucb1x00_enable(ts->ucb); |
Russell King | a336440 | 2012-01-21 14:58:28 +0000 | [diff] [blame^] | 358 | free_irq(ts->ucb->irq_base + UCB_IRQ_TSPX, ts); |
Pavel Machek | 5437775 | 2005-09-11 10:28:00 +0100 | [diff] [blame] | 359 | ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 0); |
| 360 | ucb1x00_disable(ts->ucb); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 361 | } |
| 362 | |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 363 | |
| 364 | /* |
| 365 | * Initialisation. |
| 366 | */ |
| 367 | static int ucb1x00_ts_add(struct ucb1x00_dev *dev) |
| 368 | { |
| 369 | struct ucb1x00_ts *ts; |
Dmitry Torokhov | 08c67d2 | 2006-09-29 01:59:52 -0700 | [diff] [blame] | 370 | struct input_dev *idev; |
| 371 | int err; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 372 | |
Dmitry Torokhov | bd62266 | 2005-09-15 02:01:48 -0500 | [diff] [blame] | 373 | ts = kzalloc(sizeof(struct ucb1x00_ts), GFP_KERNEL); |
Dmitry Torokhov | 08c67d2 | 2006-09-29 01:59:52 -0700 | [diff] [blame] | 374 | idev = input_allocate_device(); |
| 375 | if (!ts || !idev) { |
| 376 | err = -ENOMEM; |
| 377 | goto fail; |
Dmitry Torokhov | bd62266 | 2005-09-15 02:01:48 -0500 | [diff] [blame] | 378 | } |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 379 | |
| 380 | ts->ucb = dev->ucb; |
Dmitry Torokhov | 08c67d2 | 2006-09-29 01:59:52 -0700 | [diff] [blame] | 381 | ts->idev = idev; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 382 | ts->adcsync = adcsync ? UCB_SYNC : UCB_NOSYNC; |
Russell King | a336440 | 2012-01-21 14:58:28 +0000 | [diff] [blame^] | 383 | spin_lock_init(&ts->irq_lock); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 384 | |
Dmitry Torokhov | 08c67d2 | 2006-09-29 01:59:52 -0700 | [diff] [blame] | 385 | idev->name = "Touchscreen panel"; |
Russell King | 65f2e75 | 2012-01-20 17:38:58 +0000 | [diff] [blame] | 386 | idev->id.product = ts->ucb->id; |
Dmitry Torokhov | 08c67d2 | 2006-09-29 01:59:52 -0700 | [diff] [blame] | 387 | idev->open = ucb1x00_ts_open; |
| 388 | idev->close = ucb1x00_ts_close; |
Russell King | 945f631 | 2012-01-21 09:30:27 +0000 | [diff] [blame] | 389 | idev->dev.parent = &ts->ucb->dev; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 390 | |
Jochen Friedrich | de8c8b0 | 2011-01-30 13:40:56 +0100 | [diff] [blame] | 391 | idev->evbit[0] = BIT_MASK(EV_ABS) | BIT_MASK(EV_KEY); |
| 392 | idev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 393 | |
Dmitry Torokhov | 26be5a5 | 2007-05-11 01:16:12 -0400 | [diff] [blame] | 394 | input_set_drvdata(idev, ts); |
| 395 | |
Jochen Friedrich | 9063f1f | 2011-01-26 11:30:01 +0100 | [diff] [blame] | 396 | ucb1x00_adc_enable(ts->ucb); |
| 397 | ts->x_res = ucb1x00_ts_read_xres(ts); |
| 398 | ts->y_res = ucb1x00_ts_read_yres(ts); |
| 399 | ucb1x00_adc_disable(ts->ucb); |
| 400 | |
| 401 | input_set_abs_params(idev, ABS_X, 0, ts->x_res, 0, 0); |
| 402 | input_set_abs_params(idev, ABS_Y, 0, ts->y_res, 0, 0); |
| 403 | input_set_abs_params(idev, ABS_PRESSURE, 0, 0, 0, 0); |
| 404 | |
Dmitry Torokhov | 08c67d2 | 2006-09-29 01:59:52 -0700 | [diff] [blame] | 405 | err = input_register_device(idev); |
| 406 | if (err) |
| 407 | goto fail; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 408 | |
| 409 | dev->priv = ts; |
| 410 | |
| 411 | return 0; |
Dmitry Torokhov | 08c67d2 | 2006-09-29 01:59:52 -0700 | [diff] [blame] | 412 | |
| 413 | fail: |
| 414 | input_free_device(idev); |
| 415 | kfree(ts); |
| 416 | return err; |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 417 | } |
| 418 | |
| 419 | static void ucb1x00_ts_remove(struct ucb1x00_dev *dev) |
| 420 | { |
| 421 | struct ucb1x00_ts *ts = dev->priv; |
Dmitry Torokhov | bd62266 | 2005-09-15 02:01:48 -0500 | [diff] [blame] | 422 | |
| 423 | input_unregister_device(ts->idev); |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 424 | kfree(ts); |
| 425 | } |
| 426 | |
| 427 | static struct ucb1x00_driver ucb1x00_ts_driver = { |
| 428 | .add = ucb1x00_ts_add, |
| 429 | .remove = ucb1x00_ts_remove, |
Russell King | acb4543 | 2005-09-11 10:26:57 +0100 | [diff] [blame] | 430 | }; |
| 431 | |
| 432 | static int __init ucb1x00_ts_init(void) |
| 433 | { |
| 434 | return ucb1x00_register_driver(&ucb1x00_ts_driver); |
| 435 | } |
| 436 | |
| 437 | static void __exit ucb1x00_ts_exit(void) |
| 438 | { |
| 439 | ucb1x00_unregister_driver(&ucb1x00_ts_driver); |
| 440 | } |
| 441 | |
| 442 | module_param(adcsync, int, 0444); |
| 443 | module_init(ucb1x00_ts_init); |
| 444 | module_exit(ucb1x00_ts_exit); |
| 445 | |
| 446 | MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>"); |
| 447 | MODULE_DESCRIPTION("UCB1x00 touchscreen driver"); |
| 448 | MODULE_LICENSE("GPL"); |