1/* 2 * Philips UCB1400 touchscreen driver 3 * 4 * Author: Nicolas Pitre 5 * Created: September 25, 2006 6 * Copyright: MontaVista Software, Inc. 7 * 8 * Spliting done by: Marek Vasut <marek.vasut@gmail.com> 9 * If something doesn't work and it worked before spliting, e-mail me, 10 * dont bother Nicolas please ;-) 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License version 2 as 14 * published by the Free Software Foundation. 15 * 16 * This code is heavily based on ucb1x00-*.c copyrighted by Russell King 17 * covering the UCB1100, UCB1200 and UCB1300.. Support for the UCB1400 has 18 * been made separate from ucb1x00-core/ucb1x00-ts on Russell's request. 19 */ 20 21#include <linux/module.h> 22#include <linux/delay.h> 23#include <linux/sched.h> 24#include <linux/wait.h> 25#include <linux/input.h> 26#include <linux/device.h> 27#include <linux/interrupt.h> 28#include <linux/ucb1400.h> 29 30#define UCB1400_TS_POLL_PERIOD 10 /* ms */ 31 32static bool adcsync; 33static int ts_delay = 55; /* us */ 34static int ts_delay_pressure; /* us */ 35 36/* Switch to interrupt mode. */ 37static void ucb1400_ts_mode_int(struct ucb1400_ts *ucb) 38{ 39 ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 40 UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW | 41 UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND | 42 UCB_TS_CR_MODE_INT); 43} 44 45/* 46 * Switch to pressure mode, and read pressure. We don't need to wait 47 * here, since both plates are being driven. 48 */ 49static unsigned int ucb1400_ts_read_pressure(struct ucb1400_ts *ucb) 50{ 51 ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 52 UCB_TS_CR_TSMX_POW | UCB_TS_CR_TSPX_POW | 53 UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_GND | 54 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 55 56 udelay(ts_delay_pressure); 57 58 return ucb1400_adc_read(ucb->ac97, UCB_ADC_INP_TSPY, adcsync); 59} 60 61/* 62 * Switch to X position mode and measure Y plate. We switch the plate 63 * configuration in pressure mode, then switch to position mode. This 64 * gives a faster response time. Even so, we need to wait about 55us 65 * for things to stabilise. 66 */ 67static unsigned int ucb1400_ts_read_xpos(struct ucb1400_ts *ucb) 68{ 69 ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 70 UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | 71 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 72 ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 73 UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | 74 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 75 ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 76 UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | 77 UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA); 78 79 udelay(ts_delay); 80 81 return ucb1400_adc_read(ucb->ac97, UCB_ADC_INP_TSPY, adcsync); 82} 83 84/* 85 * Switch to Y position mode and measure X plate. We switch the plate 86 * configuration in pressure mode, then switch to position mode. This 87 * gives a faster response time. Even so, we need to wait about 55us 88 * for things to stabilise. 89 */ 90static int ucb1400_ts_read_ypos(struct ucb1400_ts *ucb) 91{ 92 ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 93 UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | 94 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 95 ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 96 UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | 97 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 98 ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 99 UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | 100 UCB_TS_CR_MODE_POS | UCB_TS_CR_BIAS_ENA); 101 102 udelay(ts_delay); 103 104 return ucb1400_adc_read(ucb->ac97, UCB_ADC_INP_TSPX, adcsync); 105} 106 107/* 108 * Switch to X plate resistance mode. Set MX to ground, PX to 109 * supply. Measure current. 110 */ 111static unsigned int ucb1400_ts_read_xres(struct ucb1400_ts *ucb) 112{ 113 ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 114 UCB_TS_CR_TSMX_GND | UCB_TS_CR_TSPX_POW | 115 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 116 return ucb1400_adc_read(ucb->ac97, 0, adcsync); 117} 118 119/* 120 * Switch to Y plate resistance mode. Set MY to ground, PY to 121 * supply. Measure current. 122 */ 123static unsigned int ucb1400_ts_read_yres(struct ucb1400_ts *ucb) 124{ 125 ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 126 UCB_TS_CR_TSMY_GND | UCB_TS_CR_TSPY_POW | 127 UCB_TS_CR_MODE_PRES | UCB_TS_CR_BIAS_ENA); 128 return ucb1400_adc_read(ucb->ac97, 0, adcsync); 129} 130 131static int ucb1400_ts_pen_up(struct ucb1400_ts *ucb) 132{ 133 unsigned short val = ucb1400_reg_read(ucb->ac97, UCB_TS_CR); 134 135 return val & (UCB_TS_CR_TSPX_LOW | UCB_TS_CR_TSMX_LOW); 136} 137 138static void ucb1400_ts_irq_enable(struct ucb1400_ts *ucb) 139{ 140 ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, UCB_IE_TSPX); 141 ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0); 142 ucb1400_reg_write(ucb->ac97, UCB_IE_FAL, UCB_IE_TSPX); 143} 144 145static void ucb1400_ts_irq_disable(struct ucb1400_ts *ucb) 146{ 147 ucb1400_reg_write(ucb->ac97, UCB_IE_FAL, 0); 148} 149 150static void ucb1400_ts_report_event(struct input_dev *idev, u16 pressure, u16 x, u16 y) 151{ 152 input_report_abs(idev, ABS_X, x); 153 input_report_abs(idev, ABS_Y, y); 154 input_report_abs(idev, ABS_PRESSURE, pressure); 155 input_report_key(idev, BTN_TOUCH, 1); 156 input_sync(idev); 157} 158 159static void ucb1400_ts_event_release(struct input_dev *idev) 160{ 161 input_report_abs(idev, ABS_PRESSURE, 0); 162 input_report_key(idev, BTN_TOUCH, 0); 163 input_sync(idev); 164} 165 166static void ucb1400_clear_pending_irq(struct ucb1400_ts *ucb) 167{ 168 unsigned int isr; 169 170 isr = ucb1400_reg_read(ucb->ac97, UCB_IE_STATUS); 171 ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, isr); 172 ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0); 173 174 if (isr & UCB_IE_TSPX) 175 ucb1400_ts_irq_disable(ucb); 176 else 177 dev_dbg(&ucb->ts_idev->dev, 178 "ucb1400: unexpected IE_STATUS = %#x\n", isr); 179} 180 181/* 182 * A restriction with interrupts exists when using the ucb1400, as 183 * the codec read/write routines may sleep while waiting for codec 184 * access completion and uses semaphores for access control to the 185 * AC97 bus. Therefore the driver is forced to use threaded interrupt 186 * handler. 187 */ 188static irqreturn_t ucb1400_irq(int irqnr, void *devid) 189{ 190 struct ucb1400_ts *ucb = devid; 191 unsigned int x, y, p; 192 bool penup; 193 194 if (unlikely(irqnr != ucb->irq)) 195 return IRQ_NONE; 196 197 ucb1400_clear_pending_irq(ucb); 198 199 /* Start with a small delay before checking pendown state */ 200 msleep(UCB1400_TS_POLL_PERIOD); 201 202 while (!ucb->stopped && !(penup = ucb1400_ts_pen_up(ucb))) { 203 204 ucb1400_adc_enable(ucb->ac97); 205 x = ucb1400_ts_read_xpos(ucb); 206 y = ucb1400_ts_read_ypos(ucb); 207 p = ucb1400_ts_read_pressure(ucb); 208 ucb1400_adc_disable(ucb->ac97); 209 210 ucb1400_ts_report_event(ucb->ts_idev, p, x, y); 211 212 wait_event_timeout(ucb->ts_wait, ucb->stopped, 213 msecs_to_jiffies(UCB1400_TS_POLL_PERIOD)); 214 } 215 216 ucb1400_ts_event_release(ucb->ts_idev); 217 218 if (!ucb->stopped) { 219 /* Switch back to interrupt mode. */ 220 ucb1400_ts_mode_int(ucb); 221 ucb1400_ts_irq_enable(ucb); 222 } 223 224 return IRQ_HANDLED; 225} 226 227static void ucb1400_ts_stop(struct ucb1400_ts *ucb) 228{ 229 /* Signal IRQ thread to stop polling and disable the handler. */ 230 ucb->stopped = true; 231 mb(); 232 wake_up(&ucb->ts_wait); 233 disable_irq(ucb->irq); 234 235 ucb1400_ts_irq_disable(ucb); 236 ucb1400_reg_write(ucb->ac97, UCB_TS_CR, 0); 237} 238 239/* Must be called with ts->lock held */ 240static void ucb1400_ts_start(struct ucb1400_ts *ucb) 241{ 242 /* Tell IRQ thread that it may poll the device. */ 243 ucb->stopped = false; 244 mb(); 245 246 ucb1400_ts_mode_int(ucb); 247 ucb1400_ts_irq_enable(ucb); 248 249 enable_irq(ucb->irq); 250} 251 252static int ucb1400_ts_open(struct input_dev *idev) 253{ 254 struct ucb1400_ts *ucb = input_get_drvdata(idev); 255 256 ucb1400_ts_start(ucb); 257 258 return 0; 259} 260 261static void ucb1400_ts_close(struct input_dev *idev) 262{ 263 struct ucb1400_ts *ucb = input_get_drvdata(idev); 264 265 ucb1400_ts_stop(ucb); 266} 267 268#ifndef NO_IRQ 269#define NO_IRQ 0 270#endif 271 272/* 273 * Try to probe our interrupt, rather than relying on lots of 274 * hard-coded machine dependencies. 275 */ 276static int ucb1400_ts_detect_irq(struct ucb1400_ts *ucb, 277 struct platform_device *pdev) 278{ 279 unsigned long mask, timeout; 280 281 mask = probe_irq_on(); 282 283 /* Enable the ADC interrupt. */ 284 ucb1400_reg_write(ucb->ac97, UCB_IE_RIS, UCB_IE_ADC); 285 ucb1400_reg_write(ucb->ac97, UCB_IE_FAL, UCB_IE_ADC); 286 ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0xffff); 287 ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0); 288 289 /* Cause an ADC interrupt. */ 290 ucb1400_reg_write(ucb->ac97, UCB_ADC_CR, UCB_ADC_ENA); 291 ucb1400_reg_write(ucb->ac97, UCB_ADC_CR, UCB_ADC_ENA | UCB_ADC_START); 292 293 /* Wait for the conversion to complete. */ 294 timeout = jiffies + HZ/2; 295 while (!(ucb1400_reg_read(ucb->ac97, UCB_ADC_DATA) & 296 UCB_ADC_DAT_VALID)) { 297 cpu_relax(); 298 if (time_after(jiffies, timeout)) { 299 dev_err(&pdev->dev, "timed out in IRQ probe\n"); 300 probe_irq_off(mask); 301 return -ENODEV; 302 } 303 } 304 ucb1400_reg_write(ucb->ac97, UCB_ADC_CR, 0); 305 306 /* Disable and clear interrupt. */ 307 ucb1400_reg_write(ucb->ac97, UCB_IE_RIS, 0); 308 ucb1400_reg_write(ucb->ac97, UCB_IE_FAL, 0); 309 ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0xffff); 310 ucb1400_reg_write(ucb->ac97, UCB_IE_CLEAR, 0); 311 312 /* Read triggered interrupt. */ 313 ucb->irq = probe_irq_off(mask); 314 if (ucb->irq < 0 || ucb->irq == NO_IRQ) 315 return -ENODEV; 316 317 return 0; 318} 319 320static int ucb1400_ts_probe(struct platform_device *pdev) 321{ 322 struct ucb1400_ts *ucb = dev_get_platdata(&pdev->dev); 323 int error, x_res, y_res; 324 u16 fcsr; 325 326 ucb->ts_idev = input_allocate_device(); 327 if (!ucb->ts_idev) { 328 error = -ENOMEM; 329 goto err; 330 } 331 332 /* Only in case the IRQ line wasn't supplied, try detecting it */ 333 if (ucb->irq < 0) { 334 error = ucb1400_ts_detect_irq(ucb, pdev); 335 if (error) { 336 dev_err(&pdev->dev, "IRQ probe failed\n"); 337 goto err_free_devs; 338 } 339 } 340 dev_dbg(&pdev->dev, "found IRQ %d\n", ucb->irq); 341 342 init_waitqueue_head(&ucb->ts_wait); 343 344 input_set_drvdata(ucb->ts_idev, ucb); 345 346 ucb->ts_idev->dev.parent = &pdev->dev; 347 ucb->ts_idev->name = "UCB1400 touchscreen interface"; 348 ucb->ts_idev->id.vendor = ucb1400_reg_read(ucb->ac97, 349 AC97_VENDOR_ID1); 350 ucb->ts_idev->id.product = ucb->id; 351 ucb->ts_idev->open = ucb1400_ts_open; 352 ucb->ts_idev->close = ucb1400_ts_close; 353 ucb->ts_idev->evbit[0] = BIT_MASK(EV_ABS) | BIT_MASK(EV_KEY); 354 ucb->ts_idev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 355 356 /* 357 * Enable ADC filter to prevent horrible jitter on Colibri. 358 * This also further reduces jitter on boards where ADCSYNC 359 * pin is connected. 360 */ 361 fcsr = ucb1400_reg_read(ucb->ac97, UCB_FCSR); 362 ucb1400_reg_write(ucb->ac97, UCB_FCSR, fcsr | UCB_FCSR_AVE); 363 364 ucb1400_adc_enable(ucb->ac97); 365 x_res = ucb1400_ts_read_xres(ucb); 366 y_res = ucb1400_ts_read_yres(ucb); 367 ucb1400_adc_disable(ucb->ac97); 368 dev_dbg(&pdev->dev, "x/y = %d/%d\n", x_res, y_res); 369 370 input_set_abs_params(ucb->ts_idev, ABS_X, 0, x_res, 0, 0); 371 input_set_abs_params(ucb->ts_idev, ABS_Y, 0, y_res, 0, 0); 372 input_set_abs_params(ucb->ts_idev, ABS_PRESSURE, 0, 0, 0, 0); 373 374 ucb1400_ts_stop(ucb); 375 376 error = request_threaded_irq(ucb->irq, NULL, ucb1400_irq, 377 IRQF_TRIGGER_RISING | IRQF_ONESHOT, 378 "UCB1400", ucb); 379 if (error) { 380 dev_err(&pdev->dev, 381 "unable to grab irq%d: %d\n", ucb->irq, error); 382 goto err_free_devs; 383 } 384 385 error = input_register_device(ucb->ts_idev); 386 if (error) 387 goto err_free_irq; 388 389 return 0; 390 391err_free_irq: 392 free_irq(ucb->irq, ucb); 393err_free_devs: 394 input_free_device(ucb->ts_idev); 395err: 396 return error; 397} 398 399static int ucb1400_ts_remove(struct platform_device *pdev) 400{ 401 struct ucb1400_ts *ucb = dev_get_platdata(&pdev->dev); 402 403 free_irq(ucb->irq, ucb); 404 input_unregister_device(ucb->ts_idev); 405 406 return 0; 407} 408 409static int __maybe_unused ucb1400_ts_suspend(struct device *dev) 410{ 411 struct ucb1400_ts *ucb = dev_get_platdata(dev); 412 struct input_dev *idev = ucb->ts_idev; 413 414 mutex_lock(&idev->mutex); 415 416 if (idev->users) 417 ucb1400_ts_start(ucb); 418 419 mutex_unlock(&idev->mutex); 420 return 0; 421} 422 423static int __maybe_unused ucb1400_ts_resume(struct device *dev) 424{ 425 struct ucb1400_ts *ucb = dev_get_platdata(dev); 426 struct input_dev *idev = ucb->ts_idev; 427 428 mutex_lock(&idev->mutex); 429 430 if (idev->users) 431 ucb1400_ts_stop(ucb); 432 433 mutex_unlock(&idev->mutex); 434 return 0; 435} 436 437static SIMPLE_DEV_PM_OPS(ucb1400_ts_pm_ops, 438 ucb1400_ts_suspend, ucb1400_ts_resume); 439 440static struct platform_driver ucb1400_ts_driver = { 441 .probe = ucb1400_ts_probe, 442 .remove = ucb1400_ts_remove, 443 .driver = { 444 .name = "ucb1400_ts", 445 .pm = &ucb1400_ts_pm_ops, 446 }, 447}; 448module_platform_driver(ucb1400_ts_driver); 449 450module_param(adcsync, bool, 0444); 451MODULE_PARM_DESC(adcsync, "Synchronize touch readings with ADCSYNC pin."); 452 453module_param(ts_delay, int, 0444); 454MODULE_PARM_DESC(ts_delay, "Delay between panel setup and" 455 " position read. Default = 55us."); 456 457module_param(ts_delay_pressure, int, 0444); 458MODULE_PARM_DESC(ts_delay_pressure, 459 "delay between panel setup and pressure read." 460 " Default = 0us."); 461 462MODULE_DESCRIPTION("Philips UCB1400 touchscreen driver"); 463MODULE_LICENSE("GPL"); 464