drivers/input/touchscreen/ad7879.c

   1 /*
   2  * AD7879/AD7889 based touchscreen and GPIO driver
   3  *
   4  * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc.
   5  *
   6  * Licensed under the GPL-2 or later.
   7  *
   8  * History:
   9  * Copyright (c) 2005 David Brownell
  10  * Copyright (c) 2006 Nokia Corporation
  11  * Various changes: Imre Deak <imre.deak@nokia.com>
  12  *
  13  * Using code from:
  14  *  - corgi_ts.c
  15  *      Copyright (C) 2004-2005 Richard Purdie
  16  *  - omap_ts.[hc], ads7846.h, ts_osk.c
  17  *      Copyright (C) 2002 MontaVista Software
  18  *      Copyright (C) 2004 Texas Instruments
  19  *      Copyright (C) 2005 Dirk Behme
  20  *  - ad7877.c
  21  *      Copyright (C) 2006-2008 Analog Devices Inc.
  22  */
  23
  24 #include <linux/device.h>
  25 #include <linux/delay.h>
  26 #include <linux/input.h>
  27 #include <linux/interrupt.h>
  28 #include <linux/irq.h>
  29 #include <linux/slab.h>
  30 #include <linux/spi/spi.h>
  31 #include <linux/i2c.h>
  32 #include <linux/gpio.h>
  33
  34 #include <linux/input/touchscreen.h>
  35 #include <linux/platform_data/ad7879.h>
  36 #include <linux/module.h>
  37 #include "ad7879.h"
  38
  39 #define AD7879_REG_ZEROS                0
  40 #define AD7879_REG_CTRL1                1
  41 #define AD7879_REG_CTRL2                2
  42 #define AD7879_REG_CTRL3                3
  43 #define AD7879_REG_AUX1HIGH             4
  44 #define AD7879_REG_AUX1LOW              5
  45 #define AD7879_REG_TEMP1HIGH            6
  46 #define AD7879_REG_TEMP1LOW             7
  47 #define AD7879_REG_XPLUS                8
  48 #define AD7879_REG_YPLUS                9
  49 #define AD7879_REG_Z1                   10
  50 #define AD7879_REG_Z2                   11
  51 #define AD7879_REG_AUXVBAT              12
  52 #define AD7879_REG_TEMP                 13
  53 #define AD7879_REG_REVID                14
  54
  55 /* Control REG 1 */
  56 #define AD7879_TMR(x)                   ((x & 0xFF) << 0)
  57 #define AD7879_ACQ(x)                   ((x & 0x3) << 8)
  58 #define AD7879_MODE_NOC                 (0 << 10)       /* Do not convert */
  59 #define AD7879_MODE_SCC                 (1 << 10)       /* Single channel conversion */
  60 #define AD7879_MODE_SEQ0                (2 << 10)       /* Sequence 0 in Slave Mode */
  61 #define AD7879_MODE_SEQ1                (3 << 10)       /* Sequence 1 in Master Mode */
  62 #define AD7879_MODE_INT                 (1 << 15)       /* PENIRQ disabled INT enabled */
  63
  64 /* Control REG 2 */
  65 #define AD7879_FCD(x)                   ((x & 0x3) << 0)
  66 #define AD7879_RESET                    (1 << 4)
  67 #define AD7879_MFS(x)                   ((x & 0x3) << 5)
  68 #define AD7879_AVG(x)                   ((x & 0x3) << 7)
  69 #define AD7879_SER                      (1 << 9)        /* non-differential */
  70 #define AD7879_DFR                      (0 << 9)        /* differential */
  71 #define AD7879_GPIOPOL                  (1 << 10)
  72 #define AD7879_GPIODIR                  (1 << 11)
  73 #define AD7879_GPIO_DATA                (1 << 12)
  74 #define AD7879_GPIO_EN                  (1 << 13)
  75 #define AD7879_PM(x)                    ((x & 0x3) << 14)
  76 #define AD7879_PM_SHUTDOWN              (0)
  77 #define AD7879_PM_DYN                   (1)
  78 #define AD7879_PM_FULLON                (2)
  79
  80 /* Control REG 3 */
  81 #define AD7879_TEMPMASK_BIT             (1<<15)
  82 #define AD7879_AUXVBATMASK_BIT          (1<<14)
  83 #define AD7879_INTMODE_BIT              (1<<13)
  84 #define AD7879_GPIOALERTMASK_BIT        (1<<12)
  85 #define AD7879_AUXLOW_BIT               (1<<11)
  86 #define AD7879_AUXHIGH_BIT              (1<<10)
  87 #define AD7879_TEMPLOW_BIT              (1<<9)
  88 #define AD7879_TEMPHIGH_BIT             (1<<8)
  89 #define AD7879_YPLUS_BIT                (1<<7)
  90 #define AD7879_XPLUS_BIT                (1<<6)
  91 #define AD7879_Z1_BIT                   (1<<5)
  92 #define AD7879_Z2_BIT                   (1<<4)
  93 #define AD7879_AUX_BIT                  (1<<3)
  94 #define AD7879_VBAT_BIT                 (1<<2)
  95 #define AD7879_TEMP_BIT                 (1<<1)
  96
  97 enum {
  98         AD7879_SEQ_YPOS  = 0,
  99         AD7879_SEQ_XPOS  = 1,
 100         AD7879_SEQ_Z1    = 2,
 101         AD7879_SEQ_Z2    = 3,
 102         AD7879_NR_SENSE  = 4,
 103 };
 104
 105 #define MAX_12BIT                       ((1<<12)-1)
 106 #define TS_PEN_UP_TIMEOUT               msecs_to_jiffies(50)
 107
 108 struct ad7879 {
 109         const struct ad7879_bus_ops *bops;
 110
 111         struct device           *dev;
 112         struct input_dev        *input;
 113         struct timer_list       timer;
 114 #ifdef CONFIG_GPIOLIB
 115         struct gpio_chip        gc;
 116         struct mutex            mutex;
 117 #endif
 118         unsigned int            irq;
 119         bool                    disabled;       /* P: input->mutex */
 120         bool                    suspended;      /* P: input->mutex */
 121         bool                    swap_xy;
 122         u16                     conversion_data[AD7879_NR_SENSE];
 123         char                    phys[32];
 124         u8                      first_conversion_delay;
 125         u8                      acquisition_time;
 126         u8                      averaging;
 127         u8                      pen_down_acc_interval;
 128         u8                      median;
 129         u16                     x_plate_ohms;
 130         u16                     cmd_crtl1;
 131         u16                     cmd_crtl2;
 132         u16                     cmd_crtl3;
 133         int                     x;
 134         int                     y;
 135         int                     Rt;
 136 };
 137
 138 static int ad7879_read(struct ad7879 *ts, u8 reg)
 139 {
 140         return ts->bops->read(ts->dev, reg);
 141 }
 142
 143 static int ad7879_multi_read(struct ad7879 *ts, u8 first_reg, u8 count, u16 *buf)
 144 {
 145         return ts->bops->multi_read(ts->dev, first_reg, count, buf);
 146 }
 147
 148 static int ad7879_write(struct ad7879 *ts, u8 reg, u16 val)
 149 {
 150         return ts->bops->write(ts->dev, reg, val);
 151 }
 152
 153 static int ad7879_report(struct ad7879 *ts)
 154 {
 155         struct input_dev *input_dev = ts->input;
 156         unsigned Rt;
 157         u16 x, y, z1, z2;
 158
 159         x = ts->conversion_data[AD7879_SEQ_XPOS] & MAX_12BIT;
 160         y = ts->conversion_data[AD7879_SEQ_YPOS] & MAX_12BIT;
 161         z1 = ts->conversion_data[AD7879_SEQ_Z1] & MAX_12BIT;
 162         z2 = ts->conversion_data[AD7879_SEQ_Z2] & MAX_12BIT;
 163
 164         if (ts->swap_xy)
 165                 swap(x, y);
 166
 167         /*
 168          * The samples processed here are already preprocessed by the AD7879.
 169          * The preprocessing function consists of a median and an averaging
 170          * filter.  The combination of these two techniques provides a robust
 171          * solution, discarding the spurious noise in the signal and keeping
 172          * only the data of interest.  The size of both filters is
 173          * programmable. (dev.platform_data, see linux/platform_data/ad7879.h)
 174          * Other user-programmable conversion controls include variable
 175          * acquisition time, and first conversion delay. Up to 16 averages can
 176          * be taken per conversion.
 177          */
 178
 179         if (likely(x && z1)) {
 180                 /* compute touch pressure resistance using equation #1 */
 181                 Rt = (z2 - z1) * x * ts->x_plate_ohms;
 182                 Rt /= z1;
 183                 Rt = (Rt + 2047) >> 12;
 184
 185                 /*
 186                  * Sample found inconsistent, pressure is beyond
 187                  * the maximum. Don't report it to user space.
 188                  */
 189                 if (Rt > input_abs_get_max(input_dev, ABS_PRESSURE))
 190                         return -EINVAL;
 191
 192                 /*
 193                  * Note that we delay reporting events by one sample.
 194                  * This is done to avoid reporting last sample of the
 195                  * touch sequence, which may be incomplete if finger
 196                  * leaves the surface before last reading is taken.
 197                  */
 198                 if (timer_pending(&ts->timer)) {
 199                         /* Touch continues */
 200                         input_report_key(input_dev, BTN_TOUCH, 1);
 201                         input_report_abs(input_dev, ABS_X, ts->x);
 202                         input_report_abs(input_dev, ABS_Y, ts->y);
 203                         input_report_abs(input_dev, ABS_PRESSURE, ts->Rt);
 204                         input_sync(input_dev);
 205                 }
 206
 207                 ts->x = x;
 208                 ts->y = y;
 209                 ts->Rt = Rt;
 210
 211                 return 0;
 212         }
 213
 214         return -EINVAL;
 215 }
 216
 217 static void ad7879_ts_event_release(struct ad7879 *ts)
 218 {
 219         struct input_dev *input_dev = ts->input;
 220
 221         input_report_abs(input_dev, ABS_PRESSURE, 0);
 222         input_report_key(input_dev, BTN_TOUCH, 0);
 223         input_sync(input_dev);
 224 }
 225
 226 static void ad7879_timer(unsigned long handle)
 227 {
 228         struct ad7879 *ts = (void *)handle;
 229
 230         ad7879_ts_event_release(ts);
 231 }
 232
 233 static irqreturn_t ad7879_irq(int irq, void *handle)
 234 {
 235         struct ad7879 *ts = handle;
 236
 237         ad7879_multi_read(ts, AD7879_REG_XPLUS, AD7879_NR_SENSE, ts->conversion_data);
 238
 239         if (!ad7879_report(ts))
 240                 mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT);
 241
 242         return IRQ_HANDLED;
 243 }
 244
 245 static void __ad7879_enable(struct ad7879 *ts)
 246 {
 247         ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
 248         ad7879_write(ts, AD7879_REG_CTRL3, ts->cmd_crtl3);
 249         ad7879_write(ts, AD7879_REG_CTRL1, ts->cmd_crtl1);
 250
 251         enable_irq(ts->irq);
 252 }
 253
 254 static void __ad7879_disable(struct ad7879 *ts)
 255 {
 256         u16 reg = (ts->cmd_crtl2 & ~AD7879_PM(-1)) |
 257                 AD7879_PM(AD7879_PM_SHUTDOWN);
 258         disable_irq(ts->irq);
 259
 260         if (del_timer_sync(&ts->timer))
 261                 ad7879_ts_event_release(ts);
 262
 263         ad7879_write(ts, AD7879_REG_CTRL2, reg);
 264 }
 265
 266
 267 static int ad7879_open(struct input_dev *input)
 268 {
 269         struct ad7879 *ts = input_get_drvdata(input);
 270
 271         /* protected by input->mutex */
 272         if (!ts->disabled && !ts->suspended)
 273                 __ad7879_enable(ts);
 274
 275         return 0;
 276 }
 277
 278 static void ad7879_close(struct input_dev* input)
 279 {
 280         struct ad7879 *ts = input_get_drvdata(input);
 281
 282         /* protected by input->mutex */
 283         if (!ts->disabled && !ts->suspended)
 284                 __ad7879_disable(ts);
 285 }
 286
 287 static int __maybe_unused ad7879_suspend(struct device *dev)
 288 {
 289         struct ad7879 *ts = dev_get_drvdata(dev);
 290
 291         mutex_lock(&ts->input->mutex);
 292
 293         if (!ts->suspended && !ts->disabled && ts->input->users)
 294                 __ad7879_disable(ts);
 295
 296         ts->suspended = true;
 297
 298         mutex_unlock(&ts->input->mutex);
 299
 300         return 0;
 301 }
 302
 303 static int __maybe_unused ad7879_resume(struct device *dev)
 304 {
 305         struct ad7879 *ts = dev_get_drvdata(dev);
 306
 307         mutex_lock(&ts->input->mutex);
 308
 309         if (ts->suspended && !ts->disabled && ts->input->users)
 310                 __ad7879_enable(ts);
 311
 312         ts->suspended = false;
 313
 314         mutex_unlock(&ts->input->mutex);
 315
 316         return 0;
 317 }
 318
 319 SIMPLE_DEV_PM_OPS(ad7879_pm_ops, ad7879_suspend, ad7879_resume);
 320 EXPORT_SYMBOL(ad7879_pm_ops);
 321
 322 static void ad7879_toggle(struct ad7879 *ts, bool disable)
 323 {
 324         mutex_lock(&ts->input->mutex);
 325
 326         if (!ts->suspended && ts->input->users != 0) {
 327
 328                 if (disable) {
 329                         if (ts->disabled)
 330                                 __ad7879_enable(ts);
 331                 } else {
 332                         if (!ts->disabled)
 333                                 __ad7879_disable(ts);
 334                 }
 335         }
 336
 337         ts->disabled = disable;
 338
 339         mutex_unlock(&ts->input->mutex);
 340 }
 341
 342 static ssize_t ad7879_disable_show(struct device *dev,
 343                                      struct device_attribute *attr, char *buf)
 344 {
 345         struct ad7879 *ts = dev_get_drvdata(dev);
 346
 347         return sprintf(buf, "%u\n", ts->disabled);
 348 }
 349
 350 static ssize_t ad7879_disable_store(struct device *dev,
 351                                      struct device_attribute *attr,
 352                                      const char *buf, size_t count)
 353 {
 354         struct ad7879 *ts = dev_get_drvdata(dev);
 355         unsigned int val;
 356         int error;
 357
 358         error = kstrtouint(buf, 10, &val);
 359         if (error)
 360                 return error;
 361
 362         ad7879_toggle(ts, val);
 363
 364         return count;
 365 }
 366
 367 static DEVICE_ATTR(disable, 0664, ad7879_disable_show, ad7879_disable_store);
 368
 369 static struct attribute *ad7879_attributes[] = {
 370         &dev_attr_disable.attr,
 371         NULL
 372 };
 373
 374 static const struct attribute_group ad7879_attr_group = {
 375         .attrs = ad7879_attributes,
 376 };
 377
 378 #ifdef CONFIG_GPIOLIB
 379 static int ad7879_gpio_direction_input(struct gpio_chip *chip,
 380                                         unsigned gpio)
 381 {
 382         struct ad7879 *ts = container_of(chip, struct ad7879, gc);
 383         int err;
 384
 385         mutex_lock(&ts->mutex);
 386         ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIODIR | AD7879_GPIOPOL;
 387         err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
 388         mutex_unlock(&ts->mutex);
 389
 390         return err;
 391 }
 392
 393 static int ad7879_gpio_direction_output(struct gpio_chip *chip,
 394                                         unsigned gpio, int level)
 395 {
 396         struct ad7879 *ts = container_of(chip, struct ad7879, gc);
 397         int err;
 398
 399         mutex_lock(&ts->mutex);
 400         ts->cmd_crtl2 &= ~AD7879_GPIODIR;
 401         ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIOPOL;
 402         if (level)
 403                 ts->cmd_crtl2 |= AD7879_GPIO_DATA;
 404         else
 405                 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
 406
 407         err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
 408         mutex_unlock(&ts->mutex);
 409
 410         return err;
 411 }
 412
 413 static int ad7879_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
 414 {
 415         struct ad7879 *ts = container_of(chip, struct ad7879, gc);
 416         u16 val;
 417
 418         mutex_lock(&ts->mutex);
 419         val = ad7879_read(ts, AD7879_REG_CTRL2);
 420         mutex_unlock(&ts->mutex);
 421
 422         return !!(val & AD7879_GPIO_DATA);
 423 }
 424
 425 static void ad7879_gpio_set_value(struct gpio_chip *chip,
 426                                   unsigned gpio, int value)
 427 {
 428         struct ad7879 *ts = container_of(chip, struct ad7879, gc);
 429
 430         mutex_lock(&ts->mutex);
 431         if (value)
 432                 ts->cmd_crtl2 |= AD7879_GPIO_DATA;
 433         else
 434                 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
 435
 436         ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
 437         mutex_unlock(&ts->mutex);
 438 }
 439
 440 static int ad7879_gpio_add(struct ad7879 *ts,
 441                            const struct ad7879_platform_data *pdata)
 442 {
 443         int ret = 0;
 444
 445         mutex_init(&ts->mutex);
 446
 447         if (pdata->gpio_export) {
 448                 ts->gc.direction_input = ad7879_gpio_direction_input;
 449                 ts->gc.direction_output = ad7879_gpio_direction_output;
 450                 ts->gc.get = ad7879_gpio_get_value;
 451                 ts->gc.set = ad7879_gpio_set_value;
 452                 ts->gc.can_sleep = 1;
 453                 ts->gc.base = pdata->gpio_base;
 454                 ts->gc.ngpio = 1;
 455                 ts->gc.label = "AD7879-GPIO";
 456                 ts->gc.owner = THIS_MODULE;
 457                 ts->gc.parent = ts->dev;
 458
 459                 ret = gpiochip_add(&ts->gc);
 460                 if (ret)
 461                         dev_err(ts->dev, "failed to register gpio %d\n",
 462                                 ts->gc.base);
 463         }
 464
 465         return ret;
 466 }
 467
 468 static void ad7879_gpio_remove(struct ad7879 *ts)
 469 {
 470         const struct ad7879_platform_data *pdata = dev_get_platdata(ts->dev);
 471
 472         if (pdata && pdata->gpio_export)
 473                 gpiochip_remove(&ts->gc);
 474
 475 }
 476 #else
 477 static inline int ad7879_gpio_add(struct ad7879 *ts,
 478                                   const struct ad7879_platform_data *pdata)
 479 {
 480         return 0;
 481 }
 482
 483 static inline void ad7879_gpio_remove(struct ad7879 *ts)
 484 {
 485 }
 486 #endif
 487
 488 static int ad7879_parse_dt(struct device *dev, struct ad7879 *ts)
 489 {
 490         int err;
 491         u32 tmp;
 492
 493         err = device_property_read_u32(dev, "adi,resistance-plate-x", &tmp);
 494         if (err) {
 495                 dev_err(dev, "failed to get resistance-plate-x property\n");
 496                 return err;
 497         }
 498         ts->x_plate_ohms = (u16)tmp;
 499
 500         device_property_read_u8(dev, "adi,first-conversion-delay",
 501                                 &ts->first_conversion_delay);
 502         device_property_read_u8(dev, "adi,acquisition-time",
 503                                 &ts->acquisition_time);
 504         device_property_read_u8(dev, "adi,median-filter-size", &ts->median);
 505         device_property_read_u8(dev, "adi,averaging", &ts->averaging);
 506         device_property_read_u8(dev, "adi,conversion-interval",
 507                                 &ts->pen_down_acc_interval);
 508
 509         ts->swap_xy = device_property_read_bool(dev, "touchscreen-swapped-x-y");
 510
 511         return 0;
 512 }
 513
 514 struct ad7879 *ad7879_probe(struct device *dev, u8 devid, unsigned int irq,
 515                             const struct ad7879_bus_ops *bops)
 516 {
 517         struct ad7879_platform_data *pdata = dev_get_platdata(dev);
 518         struct ad7879 *ts;
 519         struct input_dev *input_dev;
 520         int err;
 521         u16 revid;
 522
 523         if (!irq) {
 524                 dev_err(dev, "No IRQ specified\n");
 525                 return ERR_PTR(-EINVAL);
 526         }
 527
 528         ts = devm_kzalloc(dev, sizeof(*ts), GFP_KERNEL);
 529         if (!ts)
 530                 return ERR_PTR(-ENOMEM);
 531
 532         if (pdata) {
 533                 /* Platform data use swapped axis (backward compatibility) */
 534                 ts->swap_xy = !pdata->swap_xy;
 535
 536                 ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
 537
 538                 ts->first_conversion_delay = pdata->first_conversion_delay;
 539                 ts->acquisition_time = pdata->acquisition_time;
 540                 ts->averaging = pdata->averaging;
 541                 ts->pen_down_acc_interval = pdata->pen_down_acc_interval;
 542                 ts->median = pdata->median;
 543         } else if (dev->of_node) {
 544                 ad7879_parse_dt(dev, ts);
 545         } else {
 546                 dev_err(dev, "No platform data\n");
 547                 return ERR_PTR(-EINVAL);
 548         }
 549
 550         input_dev = devm_input_allocate_device(dev);
 551         if (!input_dev) {
 552                 dev_err(dev, "Failed to allocate input device\n");
 553                 return ERR_PTR(-ENOMEM);
 554         }
 555
 556         ts->bops = bops;
 557         ts->dev = dev;
 558         ts->input = input_dev;
 559         ts->irq = irq;
 560
 561         setup_timer(&ts->timer, ad7879_timer, (unsigned long) ts);
 562         snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
 563
 564         input_dev->name = "AD7879 Touchscreen";
 565         input_dev->phys = ts->phys;
 566         input_dev->dev.parent = dev;
 567         input_dev->id.bustype = bops->bustype;
 568
 569         input_dev->open = ad7879_open;
 570         input_dev->close = ad7879_close;
 571
 572         input_set_drvdata(input_dev, ts);
 573
 574         __set_bit(EV_ABS, input_dev->evbit);
 575         __set_bit(ABS_X, input_dev->absbit);
 576         __set_bit(ABS_Y, input_dev->absbit);
 577         __set_bit(ABS_PRESSURE, input_dev->absbit);
 578
 579         __set_bit(EV_KEY, input_dev->evbit);
 580         __set_bit(BTN_TOUCH, input_dev->keybit);
 581
 582         if (pdata) {
 583                 input_set_abs_params(input_dev, ABS_X,
 584                                 pdata->x_min ? : 0,
 585                                 pdata->x_max ? : MAX_12BIT,
 586                                 0, 0);
 587                 input_set_abs_params(input_dev, ABS_Y,
 588                                 pdata->y_min ? : 0,
 589                                 pdata->y_max ? : MAX_12BIT,
 590                                 0, 0);
 591                 input_set_abs_params(input_dev, ABS_PRESSURE,
 592                                 pdata->pressure_min,
 593                                 pdata->pressure_max ? : ~0,
 594                                 0, 0);
 595         } else {
 596                 input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, 0, 0);
 597                 input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, 0, 0);
 598                 touchscreen_parse_properties(input_dev, false, NULL);
 599                 if (!input_abs_get_max(input_dev, ABS_PRESSURE)) {
 600                         dev_err(dev, "Touchscreen pressure is not specified\n");
 601                         return ERR_PTR(-EINVAL);
 602                 }
 603         }
 604
 605         err = ad7879_write(ts, AD7879_REG_CTRL2, AD7879_RESET);
 606         if (err < 0) {
 607                 dev_err(dev, "Failed to write %s\n", input_dev->name);
 608                 return ERR_PTR(err);
 609         }
 610
 611         revid = ad7879_read(ts, AD7879_REG_REVID);
 612         input_dev->id.product = (revid & 0xff);
 613         input_dev->id.version = revid >> 8;
 614         if (input_dev->id.product != devid) {
 615                 dev_err(dev, "Failed to probe %s (%x vs %x)\n",
 616                         input_dev->name, devid, revid);
 617                 return ERR_PTR(-ENODEV);
 618         }
 619
 620         ts->cmd_crtl3 = AD7879_YPLUS_BIT |
 621                         AD7879_XPLUS_BIT |
 622                         AD7879_Z2_BIT |
 623                         AD7879_Z1_BIT |
 624                         AD7879_TEMPMASK_BIT |
 625                         AD7879_AUXVBATMASK_BIT |
 626                         AD7879_GPIOALERTMASK_BIT;
 627
 628         ts->cmd_crtl2 = AD7879_PM(AD7879_PM_DYN) | AD7879_DFR |
 629                         AD7879_AVG(ts->averaging) |
 630                         AD7879_MFS(ts->median) |
 631                         AD7879_FCD(ts->first_conversion_delay);
 632
 633         ts->cmd_crtl1 = AD7879_MODE_INT | AD7879_MODE_SEQ1 |
 634                         AD7879_ACQ(ts->acquisition_time) |
 635                         AD7879_TMR(ts->pen_down_acc_interval);
 636
 637         err = devm_request_threaded_irq(dev, ts->irq, NULL, ad7879_irq,
 638                                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
 639                                         dev_name(dev), ts);
 640         if (err) {
 641                 dev_err(dev, "Failed to request IRQ: %d\n", err);
 642                 return ERR_PTR(err);
 643         }
 644
 645         __ad7879_disable(ts);
 646
 647         err = sysfs_create_group(&dev->kobj, &ad7879_attr_group);
 648         if (err)
 649                 goto err_out;
 650
 651         if (pdata) {
 652                 err = ad7879_gpio_add(ts, pdata);
 653                 if (err)
 654                         goto err_remove_attr;
 655         }
 656
 657         err = input_register_device(input_dev);
 658         if (err)
 659                 goto err_remove_gpio;
 660
 661         return ts;
 662
 663 err_remove_gpio:
 664         ad7879_gpio_remove(ts);
 665 err_remove_attr:
 666         sysfs_remove_group(&dev->kobj, &ad7879_attr_group);
 667 err_out:
 668         return ERR_PTR(err);
 669 }
 670 EXPORT_SYMBOL(ad7879_probe);
 671
 672 void ad7879_remove(struct ad7879 *ts)
 673 {
 674         ad7879_gpio_remove(ts);
 675         sysfs_remove_group(&ts->dev->kobj, &ad7879_attr_group);
 676 }
 677 EXPORT_SYMBOL(ad7879_remove);
 678
 679 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 680 MODULE_DESCRIPTION("AD7879(-1) touchscreen Driver");
 681 MODULE_LICENSE("GPL");