drivers/input/touchscreen/ucb1400_ts.c

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