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