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