drivers/input/touchscreen/ads7846.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * ADS7846 based touchscreen and sensor driver
   4  *
   5  * Copyright (c) 2005 David Brownell
   6  * Copyright (c) 2006 Nokia Corporation
   7  * Various changes: Imre Deak <imre.deak@nokia.com>
   8  *
   9  * Using code from:
  10  *  - corgi_ts.c
  11  *      Copyright (C) 2004-2005 Richard Purdie
  12  *  - omap_ts.[hc], ads7846.h, ts_osk.c
  13  *      Copyright (C) 2002 MontaVista Software
  14  *      Copyright (C) 2004 Texas Instruments
  15  *      Copyright (C) 2005 Dirk Behme
  16  */
  17 #include <linux/types.h>
  18 #include <linux/hwmon.h>
  19 #include <linux/err.h>
  20 #include <linux/sched.h>
  21 #include <linux/delay.h>
  22 #include <linux/input.h>
  23 #include <linux/input/touchscreen.h>
  24 #include <linux/interrupt.h>
  25 #include <linux/slab.h>
  26 #include <linux/pm.h>
  27 #include <linux/property.h>
  28 #include <linux/gpio/consumer.h>
  29 #include <linux/spi/spi.h>
  30 #include <linux/spi/ads7846.h>
  31 #include <linux/regulator/consumer.h>
  32 #include <linux/module.h>
  33 #include <asm/unaligned.h>
  34
  35 /*
  36  * This code has been heavily tested on a Nokia 770, and lightly
  37  * tested on other ads7846 devices (OSK/Mistral, Lubbock, Spitz).
  38  * TSC2046 is just newer ads7846 silicon.
  39  * Support for ads7843 tested on Atmel at91sam926x-EK.
  40  * Support for ads7845 has only been stubbed in.
  41  * Support for Analog Devices AD7873 and AD7843 tested.
  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_DELAY   1       /* ms delay before the first sample */
  58 #define TS_POLL_PERIOD  5       /* ms delay between samples */
  59
  60 /* this driver doesn't aim at the peak continuous sample rate */
  61 #define SAMPLE_BITS     (8 /*cmd*/ + 16 /*sample*/ + 2 /* before, after */)
  62
  63 struct ads7846_buf {
  64         u8 cmd;
  65         __be16 data;
  66 } __packed;
  67
  68 struct ads7846_buf_layout {
  69         unsigned int offset;
  70         unsigned int count;
  71         unsigned int skip;
  72 };
  73
  74 /*
  75  * We allocate this separately to avoid cache line sharing issues when
  76  * driver is used with DMA-based SPI controllers (like atmel_spi) on
  77  * systems where main memory is not DMA-coherent (most non-x86 boards).
  78  */
  79 struct ads7846_packet {
  80         unsigned int count;
  81         unsigned int count_skip;
  82         unsigned int cmds;
  83         unsigned int last_cmd_idx;
  84         struct ads7846_buf_layout l[5];
  85         struct ads7846_buf *rx;
  86         struct ads7846_buf *tx;
  87
  88         struct ads7846_buf pwrdown_cmd;
  89
  90         bool ignore;
  91         u16 x, y, z1, z2;
  92 };
  93
  94 struct ads7846 {
  95         struct input_dev        *input;
  96         char                    phys[32];
  97         char                    name[32];
  98
  99         struct spi_device       *spi;
 100         struct regulator        *reg;
 101
 102         u16                     model;
 103         u16                     vref_mv;
 104         u16                     vref_delay_usecs;
 105         u16                     x_plate_ohms;
 106         u16                     pressure_max;
 107
 108         bool                    swap_xy;
 109         bool                    use_internal;
 110
 111         struct ads7846_packet   *packet;
 112
 113         struct spi_transfer     xfer[18];
 114         struct spi_message      msg[5];
 115         int                     msg_count;
 116         wait_queue_head_t       wait;
 117
 118         bool                    pendown;
 119
 120         int                     read_cnt;
 121         int                     read_rep;
 122         int                     last_read;
 123
 124         u16                     debounce_max;
 125         u16                     debounce_tol;
 126         u16                     debounce_rep;
 127
 128         u16                     penirq_recheck_delay_usecs;
 129
 130         struct touchscreen_properties core_prop;
 131
 132         struct mutex            lock;
 133         bool                    stopped;        /* P: lock */
 134         bool                    disabled;       /* P: lock */
 135         bool                    suspended;      /* P: lock */
 136
 137         int                     (*filter)(void *data, int data_idx, int *val);
 138         void                    *filter_data;
 139         int                     (*get_pendown_state)(void);
 140         struct gpio_desc        *gpio_pendown;
 141
 142         void                    (*wait_for_sync)(void);
 143 };
 144
 145 enum ads7846_filter {
 146         ADS7846_FILTER_OK,
 147         ADS7846_FILTER_REPEAT,
 148         ADS7846_FILTER_IGNORE,
 149 };
 150
 151 /* leave chip selected when we're done, for quicker re-select? */
 152 #if     0
 153 #define CS_CHANGE(xfer) ((xfer).cs_change = 1)
 154 #else
 155 #define CS_CHANGE(xfer) ((xfer).cs_change = 0)
 156 #endif
 157
 158 /*--------------------------------------------------------------------------*/
 159
 160 /* The ADS7846 has touchscreen and other sensors.
 161  * Earlier ads784x chips are somewhat compatible.
 162  */
 163 #define ADS_START               (1 << 7)
 164 #define ADS_A2A1A0_d_y          (1 << 4)        /* differential */
 165 #define ADS_A2A1A0_d_z1         (3 << 4)        /* differential */
 166 #define ADS_A2A1A0_d_z2         (4 << 4)        /* differential */
 167 #define ADS_A2A1A0_d_x          (5 << 4)        /* differential */
 168 #define ADS_A2A1A0_temp0        (0 << 4)        /* non-differential */
 169 #define ADS_A2A1A0_vbatt        (2 << 4)        /* non-differential */
 170 #define ADS_A2A1A0_vaux         (6 << 4)        /* non-differential */
 171 #define ADS_A2A1A0_temp1        (7 << 4)        /* non-differential */
 172 #define ADS_8_BIT               (1 << 3)
 173 #define ADS_12_BIT              (0 << 3)
 174 #define ADS_SER                 (1 << 2)        /* non-differential */
 175 #define ADS_DFR                 (0 << 2)        /* differential */
 176 #define ADS_PD10_PDOWN          (0 << 0)        /* low power mode + penirq */
 177 #define ADS_PD10_ADC_ON         (1 << 0)        /* ADC on */
 178 #define ADS_PD10_REF_ON         (2 << 0)        /* vREF on + penirq */
 179 #define ADS_PD10_ALL_ON         (3 << 0)        /* ADC + vREF on */
 180
 181 #define MAX_12BIT       ((1<<12)-1)
 182
 183 /* leave ADC powered up (disables penirq) between differential samples */
 184 #define READ_12BIT_DFR(x, adc, vref) (ADS_START | ADS_A2A1A0_d_ ## x \
 185         | ADS_12_BIT | ADS_DFR | \
 186         (adc ? ADS_PD10_ADC_ON : 0) | (vref ? ADS_PD10_REF_ON : 0))
 187
 188 #define READ_Y(vref)    (READ_12BIT_DFR(y,  1, vref))
 189 #define READ_Z1(vref)   (READ_12BIT_DFR(z1, 1, vref))
 190 #define READ_Z2(vref)   (READ_12BIT_DFR(z2, 1, vref))
 191 #define READ_X(vref)    (READ_12BIT_DFR(x,  1, vref))
 192 #define PWRDOWN         (READ_12BIT_DFR(y,  0, 0))      /* LAST */
 193
 194 /* single-ended samples need to first power up reference voltage;
 195  * we leave both ADC and VREF powered
 196  */
 197 #define READ_12BIT_SER(x) (ADS_START | ADS_A2A1A0_ ## x \
 198         | ADS_12_BIT | ADS_SER)
 199
 200 #define REF_ON  (READ_12BIT_DFR(x, 1, 1))
 201 #define REF_OFF (READ_12BIT_DFR(y, 0, 0))
 202
 203 /* Order commands in the most optimal way to reduce Vref switching and
 204  * settling time:
 205  * Measure:  X; Vref: X+, X-; IN: Y+
 206  * Measure:  Y; Vref: Y+, Y-; IN: X+
 207  * Measure: Z1; Vref: Y+, X-; IN: X+
 208  * Measure: Z2; Vref: Y+, X-; IN: Y-
 209  */
 210 enum ads7846_cmds {
 211         ADS7846_X,
 212         ADS7846_Y,
 213         ADS7846_Z1,
 214         ADS7846_Z2,
 215         ADS7846_PWDOWN,
 216 };
 217
 218 static int get_pendown_state(struct ads7846 *ts)
 219 {
 220         if (ts->get_pendown_state)
 221                 return ts->get_pendown_state();
 222
 223         return gpiod_get_value(ts->gpio_pendown);
 224 }
 225
 226 static void ads7846_report_pen_up(struct ads7846 *ts)
 227 {
 228         struct input_dev *input = ts->input;
 229
 230         input_report_key(input, BTN_TOUCH, 0);
 231         input_report_abs(input, ABS_PRESSURE, 0);
 232         input_sync(input);
 233
 234         ts->pendown = false;
 235         dev_vdbg(&ts->spi->dev, "UP\n");
 236 }
 237
 238 /* Must be called with ts->lock held */
 239 static void ads7846_stop(struct ads7846 *ts)
 240 {
 241         if (!ts->disabled && !ts->suspended) {
 242                 /* Signal IRQ thread to stop polling and disable the handler. */
 243                 ts->stopped = true;
 244                 mb();
 245                 wake_up(&ts->wait);
 246                 disable_irq(ts->spi->irq);
 247         }
 248 }
 249
 250 /* Must be called with ts->lock held */
 251 static void ads7846_restart(struct ads7846 *ts)
 252 {
 253         if (!ts->disabled && !ts->suspended) {
 254                 /* Check if pen was released since last stop */
 255                 if (ts->pendown && !get_pendown_state(ts))
 256                         ads7846_report_pen_up(ts);
 257
 258                 /* Tell IRQ thread that it may poll the device. */
 259                 ts->stopped = false;
 260                 mb();
 261                 enable_irq(ts->spi->irq);
 262         }
 263 }
 264
 265 /* Must be called with ts->lock held */
 266 static void __ads7846_disable(struct ads7846 *ts)
 267 {
 268         ads7846_stop(ts);
 269         regulator_disable(ts->reg);
 270
 271         /*
 272          * We know the chip's in low power mode since we always
 273          * leave it that way after every request
 274          */
 275 }
 276
 277 /* Must be called with ts->lock held */
 278 static void __ads7846_enable(struct ads7846 *ts)
 279 {
 280         int error;
 281
 282         error = regulator_enable(ts->reg);
 283         if (error != 0)
 284                 dev_err(&ts->spi->dev, "Failed to enable supply: %d\n", error);
 285
 286         ads7846_restart(ts);
 287 }
 288
 289 static void ads7846_disable(struct ads7846 *ts)
 290 {
 291         mutex_lock(&ts->lock);
 292
 293         if (!ts->disabled) {
 294
 295                 if  (!ts->suspended)
 296                         __ads7846_disable(ts);
 297
 298                 ts->disabled = true;
 299         }
 300
 301         mutex_unlock(&ts->lock);
 302 }
 303
 304 static void ads7846_enable(struct ads7846 *ts)
 305 {
 306         mutex_lock(&ts->lock);
 307
 308         if (ts->disabled) {
 309
 310                 ts->disabled = false;
 311
 312                 if (!ts->suspended)
 313                         __ads7846_enable(ts);
 314         }
 315
 316         mutex_unlock(&ts->lock);
 317 }
 318
 319 /*--------------------------------------------------------------------------*/
 320
 321 /*
 322  * Non-touchscreen sensors only use single-ended conversions.
 323  * The range is GND..vREF. The ads7843 and ads7835 must use external vREF;
 324  * ads7846 lets that pin be unconnected, to use internal vREF.
 325  */
 326
 327 struct ser_req {
 328         u8                      ref_on;
 329         u8                      command;
 330         u8                      ref_off;
 331         u16                     scratch;
 332         struct spi_message      msg;
 333         struct spi_transfer     xfer[6];
 334         /*
 335          * DMA (thus cache coherency maintenance) requires the
 336          * transfer buffers to live in their own cache lines.
 337          */
 338         __be16 sample ____cacheline_aligned;
 339 };
 340
 341 struct ads7845_ser_req {
 342         u8                      command[3];
 343         struct spi_message      msg;
 344         struct spi_transfer     xfer[2];
 345         /*
 346          * DMA (thus cache coherency maintenance) requires the
 347          * transfer buffers to live in their own cache lines.
 348          */
 349         u8 sample[3] ____cacheline_aligned;
 350 };
 351
 352 static int ads7846_read12_ser(struct device *dev, unsigned command)
 353 {
 354         struct spi_device *spi = to_spi_device(dev);
 355         struct ads7846 *ts = dev_get_drvdata(dev);
 356         struct ser_req *req;
 357         int status;
 358
 359         req = kzalloc(sizeof *req, GFP_KERNEL);
 360         if (!req)
 361                 return -ENOMEM;
 362
 363         spi_message_init(&req->msg);
 364
 365         /* maybe turn on internal vREF, and let it settle */
 366         if (ts->use_internal) {
 367                 req->ref_on = REF_ON;
 368                 req->xfer[0].tx_buf = &req->ref_on;
 369                 req->xfer[0].len = 1;
 370                 spi_message_add_tail(&req->xfer[0], &req->msg);
 371
 372                 req->xfer[1].rx_buf = &req->scratch;
 373                 req->xfer[1].len = 2;
 374
 375                 /* for 1uF, settle for 800 usec; no cap, 100 usec.  */
 376                 req->xfer[1].delay.value = ts->vref_delay_usecs;
 377                 req->xfer[1].delay.unit = SPI_DELAY_UNIT_USECS;
 378                 spi_message_add_tail(&req->xfer[1], &req->msg);
 379
 380                 /* Enable reference voltage */
 381                 command |= ADS_PD10_REF_ON;
 382         }
 383
 384         /* Enable ADC in every case */
 385         command |= ADS_PD10_ADC_ON;
 386
 387         /* take sample */
 388         req->command = (u8) command;
 389         req->xfer[2].tx_buf = &req->command;
 390         req->xfer[2].len = 1;
 391         spi_message_add_tail(&req->xfer[2], &req->msg);
 392
 393         req->xfer[3].rx_buf = &req->sample;
 394         req->xfer[3].len = 2;
 395         spi_message_add_tail(&req->xfer[3], &req->msg);
 396
 397         /* REVISIT:  take a few more samples, and compare ... */
 398
 399         /* converter in low power mode & enable PENIRQ */
 400         req->ref_off = PWRDOWN;
 401         req->xfer[4].tx_buf = &req->ref_off;
 402         req->xfer[4].len = 1;
 403         spi_message_add_tail(&req->xfer[4], &req->msg);
 404
 405         req->xfer[5].rx_buf = &req->scratch;
 406         req->xfer[5].len = 2;
 407         CS_CHANGE(req->xfer[5]);
 408         spi_message_add_tail(&req->xfer[5], &req->msg);
 409
 410         mutex_lock(&ts->lock);
 411         ads7846_stop(ts);
 412         status = spi_sync(spi, &req->msg);
 413         ads7846_restart(ts);
 414         mutex_unlock(&ts->lock);
 415
 416         if (status == 0) {
 417                 /* on-wire is a must-ignore bit, a BE12 value, then padding */
 418                 status = be16_to_cpu(req->sample);
 419                 status = status >> 3;
 420                 status &= 0x0fff;
 421         }
 422
 423         kfree(req);
 424         return status;
 425 }
 426
 427 static int ads7845_read12_ser(struct device *dev, unsigned command)
 428 {
 429         struct spi_device *spi = to_spi_device(dev);
 430         struct ads7846 *ts = dev_get_drvdata(dev);
 431         struct ads7845_ser_req *req;
 432         int status;
 433
 434         req = kzalloc(sizeof *req, GFP_KERNEL);
 435         if (!req)
 436                 return -ENOMEM;
 437
 438         spi_message_init(&req->msg);
 439
 440         req->command[0] = (u8) command;
 441         req->xfer[0].tx_buf = req->command;
 442         req->xfer[0].rx_buf = req->sample;
 443         req->xfer[0].len = 3;
 444         spi_message_add_tail(&req->xfer[0], &req->msg);
 445
 446         mutex_lock(&ts->lock);
 447         ads7846_stop(ts);
 448         status = spi_sync(spi, &req->msg);
 449         ads7846_restart(ts);
 450         mutex_unlock(&ts->lock);
 451
 452         if (status == 0) {
 453                 /* BE12 value, then padding */
 454                 status = get_unaligned_be16(&req->sample[1]);
 455                 status = status >> 3;
 456                 status &= 0x0fff;
 457         }
 458
 459         kfree(req);
 460         return status;
 461 }
 462
 463 #if IS_ENABLED(CONFIG_HWMON)
 464
 465 #define SHOW(name, var, adjust) static ssize_t \
 466 name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \
 467 { \
 468         struct ads7846 *ts = dev_get_drvdata(dev); \
 469         ssize_t v = ads7846_read12_ser(&ts->spi->dev, \
 470                         READ_12BIT_SER(var)); \
 471         if (v < 0) \
 472                 return v; \
 473         return sprintf(buf, "%u\n", adjust(ts, v)); \
 474 } \
 475 static DEVICE_ATTR(name, S_IRUGO, name ## _show, NULL);
 476
 477
 478 /* Sysfs conventions report temperatures in millidegrees Celsius.
 479  * ADS7846 could use the low-accuracy two-sample scheme, but can't do the high
 480  * accuracy scheme without calibration data.  For now we won't try either;
 481  * userspace sees raw sensor values, and must scale/calibrate appropriately.
 482  */
 483 static inline unsigned null_adjust(struct ads7846 *ts, ssize_t v)
 484 {
 485         return v;
 486 }
 487
 488 SHOW(temp0, temp0, null_adjust)         /* temp1_input */
 489 SHOW(temp1, temp1, null_adjust)         /* temp2_input */
 490
 491
 492 /* sysfs conventions report voltages in millivolts.  We can convert voltages
 493  * if we know vREF.  userspace may need to scale vAUX to match the board's
 494  * external resistors; we assume that vBATT only uses the internal ones.
 495  */
 496 static inline unsigned vaux_adjust(struct ads7846 *ts, ssize_t v)
 497 {
 498         unsigned retval = v;
 499
 500         /* external resistors may scale vAUX into 0..vREF */
 501         retval *= ts->vref_mv;
 502         retval = retval >> 12;
 503
 504         return retval;
 505 }
 506
 507 static inline unsigned vbatt_adjust(struct ads7846 *ts, ssize_t v)
 508 {
 509         unsigned retval = vaux_adjust(ts, v);
 510
 511         /* ads7846 has a resistor ladder to scale this signal down */
 512         if (ts->model == 7846)
 513                 retval *= 4;
 514
 515         return retval;
 516 }
 517
 518 SHOW(in0_input, vaux, vaux_adjust)
 519 SHOW(in1_input, vbatt, vbatt_adjust)
 520
 521 static umode_t ads7846_is_visible(struct kobject *kobj, struct attribute *attr,
 522                                   int index)
 523 {
 524         struct device *dev = kobj_to_dev(kobj);
 525         struct ads7846 *ts = dev_get_drvdata(dev);
 526
 527         if (ts->model == 7843 && index < 2)     /* in0, in1 */
 528                 return 0;
 529         if (ts->model == 7845 && index != 2)    /* in0 */
 530                 return 0;
 531
 532         return attr->mode;
 533 }
 534
 535 static struct attribute *ads7846_attributes[] = {
 536         &dev_attr_temp0.attr,           /* 0 */
 537         &dev_attr_temp1.attr,           /* 1 */
 538         &dev_attr_in0_input.attr,       /* 2 */
 539         &dev_attr_in1_input.attr,       /* 3 */
 540         NULL,
 541 };
 542
 543 static const struct attribute_group ads7846_attr_group = {
 544         .attrs = ads7846_attributes,
 545         .is_visible = ads7846_is_visible,
 546 };
 547 __ATTRIBUTE_GROUPS(ads7846_attr);
 548
 549 static int ads784x_hwmon_register(struct spi_device *spi, struct ads7846 *ts)
 550 {
 551         struct device *hwmon;
 552
 553         /* hwmon sensors need a reference voltage */
 554         switch (ts->model) {
 555         case 7846:
 556                 if (!ts->vref_mv) {
 557                         dev_dbg(&spi->dev, "assuming 2.5V internal vREF\n");
 558                         ts->vref_mv = 2500;
 559                         ts->use_internal = true;
 560                 }
 561                 break;
 562         case 7845:
 563         case 7843:
 564                 if (!ts->vref_mv) {
 565                         dev_warn(&spi->dev,
 566                                 "external vREF for ADS%d not specified\n",
 567                                 ts->model);
 568                         return 0;
 569                 }
 570                 break;
 571         }
 572
 573         hwmon = devm_hwmon_device_register_with_groups(&spi->dev,
 574                                                        spi->modalias, ts,
 575                                                        ads7846_attr_groups);
 576
 577         return PTR_ERR_OR_ZERO(hwmon);
 578 }
 579
 580 #else
 581 static inline int ads784x_hwmon_register(struct spi_device *spi,
 582                                          struct ads7846 *ts)
 583 {
 584         return 0;
 585 }
 586 #endif
 587
 588 static ssize_t ads7846_pen_down_show(struct device *dev,
 589                                      struct device_attribute *attr, char *buf)
 590 {
 591         struct ads7846 *ts = dev_get_drvdata(dev);
 592
 593         return sprintf(buf, "%u\n", ts->pendown);
 594 }
 595
 596 static DEVICE_ATTR(pen_down, S_IRUGO, ads7846_pen_down_show, NULL);
 597
 598 static ssize_t ads7846_disable_show(struct device *dev,
 599                                      struct device_attribute *attr, char *buf)
 600 {
 601         struct ads7846 *ts = dev_get_drvdata(dev);
 602
 603         return sprintf(buf, "%u\n", ts->disabled);
 604 }
 605
 606 static ssize_t ads7846_disable_store(struct device *dev,
 607                                      struct device_attribute *attr,
 608                                      const char *buf, size_t count)
 609 {
 610         struct ads7846 *ts = dev_get_drvdata(dev);
 611         unsigned int i;
 612         int err;
 613
 614         err = kstrtouint(buf, 10, &i);
 615         if (err)
 616                 return err;
 617
 618         if (i)
 619                 ads7846_disable(ts);
 620         else
 621                 ads7846_enable(ts);
 622
 623         return count;
 624 }
 625
 626 static DEVICE_ATTR(disable, 0664, ads7846_disable_show, ads7846_disable_store);
 627
 628 static struct attribute *ads784x_attrs[] = {
 629         &dev_attr_pen_down.attr,
 630         &dev_attr_disable.attr,
 631         NULL,
 632 };
 633 ATTRIBUTE_GROUPS(ads784x);
 634
 635 /*--------------------------------------------------------------------------*/
 636
 637 static void null_wait_for_sync(void)
 638 {
 639 }
 640
 641 static int ads7846_debounce_filter(void *ads, int data_idx, int *val)
 642 {
 643         struct ads7846 *ts = ads;
 644
 645         if (!ts->read_cnt || (abs(ts->last_read - *val) > ts->debounce_tol)) {
 646                 /* Start over collecting consistent readings. */
 647                 ts->read_rep = 0;
 648                 /*
 649                  * Repeat it, if this was the first read or the read
 650                  * wasn't consistent enough.
 651                  */
 652                 if (ts->read_cnt < ts->debounce_max) {
 653                         ts->last_read = *val;
 654                         ts->read_cnt++;
 655                         return ADS7846_FILTER_REPEAT;
 656                 } else {
 657                         /*
 658                          * Maximum number of debouncing reached and still
 659                          * not enough number of consistent readings. Abort
 660                          * the whole sample, repeat it in the next sampling
 661                          * period.
 662                          */
 663                         ts->read_cnt = 0;
 664                         return ADS7846_FILTER_IGNORE;
 665                 }
 666         } else {
 667                 if (++ts->read_rep > ts->debounce_rep) {
 668                         /*
 669                          * Got a good reading for this coordinate,
 670                          * go for the next one.
 671                          */
 672                         ts->read_cnt = 0;
 673                         ts->read_rep = 0;
 674                         return ADS7846_FILTER_OK;
 675                 } else {
 676                         /* Read more values that are consistent. */
 677                         ts->read_cnt++;
 678                         return ADS7846_FILTER_REPEAT;
 679                 }
 680         }
 681 }
 682
 683 static int ads7846_no_filter(void *ads, int data_idx, int *val)
 684 {
 685         return ADS7846_FILTER_OK;
 686 }
 687
 688 static int ads7846_get_value(struct ads7846_buf *buf)
 689 {
 690         int value;
 691
 692         value = be16_to_cpup(&buf->data);
 693
 694         /* enforce ADC output is 12 bits width */
 695         return (value >> 3) & 0xfff;
 696 }
 697
 698 static void ads7846_set_cmd_val(struct ads7846 *ts, enum ads7846_cmds cmd_idx,
 699                                 u16 val)
 700 {
 701         struct ads7846_packet *packet = ts->packet;
 702
 703         switch (cmd_idx) {
 704         case ADS7846_Y:
 705                 packet->y = val;
 706                 break;
 707         case ADS7846_X:
 708                 packet->x = val;
 709                 break;
 710         case ADS7846_Z1:
 711                 packet->z1 = val;
 712                 break;
 713         case ADS7846_Z2:
 714                 packet->z2 = val;
 715                 break;
 716         default:
 717                 WARN_ON_ONCE(1);
 718         }
 719 }
 720
 721 static u8 ads7846_get_cmd(enum ads7846_cmds cmd_idx, int vref)
 722 {
 723         switch (cmd_idx) {
 724         case ADS7846_Y:
 725                 return READ_Y(vref);
 726         case ADS7846_X:
 727                 return READ_X(vref);
 728
 729         /* 7846 specific commands  */
 730         case ADS7846_Z1:
 731                 return READ_Z1(vref);
 732         case ADS7846_Z2:
 733                 return READ_Z2(vref);
 734         case ADS7846_PWDOWN:
 735                 return PWRDOWN;
 736         default:
 737                 WARN_ON_ONCE(1);
 738         }
 739
 740         return 0;
 741 }
 742
 743 static bool ads7846_cmd_need_settle(enum ads7846_cmds cmd_idx)
 744 {
 745         switch (cmd_idx) {
 746         case ADS7846_X:
 747         case ADS7846_Y:
 748         case ADS7846_Z1:
 749         case ADS7846_Z2:
 750                 return true;
 751         case ADS7846_PWDOWN:
 752                 return false;
 753         default:
 754                 WARN_ON_ONCE(1);
 755         }
 756
 757         return false;
 758 }
 759
 760 static int ads7846_filter(struct ads7846 *ts)
 761 {
 762         struct ads7846_packet *packet = ts->packet;
 763         int action;
 764         int val;
 765         unsigned int cmd_idx, b;
 766
 767         packet->ignore = false;
 768         for (cmd_idx = packet->last_cmd_idx; cmd_idx < packet->cmds - 1; cmd_idx++) {
 769                 struct ads7846_buf_layout *l = &packet->l[cmd_idx];
 770
 771                 packet->last_cmd_idx = cmd_idx;
 772
 773                 for (b = l->skip; b < l->count; b++) {
 774                         val = ads7846_get_value(&packet->rx[l->offset + b]);
 775
 776                         action = ts->filter(ts->filter_data, cmd_idx, &val);
 777                         if (action == ADS7846_FILTER_REPEAT) {
 778                                 if (b == l->count - 1)
 779                                         return -EAGAIN;
 780                         } else if (action == ADS7846_FILTER_OK) {
 781                                 ads7846_set_cmd_val(ts, cmd_idx, val);
 782                                 break;
 783                         } else {
 784                                 packet->ignore = true;
 785                                 return 0;
 786                         }
 787                 }
 788         }
 789
 790         return 0;
 791 }
 792
 793 static void ads7846_read_state(struct ads7846 *ts)
 794 {
 795         struct ads7846_packet *packet = ts->packet;
 796         struct spi_message *m;
 797         int msg_idx = 0;
 798         int error;
 799
 800         packet->last_cmd_idx = 0;
 801
 802         while (true) {
 803                 ts->wait_for_sync();
 804
 805                 m = &ts->msg[msg_idx];
 806                 error = spi_sync(ts->spi, m);
 807                 if (error) {
 808                         dev_err(&ts->spi->dev, "spi_sync --> %d\n", error);
 809                         packet->ignore = true;
 810                         return;
 811                 }
 812
 813                 error = ads7846_filter(ts);
 814                 if (error)
 815                         continue;
 816
 817                 return;
 818         }
 819 }
 820
 821 static void ads7846_report_state(struct ads7846 *ts)
 822 {
 823         struct ads7846_packet *packet = ts->packet;
 824         unsigned int Rt;
 825         u16 x, y, z1, z2;
 826
 827         x = packet->x;
 828         y = packet->y;
 829         if (ts->model == 7845) {
 830                 z1 = 0;
 831                 z2 = 0;
 832         } else {
 833                 z1 = packet->z1;
 834                 z2 = packet->z2;
 835         }
 836
 837         /* range filtering */
 838         if (x == MAX_12BIT)
 839                 x = 0;
 840
 841         if (ts->model == 7843 || ts->model == 7845) {
 842                 Rt = ts->pressure_max / 2;
 843         } else if (likely(x && z1)) {
 844                 /* compute touch pressure resistance using equation #2 */
 845                 Rt = z2;
 846                 Rt -= z1;
 847                 Rt *= ts->x_plate_ohms;
 848                 Rt = DIV_ROUND_CLOSEST(Rt, 16);
 849                 Rt *= x;
 850                 Rt /= z1;
 851                 Rt = DIV_ROUND_CLOSEST(Rt, 256);
 852         } else {
 853                 Rt = 0;
 854         }
 855
 856         /*
 857          * Sample found inconsistent by debouncing or pressure is beyond
 858          * the maximum. Don't report it to user space, repeat at least
 859          * once more the measurement
 860          */
 861         if (packet->ignore || Rt > ts->pressure_max) {
 862                 dev_vdbg(&ts->spi->dev, "ignored %d pressure %d\n",
 863                          packet->ignore, Rt);
 864                 return;
 865         }
 866
 867         /*
 868          * Maybe check the pendown state before reporting. This discards
 869          * false readings when the pen is lifted.
 870          */
 871         if (ts->penirq_recheck_delay_usecs) {
 872                 udelay(ts->penirq_recheck_delay_usecs);
 873                 if (!get_pendown_state(ts))
 874                         Rt = 0;
 875         }
 876
 877         /*
 878          * NOTE: We can't rely on the pressure to determine the pen down
 879          * state, even this controller has a pressure sensor. The pressure
 880          * value can fluctuate for quite a while after lifting the pen and
 881          * in some cases may not even settle at the expected value.
 882          *
 883          * The only safe way to check for the pen up condition is in the
 884          * timer by reading the pen signal state (it's a GPIO _and_ IRQ).
 885          */
 886         if (Rt) {
 887                 struct input_dev *input = ts->input;
 888
 889                 if (!ts->pendown) {
 890                         input_report_key(input, BTN_TOUCH, 1);
 891                         ts->pendown = true;
 892                         dev_vdbg(&ts->spi->dev, "DOWN\n");
 893                 }
 894
 895                 touchscreen_report_pos(input, &ts->core_prop, x, y, false);
 896                 input_report_abs(input, ABS_PRESSURE, ts->pressure_max - Rt);
 897
 898                 input_sync(input);
 899                 dev_vdbg(&ts->spi->dev, "%4d/%4d/%4d\n", x, y, Rt);
 900         }
 901 }
 902
 903 static irqreturn_t ads7846_hard_irq(int irq, void *handle)
 904 {
 905         struct ads7846 *ts = handle;
 906
 907         return get_pendown_state(ts) ? IRQ_WAKE_THREAD : IRQ_HANDLED;
 908 }
 909
 910
 911 static irqreturn_t ads7846_irq(int irq, void *handle)
 912 {
 913         struct ads7846 *ts = handle;
 914
 915         /* Start with a small delay before checking pendown state */
 916         msleep(TS_POLL_DELAY);
 917
 918         while (!ts->stopped && get_pendown_state(ts)) {
 919
 920                 /* pen is down, continue with the measurement */
 921                 ads7846_read_state(ts);
 922
 923                 if (!ts->stopped)
 924                         ads7846_report_state(ts);
 925
 926                 wait_event_timeout(ts->wait, ts->stopped,
 927                                    msecs_to_jiffies(TS_POLL_PERIOD));
 928         }
 929
 930         if (ts->pendown && !ts->stopped)
 931                 ads7846_report_pen_up(ts);
 932
 933         return IRQ_HANDLED;
 934 }
 935
 936 static int ads7846_suspend(struct device *dev)
 937 {
 938         struct ads7846 *ts = dev_get_drvdata(dev);
 939
 940         mutex_lock(&ts->lock);
 941
 942         if (!ts->suspended) {
 943
 944                 if (!ts->disabled)
 945                         __ads7846_disable(ts);
 946
 947                 if (device_may_wakeup(&ts->spi->dev))
 948                         enable_irq_wake(ts->spi->irq);
 949
 950                 ts->suspended = true;
 951         }
 952
 953         mutex_unlock(&ts->lock);
 954
 955         return 0;
 956 }
 957
 958 static int ads7846_resume(struct device *dev)
 959 {
 960         struct ads7846 *ts = dev_get_drvdata(dev);
 961
 962         mutex_lock(&ts->lock);
 963
 964         if (ts->suspended) {
 965
 966                 ts->suspended = false;
 967
 968                 if (device_may_wakeup(&ts->spi->dev))
 969                         disable_irq_wake(ts->spi->irq);
 970
 971                 if (!ts->disabled)
 972                         __ads7846_enable(ts);
 973         }
 974
 975         mutex_unlock(&ts->lock);
 976
 977         return 0;
 978 }
 979
 980 static DEFINE_SIMPLE_DEV_PM_OPS(ads7846_pm, ads7846_suspend, ads7846_resume);
 981
 982 static int ads7846_setup_pendown(struct spi_device *spi,
 983                                  struct ads7846 *ts,
 984                                  const struct ads7846_platform_data *pdata)
 985 {
 986         /*
 987          * REVISIT when the irq can be triggered active-low, or if for some
 988          * reason the touchscreen isn't hooked up, we don't need to access
 989          * the pendown state.
 990          */
 991
 992         if (pdata->get_pendown_state) {
 993                 ts->get_pendown_state = pdata->get_pendown_state;
 994         } else {
 995                 ts->gpio_pendown = gpiod_get(&spi->dev, "pendown", GPIOD_IN);
 996                 if (IS_ERR(ts->gpio_pendown)) {
 997                         dev_err(&spi->dev, "failed to request pendown GPIO\n");
 998                         return PTR_ERR(ts->gpio_pendown);
 999                 }
1000                 if (pdata->gpio_pendown_debounce)
1001                         gpiod_set_debounce(ts->gpio_pendown,
1002                                            pdata->gpio_pendown_debounce);
1003         }
1004
1005         return 0;
1006 }
1007
1008 /*
1009  * Set up the transfers to read touchscreen state; this assumes we
1010  * use formula #2 for pressure, not #3.
1011  */
1012 static int ads7846_setup_spi_msg(struct ads7846 *ts,
1013                                   const struct ads7846_platform_data *pdata)
1014 {
1015         struct spi_message *m = &ts->msg[0];
1016         struct spi_transfer *x = ts->xfer;
1017         struct ads7846_packet *packet = ts->packet;
1018         int vref = pdata->keep_vref_on;
1019         unsigned int count, offset = 0;
1020         unsigned int cmd_idx, b;
1021         unsigned long time;
1022         size_t size = 0;
1023
1024         /* time per bit */
1025         time = NSEC_PER_SEC / ts->spi->max_speed_hz;
1026
1027         count = pdata->settle_delay_usecs * NSEC_PER_USEC / time;
1028         packet->count_skip = DIV_ROUND_UP(count, 24);
1029
1030         if (ts->debounce_max && ts->debounce_rep)
1031                 /* ads7846_debounce_filter() is making ts->debounce_rep + 2
1032                  * reads. So we need to get all samples for normal case. */
1033                 packet->count = ts->debounce_rep + 2;
1034         else
1035                 packet->count = 1;
1036
1037         if (ts->model == 7846)
1038                 packet->cmds = 5; /* x, y, z1, z2, pwdown */
1039         else
1040                 packet->cmds = 3; /* x, y, pwdown */
1041
1042         for (cmd_idx = 0; cmd_idx < packet->cmds; cmd_idx++) {
1043                 struct ads7846_buf_layout *l = &packet->l[cmd_idx];
1044                 unsigned int max_count;
1045
1046                 if (cmd_idx == packet->cmds - 1)
1047                         cmd_idx = ADS7846_PWDOWN;
1048
1049                 if (ads7846_cmd_need_settle(cmd_idx))
1050                         max_count = packet->count + packet->count_skip;
1051                 else
1052                         max_count = packet->count;
1053
1054                 l->offset = offset;
1055                 offset += max_count;
1056                 l->count = max_count;
1057                 l->skip = packet->count_skip;
1058                 size += sizeof(*packet->tx) * max_count;
1059         }
1060
1061         packet->tx = devm_kzalloc(&ts->spi->dev, size, GFP_KERNEL);
1062         if (!packet->tx)
1063                 return -ENOMEM;
1064
1065         packet->rx = devm_kzalloc(&ts->spi->dev, size, GFP_KERNEL);
1066         if (!packet->rx)
1067                 return -ENOMEM;
1068
1069         if (ts->model == 7873) {
1070                 /*
1071                  * The AD7873 is almost identical to the ADS7846
1072                  * keep VREF off during differential/ratiometric
1073                  * conversion modes.
1074                  */
1075                 ts->model = 7846;
1076                 vref = 0;
1077         }
1078
1079         ts->msg_count = 1;
1080         spi_message_init(m);
1081         m->context = ts;
1082
1083         for (cmd_idx = 0; cmd_idx < packet->cmds; cmd_idx++) {
1084                 struct ads7846_buf_layout *l = &packet->l[cmd_idx];
1085                 u8 cmd;
1086
1087                 if (cmd_idx == packet->cmds - 1)
1088                         cmd_idx = ADS7846_PWDOWN;
1089
1090                 cmd = ads7846_get_cmd(cmd_idx, vref);
1091
1092                 for (b = 0; b < l->count; b++)
1093                         packet->tx[l->offset + b].cmd = cmd;
1094         }
1095
1096         x->tx_buf = packet->tx;
1097         x->rx_buf = packet->rx;
1098         x->len = size;
1099         spi_message_add_tail(x, m);
1100
1101         return 0;
1102 }
1103
1104 static const struct of_device_id ads7846_dt_ids[] = {
1105         { .compatible = "ti,tsc2046",   .data = (void *) 7846 },
1106         { .compatible = "ti,ads7843",   .data = (void *) 7843 },
1107         { .compatible = "ti,ads7845",   .data = (void *) 7845 },
1108         { .compatible = "ti,ads7846",   .data = (void *) 7846 },
1109         { .compatible = "ti,ads7873",   .data = (void *) 7873 },
1110         { }
1111 };
1112 MODULE_DEVICE_TABLE(of, ads7846_dt_ids);
1113
1114 static const struct ads7846_platform_data *ads7846_get_props(struct device *dev)
1115 {
1116         struct ads7846_platform_data *pdata;
1117         u32 value;
1118
1119         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
1120         if (!pdata)
1121                 return ERR_PTR(-ENOMEM);
1122
1123         pdata->model = (uintptr_t)device_get_match_data(dev);
1124
1125         device_property_read_u16(dev, "ti,vref-delay-usecs",
1126                                  &pdata->vref_delay_usecs);
1127         device_property_read_u16(dev, "ti,vref-mv", &pdata->vref_mv);
1128         pdata->keep_vref_on = device_property_read_bool(dev, "ti,keep-vref-on");
1129
1130         pdata->swap_xy = device_property_read_bool(dev, "ti,swap-xy");
1131
1132         device_property_read_u16(dev, "ti,settle-delay-usec",
1133                                  &pdata->settle_delay_usecs);
1134         device_property_read_u16(dev, "ti,penirq-recheck-delay-usecs",
1135                                  &pdata->penirq_recheck_delay_usecs);
1136
1137         device_property_read_u16(dev, "ti,x-plate-ohms", &pdata->x_plate_ohms);
1138         device_property_read_u16(dev, "ti,y-plate-ohms", &pdata->y_plate_ohms);
1139
1140         device_property_read_u16(dev, "ti,x-min", &pdata->x_min);
1141         device_property_read_u16(dev, "ti,y-min", &pdata->y_min);
1142         device_property_read_u16(dev, "ti,x-max", &pdata->x_max);
1143         device_property_read_u16(dev, "ti,y-max", &pdata->y_max);
1144
1145         /*
1146          * touchscreen-max-pressure gets parsed during
1147          * touchscreen_parse_properties()
1148          */
1149         device_property_read_u16(dev, "ti,pressure-min", &pdata->pressure_min);
1150         if (!device_property_read_u32(dev, "touchscreen-min-pressure", &value))
1151                 pdata->pressure_min = (u16) value;
1152         device_property_read_u16(dev, "ti,pressure-max", &pdata->pressure_max);
1153
1154         device_property_read_u16(dev, "ti,debounce-max", &pdata->debounce_max);
1155         if (!device_property_read_u32(dev, "touchscreen-average-samples", &value))
1156                 pdata->debounce_max = (u16) value;
1157         device_property_read_u16(dev, "ti,debounce-tol", &pdata->debounce_tol);
1158         device_property_read_u16(dev, "ti,debounce-rep", &pdata->debounce_rep);
1159
1160         device_property_read_u32(dev, "ti,pendown-gpio-debounce",
1161                              &pdata->gpio_pendown_debounce);
1162
1163         pdata->wakeup = device_property_read_bool(dev, "wakeup-source") ||
1164                         device_property_read_bool(dev, "linux,wakeup");
1165
1166         return pdata;
1167 }
1168
1169 static void ads7846_regulator_disable(void *regulator)
1170 {
1171         regulator_disable(regulator);
1172 }
1173
1174 static int ads7846_probe(struct spi_device *spi)
1175 {
1176         const struct ads7846_platform_data *pdata;
1177         struct ads7846 *ts;
1178         struct device *dev = &spi->dev;
1179         struct ads7846_packet *packet;
1180         struct input_dev *input_dev;
1181         unsigned long irq_flags;
1182         int err;
1183
1184         if (!spi->irq) {
1185                 dev_dbg(dev, "no IRQ?\n");
1186                 return -EINVAL;
1187         }
1188
1189         /* don't exceed max specified sample rate */
1190         if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) {
1191                 dev_err(dev, "f(sample) %d KHz?\n",
1192                         (spi->max_speed_hz/SAMPLE_BITS)/1000);
1193                 return -EINVAL;
1194         }
1195
1196         /*
1197          * We'd set TX word size 8 bits and RX word size to 13 bits ... except
1198          * that even if the hardware can do that, the SPI controller driver
1199          * may not.  So we stick to very-portable 8 bit words, both RX and TX.
1200          */
1201         spi->bits_per_word = 8;
1202         spi->mode &= ~SPI_MODE_X_MASK;
1203         spi->mode |= SPI_MODE_0;
1204         err = spi_setup(spi);
1205         if (err < 0)
1206                 return err;
1207
1208         ts = devm_kzalloc(dev, sizeof(struct ads7846), GFP_KERNEL);
1209         if (!ts)
1210                 return -ENOMEM;
1211
1212         packet = devm_kzalloc(dev, sizeof(struct ads7846_packet), GFP_KERNEL);
1213         if (!packet)
1214                 return -ENOMEM;
1215
1216         input_dev = devm_input_allocate_device(dev);
1217         if (!input_dev)
1218                 return -ENOMEM;
1219
1220         spi_set_drvdata(spi, ts);
1221
1222         ts->packet = packet;
1223         ts->spi = spi;
1224         ts->input = input_dev;
1225
1226         mutex_init(&ts->lock);
1227         init_waitqueue_head(&ts->wait);
1228
1229         pdata = dev_get_platdata(dev);
1230         if (!pdata) {
1231                 pdata = ads7846_get_props(dev);
1232                 if (IS_ERR(pdata))
1233                         return PTR_ERR(pdata);
1234         }
1235
1236         ts->model = pdata->model ? : 7846;
1237         ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100;
1238         ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
1239         ts->vref_mv = pdata->vref_mv;
1240
1241         if (pdata->debounce_max) {
1242                 ts->debounce_max = pdata->debounce_max;
1243                 if (ts->debounce_max < 2)
1244                         ts->debounce_max = 2;
1245                 ts->debounce_tol = pdata->debounce_tol;
1246                 ts->debounce_rep = pdata->debounce_rep;
1247                 ts->filter = ads7846_debounce_filter;
1248                 ts->filter_data = ts;
1249         } else {
1250                 ts->filter = ads7846_no_filter;
1251         }
1252
1253         err = ads7846_setup_pendown(spi, ts, pdata);
1254         if (err)
1255                 return err;
1256
1257         if (pdata->penirq_recheck_delay_usecs)
1258                 ts->penirq_recheck_delay_usecs =
1259                                 pdata->penirq_recheck_delay_usecs;
1260
1261         ts->wait_for_sync = pdata->wait_for_sync ? : null_wait_for_sync;
1262
1263         snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
1264         snprintf(ts->name, sizeof(ts->name), "ADS%d Touchscreen", ts->model);
1265
1266         input_dev->name = ts->name;
1267         input_dev->phys = ts->phys;
1268
1269         input_dev->id.bustype = BUS_SPI;
1270         input_dev->id.product = pdata->model;
1271
1272         input_set_capability(input_dev, EV_KEY, BTN_TOUCH);
1273         input_set_abs_params(input_dev, ABS_X,
1274                         pdata->x_min ? : 0,
1275                         pdata->x_max ? : MAX_12BIT,
1276                         0, 0);
1277         input_set_abs_params(input_dev, ABS_Y,
1278                         pdata->y_min ? : 0,
1279                         pdata->y_max ? : MAX_12BIT,
1280                         0, 0);
1281         if (ts->model != 7845)
1282                 input_set_abs_params(input_dev, ABS_PRESSURE,
1283                                 pdata->pressure_min, pdata->pressure_max, 0, 0);
1284
1285         /*
1286          * Parse common framework properties. Must be done here to ensure the
1287          * correct behaviour in case of using the legacy vendor bindings. The
1288          * general binding value overrides the vendor specific one.
1289          */
1290         touchscreen_parse_properties(ts->input, false, &ts->core_prop);
1291         ts->pressure_max = input_abs_get_max(input_dev, ABS_PRESSURE) ? : ~0;
1292
1293         /*
1294          * Check if legacy ti,swap-xy binding is used instead of
1295          * touchscreen-swapped-x-y
1296          */
1297         if (!ts->core_prop.swap_x_y && pdata->swap_xy) {
1298                 swap(input_dev->absinfo[ABS_X], input_dev->absinfo[ABS_Y]);
1299                 ts->core_prop.swap_x_y = true;
1300         }
1301
1302         ads7846_setup_spi_msg(ts, pdata);
1303
1304         ts->reg = devm_regulator_get(dev, "vcc");
1305         if (IS_ERR(ts->reg)) {
1306                 err = PTR_ERR(ts->reg);
1307                 dev_err(dev, "unable to get regulator: %d\n", err);
1308                 return err;
1309         }
1310
1311         err = regulator_enable(ts->reg);
1312         if (err) {
1313                 dev_err(dev, "unable to enable regulator: %d\n", err);
1314                 return err;
1315         }
1316
1317         err = devm_add_action_or_reset(dev, ads7846_regulator_disable, ts->reg);
1318         if (err)
1319                 return err;
1320
1321         irq_flags = pdata->irq_flags ? : IRQF_TRIGGER_FALLING;
1322         irq_flags |= IRQF_ONESHOT;
1323
1324         err = devm_request_threaded_irq(dev, spi->irq,
1325                                         ads7846_hard_irq, ads7846_irq,
1326                                         irq_flags, dev->driver->name, ts);
1327         if (err && err != -EPROBE_DEFER && !pdata->irq_flags) {
1328                 dev_info(dev,
1329                         "trying pin change workaround on irq %d\n", spi->irq);
1330                 irq_flags |= IRQF_TRIGGER_RISING;
1331                 err = devm_request_threaded_irq(dev, spi->irq,
1332                                                 ads7846_hard_irq, ads7846_irq,
1333                                                 irq_flags, dev->driver->name,
1334                                                 ts);
1335         }
1336
1337         if (err) {
1338                 dev_dbg(dev, "irq %d busy?\n", spi->irq);
1339                 return err;
1340         }
1341
1342         err = ads784x_hwmon_register(spi, ts);
1343         if (err)
1344                 return err;
1345
1346         dev_info(dev, "touchscreen, irq %d\n", spi->irq);
1347
1348         /*
1349          * Take a first sample, leaving nPENIRQ active and vREF off; avoid
1350          * the touchscreen, in case it's not connected.
1351          */
1352         if (ts->model == 7845)
1353                 ads7845_read12_ser(dev, PWRDOWN);
1354         else
1355                 (void) ads7846_read12_ser(dev, READ_12BIT_SER(vaux));
1356
1357         err = input_register_device(input_dev);
1358         if (err)
1359                 return err;
1360
1361         device_init_wakeup(dev, pdata->wakeup);
1362
1363         /*
1364          * If device does not carry platform data we must have allocated it
1365          * when parsing DT data.
1366          */
1367         if (!dev_get_platdata(dev))
1368                 devm_kfree(dev, (void *)pdata);
1369
1370         return 0;
1371 }
1372
1373 static void ads7846_remove(struct spi_device *spi)
1374 {
1375         struct ads7846 *ts = spi_get_drvdata(spi);
1376
1377         ads7846_stop(ts);
1378 }
1379
1380 static struct spi_driver ads7846_driver = {
1381         .driver = {
1382                 .name           = "ads7846",
1383                 .dev_groups     = ads784x_groups,
1384                 .pm             = pm_sleep_ptr(&ads7846_pm),
1385                 .of_match_table = ads7846_dt_ids,
1386         },
1387         .probe          = ads7846_probe,
1388         .remove         = ads7846_remove,
1389 };
1390
1391 module_spi_driver(ads7846_driver);
1392
1393 MODULE_DESCRIPTION("ADS7846 TouchScreen Driver");
1394 MODULE_LICENSE("GPL");
1395 MODULE_ALIAS("spi:ads7846");