drivers/input/touchscreen/ad7877.c

   1 /*
   2  * Copyright (C) 2006-2008 Michael Hennerich, Analog Devices Inc.
   3  *
   4  * Description: AD7877 based touchscreen, sensor (ADCs), DAC and GPIO driver
   5  * Based on:    ads7846.c
   6  *
   7  * Bugs:        Enter bugs at http://blackfin.uclinux.org/
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, see the file COPYING, or write
  21  * to the Free Software Foundation, Inc.,
  22  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  23  *
  24  * History:
  25  * Copyright (c) 2005 David Brownell
  26  * Copyright (c) 2006 Nokia Corporation
  27  * Various changes: Imre Deak <imre.deak@nokia.com>
  28  *
  29  * Using code from:
  30  *  - corgi_ts.c
  31  *      Copyright (C) 2004-2005 Richard Purdie
  32  *  - omap_ts.[hc], ads7846.h, ts_osk.c
  33  *      Copyright (C) 2002 MontaVista Software
  34  *      Copyright (C) 2004 Texas Instruments
  35  *      Copyright (C) 2005 Dirk Behme
  36  */
  37
  38
  39 #include <linux/device.h>
  40 #include <linux/init.h>
  41 #include <linux/delay.h>
  42 #include <linux/input.h>
  43 #include <linux/interrupt.h>
  44 #include <linux/pm.h>
  45 #include <linux/slab.h>
  46 #include <linux/spi/spi.h>
  47 #include <linux/spi/ad7877.h>
  48 #include <linux/module.h>
  49 #include <asm/irq.h>
  50
  51 #define TS_PEN_UP_TIMEOUT       msecs_to_jiffies(100)
  52
  53 #define MAX_SPI_FREQ_HZ                 20000000
  54 #define MAX_12BIT                       ((1<<12)-1)
  55
  56 #define AD7877_REG_ZEROS                        0
  57 #define AD7877_REG_CTRL1                        1
  58 #define AD7877_REG_CTRL2                        2
  59 #define AD7877_REG_ALERT                        3
  60 #define AD7877_REG_AUX1HIGH                     4
  61 #define AD7877_REG_AUX1LOW                      5
  62 #define AD7877_REG_BAT1HIGH                     6
  63 #define AD7877_REG_BAT1LOW                      7
  64 #define AD7877_REG_BAT2HIGH                     8
  65 #define AD7877_REG_BAT2LOW                      9
  66 #define AD7877_REG_TEMP1HIGH                    10
  67 #define AD7877_REG_TEMP1LOW                     11
  68 #define AD7877_REG_SEQ0                         12
  69 #define AD7877_REG_SEQ1                         13
  70 #define AD7877_REG_DAC                          14
  71 #define AD7877_REG_NONE1                        15
  72 #define AD7877_REG_EXTWRITE                     15
  73 #define AD7877_REG_XPLUS                        16
  74 #define AD7877_REG_YPLUS                        17
  75 #define AD7877_REG_Z2                           18
  76 #define AD7877_REG_aux1                         19
  77 #define AD7877_REG_aux2                         20
  78 #define AD7877_REG_aux3                         21
  79 #define AD7877_REG_bat1                         22
  80 #define AD7877_REG_bat2                         23
  81 #define AD7877_REG_temp1                        24
  82 #define AD7877_REG_temp2                        25
  83 #define AD7877_REG_Z1                           26
  84 #define AD7877_REG_GPIOCTRL1                    27
  85 #define AD7877_REG_GPIOCTRL2                    28
  86 #define AD7877_REG_GPIODATA                     29
  87 #define AD7877_REG_NONE2                        30
  88 #define AD7877_REG_NONE3                        31
  89
  90 #define AD7877_SEQ_YPLUS_BIT                    (1<<11)
  91 #define AD7877_SEQ_XPLUS_BIT                    (1<<10)
  92 #define AD7877_SEQ_Z2_BIT                       (1<<9)
  93 #define AD7877_SEQ_AUX1_BIT                     (1<<8)
  94 #define AD7877_SEQ_AUX2_BIT                     (1<<7)
  95 #define AD7877_SEQ_AUX3_BIT                     (1<<6)
  96 #define AD7877_SEQ_BAT1_BIT                     (1<<5)
  97 #define AD7877_SEQ_BAT2_BIT                     (1<<4)
  98 #define AD7877_SEQ_TEMP1_BIT                    (1<<3)
  99 #define AD7877_SEQ_TEMP2_BIT                    (1<<2)
 100 #define AD7877_SEQ_Z1_BIT                       (1<<1)
 101
 102 enum {
 103         AD7877_SEQ_YPOS  = 0,
 104         AD7877_SEQ_XPOS  = 1,
 105         AD7877_SEQ_Z2    = 2,
 106         AD7877_SEQ_AUX1  = 3,
 107         AD7877_SEQ_AUX2  = 4,
 108         AD7877_SEQ_AUX3  = 5,
 109         AD7877_SEQ_BAT1  = 6,
 110         AD7877_SEQ_BAT2  = 7,
 111         AD7877_SEQ_TEMP1 = 8,
 112         AD7877_SEQ_TEMP2 = 9,
 113         AD7877_SEQ_Z1    = 10,
 114         AD7877_NR_SENSE  = 11,
 115 };
 116
 117 /* DAC Register Default RANGE 0 to Vcc, Volatge Mode, DAC On */
 118 #define AD7877_DAC_CONF                 0x1
 119
 120 /* If gpio3 is set AUX3/GPIO3 acts as GPIO Output */
 121 #define AD7877_EXTW_GPIO_3_CONF         0x1C4
 122 #define AD7877_EXTW_GPIO_DATA           0x200
 123
 124 /* Control REG 2 */
 125 #define AD7877_TMR(x)                   ((x & 0x3) << 0)
 126 #define AD7877_REF(x)                   ((x & 0x1) << 2)
 127 #define AD7877_POL(x)                   ((x & 0x1) << 3)
 128 #define AD7877_FCD(x)                   ((x & 0x3) << 4)
 129 #define AD7877_PM(x)                    ((x & 0x3) << 6)
 130 #define AD7877_ACQ(x)                   ((x & 0x3) << 8)
 131 #define AD7877_AVG(x)                   ((x & 0x3) << 10)
 132
 133 /* Control REG 1 */
 134 #define AD7877_SER                      (1 << 11)       /* non-differential */
 135 #define AD7877_DFR                      (0 << 11)       /* differential */
 136
 137 #define AD7877_MODE_NOC  (0)    /* Do not convert */
 138 #define AD7877_MODE_SCC  (1)    /* Single channel conversion */
 139 #define AD7877_MODE_SEQ0 (2)    /* Sequence 0 in Slave Mode */
 140 #define AD7877_MODE_SEQ1 (3)    /* Sequence 1 in Master Mode */
 141
 142 #define AD7877_CHANADD(x)               ((x&0xF)<<7)
 143 #define AD7877_READADD(x)               ((x)<<2)
 144 #define AD7877_WRITEADD(x)              ((x)<<12)
 145
 146 #define AD7877_READ_CHAN(x) (AD7877_WRITEADD(AD7877_REG_CTRL1) | AD7877_SER | \
 147                 AD7877_MODE_SCC | AD7877_CHANADD(AD7877_REG_ ## x) | \
 148                 AD7877_READADD(AD7877_REG_ ## x))
 149
 150 #define AD7877_MM_SEQUENCE (AD7877_SEQ_YPLUS_BIT | AD7877_SEQ_XPLUS_BIT | \
 151                 AD7877_SEQ_Z2_BIT | AD7877_SEQ_Z1_BIT)
 152
 153 /*
 154  * Non-touchscreen sensors only use single-ended conversions.
 155  */
 156
 157 struct ser_req {
 158         u16                     reset;
 159         u16                     ref_on;
 160         u16                     command;
 161         struct spi_message      msg;
 162         struct spi_transfer     xfer[6];
 163
 164         /*
 165          * DMA (thus cache coherency maintenance) requires the
 166          * transfer buffers to live in their own cache lines.
 167          */
 168         u16 sample ____cacheline_aligned;
 169 };
 170
 171 struct ad7877 {
 172         struct input_dev        *input;
 173         char                    phys[32];
 174
 175         struct spi_device       *spi;
 176         u16                     model;
 177         u16                     vref_delay_usecs;
 178         u16                     x_plate_ohms;
 179         u16                     pressure_max;
 180
 181         u16                     cmd_crtl1;
 182         u16                     cmd_crtl2;
 183         u16                     cmd_dummy;
 184         u16                     dac;
 185
 186         u8                      stopacq_polarity;
 187         u8                      first_conversion_delay;
 188         u8                      acquisition_time;
 189         u8                      averaging;
 190         u8                      pen_down_acc_interval;
 191
 192         struct spi_transfer     xfer[AD7877_NR_SENSE + 2];
 193         struct spi_message      msg;
 194
 195         struct mutex            mutex;
 196         bool                    disabled;       /* P: mutex */
 197         bool                    gpio3;          /* P: mutex */
 198         bool                    gpio4;          /* P: mutex */
 199
 200         spinlock_t              lock;
 201         struct timer_list       timer;          /* P: lock */
 202
 203         /*
 204          * DMA (thus cache coherency maintenance) requires the
 205          * transfer buffers to live in their own cache lines.
 206          */
 207         u16 conversion_data[AD7877_NR_SENSE] ____cacheline_aligned;
 208 };
 209
 210 static bool gpio3;
 211 module_param(gpio3, bool, 0);
 212 MODULE_PARM_DESC(gpio3, "If gpio3 is set to 1 AUX3 acts as GPIO3");
 213
 214 /*
 215  * ad7877_read/write are only used for initial setup and for sysfs controls.
 216  * The main traffic is done using spi_async() in the interrupt handler.
 217  */
 218
 219 static int ad7877_read(struct spi_device *spi, u16 reg)
 220 {
 221         struct ser_req *req;
 222         int status, ret;
 223
 224         req = kzalloc(sizeof *req, GFP_KERNEL);
 225         if (!req)
 226                 return -ENOMEM;
 227
 228         spi_message_init(&req->msg);
 229
 230         req->command = (u16) (AD7877_WRITEADD(AD7877_REG_CTRL1) |
 231                         AD7877_READADD(reg));
 232         req->xfer[0].tx_buf = &req->command;
 233         req->xfer[0].len = 2;
 234         req->xfer[0].cs_change = 1;
 235
 236         req->xfer[1].rx_buf = &req->sample;
 237         req->xfer[1].len = 2;
 238
 239         spi_message_add_tail(&req->xfer[0], &req->msg);
 240         spi_message_add_tail(&req->xfer[1], &req->msg);
 241
 242         status = spi_sync(spi, &req->msg);
 243         ret = status ? : req->sample;
 244
 245         kfree(req);
 246
 247         return ret;
 248 }
 249
 250 static int ad7877_write(struct spi_device *spi, u16 reg, u16 val)
 251 {
 252         struct ser_req *req;
 253         int status;
 254
 255         req = kzalloc(sizeof *req, GFP_KERNEL);
 256         if (!req)
 257                 return -ENOMEM;
 258
 259         spi_message_init(&req->msg);
 260
 261         req->command = (u16) (AD7877_WRITEADD(reg) | (val & MAX_12BIT));
 262         req->xfer[0].tx_buf = &req->command;
 263         req->xfer[0].len = 2;
 264
 265         spi_message_add_tail(&req->xfer[0], &req->msg);
 266
 267         status = spi_sync(spi, &req->msg);
 268
 269         kfree(req);
 270
 271         return status;
 272 }
 273
 274 static int ad7877_read_adc(struct spi_device *spi, unsigned command)
 275 {
 276         struct ad7877 *ts = dev_get_drvdata(&spi->dev);
 277         struct ser_req *req;
 278         int status;
 279         int sample;
 280         int i;
 281
 282         req = kzalloc(sizeof *req, GFP_KERNEL);
 283         if (!req)
 284                 return -ENOMEM;
 285
 286         spi_message_init(&req->msg);
 287
 288         /* activate reference, so it has time to settle; */
 289         req->ref_on = AD7877_WRITEADD(AD7877_REG_CTRL2) |
 290                          AD7877_POL(ts->stopacq_polarity) |
 291                          AD7877_AVG(0) | AD7877_PM(2) | AD7877_TMR(0) |
 292                          AD7877_ACQ(ts->acquisition_time) | AD7877_FCD(0);
 293
 294         req->reset = AD7877_WRITEADD(AD7877_REG_CTRL1) | AD7877_MODE_NOC;
 295
 296         req->command = (u16) command;
 297
 298         req->xfer[0].tx_buf = &req->reset;
 299         req->xfer[0].len = 2;
 300         req->xfer[0].cs_change = 1;
 301
 302         req->xfer[1].tx_buf = &req->ref_on;
 303         req->xfer[1].len = 2;
 304         req->xfer[1].delay_usecs = ts->vref_delay_usecs;
 305         req->xfer[1].cs_change = 1;
 306
 307         req->xfer[2].tx_buf = &req->command;
 308         req->xfer[2].len = 2;
 309         req->xfer[2].delay_usecs = ts->vref_delay_usecs;
 310         req->xfer[2].cs_change = 1;
 311
 312         req->xfer[3].rx_buf = &req->sample;
 313         req->xfer[3].len = 2;
 314         req->xfer[3].cs_change = 1;
 315
 316         req->xfer[4].tx_buf = &ts->cmd_crtl2;   /*REF OFF*/
 317         req->xfer[4].len = 2;
 318         req->xfer[4].cs_change = 1;
 319
 320         req->xfer[5].tx_buf = &ts->cmd_crtl1;   /*DEFAULT*/
 321         req->xfer[5].len = 2;
 322
 323         /* group all the transfers together, so we can't interfere with
 324          * reading touchscreen state; disable penirq while sampling
 325          */
 326         for (i = 0; i < 6; i++)
 327                 spi_message_add_tail(&req->xfer[i], &req->msg);
 328
 329         status = spi_sync(spi, &req->msg);
 330         sample = req->sample;
 331
 332         kfree(req);
 333
 334         return status ? : sample;
 335 }
 336
 337 static int ad7877_process_data(struct ad7877 *ts)
 338 {
 339         struct input_dev *input_dev = ts->input;
 340         unsigned Rt;
 341         u16 x, y, z1, z2;
 342
 343         x = ts->conversion_data[AD7877_SEQ_XPOS] & MAX_12BIT;
 344         y = ts->conversion_data[AD7877_SEQ_YPOS] & MAX_12BIT;
 345         z1 = ts->conversion_data[AD7877_SEQ_Z1] & MAX_12BIT;
 346         z2 = ts->conversion_data[AD7877_SEQ_Z2] & MAX_12BIT;
 347
 348         /*
 349          * The samples processed here are already preprocessed by the AD7877.
 350          * The preprocessing function consists of an averaging filter.
 351          * The combination of 'first conversion delay' and averaging provides a robust solution,
 352          * discarding the spurious noise in the signal and keeping only the data of interest.
 353          * The size of the averaging filter is programmable. (dev.platform_data, see linux/spi/ad7877.h)
 354          * Other user-programmable conversion controls include variable acquisition time,
 355          * and first conversion delay. Up to 16 averages can be taken per conversion.
 356          */
 357
 358         if (likely(x && z1)) {
 359                 /* compute touch pressure resistance using equation #1 */
 360                 Rt = (z2 - z1) * x * ts->x_plate_ohms;
 361                 Rt /= z1;
 362                 Rt = (Rt + 2047) >> 12;
 363
 364                 /*
 365                  * Sample found inconsistent, pressure is beyond
 366                  * the maximum. Don't report it to user space.
 367                  */
 368                 if (Rt > ts->pressure_max)
 369                         return -EINVAL;
 370
 371                 if (!timer_pending(&ts->timer))
 372                         input_report_key(input_dev, BTN_TOUCH, 1);
 373
 374                 input_report_abs(input_dev, ABS_X, x);
 375                 input_report_abs(input_dev, ABS_Y, y);
 376                 input_report_abs(input_dev, ABS_PRESSURE, Rt);
 377                 input_sync(input_dev);
 378
 379                 return 0;
 380         }
 381
 382         return -EINVAL;
 383 }
 384
 385 static inline void ad7877_ts_event_release(struct ad7877 *ts)
 386 {
 387         struct input_dev *input_dev = ts->input;
 388
 389         input_report_abs(input_dev, ABS_PRESSURE, 0);
 390         input_report_key(input_dev, BTN_TOUCH, 0);
 391         input_sync(input_dev);
 392 }
 393
 394 static void ad7877_timer(unsigned long handle)
 395 {
 396         struct ad7877 *ts = (void *)handle;
 397         unsigned long flags;
 398
 399         spin_lock_irqsave(&ts->lock, flags);
 400         ad7877_ts_event_release(ts);
 401         spin_unlock_irqrestore(&ts->lock, flags);
 402 }
 403
 404 static irqreturn_t ad7877_irq(int irq, void *handle)
 405 {
 406         struct ad7877 *ts = handle;
 407         unsigned long flags;
 408         int error;
 409
 410         error = spi_sync(ts->spi, &ts->msg);
 411         if (error) {
 412                 dev_err(&ts->spi->dev, "spi_sync --> %d\n", error);
 413                 goto out;
 414         }
 415
 416         spin_lock_irqsave(&ts->lock, flags);
 417         error = ad7877_process_data(ts);
 418         if (!error)
 419                 mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT);
 420         spin_unlock_irqrestore(&ts->lock, flags);
 421
 422 out:
 423         return IRQ_HANDLED;
 424 }
 425
 426 static void ad7877_disable(struct ad7877 *ts)
 427 {
 428         mutex_lock(&ts->mutex);
 429
 430         if (!ts->disabled) {
 431                 ts->disabled = true;
 432                 disable_irq(ts->spi->irq);
 433
 434                 if (del_timer_sync(&ts->timer))
 435                         ad7877_ts_event_release(ts);
 436         }
 437
 438         /*
 439          * We know the chip's in lowpower mode since we always
 440          * leave it that way after every request
 441          */
 442
 443         mutex_unlock(&ts->mutex);
 444 }
 445
 446 static void ad7877_enable(struct ad7877 *ts)
 447 {
 448         mutex_lock(&ts->mutex);
 449
 450         if (ts->disabled) {
 451                 ts->disabled = false;
 452                 enable_irq(ts->spi->irq);
 453         }
 454
 455         mutex_unlock(&ts->mutex);
 456 }
 457
 458 #define SHOW(name) static ssize_t \
 459 name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \
 460 { \
 461         struct ad7877 *ts = dev_get_drvdata(dev); \
 462         ssize_t v = ad7877_read_adc(ts->spi, \
 463                         AD7877_READ_CHAN(name)); \
 464         if (v < 0) \
 465                 return v; \
 466         return sprintf(buf, "%u\n", (unsigned) v); \
 467 } \
 468 static DEVICE_ATTR(name, S_IRUGO, name ## _show, NULL);
 469
 470 SHOW(aux1)
 471 SHOW(aux2)
 472 SHOW(aux3)
 473 SHOW(bat1)
 474 SHOW(bat2)
 475 SHOW(temp1)
 476 SHOW(temp2)
 477
 478 static ssize_t ad7877_disable_show(struct device *dev,
 479                                      struct device_attribute *attr, char *buf)
 480 {
 481         struct ad7877 *ts = dev_get_drvdata(dev);
 482
 483         return sprintf(buf, "%u\n", ts->disabled);
 484 }
 485
 486 static ssize_t ad7877_disable_store(struct device *dev,
 487                                      struct device_attribute *attr,
 488                                      const char *buf, size_t count)
 489 {
 490         struct ad7877 *ts = dev_get_drvdata(dev);
 491         unsigned int val;
 492         int error;
 493
 494         error = kstrtouint(buf, 10, &val);
 495         if (error)
 496                 return error;
 497
 498         if (val)
 499                 ad7877_disable(ts);
 500         else
 501                 ad7877_enable(ts);
 502
 503         return count;
 504 }
 505
 506 static DEVICE_ATTR(disable, 0664, ad7877_disable_show, ad7877_disable_store);
 507
 508 static ssize_t ad7877_dac_show(struct device *dev,
 509                                      struct device_attribute *attr, char *buf)
 510 {
 511         struct ad7877 *ts = dev_get_drvdata(dev);
 512
 513         return sprintf(buf, "%u\n", ts->dac);
 514 }
 515
 516 static ssize_t ad7877_dac_store(struct device *dev,
 517                                      struct device_attribute *attr,
 518                                      const char *buf, size_t count)
 519 {
 520         struct ad7877 *ts = dev_get_drvdata(dev);
 521         unsigned int val;
 522         int error;
 523
 524         error = kstrtouint(buf, 10, &val);
 525         if (error)
 526                 return error;
 527
 528         mutex_lock(&ts->mutex);
 529         ts->dac = val & 0xFF;
 530         ad7877_write(ts->spi, AD7877_REG_DAC, (ts->dac << 4) | AD7877_DAC_CONF);
 531         mutex_unlock(&ts->mutex);
 532
 533         return count;
 534 }
 535
 536 static DEVICE_ATTR(dac, 0664, ad7877_dac_show, ad7877_dac_store);
 537
 538 static ssize_t ad7877_gpio3_show(struct device *dev,
 539                                      struct device_attribute *attr, char *buf)
 540 {
 541         struct ad7877 *ts = dev_get_drvdata(dev);
 542
 543         return sprintf(buf, "%u\n", ts->gpio3);
 544 }
 545
 546 static ssize_t ad7877_gpio3_store(struct device *dev,
 547                                      struct device_attribute *attr,
 548                                      const char *buf, size_t count)
 549 {
 550         struct ad7877 *ts = dev_get_drvdata(dev);
 551         unsigned int val;
 552         int error;
 553
 554         error = kstrtouint(buf, 10, &val);
 555         if (error)
 556                 return error;
 557
 558         mutex_lock(&ts->mutex);
 559         ts->gpio3 = !!val;
 560         ad7877_write(ts->spi, AD7877_REG_EXTWRITE, AD7877_EXTW_GPIO_DATA |
 561                  (ts->gpio4 << 4) | (ts->gpio3 << 5));
 562         mutex_unlock(&ts->mutex);
 563
 564         return count;
 565 }
 566
 567 static DEVICE_ATTR(gpio3, 0664, ad7877_gpio3_show, ad7877_gpio3_store);
 568
 569 static ssize_t ad7877_gpio4_show(struct device *dev,
 570                                      struct device_attribute *attr, char *buf)
 571 {
 572         struct ad7877 *ts = dev_get_drvdata(dev);
 573
 574         return sprintf(buf, "%u\n", ts->gpio4);
 575 }
 576
 577 static ssize_t ad7877_gpio4_store(struct device *dev,
 578                                      struct device_attribute *attr,
 579                                      const char *buf, size_t count)
 580 {
 581         struct ad7877 *ts = dev_get_drvdata(dev);
 582         unsigned int val;
 583         int error;
 584
 585         error = kstrtouint(buf, 10, &val);
 586         if (error)
 587                 return error;
 588
 589         mutex_lock(&ts->mutex);
 590         ts->gpio4 = !!val;
 591         ad7877_write(ts->spi, AD7877_REG_EXTWRITE, AD7877_EXTW_GPIO_DATA |
 592                      (ts->gpio4 << 4) | (ts->gpio3 << 5));
 593         mutex_unlock(&ts->mutex);
 594
 595         return count;
 596 }
 597
 598 static DEVICE_ATTR(gpio4, 0664, ad7877_gpio4_show, ad7877_gpio4_store);
 599
 600 static struct attribute *ad7877_attributes[] = {
 601         &dev_attr_temp1.attr,
 602         &dev_attr_temp2.attr,
 603         &dev_attr_aux1.attr,
 604         &dev_attr_aux2.attr,
 605         &dev_attr_aux3.attr,
 606         &dev_attr_bat1.attr,
 607         &dev_attr_bat2.attr,
 608         &dev_attr_disable.attr,
 609         &dev_attr_dac.attr,
 610         &dev_attr_gpio3.attr,
 611         &dev_attr_gpio4.attr,
 612         NULL
 613 };
 614
 615 static umode_t ad7877_attr_is_visible(struct kobject *kobj,
 616                                      struct attribute *attr, int n)
 617 {
 618         umode_t mode = attr->mode;
 619
 620         if (attr == &dev_attr_aux3.attr) {
 621                 if (gpio3)
 622                         mode = 0;
 623         } else if (attr == &dev_attr_gpio3.attr) {
 624                 if (!gpio3)
 625                         mode = 0;
 626         }
 627
 628         return mode;
 629 }
 630
 631 static const struct attribute_group ad7877_attr_group = {
 632         .is_visible     = ad7877_attr_is_visible,
 633         .attrs          = ad7877_attributes,
 634 };
 635
 636 static void ad7877_setup_ts_def_msg(struct spi_device *spi, struct ad7877 *ts)
 637 {
 638         struct spi_message *m;
 639         int i;
 640
 641         ts->cmd_crtl2 = AD7877_WRITEADD(AD7877_REG_CTRL2) |
 642                         AD7877_POL(ts->stopacq_polarity) |
 643                         AD7877_AVG(ts->averaging) | AD7877_PM(1) |
 644                         AD7877_TMR(ts->pen_down_acc_interval) |
 645                         AD7877_ACQ(ts->acquisition_time) |
 646                         AD7877_FCD(ts->first_conversion_delay);
 647
 648         ad7877_write(spi, AD7877_REG_CTRL2, ts->cmd_crtl2);
 649
 650         ts->cmd_crtl1 = AD7877_WRITEADD(AD7877_REG_CTRL1) |
 651                         AD7877_READADD(AD7877_REG_XPLUS-1) |
 652                         AD7877_MODE_SEQ1 | AD7877_DFR;
 653
 654         ad7877_write(spi, AD7877_REG_CTRL1, ts->cmd_crtl1);
 655
 656         ts->cmd_dummy = 0;
 657
 658         m = &ts->msg;
 659
 660         spi_message_init(m);
 661
 662         m->context = ts;
 663
 664         ts->xfer[0].tx_buf = &ts->cmd_crtl1;
 665         ts->xfer[0].len = 2;
 666         ts->xfer[0].cs_change = 1;
 667
 668         spi_message_add_tail(&ts->xfer[0], m);
 669
 670         ts->xfer[1].tx_buf = &ts->cmd_dummy; /* Send ZERO */
 671         ts->xfer[1].len = 2;
 672         ts->xfer[1].cs_change = 1;
 673
 674         spi_message_add_tail(&ts->xfer[1], m);
 675
 676         for (i = 0; i < AD7877_NR_SENSE; i++) {
 677                 ts->xfer[i + 2].rx_buf = &ts->conversion_data[AD7877_SEQ_YPOS + i];
 678                 ts->xfer[i + 2].len = 2;
 679                 if (i < (AD7877_NR_SENSE - 1))
 680                         ts->xfer[i + 2].cs_change = 1;
 681                 spi_message_add_tail(&ts->xfer[i + 2], m);
 682         }
 683 }
 684
 685 static int __devinit ad7877_probe(struct spi_device *spi)
 686 {
 687         struct ad7877                   *ts;
 688         struct input_dev                *input_dev;
 689         struct ad7877_platform_data     *pdata = spi->dev.platform_data;
 690         int                             err;
 691         u16                             verify;
 692
 693         if (!spi->irq) {
 694                 dev_dbg(&spi->dev, "no IRQ?\n");
 695                 return -ENODEV;
 696         }
 697
 698         if (!pdata) {
 699                 dev_dbg(&spi->dev, "no platform data?\n");
 700                 return -ENODEV;
 701         }
 702
 703         /* don't exceed max specified SPI CLK frequency */
 704         if (spi->max_speed_hz > MAX_SPI_FREQ_HZ) {
 705                 dev_dbg(&spi->dev, "SPI CLK %d Hz?\n",spi->max_speed_hz);
 706                 return -EINVAL;
 707         }
 708
 709         spi->bits_per_word = 16;
 710         err = spi_setup(spi);
 711         if (err) {
 712                 dev_dbg(&spi->dev, "spi master doesn't support 16 bits/word\n");
 713                 return err;
 714         }
 715
 716         ts = kzalloc(sizeof(struct ad7877), GFP_KERNEL);
 717         input_dev = input_allocate_device();
 718         if (!ts || !input_dev) {
 719                 err = -ENOMEM;
 720                 goto err_free_mem;
 721         }
 722
 723         dev_set_drvdata(&spi->dev, ts);
 724         ts->spi = spi;
 725         ts->input = input_dev;
 726
 727         setup_timer(&ts->timer, ad7877_timer, (unsigned long) ts);
 728         mutex_init(&ts->mutex);
 729         spin_lock_init(&ts->lock);
 730
 731         ts->model = pdata->model ? : 7877;
 732         ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100;
 733         ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
 734         ts->pressure_max = pdata->pressure_max ? : ~0;
 735
 736         ts->stopacq_polarity = pdata->stopacq_polarity;
 737         ts->first_conversion_delay = pdata->first_conversion_delay;
 738         ts->acquisition_time = pdata->acquisition_time;
 739         ts->averaging = pdata->averaging;
 740         ts->pen_down_acc_interval = pdata->pen_down_acc_interval;
 741
 742         snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&spi->dev));
 743
 744         input_dev->name = "AD7877 Touchscreen";
 745         input_dev->phys = ts->phys;
 746         input_dev->dev.parent = &spi->dev;
 747
 748         __set_bit(EV_KEY, input_dev->evbit);
 749         __set_bit(BTN_TOUCH, input_dev->keybit);
 750         __set_bit(EV_ABS, input_dev->evbit);
 751         __set_bit(ABS_X, input_dev->absbit);
 752         __set_bit(ABS_Y, input_dev->absbit);
 753         __set_bit(ABS_PRESSURE, input_dev->absbit);
 754
 755         input_set_abs_params(input_dev, ABS_X,
 756                         pdata->x_min ? : 0,
 757                         pdata->x_max ? : MAX_12BIT,
 758                         0, 0);
 759         input_set_abs_params(input_dev, ABS_Y,
 760                         pdata->y_min ? : 0,
 761                         pdata->y_max ? : MAX_12BIT,
 762                         0, 0);
 763         input_set_abs_params(input_dev, ABS_PRESSURE,
 764                         pdata->pressure_min, pdata->pressure_max, 0, 0);
 765
 766         ad7877_write(spi, AD7877_REG_SEQ1, AD7877_MM_SEQUENCE);
 767
 768         verify = ad7877_read(spi, AD7877_REG_SEQ1);
 769
 770         if (verify != AD7877_MM_SEQUENCE){
 771                 dev_err(&spi->dev, "%s: Failed to probe %s\n",
 772                         dev_name(&spi->dev), input_dev->name);
 773                 err = -ENODEV;
 774                 goto err_free_mem;
 775         }
 776
 777         if (gpio3)
 778                 ad7877_write(spi, AD7877_REG_EXTWRITE, AD7877_EXTW_GPIO_3_CONF);
 779
 780         ad7877_setup_ts_def_msg(spi, ts);
 781
 782         /* Request AD7877 /DAV GPIO interrupt */
 783
 784         err = request_threaded_irq(spi->irq, NULL, ad7877_irq,
 785                                    IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 786                                    spi->dev.driver->name, ts);
 787         if (err) {
 788                 dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq);
 789                 goto err_free_mem;
 790         }
 791
 792         err = sysfs_create_group(&spi->dev.kobj, &ad7877_attr_group);
 793         if (err)
 794                 goto err_free_irq;
 795
 796         err = input_register_device(input_dev);
 797         if (err)
 798                 goto err_remove_attr_group;
 799
 800         return 0;
 801
 802 err_remove_attr_group:
 803         sysfs_remove_group(&spi->dev.kobj, &ad7877_attr_group);
 804 err_free_irq:
 805         free_irq(spi->irq, ts);
 806 err_free_mem:
 807         input_free_device(input_dev);
 808         kfree(ts);
 809         dev_set_drvdata(&spi->dev, NULL);
 810         return err;
 811 }
 812
 813 static int __devexit ad7877_remove(struct spi_device *spi)
 814 {
 815         struct ad7877 *ts = dev_get_drvdata(&spi->dev);
 816
 817         sysfs_remove_group(&spi->dev.kobj, &ad7877_attr_group);
 818
 819         ad7877_disable(ts);
 820         free_irq(ts->spi->irq, ts);
 821
 822         input_unregister_device(ts->input);
 823         kfree(ts);
 824
 825         dev_dbg(&spi->dev, "unregistered touchscreen\n");
 826         dev_set_drvdata(&spi->dev, NULL);
 827
 828         return 0;
 829 }
 830
 831 #ifdef CONFIG_PM_SLEEP
 832 static int ad7877_suspend(struct device *dev)
 833 {
 834         struct ad7877 *ts = dev_get_drvdata(dev);
 835
 836         ad7877_disable(ts);
 837
 838         return 0;
 839 }
 840
 841 static int ad7877_resume(struct device *dev)
 842 {
 843         struct ad7877 *ts = dev_get_drvdata(dev);
 844
 845         ad7877_enable(ts);
 846
 847         return 0;
 848 }
 849 #endif
 850
 851 static SIMPLE_DEV_PM_OPS(ad7877_pm, ad7877_suspend, ad7877_resume);
 852
 853 static struct spi_driver ad7877_driver = {
 854         .driver = {
 855                 .name   = "ad7877",
 856                 .owner  = THIS_MODULE,
 857                 .pm     = &ad7877_pm,
 858         },
 859         .probe          = ad7877_probe,
 860         .remove         = __devexit_p(ad7877_remove),
 861 };
 862
 863 static int __init ad7877_init(void)
 864 {
 865         return spi_register_driver(&ad7877_driver);
 866 }
 867 module_init(ad7877_init);
 868
 869 static void __exit ad7877_exit(void)
 870 {
 871         spi_unregister_driver(&ad7877_driver);
 872 }
 873 module_exit(ad7877_exit);
 874
 875 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 876 MODULE_DESCRIPTION("AD7877 touchscreen Driver");
 877 MODULE_LICENSE("GPL");
 878 MODULE_ALIAS("spi:ad7877");