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