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 disable_irq(ts->irq); 253 254 if (del_timer_sync(&ts->timer)) 255 ad7879_ts_event_release(ts); 256 257 ad7879_write(ts, AD7879_REG_CTRL2, AD7879_PM(AD7879_PM_SHUTDOWN)); 258 } 259 260 261 static int ad7879_open(struct input_dev *input) 262 { 263 struct ad7879 *ts = input_get_drvdata(input); 264 265 /* protected by input->mutex */ 266 if (!ts->disabled && !ts->suspended) 267 __ad7879_enable(ts); 268 269 return 0; 270 } 271 272 static void ad7879_close(struct input_dev* input) 273 { 274 struct ad7879 *ts = input_get_drvdata(input); 275 276 /* protected by input->mutex */ 277 if (!ts->disabled && !ts->suspended) 278 __ad7879_disable(ts); 279 } 280 281 void ad7879_suspend(struct ad7879 *ts) 282 { 283 mutex_lock(&ts->input->mutex); 284 285 if (!ts->suspended && !ts->disabled && ts->input->users) 286 __ad7879_disable(ts); 287 288 ts->suspended = true; 289 290 mutex_unlock(&ts->input->mutex); 291 } 292 EXPORT_SYMBOL(ad7879_suspend); 293 294 void ad7879_resume(struct ad7879 *ts) 295 { 296 mutex_lock(&ts->input->mutex); 297 298 if (ts->suspended && !ts->disabled && ts->input->users) 299 __ad7879_enable(ts); 300 301 ts->suspended = false; 302 303 mutex_unlock(&ts->input->mutex); 304 } 305 EXPORT_SYMBOL(ad7879_resume); 306 307 static void ad7879_toggle(struct ad7879 *ts, bool disable) 308 { 309 mutex_lock(&ts->input->mutex); 310 311 if (!ts->suspended && ts->input->users != 0) { 312 313 if (disable) { 314 if (ts->disabled) 315 __ad7879_enable(ts); 316 } else { 317 if (!ts->disabled) 318 __ad7879_disable(ts); 319 } 320 } 321 322 ts->disabled = disable; 323 324 mutex_unlock(&ts->input->mutex); 325 } 326 327 static ssize_t ad7879_disable_show(struct device *dev, 328 struct device_attribute *attr, char *buf) 329 { 330 struct ad7879 *ts = dev_get_drvdata(dev); 331 332 return sprintf(buf, "%u\n", ts->disabled); 333 } 334 335 static ssize_t ad7879_disable_store(struct device *dev, 336 struct device_attribute *attr, 337 const char *buf, size_t count) 338 { 339 struct ad7879 *ts = dev_get_drvdata(dev); 340 unsigned long val; 341 int error; 342 343 error = strict_strtoul(buf, 10, &val); 344 if (error) 345 return error; 346 347 ad7879_toggle(ts, val); 348 349 return count; 350 } 351 352 static DEVICE_ATTR(disable, 0664, ad7879_disable_show, ad7879_disable_store); 353 354 static struct attribute *ad7879_attributes[] = { 355 &dev_attr_disable.attr, 356 NULL 357 }; 358 359 static const struct attribute_group ad7879_attr_group = { 360 .attrs = ad7879_attributes, 361 }; 362 363 #ifdef CONFIG_GPIOLIB 364 static int ad7879_gpio_direction_input(struct gpio_chip *chip, 365 unsigned gpio) 366 { 367 struct ad7879 *ts = container_of(chip, struct ad7879, gc); 368 int err; 369 370 mutex_lock(&ts->mutex); 371 ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIODIR | AD7879_GPIOPOL; 372 err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2); 373 mutex_unlock(&ts->mutex); 374 375 return err; 376 } 377 378 static int ad7879_gpio_direction_output(struct gpio_chip *chip, 379 unsigned gpio, int level) 380 { 381 struct ad7879 *ts = container_of(chip, struct ad7879, gc); 382 int err; 383 384 mutex_lock(&ts->mutex); 385 ts->cmd_crtl2 &= ~AD7879_GPIODIR; 386 ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIOPOL; 387 if (level) 388 ts->cmd_crtl2 |= AD7879_GPIO_DATA; 389 else 390 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA; 391 392 err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2); 393 mutex_unlock(&ts->mutex); 394 395 return err; 396 } 397 398 static int ad7879_gpio_get_value(struct gpio_chip *chip, unsigned gpio) 399 { 400 struct ad7879 *ts = container_of(chip, struct ad7879, gc); 401 u16 val; 402 403 mutex_lock(&ts->mutex); 404 val = ad7879_read(ts, AD7879_REG_CTRL2); 405 mutex_unlock(&ts->mutex); 406 407 return !!(val & AD7879_GPIO_DATA); 408 } 409 410 static void ad7879_gpio_set_value(struct gpio_chip *chip, 411 unsigned gpio, int value) 412 { 413 struct ad7879 *ts = container_of(chip, struct ad7879, gc); 414 415 mutex_lock(&ts->mutex); 416 if (value) 417 ts->cmd_crtl2 |= AD7879_GPIO_DATA; 418 else 419 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA; 420 421 ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2); 422 mutex_unlock(&ts->mutex); 423 } 424 425 static int ad7879_gpio_add(struct ad7879 *ts, 426 const struct ad7879_platform_data *pdata) 427 { 428 int ret = 0; 429 430 mutex_init(&ts->mutex); 431 432 if (pdata->gpio_export) { 433 ts->gc.direction_input = ad7879_gpio_direction_input; 434 ts->gc.direction_output = ad7879_gpio_direction_output; 435 ts->gc.get = ad7879_gpio_get_value; 436 ts->gc.set = ad7879_gpio_set_value; 437 ts->gc.can_sleep = 1; 438 ts->gc.base = pdata->gpio_base; 439 ts->gc.ngpio = 1; 440 ts->gc.label = "AD7879-GPIO"; 441 ts->gc.owner = THIS_MODULE; 442 ts->gc.dev = ts->dev; 443 444 ret = gpiochip_add(&ts->gc); 445 if (ret) 446 dev_err(ts->dev, "failed to register gpio %d\n", 447 ts->gc.base); 448 } 449 450 return ret; 451 } 452 453 static void ad7879_gpio_remove(struct ad7879 *ts) 454 { 455 const struct ad7879_platform_data *pdata = ts->dev->platform_data; 456 int ret; 457 458 if (pdata->gpio_export) { 459 ret = gpiochip_remove(&ts->gc); 460 if (ret) 461 dev_err(ts->dev, "failed to remove gpio %d\n", 462 ts->gc.base); 463 } 464 } 465 #else 466 static inline int ad7879_gpio_add(struct ad7879 *ts, 467 const struct ad7879_platform_data *pdata) 468 { 469 return 0; 470 } 471 472 static inline void ad7879_gpio_remove(struct ad7879 *ts) 473 { 474 } 475 #endif 476 477 struct ad7879 *ad7879_probe(struct device *dev, u8 devid, unsigned int irq, 478 const struct ad7879_bus_ops *bops) 479 { 480 struct ad7879_platform_data *pdata = dev->platform_data; 481 struct ad7879 *ts; 482 struct input_dev *input_dev; 483 int err; 484 u16 revid; 485 486 if (!irq) { 487 dev_err(dev, "no IRQ?\n"); 488 err = -EINVAL; 489 goto err_out; 490 } 491 492 if (!pdata) { 493 dev_err(dev, "no platform data?\n"); 494 err = -EINVAL; 495 goto err_out; 496 } 497 498 ts = kzalloc(sizeof(*ts), GFP_KERNEL); 499 input_dev = input_allocate_device(); 500 if (!ts || !input_dev) { 501 err = -ENOMEM; 502 goto err_free_mem; 503 } 504 505 ts->bops = bops; 506 ts->dev = dev; 507 ts->input = input_dev; 508 ts->irq = irq; 509 510 setup_timer(&ts->timer, ad7879_timer, (unsigned long) ts); 511 512 ts->x_plate_ohms = pdata->x_plate_ohms ? : 400; 513 ts->pressure_max = pdata->pressure_max ? : ~0; 514 515 ts->first_conversion_delay = pdata->first_conversion_delay; 516 ts->acquisition_time = pdata->acquisition_time; 517 ts->averaging = pdata->averaging; 518 ts->pen_down_acc_interval = pdata->pen_down_acc_interval; 519 ts->median = pdata->median; 520 521 snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev)); 522 523 input_dev->name = "AD7879 Touchscreen"; 524 input_dev->phys = ts->phys; 525 input_dev->dev.parent = dev; 526 input_dev->id.bustype = bops->bustype; 527 528 input_dev->open = ad7879_open; 529 input_dev->close = ad7879_close; 530 531 input_set_drvdata(input_dev, ts); 532 533 __set_bit(EV_ABS, input_dev->evbit); 534 __set_bit(ABS_X, input_dev->absbit); 535 __set_bit(ABS_Y, input_dev->absbit); 536 __set_bit(ABS_PRESSURE, input_dev->absbit); 537 538 __set_bit(EV_KEY, input_dev->evbit); 539 __set_bit(BTN_TOUCH, input_dev->keybit); 540 541 input_set_abs_params(input_dev, ABS_X, 542 pdata->x_min ? : 0, 543 pdata->x_max ? : MAX_12BIT, 544 0, 0); 545 input_set_abs_params(input_dev, ABS_Y, 546 pdata->y_min ? : 0, 547 pdata->y_max ? : MAX_12BIT, 548 0, 0); 549 input_set_abs_params(input_dev, ABS_PRESSURE, 550 pdata->pressure_min, pdata->pressure_max, 0, 0); 551 552 err = ad7879_write(ts, AD7879_REG_CTRL2, AD7879_RESET); 553 if (err < 0) { 554 dev_err(dev, "Failed to write %s\n", input_dev->name); 555 goto err_free_mem; 556 } 557 558 revid = ad7879_read(ts, AD7879_REG_REVID); 559 input_dev->id.product = (revid & 0xff); 560 input_dev->id.version = revid >> 8; 561 if (input_dev->id.product != devid) { 562 dev_err(dev, "Failed to probe %s (%x vs %x)\n", 563 input_dev->name, devid, revid); 564 err = -ENODEV; 565 goto err_free_mem; 566 } 567 568 ts->cmd_crtl3 = AD7879_YPLUS_BIT | 569 AD7879_XPLUS_BIT | 570 AD7879_Z2_BIT | 571 AD7879_Z1_BIT | 572 AD7879_TEMPMASK_BIT | 573 AD7879_AUXVBATMASK_BIT | 574 AD7879_GPIOALERTMASK_BIT; 575 576 ts->cmd_crtl2 = AD7879_PM(AD7879_PM_DYN) | AD7879_DFR | 577 AD7879_AVG(ts->averaging) | 578 AD7879_MFS(ts->median) | 579 AD7879_FCD(ts->first_conversion_delay); 580 581 ts->cmd_crtl1 = AD7879_MODE_INT | AD7879_MODE_SEQ1 | 582 AD7879_ACQ(ts->acquisition_time) | 583 AD7879_TMR(ts->pen_down_acc_interval); 584 585 err = request_threaded_irq(ts->irq, NULL, ad7879_irq, 586 IRQF_TRIGGER_FALLING, 587 dev_name(dev), ts); 588 if (err) { 589 dev_err(dev, "irq %d busy?\n", ts->irq); 590 goto err_free_mem; 591 } 592 593 __ad7879_disable(ts); 594 595 err = sysfs_create_group(&dev->kobj, &ad7879_attr_group); 596 if (err) 597 goto err_free_irq; 598 599 err = ad7879_gpio_add(ts, pdata); 600 if (err) 601 goto err_remove_attr; 602 603 err = input_register_device(input_dev); 604 if (err) 605 goto err_remove_gpio; 606 607 return ts; 608 609 err_remove_gpio: 610 ad7879_gpio_remove(ts); 611 err_remove_attr: 612 sysfs_remove_group(&dev->kobj, &ad7879_attr_group); 613 err_free_irq: 614 free_irq(ts->irq, ts); 615 err_free_mem: 616 input_free_device(input_dev); 617 kfree(ts); 618 err_out: 619 return ERR_PTR(err); 620 } 621 EXPORT_SYMBOL(ad7879_probe); 622 623 void ad7879_remove(struct ad7879 *ts) 624 { 625 ad7879_gpio_remove(ts); 626 sysfs_remove_group(&ts->dev->kobj, &ad7879_attr_group); 627 free_irq(ts->irq, ts); 628 input_unregister_device(ts->input); 629 kfree(ts); 630 } 631 EXPORT_SYMBOL(ad7879_remove); 632 633 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>"); 634 MODULE_DESCRIPTION("AD7879(-1) touchscreen Driver"); 635 MODULE_LICENSE("GPL"); 636