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