drivers/input/touchscreen/ad7877.c

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