1 /* 2 * Touchscreen driver for UCB1x00-based touchscreens 3 * 4 * Copyright (C) 2001 Russell King, All Rights Reserved. 5 * Copyright (C) 2005 Pavel Machek 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 */ 20 #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> 31 #include <linux/suspend.h> 32 #include <linux/slab.h> 33 #include <linux/kthread.h> 34 35 #include <asm/dma.h> 36 #include <asm/semaphore.h> 37 #include <asm/arch/collie.h> 38 #include <asm/mach-types.h> 39 40 #include "ucb1x00.h" 41 42 43 struct ucb1x00_ts { 44 struct input_dev *idev; 45 struct ucb1x00 *ucb; 46 47 wait_queue_head_t irq_wait; 48 struct task_struct *rtask; 49 u16 x_res; 50 u16 y_res; 51 52 unsigned int restart:1; 53 unsigned int adcsync:1; 54 }; 55 56 static int adcsync; 57 58 static inline void ucb1x00_ts_evt_add(struct ucb1x00_ts *ts, u16 pressure, u16 x, u16 y) 59 { 60 struct input_dev *idev = ts->idev; 61 62 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); 66 } 67 68 static inline void ucb1x00_ts_event_release(struct ucb1x00_ts *ts) 69 { 70 struct input_dev *idev = ts->idev; 71 72 input_report_abs(idev, ABS_PRESSURE, 0); 73 input_sync(idev); 74 } 75 76 /* 77 * Switch to interrupt mode. 78 */ 79 static 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 */ 91 static inline unsigned int ucb1x00_ts_read_pressure(struct ucb1x00_ts *ts) 92 { 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); 98 99 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 } 110 } 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 */ 118 static inline unsigned int ucb1x00_ts_read_xpos(struct ucb1x00_ts *ts) 119 { 120 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 } 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); 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 */ 145 static inline unsigned int ucb1x00_ts_read_ypos(struct ucb1x00_ts *ts) 146 { 147 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 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); 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 */ 171 static 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 */ 183 static 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 191 static inline int ucb1x00_ts_pen_down(struct ucb1x00_ts *ts) 192 { 193 unsigned int val = ucb1x00_reg_read(ts->ucb, UCB_TS_CR); 194 195 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 201 /* 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 */ 206 static 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 213 /* 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 220 valid = 0; 221 222 add_wait_queue(&ts->irq_wait, &wait); 223 while (!kthread_should_stop()) { 224 unsigned int x, y, p; 225 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 241 msleep(10); 242 243 ucb1x00_enable(ts->ucb); 244 245 246 if (ucb1x00_ts_pen_down(ts)) { 247 set_task_state(tsk, TASK_INTERRUPTIBLE); 248 249 ucb1x00_enable_irq(ts->ucb, UCB_IRQ_TSPX, machine_is_collie() ? UCB_RISING : UCB_FALLING); 250 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); 282 } 283 284 remove_wait_queue(&ts->irq_wait, &wait); 285 286 ts->rtask = NULL; 287 return 0; 288 } 289 290 /* 291 * We only detect touch screen _touches_ with this interrupt 292 * handler, and even then we just schedule our task. 293 */ 294 static void ucb1x00_ts_irq(int idx, void *id) 295 { 296 struct ucb1x00_ts *ts = id; 297 298 ucb1x00_disable_irq(ts->ucb, UCB_IRQ_TSPX, UCB_FALLING); 299 wake_up(&ts->irq_wait); 300 } 301 302 static int ucb1x00_ts_open(struct input_dev *idev) 303 { 304 struct ucb1x00_ts *ts = idev->private; 305 int ret = 0; 306 307 BUG_ON(ts->rtask); 308 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 323 ts->rtask = kthread_run(ucb1x00_thread, ts, "ktsd"); 324 if (!IS_ERR(ts->rtask)) { 325 ret = 0; 326 } else { 327 ucb1x00_free_irq(ts->ucb, UCB_IRQ_TSPX, ts); 328 ts->rtask = NULL; 329 ret = -EFAULT; 330 } 331 332 out: 333 return ret; 334 } 335 336 /* 337 * Release touchscreen resources. Disable IRQs. 338 */ 339 static void ucb1x00_ts_close(struct input_dev *idev) 340 { 341 struct ucb1x00_ts *ts = idev->private; 342 343 if (ts->rtask) 344 kthread_stop(ts->rtask); 345 346 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); 350 } 351 352 #ifdef CONFIG_PM 353 static 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 */ 376 static int ucb1x00_ts_add(struct ucb1x00_dev *dev) 377 { 378 struct ucb1x00_ts *ts; 379 struct input_dev *idev; 380 int err; 381 382 ts = kzalloc(sizeof(struct ucb1x00_ts), GFP_KERNEL); 383 idev = input_allocate_device(); 384 if (!ts || !idev) { 385 err = -ENOMEM; 386 goto fail; 387 } 388 389 ts->ucb = dev->ucb; 390 ts->idev = idev; 391 ts->adcsync = adcsync ? UCB_SYNC : UCB_NOSYNC; 392 393 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; 398 399 __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); 403 404 err = input_register_device(idev); 405 if (err) 406 goto fail; 407 408 dev->priv = ts; 409 410 return 0; 411 412 fail: 413 input_free_device(idev); 414 kfree(ts); 415 return err; 416 } 417 418 static void ucb1x00_ts_remove(struct ucb1x00_dev *dev) 419 { 420 struct ucb1x00_ts *ts = dev->priv; 421 422 input_unregister_device(ts->idev); 423 kfree(ts); 424 } 425 426 static struct ucb1x00_driver ucb1x00_ts_driver = { 427 .add = ucb1x00_ts_add, 428 .remove = ucb1x00_ts_remove, 429 .resume = ucb1x00_ts_resume, 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"); 449