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 = gpiochip_get_data(chip); 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 = gpiochip_get_data(chip); 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 = gpiochip_get_data(chip); 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 = gpiochip_get_data(chip); 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_data(&ts->gc, ts); 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); 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"); 682