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/sched.h> 25#include <linux/completion.h> 26#include <linux/delay.h> 27#include <linux/string.h> 28#include <linux/input.h> 29#include <linux/device.h> 30#include <linux/freezer.h> 31#include <linux/slab.h> 32#include <linux/kthread.h> 33#include <linux/mfd/ucb1x00.h> 34 35#include <mach/dma.h> 36#include <mach/collie.h> 37#include <asm/mach-types.h> 38 39 40 41struct ucb1x00_ts { 42 struct input_dev *idev; 43 struct ucb1x00 *ucb; 44 45 wait_queue_head_t irq_wait; 46 struct task_struct *rtask; 47 u16 x_res; 48 u16 y_res; 49 50 unsigned int restart:1; 51 unsigned int adcsync:1; 52}; 53 54static int adcsync; 55 56static inline void ucb1x00_ts_evt_add(struct ucb1x00_ts *ts, u16 pressure, u16 x, u16 y) 57{ 58 struct input_dev *idev = ts->idev; 59 60 input_report_abs(idev, ABS_X, x); 61 input_report_abs(idev, ABS_Y, y); 62 input_report_abs(idev, ABS_PRESSURE, pressure); 63 input_sync(idev); 64} 65 66static inline void ucb1x00_ts_event_release(struct ucb1x00_ts *ts) 67{ 68 struct input_dev *idev = ts->idev; 69 70 input_report_abs(idev, ABS_PRESSURE, 0); 71 input_sync(idev); 72} 73 74/* 75 * Switch to interrupt mode. 76 */ 77static 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 */ 89static 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 */ 116static 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 */ 143static 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 */ 169static 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 */ 181static 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 189static inline int ucb1x00_ts_pen_down(struct ucb1x00_ts *ts) 190{ 191 unsigned int val = ucb1x00_reg_read(ts->ucb, UCB_TS_CR); 192 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 */ 204static int ucb1x00_thread(void *_ts) 205{ 206 struct ucb1x00_ts *ts = _ts; 207 DECLARE_WAITQUEUE(wait, current); 208 int valid = 0; 209 210 set_freezable(); 211 add_wait_queue(&ts->irq_wait, &wait); 212 while (!kthread_should_stop()) { 213 unsigned int x, y, p; 214 signed long timeout; 215 216 ts->restart = 0; 217 218 ucb1x00_adc_enable(ts->ucb); 219 220 x = ucb1x00_ts_read_xpos(ts); 221 y = ucb1x00_ts_read_ypos(ts); 222 p = ucb1x00_ts_read_pressure(ts); 223 224 /* 225 * Switch back to interrupt mode. 226 */ 227 ucb1x00_ts_mode_int(ts); 228 ucb1x00_adc_disable(ts->ucb); 229 230 msleep(10); 231 232 ucb1x00_enable(ts->ucb); 233 234 235 if (ucb1x00_ts_pen_down(ts)) { 236 set_current_state(TASK_INTERRUPTIBLE); 237 238 ucb1x00_enable_irq(ts->ucb, UCB_IRQ_TSPX, machine_is_collie() ? UCB_RISING : UCB_FALLING); 239 ucb1x00_disable(ts->ucb); 240 241 /* 242 * If we spat out a valid sample set last time, 243 * spit out a "pen off" sample here. 244 */ 245 if (valid) { 246 ucb1x00_ts_event_release(ts); 247 valid = 0; 248 } 249 250 timeout = MAX_SCHEDULE_TIMEOUT; 251 } else { 252 ucb1x00_disable(ts->ucb); 253 254 /* 255 * Filtering is policy. Policy belongs in user 256 * space. We therefore leave it to user space 257 * to do any filtering they please. 258 */ 259 if (!ts->restart) { 260 ucb1x00_ts_evt_add(ts, p, x, y); 261 valid = 1; 262 } 263 264 set_current_state(TASK_INTERRUPTIBLE); 265 timeout = HZ / 100; 266 } 267 268 try_to_freeze(); 269 270 schedule_timeout(timeout); 271 } 272 273 remove_wait_queue(&ts->irq_wait, &wait); 274 275 ts->rtask = NULL; 276 return 0; 277} 278 279/* 280 * We only detect touch screen _touches_ with this interrupt 281 * handler, and even then we just schedule our task. 282 */ 283static void ucb1x00_ts_irq(int idx, void *id) 284{ 285 struct ucb1x00_ts *ts = id; 286 287 ucb1x00_disable_irq(ts->ucb, UCB_IRQ_TSPX, UCB_FALLING); 288 wake_up(&ts->irq_wait); 289} 290 291static int ucb1x00_ts_open(struct input_dev *idev) 292{ 293 struct ucb1x00_ts *ts = input_get_drvdata(idev); 294 int ret = 0; 295 296 BUG_ON(ts->rtask); 297 298 init_waitqueue_head(&ts->irq_wait); 299 ret = ucb1x00_hook_irq(ts->ucb, UCB_IRQ_TSPX, ucb1x00_ts_irq, ts); 300 if (ret < 0) 301 goto out; 302 303 /* 304 * If we do this at all, we should allow the user to 305 * measure and read the X and Y resistance at any time. 306 */ 307 ucb1x00_adc_enable(ts->ucb); 308 ts->x_res = ucb1x00_ts_read_xres(ts); 309 ts->y_res = ucb1x00_ts_read_yres(ts); 310 ucb1x00_adc_disable(ts->ucb); 311 312 ts->rtask = kthread_run(ucb1x00_thread, ts, "ktsd"); 313 if (!IS_ERR(ts->rtask)) { 314 ret = 0; 315 } else { 316 ucb1x00_free_irq(ts->ucb, UCB_IRQ_TSPX, ts); 317 ts->rtask = NULL; 318 ret = -EFAULT; 319 } 320 321 out: 322 return ret; 323} 324 325/* 326 * Release touchscreen resources. Disable IRQs. 327 */ 328static void ucb1x00_ts_close(struct input_dev *idev) 329{ 330 struct ucb1x00_ts *ts = input_get_drvdata(idev); 331 332 if (ts->rtask) 333 kthread_stop(ts->rtask); 334 335 ucb1x00_enable(ts->ucb); 336 ucb1x00_free_irq(ts->ucb, UCB_IRQ_TSPX, ts); 337 ucb1x00_reg_write(ts->ucb, UCB_TS_CR, 0); 338 ucb1x00_disable(ts->ucb); 339} 340 341#ifdef CONFIG_PM 342static int ucb1x00_ts_resume(struct ucb1x00_dev *dev) 343{ 344 struct ucb1x00_ts *ts = dev->priv; 345 346 if (ts->rtask != NULL) { 347 /* 348 * Restart the TS thread to ensure the 349 * TS interrupt mode is set up again 350 * after sleep. 351 */ 352 ts->restart = 1; 353 wake_up(&ts->irq_wait); 354 } 355 return 0; 356} 357#else 358#define ucb1x00_ts_resume NULL 359#endif 360 361 362/* 363 * Initialisation. 364 */ 365static int ucb1x00_ts_add(struct ucb1x00_dev *dev) 366{ 367 struct ucb1x00_ts *ts; 368 struct input_dev *idev; 369 int err; 370 371 ts = kzalloc(sizeof(struct ucb1x00_ts), GFP_KERNEL); 372 idev = input_allocate_device(); 373 if (!ts || !idev) { 374 err = -ENOMEM; 375 goto fail; 376 } 377 378 ts->ucb = dev->ucb; 379 ts->idev = idev; 380 ts->adcsync = adcsync ? UCB_SYNC : UCB_NOSYNC; 381 382 idev->name = "Touchscreen panel"; 383 idev->id.product = ts->ucb->id; 384 idev->open = ucb1x00_ts_open; 385 idev->close = ucb1x00_ts_close; 386 387 __set_bit(EV_ABS, idev->evbit); 388 __set_bit(ABS_X, idev->absbit); 389 __set_bit(ABS_Y, idev->absbit); 390 __set_bit(ABS_PRESSURE, idev->absbit); 391 392 input_set_drvdata(idev, ts); 393 394 err = input_register_device(idev); 395 if (err) 396 goto fail; 397 398 dev->priv = ts; 399 400 return 0; 401 402 fail: 403 input_free_device(idev); 404 kfree(ts); 405 return err; 406} 407 408static 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 416static struct ucb1x00_driver ucb1x00_ts_driver = { 417 .add = ucb1x00_ts_add, 418 .remove = ucb1x00_ts_remove, 419 .resume = ucb1x00_ts_resume, 420}; 421 422static int __init ucb1x00_ts_init(void) 423{ 424 return ucb1x00_register_driver(&ucb1x00_ts_driver); 425} 426 427static void __exit ucb1x00_ts_exit(void) 428{ 429 ucb1x00_unregister_driver(&ucb1x00_ts_driver); 430} 431 432module_param(adcsync, int, 0444); 433module_init(ucb1x00_ts_init); 434module_exit(ucb1x00_ts_exit); 435 436MODULE_AUTHOR("Russell King <rmk@arm.linux.org.uk>"); 437MODULE_DESCRIPTION("UCB1x00 touchscreen driver"); 438MODULE_LICENSE("GPL"); 439