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/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 36 #include <asm/dma.h> 37 #include <asm/semaphore.h> 38 #include <asm/arch/collie.h> 39 #include <asm/mach-types.h> 40 41 #include "ucb1x00.h" 42 43 44 struct ucb1x00_ts { 45 struct input_dev *idev; 46 struct ucb1x00 *ucb; 47 48 wait_queue_head_t irq_wait; 49 struct task_struct *rtask; 50 u16 x_res; 51 u16 y_res; 52 53 unsigned int restart:1; 54 unsigned int adcsync:1; 55 }; 56 57 static int adcsync; 58 59 static inline void ucb1x00_ts_evt_add(struct ucb1x00_ts *ts, u16 pressure, u16 x, u16 y) 60 { 61 struct input_dev *idev = ts->idev; 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 input_report_abs(idev, ABS_PRESSURE, 0); 72 input_sync(idev); 73 } 74 75 /* 76 * Switch to interrupt mode. 77 */ 78 static inline void ucb1x00_ts_mode_int(struct ucb1x00_ts *ts) 79 { 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 | 83 UCB_TS_CR_MODE_INT); 84 } 85 86 /* 87 * Switch to pressure mode, and read pressure. We don't need to wait 88 * here, since both plates are being driven. 89 */ 90 static inline unsigned int ucb1x00_ts_read_pressure(struct ucb1x00_ts *ts) 91 { 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); 97 98 udelay(55); 99 100 return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_AD2, ts->adcsync); 101 } else { 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); 106 107 return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync); 108 } 109 } 110 111 /* 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. 116 */ 117 static inline unsigned int ucb1x00_ts_read_xpos(struct ucb1x00_ts *ts) 118 { 119 if (machine_is_collie()) 120 ucb1x00_io_write(ts->ucb, 0, COLLIE_TC35143_GPIO_TBL_CHK); 121 else { 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); 128 } 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); 132 133 udelay(55); 134 135 return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPY, ts->adcsync); 136 } 137 138 /* 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. 143 */ 144 static inline unsigned int ucb1x00_ts_read_ypos(struct ucb1x00_ts *ts) 145 { 146 if (machine_is_collie()) 147 ucb1x00_io_write(ts->ucb, 0, COLLIE_TC35143_GPIO_TBL_CHK); 148 else { 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); 155 } 156 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); 160 161 udelay(55); 162 163 return ucb1x00_adc_read(ts->ucb, UCB_ADC_INP_TSPX, ts->adcsync); 164 } 165 166 /* 167 * Switch to X plate resistance mode. Set MX to ground, PX to 168 * supply. Measure current. 169 */ 170 static inline unsigned int ucb1x00_ts_read_xres(struct ucb1x00_ts *ts) 171 { 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); 176 } 177 178 /* 179 * Switch to Y plate resistance mode. Set MY to ground, PY to 180 * supply. Measure current. 181 */ 182 static inline unsigned int ucb1x00_ts_read_yres(struct ucb1x00_ts *ts) 183 { 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); 188 } 189 190 static inline int ucb1x00_ts_pen_down(struct ucb1x00_ts *ts) 191 { 192 unsigned int val = ucb1x00_reg_read(ts->ucb, UCB_TS_CR); 193 if (machine_is_collie()) 194 return (!(val & (UCB_TS_CR_TSPX_LOW))); 195 else 196 return (val & (UCB_TS_CR_TSPX_LOW | UCB_TS_CR_TSMX_LOW)); 197 } 198 199 /* 200 * This is a RT kernel thread that handles the ADC accesses 201 * (mainly so we can use semaphores in the UCB1200 core code 202 * to serialise accesses to the ADC). 203 */ 204 static int ucb1x00_thread(void *_ts) 205 { 206 struct ucb1x00_ts *ts = _ts; 207 struct task_struct *tsk = current; 208 DECLARE_WAITQUEUE(wait, tsk); 209 int valid; 210 211 /* 212 * We could run as a real-time thread. However, thus far 213 * this doesn't seem to be necessary. 214 */ 215 // tsk->policy = SCHED_FIFO; 216 // tsk->rt_priority = 1; 217 218 valid = 0; 219 220 add_wait_queue(&ts->irq_wait, &wait); 221 while (!kthread_should_stop()) { 222 unsigned int x, y, p; 223 signed long timeout; 224 225 ts->restart = 0; 226 227 ucb1x00_adc_enable(ts->ucb); 228 229 x = ucb1x00_ts_read_xpos(ts); 230 y = ucb1x00_ts_read_ypos(ts); 231 p = ucb1x00_ts_read_pressure(ts); 232 233 /* 234 * Switch back to interrupt mode. 235 */ 236 ucb1x00_ts_mode_int(ts); 237 ucb1x00_adc_disable(ts->ucb); 238 239 msleep(10); 240 241 ucb1x00_enable(ts->ucb); 242 243 244 if (ucb1x00_ts_pen_down(ts)) { 245 set_task_state(tsk, TASK_INTERRUPTIBLE); 246 247 ucb1x00_enable_irq(ts->ucb, UCB_IRQ_TSPX, machine_is_collie() ? UCB_RISING : UCB_FALLING); 248 ucb1x00_disable(ts->ucb); 249 250 /* 251 * If we spat out a valid sample set last time, 252 * spit out a "pen off" sample here. 253 */ 254 if (valid) { 255 ucb1x00_ts_event_release(ts); 256 valid = 0; 257 } 258 259 timeout = MAX_SCHEDULE_TIMEOUT; 260 } else { 261 ucb1x00_disable(ts->ucb); 262 263 /* 264 * Filtering is policy. Policy belongs in user 265 * space. We therefore leave it to user space 266 * to do any filtering they please. 267 */ 268 if (!ts->restart) { 269 ucb1x00_ts_evt_add(ts, p, x, y); 270 valid = 1; 271 } 272 273 set_task_state(tsk, TASK_INTERRUPTIBLE); 274 timeout = HZ / 100; 275 } 276 277 try_to_freeze(); 278 279 schedule_timeout(timeout); 280 } 281 282 remove_wait_queue(&ts->irq_wait, &wait); 283 284 ts->rtask = NULL; 285 return 0; 286 } 287 288 /* 289 * We only detect touch screen _touches_ with this interrupt 290 * handler, and even then we just schedule our task. 291 */ 292 static void ucb1x00_ts_irq(int idx, void *id) 293 { 294 struct ucb1x00_ts *ts = id; 295 ucb1x00_disable_irq(ts->ucb, UCB_IRQ_TSPX, UCB_FALLING); 296 wake_up(&ts->irq_wait); 297 } 298 299 static int ucb1x00_ts_open(struct input_dev *idev) 300 { 301 struct ucb1x00_ts *ts = idev->private; 302 int ret = 0; 303 304 BUG_ON(ts->rtask); 305 306 init_waitqueue_head(&ts->irq_wait); 307 ret = ucb1x00_hook_irq(ts->ucb, UCB_IRQ_TSPX, ucb1x00_ts_irq, ts); 308 if (ret < 0) 309 goto out; 310 311 /* 312 * If we do this at all, we should allow the user to 313 * measure and read the X and Y resistance at any time. 314 */ 315 ucb1x00_adc_enable(ts->ucb); 316 ts->x_res = ucb1x00_ts_read_xres(ts); 317 ts->y_res = ucb1x00_ts_read_yres(ts); 318 ucb1x00_adc_disable(ts->ucb); 319 320 ts->rtask = kthread_run(ucb1x00_thread, ts, "ktsd"); 321 if (!IS_ERR(ts->rtask)) { 322 ret = 0; 323 } else { 324 ucb1x00_free_irq(ts->ucb, UCB_IRQ_TSPX, ts); 325 ts->rtask = NULL; 326 ret = -EFAULT; 327 } 328 329 out: 330 return ret; 331 } 332 333 /* 334 * Release touchscreen resources. Disable IRQs. 335 */ 336 static void ucb1x00_ts_close(struct input_dev *idev) 337 { 338 struct ucb1x00_ts *ts = idev->private; 339 340 if (ts->rtask) 341 kthread_stop(ts->rtask); 342 343 ucb1x00_enable(ts->ucb); 344 ucb1x00_free_irq(ts->ucb, UCB_IRQ_TSPX, ts); 345 ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 0); 346 ucb1x00_disable(ts->ucb); 347 } 348 349 #ifdef CONFIG_PM 350 static int ucb1x00_ts_resume(struct ucb1x00_dev *dev) 351 { 352 struct ucb1x00_ts *ts = dev->priv; 353 354 if (ts->rtask != NULL) { 355 /* 356 * Restart the TS thread to ensure the 357 * TS interrupt mode is set up again 358 * after sleep. 359 */ 360 ts->restart = 1; 361 wake_up(&ts->irq_wait); 362 } 363 return 0; 364 } 365 #else 366 #define ucb1x00_ts_resume NULL 367 #endif 368 369 370 /* 371 * Initialisation. 372 */ 373 static int ucb1x00_ts_add(struct ucb1x00_dev *dev) 374 { 375 struct ucb1x00_ts *ts; 376 377 ts = kzalloc(sizeof(struct ucb1x00_ts), GFP_KERNEL); 378 if (!ts) 379 return -ENOMEM; 380 381 ts->idev = input_allocate_device(); 382 if (!ts->idev) { 383 kfree(ts); 384 return -ENOMEM; 385 } 386 387 ts->ucb = dev->ucb; 388 ts->adcsync = adcsync ? UCB_SYNC : UCB_NOSYNC; 389 390 ts->idev->private = ts; 391 ts->idev->name = "Touchscreen panel"; 392 ts->idev->id.product = ts->ucb->id; 393 ts->idev->open = ucb1x00_ts_open; 394 ts->idev->close = ucb1x00_ts_close; 395 396 __set_bit(EV_ABS, ts->idev->evbit); 397 __set_bit(ABS_X, ts->idev->absbit); 398 __set_bit(ABS_Y, ts->idev->absbit); 399 __set_bit(ABS_PRESSURE, ts->idev->absbit); 400 401 input_register_device(ts->idev); 402 403 dev->priv = ts; 404 405 return 0; 406 } 407 408 static void ucb1x00_ts_remove(struct ucb1x00_dev *dev) 409 { 410 struct ucb1x00_ts *ts = dev->priv; 411 412 input_unregister_device(ts->idev); 413 kfree(ts); 414 } 415 416 static struct ucb1x00_driver ucb1x00_ts_driver = { 417 .add = ucb1x00_ts_add, 418 .remove = ucb1x00_ts_remove, 419 .resume = ucb1x00_ts_resume, 420 }; 421 422 static int __init ucb1x00_ts_init(void) 423 { 424 return ucb1x00_register_driver(&ucb1x00_ts_driver); 425 } 426 427 static void __exit ucb1x00_ts_exit(void) 428 { 429 ucb1x00_unregister_driver(&ucb1x00_ts_driver); 430 } 431 432 module_param(adcsync, int, 0444); 433 module_init(ucb1x00_ts_init); 434 module_exit(ucb1x00_ts_exit); 435 436 MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>"); 437 MODULE_DESCRIPTION("UCB1x00 touchscreen driver"); 438 MODULE_LICENSE("GPL"); 439