drivers/input/touchscreen/ads7846.c

   1 /*
   2  * ADS7846 based touchscreen and sensor driver
   3  *
   4  * Copyright (c) 2005 David Brownell
   5  * Copyright (c) 2006 Nokia Corporation
   6  * Various changes: Imre Deak <imre.deak@nokia.com>
   7  *
   8  * Using code from:
   9  *  - corgi_ts.c
  10  *      Copyright (C) 2004-2005 Richard Purdie
  11  *  - omap_ts.[hc], ads7846.h, ts_osk.c
  12  *      Copyright (C) 2002 MontaVista Software
  13  *      Copyright (C) 2004 Texas Instruments
  14  *      Copyright (C) 2005 Dirk Behme
  15  *
  16  *  This program is free software; you can redistribute it and/or modify
  17  *  it under the terms of the GNU General Public License version 2 as
  18  *  published by the Free Software Foundation.
  19  */
  20 #include <linux/device.h>
  21 #include <linux/init.h>
  22 #include <linux/delay.h>
  23 #include <linux/input.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/slab.h>
  26 #include <linux/spi/spi.h>
  27 #include <linux/spi/ads7846.h>
  28 #include <asm/irq.h>
  29
  30 #ifdef  CONFIG_ARM
  31 #include <asm/mach-types.h>
  32 #ifdef  CONFIG_ARCH_OMAP
  33 #include <asm/arch/gpio.h>
  34 #endif
  35 #endif
  36
  37
  38 /*
  39  * This code has been heavily tested on a Nokia 770, and lightly
  40  * tested on other ads7846 devices (OSK/Mistral, Lubbock).
  41  * Support for ads7843 and ads7845 has only been stubbed in.
  42  *
  43  * IRQ handling needs a workaround because of a shortcoming in handling
  44  * edge triggered IRQs on some platforms like the OMAP1/2. These
  45  * platforms don't handle the ARM lazy IRQ disabling properly, thus we
  46  * have to maintain our own SW IRQ disabled status. This should be
  47  * removed as soon as the affected platform's IRQ handling is fixed.
  48  *
  49  * app note sbaa036 talks in more detail about accurate sampling...
  50  * that ought to help in situations like LCDs inducing noise (which
  51  * can also be helped by using synch signals) and more generally.
  52  * This driver tries to utilize the measures described in the app
  53  * note. The strength of filtering can be set in the board-* specific
  54  * files.
  55  */
  56
  57 #define TS_POLL_PERIOD  msecs_to_jiffies(10)
  58
  59 /* this driver doesn't aim at the peak continuous sample rate */
  60 #define SAMPLE_BITS     (8 /*cmd*/ + 16 /*sample*/ + 2 /* before, after */)
  61
  62 struct ts_event {
  63         /* For portability, we can't read 12 bit values using SPI (which
  64          * would make the controller deliver them as native byteorder u16
  65          * with msbs zeroed).  Instead, we read them as two 8-bit values,
  66          * which need byteswapping then range adjustment.
  67          */
  68         __be16 x;
  69         __be16 y;
  70         __be16 z1, z2;
  71         int    ignore;
  72 };
  73
  74 struct ads7846 {
  75         struct input_dev        *input;
  76         char                    phys[32];
  77
  78         struct spi_device       *spi;
  79         struct attribute_group  *attr_group;
  80         u16                     model;
  81         u16                     vref_delay_usecs;
  82         u16                     x_plate_ohms;
  83         u16                     pressure_max;
  84
  85         u8                      read_x, read_y, read_z1, read_z2, pwrdown;
  86         u16                     dummy;          /* for the pwrdown read */
  87         struct ts_event         tc;
  88
  89         struct spi_transfer     xfer[10];
  90         struct spi_message      msg[5];
  91         struct spi_message      *last_msg;
  92         int                     msg_idx;
  93         int                     read_cnt;
  94         int                     read_rep;
  95         int                     last_read;
  96
  97         u16                     debounce_max;
  98         u16                     debounce_tol;
  99         u16                     debounce_rep;
 100
 101         spinlock_t              lock;
 102         struct timer_list       timer;          /* P: lock */
 103         unsigned                pendown:1;      /* P: lock */
 104         unsigned                pending:1;      /* P: lock */
 105 // FIXME remove "irq_disabled"
 106         unsigned                irq_disabled:1; /* P: lock */
 107         unsigned                disabled:1;
 108
 109         int                     (*get_pendown_state)(void);
 110 };
 111
 112 /* leave chip selected when we're done, for quicker re-select? */
 113 #if     0
 114 #define CS_CHANGE(xfer) ((xfer).cs_change = 1)
 115 #else
 116 #define CS_CHANGE(xfer) ((xfer).cs_change = 0)
 117 #endif
 118
 119 /*--------------------------------------------------------------------------*/
 120
 121 /* The ADS7846 has touchscreen and other sensors.
 122  * Earlier ads784x chips are somewhat compatible.
 123  */
 124 #define ADS_START               (1 << 7)
 125 #define ADS_A2A1A0_d_y          (1 << 4)        /* differential */
 126 #define ADS_A2A1A0_d_z1         (3 << 4)        /* differential */
 127 #define ADS_A2A1A0_d_z2         (4 << 4)        /* differential */
 128 #define ADS_A2A1A0_d_x          (5 << 4)        /* differential */
 129 #define ADS_A2A1A0_temp0        (0 << 4)        /* non-differential */
 130 #define ADS_A2A1A0_vbatt        (2 << 4)        /* non-differential */
 131 #define ADS_A2A1A0_vaux         (6 << 4)        /* non-differential */
 132 #define ADS_A2A1A0_temp1        (7 << 4)        /* non-differential */
 133 #define ADS_8_BIT               (1 << 3)
 134 #define ADS_12_BIT              (0 << 3)
 135 #define ADS_SER                 (1 << 2)        /* non-differential */
 136 #define ADS_DFR                 (0 << 2)        /* differential */
 137 #define ADS_PD10_PDOWN          (0 << 0)        /* lowpower mode + penirq */
 138 #define ADS_PD10_ADC_ON         (1 << 0)        /* ADC on */
 139 #define ADS_PD10_REF_ON         (2 << 0)        /* vREF on + penirq */
 140 #define ADS_PD10_ALL_ON         (3 << 0)        /* ADC + vREF on */
 141
 142 #define MAX_12BIT       ((1<<12)-1)
 143
 144 /* leave ADC powered up (disables penirq) between differential samples */
 145 #define READ_12BIT_DFR(x) (ADS_START | ADS_A2A1A0_d_ ## x \
 146         | ADS_12_BIT | ADS_DFR)
 147
 148 #define READ_Y  (READ_12BIT_DFR(y)  | ADS_PD10_ADC_ON)
 149 #define READ_Z1 (READ_12BIT_DFR(z1) | ADS_PD10_ADC_ON)
 150 #define READ_Z2 (READ_12BIT_DFR(z2) | ADS_PD10_ADC_ON)
 151
 152 #define READ_X  (READ_12BIT_DFR(x)  | ADS_PD10_ADC_ON)
 153 #define PWRDOWN (READ_12BIT_DFR(y)  | ADS_PD10_PDOWN)   /* LAST */
 154
 155 /* single-ended samples need to first power up reference voltage;
 156  * we leave both ADC and VREF powered
 157  */
 158 #define READ_12BIT_SER(x) (ADS_START | ADS_A2A1A0_ ## x \
 159         | ADS_12_BIT | ADS_SER)
 160
 161 #define REF_ON  (READ_12BIT_DFR(x) | ADS_PD10_ALL_ON)
 162 #define REF_OFF (READ_12BIT_DFR(y) | ADS_PD10_PDOWN)
 163
 164 /*--------------------------------------------------------------------------*/
 165
 166 /*
 167  * Non-touchscreen sensors only use single-ended conversions.
 168  */
 169
 170 struct ser_req {
 171         u8                      ref_on;
 172         u8                      command;
 173         u8                      ref_off;
 174         u16                     scratch;
 175         __be16                  sample;
 176         struct spi_message      msg;
 177         struct spi_transfer     xfer[6];
 178 };
 179
 180 static void ads7846_enable(struct ads7846 *ts);
 181 static void ads7846_disable(struct ads7846 *ts);
 182
 183 static int device_suspended(struct device *dev)
 184 {
 185         struct ads7846 *ts = dev_get_drvdata(dev);
 186         return dev->power.power_state.event != PM_EVENT_ON || ts->disabled;
 187 }
 188
 189 static int ads7846_read12_ser(struct device *dev, unsigned command)
 190 {
 191         struct spi_device       *spi = to_spi_device(dev);
 192         struct ads7846          *ts = dev_get_drvdata(dev);
 193         struct ser_req          *req = kzalloc(sizeof *req, GFP_KERNEL);
 194         int                     status;
 195         int                     sample;
 196         int                     i;
 197
 198         if (!req)
 199                 return -ENOMEM;
 200
 201         spi_message_init(&req->msg);
 202
 203         /* activate reference, so it has time to settle; */
 204         req->ref_on = REF_ON;
 205         req->xfer[0].tx_buf = &req->ref_on;
 206         req->xfer[0].len = 1;
 207         req->xfer[1].rx_buf = &req->scratch;
 208         req->xfer[1].len = 2;
 209
 210         /*
 211          * for external VREF, 0 usec (and assume it's always on);
 212          * for 1uF, use 800 usec;
 213          * no cap, 100 usec.
 214          */
 215         req->xfer[1].delay_usecs = ts->vref_delay_usecs;
 216
 217         /* take sample */
 218         req->command = (u8) command;
 219         req->xfer[2].tx_buf = &req->command;
 220         req->xfer[2].len = 1;
 221         req->xfer[3].rx_buf = &req->sample;
 222         req->xfer[3].len = 2;
 223
 224         /* REVISIT:  take a few more samples, and compare ... */
 225
 226         /* turn off reference */
 227         req->ref_off = REF_OFF;
 228         req->xfer[4].tx_buf = &req->ref_off;
 229         req->xfer[4].len = 1;
 230         req->xfer[5].rx_buf = &req->scratch;
 231         req->xfer[5].len = 2;
 232
 233         CS_CHANGE(req->xfer[5]);
 234
 235         /* group all the transfers together, so we can't interfere with
 236          * reading touchscreen state; disable penirq while sampling
 237          */
 238         for (i = 0; i < 6; i++)
 239                 spi_message_add_tail(&req->xfer[i], &req->msg);
 240
 241         ts->irq_disabled = 1;
 242         disable_irq(spi->irq);
 243         status = spi_sync(spi, &req->msg);
 244         ts->irq_disabled = 0;
 245         enable_irq(spi->irq);
 246
 247         if (req->msg.status)
 248                 status = req->msg.status;
 249
 250         /* on-wire is a must-ignore bit, a BE12 value, then padding */
 251         sample = be16_to_cpu(req->sample);
 252         sample = sample >> 3;
 253         sample &= 0x0fff;
 254
 255         kfree(req);
 256         return status ? status : sample;
 257 }
 258
 259 #define SHOW(name) static ssize_t \
 260 name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \
 261 { \
 262         ssize_t v = ads7846_read12_ser(dev, \
 263                         READ_12BIT_SER(name) | ADS_PD10_ALL_ON); \
 264         if (v < 0) \
 265                 return v; \
 266         return sprintf(buf, "%u\n", (unsigned) v); \
 267 } \
 268 static DEVICE_ATTR(name, S_IRUGO, name ## _show, NULL);
 269
 270 SHOW(temp0)
 271 SHOW(temp1)
 272 SHOW(vaux)
 273 SHOW(vbatt)
 274
 275 static int is_pen_down(struct device *dev)
 276 {
 277         struct ads7846          *ts = dev_get_drvdata(dev);
 278
 279         return ts->pendown;
 280 }
 281
 282 static ssize_t ads7846_pen_down_show(struct device *dev,
 283                                      struct device_attribute *attr, char *buf)
 284 {
 285         return sprintf(buf, "%u\n", is_pen_down(dev));
 286 }
 287
 288 static DEVICE_ATTR(pen_down, S_IRUGO, ads7846_pen_down_show, NULL);
 289
 290 static ssize_t ads7846_disable_show(struct device *dev,
 291                                      struct device_attribute *attr, char *buf)
 292 {
 293         struct ads7846  *ts = dev_get_drvdata(dev);
 294
 295         return sprintf(buf, "%u\n", ts->disabled);
 296 }
 297
 298 static ssize_t ads7846_disable_store(struct device *dev,
 299                                      struct device_attribute *attr,
 300                                      const char *buf, size_t count)
 301 {
 302         struct ads7846 *ts = dev_get_drvdata(dev);
 303         char *endp;
 304         int i;
 305
 306         i = simple_strtoul(buf, &endp, 10);
 307         spin_lock_irq(&ts->lock);
 308
 309         if (i)
 310                 ads7846_disable(ts);
 311         else
 312                 ads7846_enable(ts);
 313
 314         spin_unlock_irq(&ts->lock);
 315
 316         return count;
 317 }
 318
 319 static DEVICE_ATTR(disable, 0664, ads7846_disable_show, ads7846_disable_store);
 320
 321 static struct attribute *ads7846_attributes[] = {
 322         &dev_attr_temp0.attr,
 323         &dev_attr_temp1.attr,
 324         &dev_attr_vbatt.attr,
 325         &dev_attr_vaux.attr,
 326         &dev_attr_pen_down.attr,
 327         &dev_attr_disable.attr,
 328         NULL,
 329 };
 330
 331 static struct attribute_group ads7846_attr_group = {
 332         .attrs = ads7846_attributes,
 333 };
 334
 335 /*
 336  * ads7843/7845 don't have temperature sensors, and
 337  * use the other sensors a bit differently too
 338  */
 339
 340 static struct attribute *ads7843_attributes[] = {
 341         &dev_attr_vbatt.attr,
 342         &dev_attr_vaux.attr,
 343         &dev_attr_pen_down.attr,
 344         &dev_attr_disable.attr,
 345         NULL,
 346 };
 347
 348 static struct attribute_group ads7843_attr_group = {
 349         .attrs = ads7843_attributes,
 350 };
 351
 352 static struct attribute *ads7845_attributes[] = {
 353         &dev_attr_vaux.attr,
 354         &dev_attr_pen_down.attr,
 355         &dev_attr_disable.attr,
 356         NULL,
 357 };
 358
 359 static struct attribute_group ads7845_attr_group = {
 360         .attrs = ads7845_attributes,
 361 };
 362
 363 /*--------------------------------------------------------------------------*/
 364
 365 /*
 366  * PENIRQ only kicks the timer.  The timer only reissues the SPI transfer,
 367  * to retrieve touchscreen status.
 368  *
 369  * The SPI transfer completion callback does the real work.  It reports
 370  * touchscreen events and reactivates the timer (or IRQ) as appropriate.
 371  */
 372
 373 static void ads7846_rx(void *ads)
 374 {
 375         struct ads7846          *ts = ads;
 376         struct input_dev        *input_dev = ts->input;
 377         unsigned                Rt;
 378         unsigned                sync = 0;
 379         u16                     x, y, z1, z2;
 380         unsigned long           flags;
 381
 382         /* adjust:  on-wire is a must-ignore bit, a BE12 value, then padding;
 383          * built from two 8 bit values written msb-first.
 384          */
 385         x = (be16_to_cpu(ts->tc.x) >> 3) & 0x0fff;
 386         y = (be16_to_cpu(ts->tc.y) >> 3) & 0x0fff;
 387         z1 = (be16_to_cpu(ts->tc.z1) >> 3) & 0x0fff;
 388         z2 = (be16_to_cpu(ts->tc.z2) >> 3) & 0x0fff;
 389
 390         /* range filtering */
 391         if (x == MAX_12BIT)
 392                 x = 0;
 393
 394         if (likely(x && z1 && !device_suspended(&ts->spi->dev))) {
 395                 /* compute touch pressure resistance using equation #2 */
 396                 Rt = z2;
 397                 Rt -= z1;
 398                 Rt *= x;
 399                 Rt *= ts->x_plate_ohms;
 400                 Rt /= z1;
 401                 Rt = (Rt + 2047) >> 12;
 402         } else
 403                 Rt = 0;
 404
 405         /* Sample found inconsistent by debouncing or pressure is beyond
 406         * the maximum. Don't report it to user space, repeat at least
 407         * once more the measurement */
 408         if (ts->tc.ignore || Rt > ts->pressure_max) {
 409                 mod_timer(&ts->timer, jiffies + TS_POLL_PERIOD);
 410                 return;
 411         }
 412
 413         /* NOTE:  "pendown" is inferred from pressure; we don't rely on
 414          * being able to check nPENIRQ status, or "friendly" trigger modes
 415          * (both-edges is much better than just-falling or low-level).
 416          *
 417          * REVISIT:  some boards may require reading nPENIRQ; it's
 418          * needed on 7843.  and 7845 reads pressure differently...
 419          *
 420          * REVISIT:  the touchscreen might not be connected; this code
 421          * won't notice that, even if nPENIRQ never fires ...
 422          */
 423         if (!ts->pendown && Rt != 0) {
 424                 input_report_key(input_dev, BTN_TOUCH, 1);
 425                 sync = 1;
 426         } else if (ts->pendown && Rt == 0) {
 427                 input_report_key(input_dev, BTN_TOUCH, 0);
 428                 sync = 1;
 429         }
 430
 431         if (Rt) {
 432                 input_report_abs(input_dev, ABS_X, x);
 433                 input_report_abs(input_dev, ABS_Y, y);
 434                 sync = 1;
 435         }
 436
 437         if (sync) {
 438                 input_report_abs(input_dev, ABS_PRESSURE, Rt);
 439                 input_sync(input_dev);
 440         }
 441
 442 #ifdef  VERBOSE
 443         if (Rt || ts->pendown)
 444                 pr_debug("%s: %d/%d/%d%s\n", ts->spi->dev.bus_id,
 445                         x, y, Rt, Rt ? "" : " UP");
 446 #endif
 447
 448         spin_lock_irqsave(&ts->lock, flags);
 449
 450         ts->pendown = (Rt != 0);
 451         mod_timer(&ts->timer, jiffies + TS_POLL_PERIOD);
 452
 453         spin_unlock_irqrestore(&ts->lock, flags);
 454 }
 455
 456 static void ads7846_debounce(void *ads)
 457 {
 458         struct ads7846          *ts = ads;
 459         struct spi_message      *m;
 460         struct spi_transfer     *t;
 461         int                     val;
 462         int                     status;
 463
 464         m = &ts->msg[ts->msg_idx];
 465         t = list_entry(m->transfers.prev, struct spi_transfer, transfer_list);
 466         val = (be16_to_cpu(*(__be16 *)t->rx_buf) >> 3) & 0x0fff;
 467         if (!ts->read_cnt || (abs(ts->last_read - val) > ts->debounce_tol)) {
 468                 /* Repeat it, if this was the first read or the read
 469                  * wasn't consistent enough. */
 470                 if (ts->read_cnt < ts->debounce_max) {
 471                         ts->last_read = val;
 472                         ts->read_cnt++;
 473                 } else {
 474                         /* Maximum number of debouncing reached and still
 475                          * not enough number of consistent readings. Abort
 476                          * the whole sample, repeat it in the next sampling
 477                          * period.
 478                          */
 479                         ts->tc.ignore = 1;
 480                         ts->read_cnt = 0;
 481                         /* Last message will contain ads7846_rx() as the
 482                          * completion function.
 483                          */
 484                         m = ts->last_msg;
 485                 }
 486                 /* Start over collecting consistent readings. */
 487                 ts->read_rep = 0;
 488         } else {
 489                 if (++ts->read_rep > ts->debounce_rep) {
 490                         /* Got a good reading for this coordinate,
 491                          * go for the next one. */
 492                         ts->tc.ignore = 0;
 493                         ts->msg_idx++;
 494                         ts->read_cnt = 0;
 495                         ts->read_rep = 0;
 496                         m++;
 497                 } else
 498                         /* Read more values that are consistent. */
 499                         ts->read_cnt++;
 500         }
 501         status = spi_async(ts->spi, m);
 502         if (status)
 503                 dev_err(&ts->spi->dev, "spi_async --> %d\n",
 504                                 status);
 505 }
 506
 507 static void ads7846_timer(unsigned long handle)
 508 {
 509         struct ads7846  *ts = (void *)handle;
 510         int             status = 0;
 511
 512         spin_lock_irq(&ts->lock);
 513
 514         if (unlikely(ts->msg_idx && !ts->pendown)) {
 515                 /* measurement cycle ended */
 516                 if (!device_suspended(&ts->spi->dev)) {
 517                         ts->irq_disabled = 0;
 518                         enable_irq(ts->spi->irq);
 519                 }
 520                 ts->pending = 0;
 521                 ts->msg_idx = 0;
 522         } else {
 523                 /* pen is still down, continue with the measurement */
 524                 ts->msg_idx = 0;
 525                 status = spi_async(ts->spi, &ts->msg[0]);
 526                 if (status)
 527                         dev_err(&ts->spi->dev, "spi_async --> %d\n", status);
 528         }
 529
 530         spin_unlock_irq(&ts->lock);
 531 }
 532
 533 static irqreturn_t ads7846_irq(int irq, void *handle)
 534 {
 535         struct ads7846 *ts = handle;
 536         unsigned long flags;
 537
 538         spin_lock_irqsave(&ts->lock, flags);
 539         if (likely(ts->get_pendown_state())) {
 540                 if (!ts->irq_disabled) {
 541                         /* The ARM do_simple_IRQ() dispatcher doesn't act
 542                          * like the other dispatchers:  it will report IRQs
 543                          * even after they've been disabled.  We work around
 544                          * that here.  (The "generic irq" framework may help...)
 545                          */
 546                         ts->irq_disabled = 1;
 547                         disable_irq(ts->spi->irq);
 548                         ts->pending = 1;
 549                         mod_timer(&ts->timer, jiffies);
 550                 }
 551         }
 552         spin_unlock_irqrestore(&ts->lock, flags);
 553
 554         return IRQ_HANDLED;
 555 }
 556
 557 /*--------------------------------------------------------------------------*/
 558
 559 /* Must be called with ts->lock held */
 560 static void ads7846_disable(struct ads7846 *ts)
 561 {
 562         if (ts->disabled)
 563                 return;
 564
 565         ts->disabled = 1;
 566
 567         /* are we waiting for IRQ, or polling? */
 568         if (!ts->pending) {
 569                 ts->irq_disabled = 1;
 570                 disable_irq(ts->spi->irq);
 571         } else {
 572                 /* the timer will run at least once more, and
 573                  * leave everything in a clean state, IRQ disabled
 574                  */
 575                 while (ts->pending) {
 576                         spin_unlock_irq(&ts->lock);
 577                         msleep(1);
 578                         spin_lock_irq(&ts->lock);
 579                 }
 580         }
 581
 582         /* we know the chip's in lowpower mode since we always
 583          * leave it that way after every request
 584          */
 585
 586 }
 587
 588 /* Must be called with ts->lock held */
 589 static void ads7846_enable(struct ads7846 *ts)
 590 {
 591         if (!ts->disabled)
 592                 return;
 593
 594         ts->disabled = 0;
 595         ts->irq_disabled = 0;
 596         enable_irq(ts->spi->irq);
 597 }
 598
 599 static int ads7846_suspend(struct spi_device *spi, pm_message_t message)
 600 {
 601         struct ads7846 *ts = dev_get_drvdata(&spi->dev);
 602
 603         spin_lock_irq(&ts->lock);
 604
 605         spi->dev.power.power_state = message;
 606         ads7846_disable(ts);
 607
 608         spin_unlock_irq(&ts->lock);
 609
 610         return 0;
 611
 612 }
 613
 614 static int ads7846_resume(struct spi_device *spi)
 615 {
 616         struct ads7846 *ts = dev_get_drvdata(&spi->dev);
 617
 618         spin_lock_irq(&ts->lock);
 619
 620         spi->dev.power.power_state = PMSG_ON;
 621         ads7846_enable(ts);
 622
 623         spin_unlock_irq(&ts->lock);
 624
 625         return 0;
 626 }
 627
 628 static int __devinit ads7846_probe(struct spi_device *spi)
 629 {
 630         struct ads7846                  *ts;
 631         struct input_dev                *input_dev;
 632         struct ads7846_platform_data    *pdata = spi->dev.platform_data;
 633         struct spi_message              *m;
 634         struct spi_transfer             *x;
 635         int                             err;
 636
 637         if (!spi->irq) {
 638                 dev_dbg(&spi->dev, "no IRQ?\n");
 639                 return -ENODEV;
 640         }
 641
 642         if (!pdata) {
 643                 dev_dbg(&spi->dev, "no platform data?\n");
 644                 return -ENODEV;
 645         }
 646
 647         /* don't exceed max specified sample rate */
 648         if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) {
 649                 dev_dbg(&spi->dev, "f(sample) %d KHz?\n",
 650                                 (spi->max_speed_hz/SAMPLE_BITS)/1000);
 651                 return -EINVAL;
 652         }
 653
 654         /* REVISIT when the irq can be triggered active-low, or if for some
 655          * reason the touchscreen isn't hooked up, we don't need to access
 656          * the pendown state.
 657          */
 658         if (pdata->get_pendown_state == NULL) {
 659                 dev_dbg(&spi->dev, "no get_pendown_state function?\n");
 660                 return -EINVAL;
 661         }
 662
 663         /* We'd set TX wordsize 8 bits and RX wordsize to 13 bits ... except
 664          * that even if the hardware can do that, the SPI controller driver
 665          * may not.  So we stick to very-portable 8 bit words, both RX and TX.
 666          */
 667         spi->bits_per_word = 8;
 668
 669         ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL);
 670         input_dev = input_allocate_device();
 671         if (!ts || !input_dev) {
 672                 err = -ENOMEM;
 673                 goto err_free_mem;
 674         }
 675
 676         dev_set_drvdata(&spi->dev, ts);
 677         spi->dev.power.power_state = PMSG_ON;
 678
 679         ts->spi = spi;
 680         ts->input = input_dev;
 681
 682         init_timer(&ts->timer);
 683         ts->timer.data = (unsigned long) ts;
 684         ts->timer.function = ads7846_timer;
 685
 686         spin_lock_init(&ts->lock);
 687
 688         ts->model = pdata->model ? : 7846;
 689         ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100;
 690         ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
 691         ts->pressure_max = pdata->pressure_max ? : ~0;
 692         if (pdata->debounce_max) {
 693                 ts->debounce_max = pdata->debounce_max;
 694                 ts->debounce_tol = pdata->debounce_tol;
 695                 ts->debounce_rep = pdata->debounce_rep;
 696                 if (ts->debounce_rep > ts->debounce_max + 1)
 697                         ts->debounce_rep = ts->debounce_max - 1;
 698         } else
 699                 ts->debounce_tol = ~0;
 700         ts->get_pendown_state = pdata->get_pendown_state;
 701
 702         snprintf(ts->phys, sizeof(ts->phys), "%s/input0", spi->dev.bus_id);
 703
 704         input_dev->name = "ADS784x Touchscreen";
 705         input_dev->phys = ts->phys;
 706         input_dev->cdev.dev = &spi->dev;
 707
 708         input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS);
 709         input_dev->keybit[LONG(BTN_TOUCH)] = BIT(BTN_TOUCH);
 710         input_set_abs_params(input_dev, ABS_X,
 711                         pdata->x_min ? : 0,
 712                         pdata->x_max ? : MAX_12BIT,
 713                         0, 0);
 714         input_set_abs_params(input_dev, ABS_Y,
 715                         pdata->y_min ? : 0,
 716                         pdata->y_max ? : MAX_12BIT,
 717                         0, 0);
 718         input_set_abs_params(input_dev, ABS_PRESSURE,
 719                         pdata->pressure_min, pdata->pressure_max, 0, 0);
 720
 721         /* set up the transfers to read touchscreen state; this assumes we
 722          * use formula #2 for pressure, not #3.
 723          */
 724         m = &ts->msg[0];
 725         x = ts->xfer;
 726
 727         spi_message_init(m);
 728
 729         /* y- still on; turn on only y+ (and ADC) */
 730         ts->read_y = READ_Y;
 731         x->tx_buf = &ts->read_y;
 732         x->len = 1;
 733         spi_message_add_tail(x, m);
 734
 735         x++;
 736         x->rx_buf = &ts->tc.y;
 737         x->len = 2;
 738         spi_message_add_tail(x, m);
 739
 740         m->complete = ads7846_debounce;
 741         m->context = ts;
 742
 743         m++;
 744         spi_message_init(m);
 745
 746         /* turn y- off, x+ on, then leave in lowpower */
 747         x++;
 748         ts->read_x = READ_X;
 749         x->tx_buf = &ts->read_x;
 750         x->len = 1;
 751         spi_message_add_tail(x, m);
 752
 753         x++;
 754         x->rx_buf = &ts->tc.x;
 755         x->len = 2;
 756         spi_message_add_tail(x, m);
 757
 758         m->complete = ads7846_debounce;
 759         m->context = ts;
 760
 761         /* turn y+ off, x- on; we'll use formula #2 */
 762         if (ts->model == 7846) {
 763                 m++;
 764                 spi_message_init(m);
 765
 766                 x++;
 767                 ts->read_z1 = READ_Z1;
 768                 x->tx_buf = &ts->read_z1;
 769                 x->len = 1;
 770                 spi_message_add_tail(x, m);
 771
 772                 x++;
 773                 x->rx_buf = &ts->tc.z1;
 774                 x->len = 2;
 775                 spi_message_add_tail(x, m);
 776
 777                 m->complete = ads7846_debounce;
 778                 m->context = ts;
 779
 780                 m++;
 781                 spi_message_init(m);
 782
 783                 x++;
 784                 ts->read_z2 = READ_Z2;
 785                 x->tx_buf = &ts->read_z2;
 786                 x->len = 1;
 787                 spi_message_add_tail(x, m);
 788
 789                 x++;
 790                 x->rx_buf = &ts->tc.z2;
 791                 x->len = 2;
 792                 spi_message_add_tail(x, m);
 793
 794                 m->complete = ads7846_debounce;
 795                 m->context = ts;
 796         }
 797
 798         /* power down */
 799         m++;
 800         spi_message_init(m);
 801
 802         x++;
 803         ts->pwrdown = PWRDOWN;
 804         x->tx_buf = &ts->pwrdown;
 805         x->len = 1;
 806         spi_message_add_tail(x, m);
 807
 808         x++;
 809         x->rx_buf = &ts->dummy;
 810         x->len = 2;
 811         CS_CHANGE(*x);
 812         spi_message_add_tail(x, m);
 813
 814         m->complete = ads7846_rx;
 815         m->context = ts;
 816
 817         ts->last_msg = m;
 818
 819         if (request_irq(spi->irq, ads7846_irq, IRQF_TRIGGER_FALLING,
 820                         spi->dev.driver->name, ts)) {
 821                 dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
 822                 err = -EBUSY;
 823                 goto err_free_mem;
 824         }
 825
 826         dev_info(&spi->dev, "touchscreen, irq %d\n", spi->irq);
 827
 828         /* take a first sample, leaving nPENIRQ active; avoid
 829          * the touchscreen, in case it's not connected.
 830          */
 831         (void) ads7846_read12_ser(&spi->dev,
 832                           READ_12BIT_SER(vaux) | ADS_PD10_ALL_ON);
 833
 834         switch (ts->model) {
 835         case 7846:
 836                 ts->attr_group = &ads7846_attr_group;
 837                 break;
 838         case 7845:
 839                 ts->attr_group = &ads7845_attr_group;
 840                 break;
 841         default:
 842                 ts->attr_group = &ads7843_attr_group;
 843                 break;
 844         }
 845         err = sysfs_create_group(&spi->dev.kobj, ts->attr_group);
 846         if (err)
 847                 goto err_free_irq;
 848
 849         err = input_register_device(input_dev);
 850         if (err)
 851                 goto err_remove_attr_group;
 852
 853         return 0;
 854
 855  err_remove_attr_group:
 856         sysfs_remove_group(&spi->dev.kobj, ts->attr_group);
 857  err_free_irq:
 858         free_irq(spi->irq, ts);
 859  err_free_mem:
 860         input_free_device(input_dev);
 861         kfree(ts);
 862         return err;
 863 }
 864
 865 static int __devexit ads7846_remove(struct spi_device *spi)
 866 {
 867         struct ads7846          *ts = dev_get_drvdata(&spi->dev);
 868
 869         input_unregister_device(ts->input);
 870
 871         ads7846_suspend(spi, PMSG_SUSPEND);
 872
 873         sysfs_remove_group(&spi->dev.kobj, ts->attr_group);
 874
 875         free_irq(ts->spi->irq, ts);
 876         /* suspend left the IRQ disabled */
 877         enable_irq(ts->spi->irq);
 878
 879         kfree(ts);
 880
 881         dev_dbg(&spi->dev, "unregistered touchscreen\n");
 882         return 0;
 883 }
 884
 885 static struct spi_driver ads7846_driver = {
 886         .driver = {
 887                 .name   = "ads7846",
 888                 .bus    = &spi_bus_type,
 889                 .owner  = THIS_MODULE,
 890         },
 891         .probe          = ads7846_probe,
 892         .remove         = __devexit_p(ads7846_remove),
 893         .suspend        = ads7846_suspend,
 894         .resume         = ads7846_resume,
 895 };
 896
 897 static int __init ads7846_init(void)
 898 {
 899         /* grr, board-specific init should stay out of drivers!! */
 900
 901 #ifdef  CONFIG_ARCH_OMAP
 902         if (machine_is_omap_osk()) {
 903                 /* GPIO4 = PENIRQ; GPIO6 = BUSY */
 904                 omap_request_gpio(4);
 905                 omap_set_gpio_direction(4, 1);
 906                 omap_request_gpio(6);
 907                 omap_set_gpio_direction(6, 1);
 908         }
 909         // also TI 1510 Innovator, bitbanging through FPGA
 910         // also Nokia 770
 911         // also Palm Tungsten T2
 912 #endif
 913
 914         // PXA:
 915         // also Dell Axim X50
 916         // also HP iPaq H191x/H192x/H415x/H435x
 917         // also Intel Lubbock (additional to UCB1400; as temperature sensor)
 918         // also Sharp Zaurus C7xx, C8xx (corgi/sheperd/husky)
 919
 920         // Atmel at91sam9261-EK uses ads7843
 921
 922         // also various AMD Au1x00 devel boards
 923
 924         return spi_register_driver(&ads7846_driver);
 925 }
 926 module_init(ads7846_init);
 927
 928 static void __exit ads7846_exit(void)
 929 {
 930         spi_unregister_driver(&ads7846_driver);
 931
 932 #ifdef  CONFIG_ARCH_OMAP
 933         if (machine_is_omap_osk()) {
 934                 omap_free_gpio(4);
 935                 omap_free_gpio(6);
 936         }
 937 #endif
 938
 939 }
 940 module_exit(ads7846_exit);
 941
 942 MODULE_DESCRIPTION("ADS7846 TouchScreen Driver");
 943 MODULE_LICENSE("GPL");