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         u16                     model;
 105         u16                     vref_mv;
 106         u16                     vref_delay_usecs;
 107         u16                     x_plate_ohms;
 108         u16                     pressure_max;
 109
 110         bool                    swap_xy;
 111         bool                    use_internal;
 112
 113         struct ads7846_packet   *packet;
 114
 115         struct spi_transfer     xfer[18];
 116         struct spi_message      msg[5];
 117         int                     msg_count;
 118         wait_queue_head_t       wait;
 119
 120         bool                    pendown;
 121
 122         int                     read_cnt;
 123         int                     read_rep;
 124         int                     last_read;
 125
 126         u16                     debounce_max;
 127         u16                     debounce_tol;
 128         u16                     debounce_rep;
 129
 130         u16                     penirq_recheck_delay_usecs;
 131
 132         struct touchscreen_properties core_prop;
 133
 134         struct mutex            lock;
 135         bool                    stopped;        /* P: lock */
 136         bool                    disabled;       /* P: lock */
 137         bool                    suspended;      /* P: lock */
 138
 139         int                     (*filter)(void *data, int data_idx, int *val);
 140         void                    *filter_data;
 141         int                     (*get_pendown_state)(void);
 142         int                     gpio_pendown;
 143
 144         void                    (*wait_for_sync)(void);
 145 };
 146
 147 enum ads7846_filter {
 148         ADS7846_FILTER_OK,
 149         ADS7846_FILTER_REPEAT,
 150         ADS7846_FILTER_IGNORE,
 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 = kobj_to_dev(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         struct device *hwmon;
 554
 555         /* hwmon sensors need a reference voltage */
 556         switch (ts->model) {
 557         case 7846:
 558                 if (!ts->vref_mv) {
 559                         dev_dbg(&spi->dev, "assuming 2.5V internal vREF\n");
 560                         ts->vref_mv = 2500;
 561                         ts->use_internal = true;
 562                 }
 563                 break;
 564         case 7845:
 565         case 7843:
 566                 if (!ts->vref_mv) {
 567                         dev_warn(&spi->dev,
 568                                 "external vREF for ADS%d not specified\n",
 569                                 ts->model);
 570                         return 0;
 571                 }
 572                 break;
 573         }
 574
 575         hwmon = devm_hwmon_device_register_with_groups(&spi->dev,
 576                                                        spi->modalias, ts,
 577                                                        ads7846_attr_groups);
 578
 579         return PTR_ERR_OR_ZERO(hwmon);
 580 }
 581
 582 #else
 583 static inline int ads784x_hwmon_register(struct spi_device *spi,
 584                                          struct ads7846 *ts)
 585 {
 586         return 0;
 587 }
 588 #endif
 589
 590 static ssize_t ads7846_pen_down_show(struct device *dev,
 591                                      struct device_attribute *attr, char *buf)
 592 {
 593         struct ads7846 *ts = dev_get_drvdata(dev);
 594
 595         return sprintf(buf, "%u\n", ts->pendown);
 596 }
 597
 598 static DEVICE_ATTR(pen_down, S_IRUGO, ads7846_pen_down_show, NULL);
 599
 600 static ssize_t ads7846_disable_show(struct device *dev,
 601                                      struct device_attribute *attr, char *buf)
 602 {
 603         struct ads7846 *ts = dev_get_drvdata(dev);
 604
 605         return sprintf(buf, "%u\n", ts->disabled);
 606 }
 607
 608 static ssize_t ads7846_disable_store(struct device *dev,
 609                                      struct device_attribute *attr,
 610                                      const char *buf, size_t count)
 611 {
 612         struct ads7846 *ts = dev_get_drvdata(dev);
 613         unsigned int i;
 614         int err;
 615
 616         err = kstrtouint(buf, 10, &i);
 617         if (err)
 618                 return err;
 619
 620         if (i)
 621                 ads7846_disable(ts);
 622         else
 623                 ads7846_enable(ts);
 624
 625         return count;
 626 }
 627
 628 static DEVICE_ATTR(disable, 0664, ads7846_disable_show, ads7846_disable_store);
 629
 630 static struct attribute *ads784x_attributes[] = {
 631         &dev_attr_pen_down.attr,
 632         &dev_attr_disable.attr,
 633         NULL,
 634 };
 635
 636 static const struct attribute_group ads784x_attr_group = {
 637         .attrs = ads784x_attributes,
 638 };
 639
 640 /*--------------------------------------------------------------------------*/
 641
 642 static void null_wait_for_sync(void)
 643 {
 644 }
 645
 646 static int ads7846_debounce_filter(void *ads, int data_idx, int *val)
 647 {
 648         struct ads7846 *ts = ads;
 649
 650         if (!ts->read_cnt || (abs(ts->last_read - *val) > ts->debounce_tol)) {
 651                 /* Start over collecting consistent readings. */
 652                 ts->read_rep = 0;
 653                 /*
 654                  * Repeat it, if this was the first read or the read
 655                  * wasn't consistent enough.
 656                  */
 657                 if (ts->read_cnt < ts->debounce_max) {
 658                         ts->last_read = *val;
 659                         ts->read_cnt++;
 660                         return ADS7846_FILTER_REPEAT;
 661                 } else {
 662                         /*
 663                          * Maximum number of debouncing reached and still
 664                          * not enough number of consistent readings. Abort
 665                          * the whole sample, repeat it in the next sampling
 666                          * period.
 667                          */
 668                         ts->read_cnt = 0;
 669                         return ADS7846_FILTER_IGNORE;
 670                 }
 671         } else {
 672                 if (++ts->read_rep > ts->debounce_rep) {
 673                         /*
 674                          * Got a good reading for this coordinate,
 675                          * go for the next one.
 676                          */
 677                         ts->read_cnt = 0;
 678                         ts->read_rep = 0;
 679                         return ADS7846_FILTER_OK;
 680                 } else {
 681                         /* Read more values that are consistent. */
 682                         ts->read_cnt++;
 683                         return ADS7846_FILTER_REPEAT;
 684                 }
 685         }
 686 }
 687
 688 static int ads7846_no_filter(void *ads, int data_idx, int *val)
 689 {
 690         return ADS7846_FILTER_OK;
 691 }
 692
 693 static int ads7846_get_value(struct ads7846_buf *buf)
 694 {
 695         int value;
 696
 697         value = be16_to_cpup(&buf->data);
 698
 699         /* enforce ADC output is 12 bits width */
 700         return (value >> 3) & 0xfff;
 701 }
 702
 703 static void ads7846_set_cmd_val(struct ads7846 *ts, enum ads7846_cmds cmd_idx,
 704                                 u16 val)
 705 {
 706         struct ads7846_packet *packet = ts->packet;
 707
 708         switch (cmd_idx) {
 709         case ADS7846_Y:
 710                 packet->y = val;
 711                 break;
 712         case ADS7846_X:
 713                 packet->x = val;
 714                 break;
 715         case ADS7846_Z1:
 716                 packet->z1 = val;
 717                 break;
 718         case ADS7846_Z2:
 719                 packet->z2 = val;
 720                 break;
 721         default:
 722                 WARN_ON_ONCE(1);
 723         }
 724 }
 725
 726 static u8 ads7846_get_cmd(enum ads7846_cmds cmd_idx, int vref)
 727 {
 728         switch (cmd_idx) {
 729         case ADS7846_Y:
 730                 return READ_Y(vref);
 731         case ADS7846_X:
 732                 return READ_X(vref);
 733
 734         /* 7846 specific commands  */
 735         case ADS7846_Z1:
 736                 return READ_Z1(vref);
 737         case ADS7846_Z2:
 738                 return READ_Z2(vref);
 739         case ADS7846_PWDOWN:
 740                 return PWRDOWN;
 741         default:
 742                 WARN_ON_ONCE(1);
 743         }
 744
 745         return 0;
 746 }
 747
 748 static bool ads7846_cmd_need_settle(enum ads7846_cmds cmd_idx)
 749 {
 750         switch (cmd_idx) {
 751         case ADS7846_X:
 752         case ADS7846_Y:
 753         case ADS7846_Z1:
 754         case ADS7846_Z2:
 755                 return true;
 756         case ADS7846_PWDOWN:
 757                 return false;
 758         default:
 759                 WARN_ON_ONCE(1);
 760         }
 761
 762         return false;
 763 }
 764
 765 static int ads7846_filter(struct ads7846 *ts)
 766 {
 767         struct ads7846_packet *packet = ts->packet;
 768         int action;
 769         int val;
 770         unsigned int cmd_idx, b;
 771
 772         packet->ignore = false;
 773         for (cmd_idx = packet->last_cmd_idx; cmd_idx < packet->cmds - 1; cmd_idx++) {
 774                 struct ads7846_buf_layout *l = &packet->l[cmd_idx];
 775
 776                 packet->last_cmd_idx = cmd_idx;
 777
 778                 for (b = l->skip; b < l->count; b++) {
 779                         val = ads7846_get_value(&packet->rx[l->offset + b]);
 780
 781                         action = ts->filter(ts->filter_data, cmd_idx, &val);
 782                         if (action == ADS7846_FILTER_REPEAT) {
 783                                 if (b == l->count - 1)
 784                                         return -EAGAIN;
 785                         } else if (action == ADS7846_FILTER_OK) {
 786                                 ads7846_set_cmd_val(ts, cmd_idx, val);
 787                                 break;
 788                         } else {
 789                                 packet->ignore = true;
 790                                 return 0;
 791                         }
 792                 }
 793         }
 794
 795         return 0;
 796 }
 797
 798 static void ads7846_read_state(struct ads7846 *ts)
 799 {
 800         struct ads7846_packet *packet = ts->packet;
 801         struct spi_message *m;
 802         int msg_idx = 0;
 803         int error;
 804
 805         packet->last_cmd_idx = 0;
 806
 807         while (true) {
 808                 ts->wait_for_sync();
 809
 810                 m = &ts->msg[msg_idx];
 811                 error = spi_sync(ts->spi, m);
 812                 if (error) {
 813                         dev_err(&ts->spi->dev, "spi_sync --> %d\n", error);
 814                         packet->ignore = true;
 815                         return;
 816                 }
 817
 818                 error = ads7846_filter(ts);
 819                 if (error)
 820                         continue;
 821
 822                 return;
 823         }
 824 }
 825
 826 static void ads7846_report_state(struct ads7846 *ts)
 827 {
 828         struct ads7846_packet *packet = ts->packet;
 829         unsigned int Rt;
 830         u16 x, y, z1, z2;
 831
 832         x = packet->x;
 833         y = packet->y;
 834         if (ts->model == 7845) {
 835                 z1 = 0;
 836                 z2 = 0;
 837         } else {
 838                 z1 = packet->z1;
 839                 z2 = packet->z2;
 840         }
 841
 842         /* range filtering */
 843         if (x == MAX_12BIT)
 844                 x = 0;
 845
 846         if (ts->model == 7843) {
 847                 Rt = ts->pressure_max / 2;
 848         } else if (ts->model == 7845) {
 849                 if (get_pendown_state(ts))
 850                         Rt = ts->pressure_max / 2;
 851                 else
 852                         Rt = 0;
 853                 dev_vdbg(&ts->spi->dev, "x/y: %d/%d, PD %d\n", x, y, Rt);
 854         } else if (likely(x && z1)) {
 855                 /* compute touch pressure resistance using equation #2 */
 856                 Rt = z2;
 857                 Rt -= z1;
 858                 Rt *= ts->x_plate_ohms;
 859                 Rt = DIV_ROUND_CLOSEST(Rt, 16);
 860                 Rt *= x;
 861                 Rt /= z1;
 862                 Rt = DIV_ROUND_CLOSEST(Rt, 256);
 863         } else {
 864                 Rt = 0;
 865         }
 866
 867         /*
 868          * Sample found inconsistent by debouncing or pressure is beyond
 869          * the maximum. Don't report it to user space, repeat at least
 870          * once more the measurement
 871          */
 872         if (packet->ignore || Rt > ts->pressure_max) {
 873                 dev_vdbg(&ts->spi->dev, "ignored %d pressure %d\n",
 874                          packet->ignore, Rt);
 875                 return;
 876         }
 877
 878         /*
 879          * Maybe check the pendown state before reporting. This discards
 880          * false readings when the pen is lifted.
 881          */
 882         if (ts->penirq_recheck_delay_usecs) {
 883                 udelay(ts->penirq_recheck_delay_usecs);
 884                 if (!get_pendown_state(ts))
 885                         Rt = 0;
 886         }
 887
 888         /*
 889          * NOTE: We can't rely on the pressure to determine the pen down
 890          * state, even this controller has a pressure sensor. The pressure
 891          * value can fluctuate for quite a while after lifting the pen and
 892          * in some cases may not even settle at the expected value.
 893          *
 894          * The only safe way to check for the pen up condition is in the
 895          * timer by reading the pen signal state (it's a GPIO _and_ IRQ).
 896          */
 897         if (Rt) {
 898                 struct input_dev *input = ts->input;
 899
 900                 if (!ts->pendown) {
 901                         input_report_key(input, BTN_TOUCH, 1);
 902                         ts->pendown = true;
 903                         dev_vdbg(&ts->spi->dev, "DOWN\n");
 904                 }
 905
 906                 touchscreen_report_pos(input, &ts->core_prop, x, y, false);
 907                 input_report_abs(input, ABS_PRESSURE, ts->pressure_max - Rt);
 908
 909                 input_sync(input);
 910                 dev_vdbg(&ts->spi->dev, "%4d/%4d/%4d\n", x, y, Rt);
 911         }
 912 }
 913
 914 static irqreturn_t ads7846_hard_irq(int irq, void *handle)
 915 {
 916         struct ads7846 *ts = handle;
 917
 918         return get_pendown_state(ts) ? IRQ_WAKE_THREAD : IRQ_HANDLED;
 919 }
 920
 921
 922 static irqreturn_t ads7846_irq(int irq, void *handle)
 923 {
 924         struct ads7846 *ts = handle;
 925
 926         /* Start with a small delay before checking pendown state */
 927         msleep(TS_POLL_DELAY);
 928
 929         while (!ts->stopped && get_pendown_state(ts)) {
 930
 931                 /* pen is down, continue with the measurement */
 932                 ads7846_read_state(ts);
 933
 934                 if (!ts->stopped)
 935                         ads7846_report_state(ts);
 936
 937                 wait_event_timeout(ts->wait, ts->stopped,
 938                                    msecs_to_jiffies(TS_POLL_PERIOD));
 939         }
 940
 941         if (ts->pendown && !ts->stopped)
 942                 ads7846_report_pen_up(ts);
 943
 944         return IRQ_HANDLED;
 945 }
 946
 947 static int __maybe_unused ads7846_suspend(struct device *dev)
 948 {
 949         struct ads7846 *ts = dev_get_drvdata(dev);
 950
 951         mutex_lock(&ts->lock);
 952
 953         if (!ts->suspended) {
 954
 955                 if (!ts->disabled)
 956                         __ads7846_disable(ts);
 957
 958                 if (device_may_wakeup(&ts->spi->dev))
 959                         enable_irq_wake(ts->spi->irq);
 960
 961                 ts->suspended = true;
 962         }
 963
 964         mutex_unlock(&ts->lock);
 965
 966         return 0;
 967 }
 968
 969 static int __maybe_unused ads7846_resume(struct device *dev)
 970 {
 971         struct ads7846 *ts = dev_get_drvdata(dev);
 972
 973         mutex_lock(&ts->lock);
 974
 975         if (ts->suspended) {
 976
 977                 ts->suspended = false;
 978
 979                 if (device_may_wakeup(&ts->spi->dev))
 980                         disable_irq_wake(ts->spi->irq);
 981
 982                 if (!ts->disabled)
 983                         __ads7846_enable(ts);
 984         }
 985
 986         mutex_unlock(&ts->lock);
 987
 988         return 0;
 989 }
 990
 991 static SIMPLE_DEV_PM_OPS(ads7846_pm, ads7846_suspend, ads7846_resume);
 992
 993 static int ads7846_setup_pendown(struct spi_device *spi,
 994                                  struct ads7846 *ts,
 995                                  const struct ads7846_platform_data *pdata)
 996 {
 997         int err;
 998
 999         /*
1000          * REVISIT when the irq can be triggered active-low, or if for some
1001          * reason the touchscreen isn't hooked up, we don't need to access
1002          * the pendown state.
1003          */
1004
1005         if (pdata->get_pendown_state) {
1006                 ts->get_pendown_state = pdata->get_pendown_state;
1007         } else if (gpio_is_valid(pdata->gpio_pendown)) {
1008
1009                 err = devm_gpio_request_one(&spi->dev, pdata->gpio_pendown,
1010                                             GPIOF_IN, "ads7846_pendown");
1011                 if (err) {
1012                         dev_err(&spi->dev,
1013                                 "failed to request/setup pendown GPIO%d: %d\n",
1014                                 pdata->gpio_pendown, err);
1015                         return err;
1016                 }
1017
1018                 ts->gpio_pendown = pdata->gpio_pendown;
1019
1020                 if (pdata->gpio_pendown_debounce)
1021                         gpio_set_debounce(pdata->gpio_pendown,
1022                                           pdata->gpio_pendown_debounce);
1023         } else {
1024                 dev_err(&spi->dev, "no get_pendown_state nor gpio_pendown?\n");
1025                 return -EINVAL;
1026         }
1027
1028         return 0;
1029 }
1030
1031 /*
1032  * Set up the transfers to read touchscreen state; this assumes we
1033  * use formula #2 for pressure, not #3.
1034  */
1035 static int ads7846_setup_spi_msg(struct ads7846 *ts,
1036                                   const struct ads7846_platform_data *pdata)
1037 {
1038         struct spi_message *m = &ts->msg[0];
1039         struct spi_transfer *x = ts->xfer;
1040         struct ads7846_packet *packet = ts->packet;
1041         int vref = pdata->keep_vref_on;
1042         unsigned int count, offset = 0;
1043         unsigned int cmd_idx, b;
1044         unsigned long time;
1045         size_t size = 0;
1046
1047         /* time per bit */
1048         time = NSEC_PER_SEC / ts->spi->max_speed_hz;
1049
1050         count = pdata->settle_delay_usecs * NSEC_PER_USEC / time;
1051         packet->count_skip = DIV_ROUND_UP(count, 24);
1052
1053         if (ts->debounce_max && ts->debounce_rep)
1054                 /* ads7846_debounce_filter() is making ts->debounce_rep + 2
1055                  * reads. So we need to get all samples for normal case. */
1056                 packet->count = ts->debounce_rep + 2;
1057         else
1058                 packet->count = 1;
1059
1060         if (ts->model == 7846)
1061                 packet->cmds = 5; /* x, y, z1, z2, pwdown */
1062         else
1063                 packet->cmds = 3; /* x, y, pwdown */
1064
1065         for (cmd_idx = 0; cmd_idx < packet->cmds; cmd_idx++) {
1066                 struct ads7846_buf_layout *l = &packet->l[cmd_idx];
1067                 unsigned int max_count;
1068
1069                 if (ads7846_cmd_need_settle(cmd_idx))
1070                         max_count = packet->count + packet->count_skip;
1071                 else
1072                         max_count = packet->count;
1073
1074                 l->offset = offset;
1075                 offset += max_count;
1076                 l->count = max_count;
1077                 l->skip = packet->count_skip;
1078                 size += sizeof(*packet->tx) * max_count;
1079         }
1080
1081         packet->tx = devm_kzalloc(&ts->spi->dev, size, GFP_KERNEL);
1082         if (!packet->tx)
1083                 return -ENOMEM;
1084
1085         packet->rx = devm_kzalloc(&ts->spi->dev, size, GFP_KERNEL);
1086         if (!packet->rx)
1087                 return -ENOMEM;
1088
1089         if (ts->model == 7873) {
1090                 /*
1091                  * The AD7873 is almost identical to the ADS7846
1092                  * keep VREF off during differential/ratiometric
1093                  * conversion modes.
1094                  */
1095                 ts->model = 7846;
1096                 vref = 0;
1097         }
1098
1099         ts->msg_count = 1;
1100         spi_message_init(m);
1101         m->context = ts;
1102
1103         for (cmd_idx = 0; cmd_idx < packet->cmds; cmd_idx++) {
1104                 struct ads7846_buf_layout *l = &packet->l[cmd_idx];
1105                 u8 cmd = ads7846_get_cmd(cmd_idx, vref);
1106
1107                 for (b = 0; b < l->count; b++)
1108                         packet->tx[l->offset + b].cmd = cmd;
1109         }
1110
1111         x->tx_buf = packet->tx;
1112         x->rx_buf = packet->rx;
1113         x->len = size;
1114         spi_message_add_tail(x, m);
1115
1116         return 0;
1117 }
1118
1119 #ifdef CONFIG_OF
1120 static const struct of_device_id ads7846_dt_ids[] = {
1121         { .compatible = "ti,tsc2046",   .data = (void *) 7846 },
1122         { .compatible = "ti,ads7843",   .data = (void *) 7843 },
1123         { .compatible = "ti,ads7845",   .data = (void *) 7845 },
1124         { .compatible = "ti,ads7846",   .data = (void *) 7846 },
1125         { .compatible = "ti,ads7873",   .data = (void *) 7873 },
1126         { }
1127 };
1128 MODULE_DEVICE_TABLE(of, ads7846_dt_ids);
1129
1130 static const struct ads7846_platform_data *ads7846_probe_dt(struct device *dev)
1131 {
1132         struct ads7846_platform_data *pdata;
1133         struct device_node *node = dev->of_node;
1134         const struct of_device_id *match;
1135         u32 value;
1136
1137         if (!node) {
1138                 dev_err(dev, "Device does not have associated DT data\n");
1139                 return ERR_PTR(-EINVAL);
1140         }
1141
1142         match = of_match_device(ads7846_dt_ids, dev);
1143         if (!match) {
1144                 dev_err(dev, "Unknown device model\n");
1145                 return ERR_PTR(-EINVAL);
1146         }
1147
1148         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
1149         if (!pdata)
1150                 return ERR_PTR(-ENOMEM);
1151
1152         pdata->model = (unsigned long)match->data;
1153
1154         of_property_read_u16(node, "ti,vref-delay-usecs",
1155                              &pdata->vref_delay_usecs);
1156         of_property_read_u16(node, "ti,vref-mv", &pdata->vref_mv);
1157         pdata->keep_vref_on = of_property_read_bool(node, "ti,keep-vref-on");
1158
1159         pdata->swap_xy = of_property_read_bool(node, "ti,swap-xy");
1160
1161         of_property_read_u16(node, "ti,settle-delay-usec",
1162                              &pdata->settle_delay_usecs);
1163         of_property_read_u16(node, "ti,penirq-recheck-delay-usecs",
1164                              &pdata->penirq_recheck_delay_usecs);
1165
1166         of_property_read_u16(node, "ti,x-plate-ohms", &pdata->x_plate_ohms);
1167         of_property_read_u16(node, "ti,y-plate-ohms", &pdata->y_plate_ohms);
1168
1169         of_property_read_u16(node, "ti,x-min", &pdata->x_min);
1170         of_property_read_u16(node, "ti,y-min", &pdata->y_min);
1171         of_property_read_u16(node, "ti,x-max", &pdata->x_max);
1172         of_property_read_u16(node, "ti,y-max", &pdata->y_max);
1173
1174         /*
1175          * touchscreen-max-pressure gets parsed during
1176          * touchscreen_parse_properties()
1177          */
1178         of_property_read_u16(node, "ti,pressure-min", &pdata->pressure_min);
1179         if (!of_property_read_u32(node, "touchscreen-min-pressure", &value))
1180                 pdata->pressure_min = (u16) value;
1181         of_property_read_u16(node, "ti,pressure-max", &pdata->pressure_max);
1182
1183         of_property_read_u16(node, "ti,debounce-max", &pdata->debounce_max);
1184         if (!of_property_read_u32(node, "touchscreen-average-samples", &value))
1185                 pdata->debounce_max = (u16) value;
1186         of_property_read_u16(node, "ti,debounce-tol", &pdata->debounce_tol);
1187         of_property_read_u16(node, "ti,debounce-rep", &pdata->debounce_rep);
1188
1189         of_property_read_u32(node, "ti,pendown-gpio-debounce",
1190                              &pdata->gpio_pendown_debounce);
1191
1192         pdata->wakeup = of_property_read_bool(node, "wakeup-source") ||
1193                         of_property_read_bool(node, "linux,wakeup");
1194
1195         pdata->gpio_pendown = of_get_named_gpio(dev->of_node, "pendown-gpio", 0);
1196
1197         return pdata;
1198 }
1199 #else
1200 static const struct ads7846_platform_data *ads7846_probe_dt(struct device *dev)
1201 {
1202         dev_err(dev, "no platform data defined\n");
1203         return ERR_PTR(-EINVAL);
1204 }
1205 #endif
1206
1207 static void ads7846_regulator_disable(void *regulator)
1208 {
1209         regulator_disable(regulator);
1210 }
1211
1212 static int ads7846_probe(struct spi_device *spi)
1213 {
1214         const struct ads7846_platform_data *pdata;
1215         struct ads7846 *ts;
1216         struct device *dev = &spi->dev;
1217         struct ads7846_packet *packet;
1218         struct input_dev *input_dev;
1219         unsigned long irq_flags;
1220         int err;
1221
1222         if (!spi->irq) {
1223                 dev_dbg(dev, "no IRQ?\n");
1224                 return -EINVAL;
1225         }
1226
1227         /* don't exceed max specified sample rate */
1228         if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) {
1229                 dev_err(dev, "f(sample) %d KHz?\n",
1230                         (spi->max_speed_hz/SAMPLE_BITS)/1000);
1231                 return -EINVAL;
1232         }
1233
1234         /*
1235          * We'd set TX word size 8 bits and RX word size to 13 bits ... except
1236          * that even if the hardware can do that, the SPI controller driver
1237          * may not.  So we stick to very-portable 8 bit words, both RX and TX.
1238          */
1239         spi->bits_per_word = 8;
1240         spi->mode &= ~SPI_MODE_X_MASK;
1241         spi->mode |= SPI_MODE_0;
1242         err = spi_setup(spi);
1243         if (err < 0)
1244                 return err;
1245
1246         ts = devm_kzalloc(dev, sizeof(struct ads7846), GFP_KERNEL);
1247         if (!ts)
1248                 return -ENOMEM;
1249
1250         packet = devm_kzalloc(dev, sizeof(struct ads7846_packet), GFP_KERNEL);
1251         if (!packet)
1252                 return -ENOMEM;
1253
1254         input_dev = devm_input_allocate_device(dev);
1255         if (!input_dev)
1256                 return -ENOMEM;
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(dev);
1268         if (!pdata) {
1269                 pdata = ads7846_probe_dt(dev);
1270                 if (IS_ERR(pdata))
1271                         return PTR_ERR(pdata);
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->debounce_max) {
1280                 ts->debounce_max = pdata->debounce_max;
1281                 if (ts->debounce_max < 2)
1282                         ts->debounce_max = 2;
1283                 ts->debounce_tol = pdata->debounce_tol;
1284                 ts->debounce_rep = pdata->debounce_rep;
1285                 ts->filter = ads7846_debounce_filter;
1286                 ts->filter_data = ts;
1287         } else {
1288                 ts->filter = ads7846_no_filter;
1289         }
1290
1291         err = ads7846_setup_pendown(spi, ts, pdata);
1292         if (err)
1293                 return err;
1294
1295         if (pdata->penirq_recheck_delay_usecs)
1296                 ts->penirq_recheck_delay_usecs =
1297                                 pdata->penirq_recheck_delay_usecs;
1298
1299         ts->wait_for_sync = pdata->wait_for_sync ? : null_wait_for_sync;
1300
1301         snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
1302         snprintf(ts->name, sizeof(ts->name), "ADS%d Touchscreen", ts->model);
1303
1304         input_dev->name = ts->name;
1305         input_dev->phys = ts->phys;
1306
1307         input_dev->id.bustype = BUS_SPI;
1308         input_dev->id.product = pdata->model;
1309
1310         input_set_capability(input_dev, EV_KEY, BTN_TOUCH);
1311         input_set_abs_params(input_dev, ABS_X,
1312                         pdata->x_min ? : 0,
1313                         pdata->x_max ? : MAX_12BIT,
1314                         0, 0);
1315         input_set_abs_params(input_dev, ABS_Y,
1316                         pdata->y_min ? : 0,
1317                         pdata->y_max ? : MAX_12BIT,
1318                         0, 0);
1319         input_set_abs_params(input_dev, ABS_PRESSURE,
1320                         pdata->pressure_min, pdata->pressure_max, 0, 0);
1321
1322         /*
1323          * Parse common framework properties. Must be done here to ensure the
1324          * correct behaviour in case of using the legacy vendor bindings. The
1325          * general binding value overrides the vendor specific one.
1326          */
1327         touchscreen_parse_properties(ts->input, false, &ts->core_prop);
1328         ts->pressure_max = input_abs_get_max(input_dev, ABS_PRESSURE) ? : ~0;
1329
1330         /*
1331          * Check if legacy ti,swap-xy binding is used instead of
1332          * touchscreen-swapped-x-y
1333          */
1334         if (!ts->core_prop.swap_x_y && pdata->swap_xy) {
1335                 swap(input_dev->absinfo[ABS_X], input_dev->absinfo[ABS_Y]);
1336                 ts->core_prop.swap_x_y = true;
1337         }
1338
1339         ads7846_setup_spi_msg(ts, pdata);
1340
1341         ts->reg = devm_regulator_get(dev, "vcc");
1342         if (IS_ERR(ts->reg)) {
1343                 err = PTR_ERR(ts->reg);
1344                 dev_err(dev, "unable to get regulator: %d\n", err);
1345                 return err;
1346         }
1347
1348         err = regulator_enable(ts->reg);
1349         if (err) {
1350                 dev_err(dev, "unable to enable regulator: %d\n", err);
1351                 return err;
1352         }
1353
1354         err = devm_add_action_or_reset(dev, ads7846_regulator_disable, ts->reg);
1355         if (err)
1356                 return err;
1357
1358         irq_flags = pdata->irq_flags ? : IRQF_TRIGGER_FALLING;
1359         irq_flags |= IRQF_ONESHOT;
1360
1361         err = devm_request_threaded_irq(dev, spi->irq,
1362                                         ads7846_hard_irq, ads7846_irq,
1363                                         irq_flags, dev->driver->name, ts);
1364         if (err && !pdata->irq_flags) {
1365                 dev_info(dev,
1366                         "trying pin change workaround on irq %d\n", spi->irq);
1367                 irq_flags |= IRQF_TRIGGER_RISING;
1368                 err = devm_request_threaded_irq(dev, spi->irq,
1369                                                 ads7846_hard_irq, ads7846_irq,
1370                                                 irq_flags, dev->driver->name,
1371                                                 ts);
1372         }
1373
1374         if (err) {
1375                 dev_dbg(dev, "irq %d busy?\n", spi->irq);
1376                 return err;
1377         }
1378
1379         err = ads784x_hwmon_register(spi, ts);
1380         if (err)
1381                 return err;
1382
1383         dev_info(dev, "touchscreen, irq %d\n", spi->irq);
1384
1385         /*
1386          * Take a first sample, leaving nPENIRQ active and vREF off; avoid
1387          * the touchscreen, in case it's not connected.
1388          */
1389         if (ts->model == 7845)
1390                 ads7845_read12_ser(dev, PWRDOWN);
1391         else
1392                 (void) ads7846_read12_ser(dev, READ_12BIT_SER(vaux));
1393
1394         err = devm_device_add_group(dev, &ads784x_attr_group);
1395         if (err)
1396                 return err;
1397
1398         err = input_register_device(input_dev);
1399         if (err)
1400                 return err;
1401
1402         device_init_wakeup(dev, pdata->wakeup);
1403
1404         /*
1405          * If device does not carry platform data we must have allocated it
1406          * when parsing DT data.
1407          */
1408         if (!dev_get_platdata(dev))
1409                 devm_kfree(dev, (void *)pdata);
1410
1411         return 0;
1412 }
1413
1414 static int ads7846_remove(struct spi_device *spi)
1415 {
1416         struct ads7846 *ts = spi_get_drvdata(spi);
1417
1418         ads7846_stop(ts);
1419
1420         return 0;
1421 }
1422
1423 static struct spi_driver ads7846_driver = {
1424         .driver = {
1425                 .name   = "ads7846",
1426                 .pm     = &ads7846_pm,
1427                 .of_match_table = of_match_ptr(ads7846_dt_ids),
1428         },
1429         .probe          = ads7846_probe,
1430         .remove         = ads7846_remove,
1431 };
1432
1433 module_spi_driver(ads7846_driver);
1434
1435 MODULE_DESCRIPTION("ADS7846 TouchScreen Driver");
1436 MODULE_LICENSE("GPL");
1437 MODULE_ALIAS("spi:ads7846");