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