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