1 /* 2 * ADS7846 based touchscreen and sensor driver 3 * 4 * Copyright (c) 2005 David Brownell 5 * Copyright (c) 2006 Nokia Corporation 6 * Various changes: Imre Deak <imre.deak@nokia.com> 7 * 8 * Using code from: 9 * - corgi_ts.c 10 * Copyright (C) 2004-2005 Richard Purdie 11 * - omap_ts.[hc], ads7846.h, ts_osk.c 12 * Copyright (C) 2002 MontaVista Software 13 * Copyright (C) 2004 Texas Instruments 14 * Copyright (C) 2005 Dirk Behme 15 * 16 * This program is free software; you can redistribute it and/or modify 17 * it under the terms of the GNU General Public License version 2 as 18 * published by the Free Software Foundation. 19 */ 20 #include <linux/types.h> 21 #include <linux/hwmon.h> 22 #include <linux/init.h> 23 #include <linux/err.h> 24 #include <linux/sched.h> 25 #include <linux/delay.h> 26 #include <linux/input.h> 27 #include <linux/interrupt.h> 28 #include <linux/slab.h> 29 #include <linux/pm.h> 30 #include <linux/gpio.h> 31 #include <linux/spi/spi.h> 32 #include <linux/spi/ads7846.h> 33 #include <linux/regulator/consumer.h> 34 #include <asm/irq.h> 35 36 /* 37 * This code has been heavily tested on a Nokia 770, and lightly 38 * tested on other ads7846 devices (OSK/Mistral, Lubbock, Spitz). 39 * TSC2046 is just newer ads7846 silicon. 40 * Support for ads7843 tested on Atmel at91sam926x-EK. 41 * Support for ads7845 has only been stubbed in. 42 * Support for Analog Devices AD7873 and AD7843 tested. 43 * 44 * IRQ handling needs a workaround because of a shortcoming in handling 45 * edge triggered IRQs on some platforms like the OMAP1/2. These 46 * platforms don't handle the ARM lazy IRQ disabling properly, thus we 47 * have to maintain our own SW IRQ disabled status. This should be 48 * removed as soon as the affected platform's IRQ handling is fixed. 49 * 50 * App note sbaa036 talks in more detail about accurate sampling... 51 * that ought to help in situations like LCDs inducing noise (which 52 * can also be helped by using synch signals) and more generally. 53 * This driver tries to utilize the measures described in the app 54 * note. The strength of filtering can be set in the board-* specific 55 * files. 56 */ 57 58 #define TS_POLL_DELAY 1 /* ms delay before the first sample */ 59 #define TS_POLL_PERIOD 5 /* ms delay between samples */ 60 61 /* this driver doesn't aim at the peak continuous sample rate */ 62 #define SAMPLE_BITS (8 /*cmd*/ + 16 /*sample*/ + 2 /* before, after */) 63 64 struct ts_event { 65 /* 66 * For portability, we can't read 12 bit values using SPI (which 67 * would make the controller deliver them as native byte order u16 68 * with msbs zeroed). Instead, we read them as two 8-bit values, 69 * *** WHICH NEED BYTESWAPPING *** and range adjustment. 70 */ 71 u16 x; 72 u16 y; 73 u16 z1, z2; 74 bool ignore; 75 u8 x_buf[3]; 76 u8 y_buf[3]; 77 }; 78 79 /* 80 * We allocate this separately to avoid cache line sharing issues when 81 * driver is used with DMA-based SPI controllers (like atmel_spi) on 82 * systems where main memory is not DMA-coherent (most non-x86 boards). 83 */ 84 struct ads7846_packet { 85 u8 read_x, read_y, read_z1, read_z2, pwrdown; 86 u16 dummy; /* for the pwrdown read */ 87 struct ts_event tc; 88 /* for ads7845 with mpc5121 psc spi we use 3-byte buffers */ 89 u8 read_x_cmd[3], read_y_cmd[3], pwrdown_cmd[3]; 90 }; 91 92 struct ads7846 { 93 struct input_dev *input; 94 char phys[32]; 95 char name[32]; 96 97 struct spi_device *spi; 98 struct regulator *reg; 99 100 #if defined(CONFIG_HWMON) || defined(CONFIG_HWMON_MODULE) 101 struct attribute_group *attr_group; 102 struct device *hwmon; 103 #endif 104 105 u16 model; 106 u16 vref_mv; 107 u16 vref_delay_usecs; 108 u16 x_plate_ohms; 109 u16 pressure_max; 110 111 bool swap_xy; 112 113 struct ads7846_packet *packet; 114 115 struct spi_transfer xfer[18]; 116 struct spi_message msg[5]; 117 int msg_count; 118 wait_queue_head_t wait; 119 120 bool pendown; 121 122 int read_cnt; 123 int read_rep; 124 int last_read; 125 126 u16 debounce_max; 127 u16 debounce_tol; 128 u16 debounce_rep; 129 130 u16 penirq_recheck_delay_usecs; 131 132 struct mutex lock; 133 bool stopped; /* P: lock */ 134 bool disabled; /* P: lock */ 135 bool suspended; /* P: lock */ 136 137 int (*filter)(void *data, int data_idx, int *val); 138 void *filter_data; 139 void (*filter_cleanup)(void *data); 140 int (*get_pendown_state)(void); 141 int gpio_pendown; 142 143 void (*wait_for_sync)(void); 144 }; 145 146 /* leave chip selected when we're done, for quicker re-select? */ 147 #if 0 148 #define CS_CHANGE(xfer) ((xfer).cs_change = 1) 149 #else 150 #define CS_CHANGE(xfer) ((xfer).cs_change = 0) 151 #endif 152 153 /*--------------------------------------------------------------------------*/ 154 155 /* The ADS7846 has touchscreen and other sensors. 156 * Earlier ads784x chips are somewhat compatible. 157 */ 158 #define ADS_START (1 << 7) 159 #define ADS_A2A1A0_d_y (1 << 4) /* differential */ 160 #define ADS_A2A1A0_d_z1 (3 << 4) /* differential */ 161 #define ADS_A2A1A0_d_z2 (4 << 4) /* differential */ 162 #define ADS_A2A1A0_d_x (5 << 4) /* differential */ 163 #define ADS_A2A1A0_temp0 (0 << 4) /* non-differential */ 164 #define ADS_A2A1A0_vbatt (2 << 4) /* non-differential */ 165 #define ADS_A2A1A0_vaux (6 << 4) /* non-differential */ 166 #define ADS_A2A1A0_temp1 (7 << 4) /* non-differential */ 167 #define ADS_8_BIT (1 << 3) 168 #define ADS_12_BIT (0 << 3) 169 #define ADS_SER (1 << 2) /* non-differential */ 170 #define ADS_DFR (0 << 2) /* differential */ 171 #define ADS_PD10_PDOWN (0 << 0) /* low power mode + penirq */ 172 #define ADS_PD10_ADC_ON (1 << 0) /* ADC on */ 173 #define ADS_PD10_REF_ON (2 << 0) /* vREF on + penirq */ 174 #define ADS_PD10_ALL_ON (3 << 0) /* ADC + vREF on */ 175 176 #define MAX_12BIT ((1<<12)-1) 177 178 /* leave ADC powered up (disables penirq) between differential samples */ 179 #define READ_12BIT_DFR(x, adc, vref) (ADS_START | ADS_A2A1A0_d_ ## x \ 180 | ADS_12_BIT | ADS_DFR | \ 181 (adc ? ADS_PD10_ADC_ON : 0) | (vref ? ADS_PD10_REF_ON : 0)) 182 183 #define READ_Y(vref) (READ_12BIT_DFR(y, 1, vref)) 184 #define READ_Z1(vref) (READ_12BIT_DFR(z1, 1, vref)) 185 #define READ_Z2(vref) (READ_12BIT_DFR(z2, 1, vref)) 186 187 #define READ_X(vref) (READ_12BIT_DFR(x, 1, vref)) 188 #define PWRDOWN (READ_12BIT_DFR(y, 0, 0)) /* LAST */ 189 190 /* single-ended samples need to first power up reference voltage; 191 * we leave both ADC and VREF powered 192 */ 193 #define READ_12BIT_SER(x) (ADS_START | ADS_A2A1A0_ ## x \ 194 | ADS_12_BIT | ADS_SER) 195 196 #define REF_ON (READ_12BIT_DFR(x, 1, 1)) 197 #define REF_OFF (READ_12BIT_DFR(y, 0, 0)) 198 199 /* Must be called with ts->lock held */ 200 static void ads7846_stop(struct ads7846 *ts) 201 { 202 if (!ts->disabled && !ts->suspended) { 203 /* Signal IRQ thread to stop polling and disable the handler. */ 204 ts->stopped = true; 205 mb(); 206 wake_up(&ts->wait); 207 disable_irq(ts->spi->irq); 208 } 209 } 210 211 /* Must be called with ts->lock held */ 212 static void ads7846_restart(struct ads7846 *ts) 213 { 214 if (!ts->disabled && !ts->suspended) { 215 /* Tell IRQ thread that it may poll the device. */ 216 ts->stopped = false; 217 mb(); 218 enable_irq(ts->spi->irq); 219 } 220 } 221 222 /* Must be called with ts->lock held */ 223 static void __ads7846_disable(struct ads7846 *ts) 224 { 225 ads7846_stop(ts); 226 regulator_disable(ts->reg); 227 228 /* 229 * We know the chip's in low power mode since we always 230 * leave it that way after every request 231 */ 232 } 233 234 /* Must be called with ts->lock held */ 235 static void __ads7846_enable(struct ads7846 *ts) 236 { 237 regulator_enable(ts->reg); 238 ads7846_restart(ts); 239 } 240 241 static void ads7846_disable(struct ads7846 *ts) 242 { 243 mutex_lock(&ts->lock); 244 245 if (!ts->disabled) { 246 247 if (!ts->suspended) 248 __ads7846_disable(ts); 249 250 ts->disabled = true; 251 } 252 253 mutex_unlock(&ts->lock); 254 } 255 256 static void ads7846_enable(struct ads7846 *ts) 257 { 258 mutex_lock(&ts->lock); 259 260 if (ts->disabled) { 261 262 ts->disabled = false; 263 264 if (!ts->suspended) 265 __ads7846_enable(ts); 266 } 267 268 mutex_unlock(&ts->lock); 269 } 270 271 /*--------------------------------------------------------------------------*/ 272 273 /* 274 * Non-touchscreen sensors only use single-ended conversions. 275 * The range is GND..vREF. The ads7843 and ads7835 must use external vREF; 276 * ads7846 lets that pin be unconnected, to use internal vREF. 277 */ 278 279 struct ser_req { 280 u8 ref_on; 281 u8 command; 282 u8 ref_off; 283 u16 scratch; 284 struct spi_message msg; 285 struct spi_transfer xfer[6]; 286 /* 287 * DMA (thus cache coherency maintenance) requires the 288 * transfer buffers to live in their own cache lines. 289 */ 290 __be16 sample ____cacheline_aligned; 291 }; 292 293 struct ads7845_ser_req { 294 u8 command[3]; 295 struct spi_message msg; 296 struct spi_transfer xfer[2]; 297 /* 298 * DMA (thus cache coherency maintenance) requires the 299 * transfer buffers to live in their own cache lines. 300 */ 301 u8 sample[3] ____cacheline_aligned; 302 }; 303 304 static int ads7846_read12_ser(struct device *dev, unsigned command) 305 { 306 struct spi_device *spi = to_spi_device(dev); 307 struct ads7846 *ts = dev_get_drvdata(dev); 308 struct ser_req *req; 309 int status; 310 int use_internal; 311 312 req = kzalloc(sizeof *req, GFP_KERNEL); 313 if (!req) 314 return -ENOMEM; 315 316 spi_message_init(&req->msg); 317 318 /* FIXME boards with ads7846 might use external vref instead ... */ 319 use_internal = (ts->model == 7846); 320 321 /* maybe turn on internal vREF, and let it settle */ 322 if (use_internal) { 323 req->ref_on = REF_ON; 324 req->xfer[0].tx_buf = &req->ref_on; 325 req->xfer[0].len = 1; 326 spi_message_add_tail(&req->xfer[0], &req->msg); 327 328 req->xfer[1].rx_buf = &req->scratch; 329 req->xfer[1].len = 2; 330 331 /* for 1uF, settle for 800 usec; no cap, 100 usec. */ 332 req->xfer[1].delay_usecs = ts->vref_delay_usecs; 333 spi_message_add_tail(&req->xfer[1], &req->msg); 334 } 335 336 /* take sample */ 337 req->command = (u8) command; 338 req->xfer[2].tx_buf = &req->command; 339 req->xfer[2].len = 1; 340 spi_message_add_tail(&req->xfer[2], &req->msg); 341 342 req->xfer[3].rx_buf = &req->sample; 343 req->xfer[3].len = 2; 344 spi_message_add_tail(&req->xfer[3], &req->msg); 345 346 /* REVISIT: take a few more samples, and compare ... */ 347 348 /* converter in low power mode & enable PENIRQ */ 349 req->ref_off = PWRDOWN; 350 req->xfer[4].tx_buf = &req->ref_off; 351 req->xfer[4].len = 1; 352 spi_message_add_tail(&req->xfer[4], &req->msg); 353 354 req->xfer[5].rx_buf = &req->scratch; 355 req->xfer[5].len = 2; 356 CS_CHANGE(req->xfer[5]); 357 spi_message_add_tail(&req->xfer[5], &req->msg); 358 359 mutex_lock(&ts->lock); 360 ads7846_stop(ts); 361 status = spi_sync(spi, &req->msg); 362 ads7846_restart(ts); 363 mutex_unlock(&ts->lock); 364 365 if (status == 0) { 366 /* on-wire is a must-ignore bit, a BE12 value, then padding */ 367 status = be16_to_cpu(req->sample); 368 status = status >> 3; 369 status &= 0x0fff; 370 } 371 372 kfree(req); 373 return status; 374 } 375 376 static int ads7845_read12_ser(struct device *dev, unsigned command) 377 { 378 struct spi_device *spi = to_spi_device(dev); 379 struct ads7846 *ts = dev_get_drvdata(dev); 380 struct ads7845_ser_req *req; 381 int status; 382 383 req = kzalloc(sizeof *req, GFP_KERNEL); 384 if (!req) 385 return -ENOMEM; 386 387 spi_message_init(&req->msg); 388 389 req->command[0] = (u8) command; 390 req->xfer[0].tx_buf = req->command; 391 req->xfer[0].rx_buf = req->sample; 392 req->xfer[0].len = 3; 393 spi_message_add_tail(&req->xfer[0], &req->msg); 394 395 mutex_lock(&ts->lock); 396 ads7846_stop(ts); 397 status = spi_sync(spi, &req->msg); 398 ads7846_restart(ts); 399 mutex_unlock(&ts->lock); 400 401 if (status == 0) { 402 /* BE12 value, then padding */ 403 status = be16_to_cpu(*((u16 *)&req->sample[1])); 404 status = status >> 3; 405 status &= 0x0fff; 406 } 407 408 kfree(req); 409 return status; 410 } 411 412 #if defined(CONFIG_HWMON) || defined(CONFIG_HWMON_MODULE) 413 414 #define SHOW(name, var, adjust) static ssize_t \ 415 name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \ 416 { \ 417 struct ads7846 *ts = dev_get_drvdata(dev); \ 418 ssize_t v = ads7846_read12_ser(dev, \ 419 READ_12BIT_SER(var) | ADS_PD10_ALL_ON); \ 420 if (v < 0) \ 421 return v; \ 422 return sprintf(buf, "%u\n", adjust(ts, v)); \ 423 } \ 424 static DEVICE_ATTR(name, S_IRUGO, name ## _show, NULL); 425 426 427 /* Sysfs conventions report temperatures in millidegrees Celsius. 428 * ADS7846 could use the low-accuracy two-sample scheme, but can't do the high 429 * accuracy scheme without calibration data. For now we won't try either; 430 * userspace sees raw sensor values, and must scale/calibrate appropriately. 431 */ 432 static inline unsigned null_adjust(struct ads7846 *ts, ssize_t v) 433 { 434 return v; 435 } 436 437 SHOW(temp0, temp0, null_adjust) /* temp1_input */ 438 SHOW(temp1, temp1, null_adjust) /* temp2_input */ 439 440 441 /* sysfs conventions report voltages in millivolts. We can convert voltages 442 * if we know vREF. userspace may need to scale vAUX to match the board's 443 * external resistors; we assume that vBATT only uses the internal ones. 444 */ 445 static inline unsigned vaux_adjust(struct ads7846 *ts, ssize_t v) 446 { 447 unsigned retval = v; 448 449 /* external resistors may scale vAUX into 0..vREF */ 450 retval *= ts->vref_mv; 451 retval = retval >> 12; 452 453 return retval; 454 } 455 456 static inline unsigned vbatt_adjust(struct ads7846 *ts, ssize_t v) 457 { 458 unsigned retval = vaux_adjust(ts, v); 459 460 /* ads7846 has a resistor ladder to scale this signal down */ 461 if (ts->model == 7846) 462 retval *= 4; 463 464 return retval; 465 } 466 467 SHOW(in0_input, vaux, vaux_adjust) 468 SHOW(in1_input, vbatt, vbatt_adjust) 469 470 static struct attribute *ads7846_attributes[] = { 471 &dev_attr_temp0.attr, 472 &dev_attr_temp1.attr, 473 &dev_attr_in0_input.attr, 474 &dev_attr_in1_input.attr, 475 NULL, 476 }; 477 478 static struct attribute_group ads7846_attr_group = { 479 .attrs = ads7846_attributes, 480 }; 481 482 static struct attribute *ads7843_attributes[] = { 483 &dev_attr_in0_input.attr, 484 &dev_attr_in1_input.attr, 485 NULL, 486 }; 487 488 static struct attribute_group ads7843_attr_group = { 489 .attrs = ads7843_attributes, 490 }; 491 492 static struct attribute *ads7845_attributes[] = { 493 &dev_attr_in0_input.attr, 494 NULL, 495 }; 496 497 static struct attribute_group ads7845_attr_group = { 498 .attrs = ads7845_attributes, 499 }; 500 501 static int ads784x_hwmon_register(struct spi_device *spi, struct ads7846 *ts) 502 { 503 struct device *hwmon; 504 int err; 505 506 /* hwmon sensors need a reference voltage */ 507 switch (ts->model) { 508 case 7846: 509 if (!ts->vref_mv) { 510 dev_dbg(&spi->dev, "assuming 2.5V internal vREF\n"); 511 ts->vref_mv = 2500; 512 } 513 break; 514 case 7845: 515 case 7843: 516 if (!ts->vref_mv) { 517 dev_warn(&spi->dev, 518 "external vREF for ADS%d not specified\n", 519 ts->model); 520 return 0; 521 } 522 break; 523 } 524 525 /* different chips have different sensor groups */ 526 switch (ts->model) { 527 case 7846: 528 ts->attr_group = &ads7846_attr_group; 529 break; 530 case 7845: 531 ts->attr_group = &ads7845_attr_group; 532 break; 533 case 7843: 534 ts->attr_group = &ads7843_attr_group; 535 break; 536 default: 537 dev_dbg(&spi->dev, "ADS%d not recognized\n", ts->model); 538 return 0; 539 } 540 541 err = sysfs_create_group(&spi->dev.kobj, ts->attr_group); 542 if (err) 543 return err; 544 545 hwmon = hwmon_device_register(&spi->dev); 546 if (IS_ERR(hwmon)) { 547 sysfs_remove_group(&spi->dev.kobj, ts->attr_group); 548 return PTR_ERR(hwmon); 549 } 550 551 ts->hwmon = hwmon; 552 return 0; 553 } 554 555 static void ads784x_hwmon_unregister(struct spi_device *spi, 556 struct ads7846 *ts) 557 { 558 if (ts->hwmon) { 559 sysfs_remove_group(&spi->dev.kobj, ts->attr_group); 560 hwmon_device_unregister(ts->hwmon); 561 } 562 } 563 564 #else 565 static inline int ads784x_hwmon_register(struct spi_device *spi, 566 struct ads7846 *ts) 567 { 568 return 0; 569 } 570 571 static inline void ads784x_hwmon_unregister(struct spi_device *spi, 572 struct ads7846 *ts) 573 { 574 } 575 #endif 576 577 static ssize_t ads7846_pen_down_show(struct device *dev, 578 struct device_attribute *attr, char *buf) 579 { 580 struct ads7846 *ts = dev_get_drvdata(dev); 581 582 return sprintf(buf, "%u\n", ts->pendown); 583 } 584 585 static DEVICE_ATTR(pen_down, S_IRUGO, ads7846_pen_down_show, NULL); 586 587 static ssize_t ads7846_disable_show(struct device *dev, 588 struct device_attribute *attr, char *buf) 589 { 590 struct ads7846 *ts = dev_get_drvdata(dev); 591 592 return sprintf(buf, "%u\n", ts->disabled); 593 } 594 595 static ssize_t ads7846_disable_store(struct device *dev, 596 struct device_attribute *attr, 597 const char *buf, size_t count) 598 { 599 struct ads7846 *ts = dev_get_drvdata(dev); 600 unsigned long i; 601 602 if (strict_strtoul(buf, 10, &i)) 603 return -EINVAL; 604 605 if (i) 606 ads7846_disable(ts); 607 else 608 ads7846_enable(ts); 609 610 return count; 611 } 612 613 static DEVICE_ATTR(disable, 0664, ads7846_disable_show, ads7846_disable_store); 614 615 static struct attribute *ads784x_attributes[] = { 616 &dev_attr_pen_down.attr, 617 &dev_attr_disable.attr, 618 NULL, 619 }; 620 621 static struct attribute_group ads784x_attr_group = { 622 .attrs = ads784x_attributes, 623 }; 624 625 /*--------------------------------------------------------------------------*/ 626 627 static int get_pendown_state(struct ads7846 *ts) 628 { 629 if (ts->get_pendown_state) 630 return ts->get_pendown_state(); 631 632 return !gpio_get_value(ts->gpio_pendown); 633 } 634 635 static void null_wait_for_sync(void) 636 { 637 } 638 639 static int ads7846_debounce_filter(void *ads, int data_idx, int *val) 640 { 641 struct ads7846 *ts = ads; 642 643 if (!ts->read_cnt || (abs(ts->last_read - *val) > ts->debounce_tol)) { 644 /* Start over collecting consistent readings. */ 645 ts->read_rep = 0; 646 /* 647 * Repeat it, if this was the first read or the read 648 * wasn't consistent enough. 649 */ 650 if (ts->read_cnt < ts->debounce_max) { 651 ts->last_read = *val; 652 ts->read_cnt++; 653 return ADS7846_FILTER_REPEAT; 654 } else { 655 /* 656 * Maximum number of debouncing reached and still 657 * not enough number of consistent readings. Abort 658 * the whole sample, repeat it in the next sampling 659 * period. 660 */ 661 ts->read_cnt = 0; 662 return ADS7846_FILTER_IGNORE; 663 } 664 } else { 665 if (++ts->read_rep > ts->debounce_rep) { 666 /* 667 * Got a good reading for this coordinate, 668 * go for the next one. 669 */ 670 ts->read_cnt = 0; 671 ts->read_rep = 0; 672 return ADS7846_FILTER_OK; 673 } else { 674 /* Read more values that are consistent. */ 675 ts->read_cnt++; 676 return ADS7846_FILTER_REPEAT; 677 } 678 } 679 } 680 681 static int ads7846_no_filter(void *ads, int data_idx, int *val) 682 { 683 return ADS7846_FILTER_OK; 684 } 685 686 static int ads7846_get_value(struct ads7846 *ts, struct spi_message *m) 687 { 688 struct spi_transfer *t = 689 list_entry(m->transfers.prev, struct spi_transfer, transfer_list); 690 691 if (ts->model == 7845) { 692 return be16_to_cpup((__be16 *)&(((char*)t->rx_buf)[1])) >> 3; 693 } else { 694 /* 695 * adjust: on-wire is a must-ignore bit, a BE12 value, then 696 * padding; built from two 8 bit values written msb-first. 697 */ 698 return be16_to_cpup((__be16 *)t->rx_buf) >> 3; 699 } 700 } 701 702 static void ads7846_update_value(struct spi_message *m, int val) 703 { 704 struct spi_transfer *t = 705 list_entry(m->transfers.prev, struct spi_transfer, transfer_list); 706 707 *(u16 *)t->rx_buf = val; 708 } 709 710 static void ads7846_read_state(struct ads7846 *ts) 711 { 712 struct ads7846_packet *packet = ts->packet; 713 struct spi_message *m; 714 int msg_idx = 0; 715 int val; 716 int action; 717 int error; 718 719 while (msg_idx < ts->msg_count) { 720 721 ts->wait_for_sync(); 722 723 m = &ts->msg[msg_idx]; 724 error = spi_sync(ts->spi, m); 725 if (error) { 726 dev_err(&ts->spi->dev, "spi_async --> %d\n", error); 727 packet->tc.ignore = true; 728 return; 729 } 730 731 /* 732 * Last message is power down request, no need to convert 733 * or filter the value. 734 */ 735 if (msg_idx < ts->msg_count - 1) { 736 737 val = ads7846_get_value(ts, m); 738 739 action = ts->filter(ts->filter_data, msg_idx, &val); 740 switch (action) { 741 case ADS7846_FILTER_REPEAT: 742 continue; 743 744 case ADS7846_FILTER_IGNORE: 745 packet->tc.ignore = true; 746 msg_idx = ts->msg_count - 1; 747 continue; 748 749 case ADS7846_FILTER_OK: 750 ads7846_update_value(m, val); 751 packet->tc.ignore = false; 752 msg_idx++; 753 break; 754 755 default: 756 BUG(); 757 } 758 } else { 759 msg_idx++; 760 } 761 } 762 } 763 764 static void ads7846_report_state(struct ads7846 *ts) 765 { 766 struct ads7846_packet *packet = ts->packet; 767 unsigned int Rt; 768 u16 x, y, z1, z2; 769 770 /* 771 * ads7846_get_value() does in-place conversion (including byte swap) 772 * from on-the-wire format as part of debouncing to get stable 773 * readings. 774 */ 775 if (ts->model == 7845) { 776 x = *(u16 *)packet->tc.x_buf; 777 y = *(u16 *)packet->tc.y_buf; 778 z1 = 0; 779 z2 = 0; 780 } else { 781 x = packet->tc.x; 782 y = packet->tc.y; 783 z1 = packet->tc.z1; 784 z2 = packet->tc.z2; 785 } 786 787 /* range filtering */ 788 if (x == MAX_12BIT) 789 x = 0; 790 791 if (ts->model == 7843) { 792 Rt = ts->pressure_max / 2; 793 } else if (ts->model == 7845) { 794 if (get_pendown_state(ts)) 795 Rt = ts->pressure_max / 2; 796 else 797 Rt = 0; 798 dev_vdbg(&ts->spi->dev, "x/y: %d/%d, PD %d\n", x, y, Rt); 799 } else if (likely(x && z1)) { 800 /* compute touch pressure resistance using equation #2 */ 801 Rt = z2; 802 Rt -= z1; 803 Rt *= x; 804 Rt *= ts->x_plate_ohms; 805 Rt /= z1; 806 Rt = (Rt + 2047) >> 12; 807 } else { 808 Rt = 0; 809 } 810 811 /* 812 * Sample found inconsistent by debouncing or pressure is beyond 813 * the maximum. Don't report it to user space, repeat at least 814 * once more the measurement 815 */ 816 if (packet->tc.ignore || Rt > ts->pressure_max) { 817 dev_vdbg(&ts->spi->dev, "ignored %d pressure %d\n", 818 packet->tc.ignore, Rt); 819 return; 820 } 821 822 /* 823 * Maybe check the pendown state before reporting. This discards 824 * false readings when the pen is lifted. 825 */ 826 if (ts->penirq_recheck_delay_usecs) { 827 udelay(ts->penirq_recheck_delay_usecs); 828 if (!get_pendown_state(ts)) 829 Rt = 0; 830 } 831 832 /* 833 * NOTE: We can't rely on the pressure to determine the pen down 834 * state, even this controller has a pressure sensor. The pressure 835 * value can fluctuate for quite a while after lifting the pen and 836 * in some cases may not even settle at the expected value. 837 * 838 * The only safe way to check for the pen up condition is in the 839 * timer by reading the pen signal state (it's a GPIO _and_ IRQ). 840 */ 841 if (Rt) { 842 struct input_dev *input = ts->input; 843 844 if (ts->swap_xy) 845 swap(x, y); 846 847 if (!ts->pendown) { 848 input_report_key(input, BTN_TOUCH, 1); 849 ts->pendown = true; 850 dev_vdbg(&ts->spi->dev, "DOWN\n"); 851 } 852 853 input_report_abs(input, ABS_X, x); 854 input_report_abs(input, ABS_Y, y); 855 input_report_abs(input, ABS_PRESSURE, ts->pressure_max - Rt); 856 857 input_sync(input); 858 dev_vdbg(&ts->spi->dev, "%4d/%4d/%4d\n", x, y, Rt); 859 } 860 } 861 862 static irqreturn_t ads7846_hard_irq(int irq, void *handle) 863 { 864 struct ads7846 *ts = handle; 865 866 return get_pendown_state(ts) ? IRQ_WAKE_THREAD : IRQ_HANDLED; 867 } 868 869 870 static irqreturn_t ads7846_irq(int irq, void *handle) 871 { 872 struct ads7846 *ts = handle; 873 874 /* Start with a small delay before checking pendown state */ 875 msleep(TS_POLL_DELAY); 876 877 while (!ts->stopped && get_pendown_state(ts)) { 878 879 /* pen is down, continue with the measurement */ 880 ads7846_read_state(ts); 881 882 if (!ts->stopped) 883 ads7846_report_state(ts); 884 885 wait_event_timeout(ts->wait, ts->stopped, 886 msecs_to_jiffies(TS_POLL_PERIOD)); 887 } 888 889 if (ts->pendown) { 890 struct input_dev *input = ts->input; 891 892 input_report_key(input, BTN_TOUCH, 0); 893 input_report_abs(input, ABS_PRESSURE, 0); 894 input_sync(input); 895 896 ts->pendown = false; 897 dev_vdbg(&ts->spi->dev, "UP\n"); 898 } 899 900 return IRQ_HANDLED; 901 } 902 903 #ifdef CONFIG_PM_SLEEP 904 static int ads7846_suspend(struct device *dev) 905 { 906 struct ads7846 *ts = dev_get_drvdata(dev); 907 908 mutex_lock(&ts->lock); 909 910 if (!ts->suspended) { 911 912 if (!ts->disabled) 913 __ads7846_disable(ts); 914 915 if (device_may_wakeup(&ts->spi->dev)) 916 enable_irq_wake(ts->spi->irq); 917 918 ts->suspended = true; 919 } 920 921 mutex_unlock(&ts->lock); 922 923 return 0; 924 } 925 926 static int ads7846_resume(struct device *dev) 927 { 928 struct ads7846 *ts = dev_get_drvdata(dev); 929 930 mutex_lock(&ts->lock); 931 932 if (ts->suspended) { 933 934 ts->suspended = false; 935 936 if (device_may_wakeup(&ts->spi->dev)) 937 disable_irq_wake(ts->spi->irq); 938 939 if (!ts->disabled) 940 __ads7846_enable(ts); 941 } 942 943 mutex_unlock(&ts->lock); 944 945 return 0; 946 } 947 #endif 948 949 static SIMPLE_DEV_PM_OPS(ads7846_pm, ads7846_suspend, ads7846_resume); 950 951 static int __devinit ads7846_setup_pendown(struct spi_device *spi, struct ads7846 *ts) 952 { 953 struct ads7846_platform_data *pdata = spi->dev.platform_data; 954 int err; 955 956 /* 957 * REVISIT when the irq can be triggered active-low, or if for some 958 * reason the touchscreen isn't hooked up, we don't need to access 959 * the pendown state. 960 */ 961 962 if (pdata->get_pendown_state) { 963 ts->get_pendown_state = pdata->get_pendown_state; 964 } else if (gpio_is_valid(pdata->gpio_pendown)) { 965 966 err = gpio_request(pdata->gpio_pendown, "ads7846_pendown"); 967 if (err) { 968 dev_err(&spi->dev, "failed to request pendown GPIO%d\n", 969 pdata->gpio_pendown); 970 return err; 971 } 972 973 ts->gpio_pendown = pdata->gpio_pendown; 974 975 } else { 976 dev_err(&spi->dev, "no get_pendown_state nor gpio_pendown?\n"); 977 return -EINVAL; 978 } 979 980 return 0; 981 } 982 983 /* 984 * Set up the transfers to read touchscreen state; this assumes we 985 * use formula #2 for pressure, not #3. 986 */ 987 static void __devinit ads7846_setup_spi_msg(struct ads7846 *ts, 988 const struct ads7846_platform_data *pdata) 989 { 990 struct spi_message *m = &ts->msg[0]; 991 struct spi_transfer *x = ts->xfer; 992 struct ads7846_packet *packet = ts->packet; 993 int vref = pdata->keep_vref_on; 994 995 if (ts->model == 7873) { 996 /* 997 * The AD7873 is almost identical to the ADS7846 998 * keep VREF off during differential/ratiometric 999 * conversion modes. 1000 */ 1001 ts->model = 7846; 1002 vref = 0; 1003 } 1004 1005 ts->msg_count = 1; 1006 spi_message_init(m); 1007 m->context = ts; 1008 1009 if (ts->model == 7845) { 1010 packet->read_y_cmd[0] = READ_Y(vref); 1011 packet->read_y_cmd[1] = 0; 1012 packet->read_y_cmd[2] = 0; 1013 x->tx_buf = &packet->read_y_cmd[0]; 1014 x->rx_buf = &packet->tc.y_buf[0]; 1015 x->len = 3; 1016 spi_message_add_tail(x, m); 1017 } else { 1018 /* y- still on; turn on only y+ (and ADC) */ 1019 packet->read_y = READ_Y(vref); 1020 x->tx_buf = &packet->read_y; 1021 x->len = 1; 1022 spi_message_add_tail(x, m); 1023 1024 x++; 1025 x->rx_buf = &packet->tc.y; 1026 x->len = 2; 1027 spi_message_add_tail(x, m); 1028 } 1029 1030 /* 1031 * The first sample after switching drivers can be low quality; 1032 * optionally discard it, using a second one after the signals 1033 * have had enough time to stabilize. 1034 */ 1035 if (pdata->settle_delay_usecs) { 1036 x->delay_usecs = pdata->settle_delay_usecs; 1037 1038 x++; 1039 x->tx_buf = &packet->read_y; 1040 x->len = 1; 1041 spi_message_add_tail(x, m); 1042 1043 x++; 1044 x->rx_buf = &packet->tc.y; 1045 x->len = 2; 1046 spi_message_add_tail(x, m); 1047 } 1048 1049 ts->msg_count++; 1050 m++; 1051 spi_message_init(m); 1052 m->context = ts; 1053 1054 if (ts->model == 7845) { 1055 x++; 1056 packet->read_x_cmd[0] = READ_X(vref); 1057 packet->read_x_cmd[1] = 0; 1058 packet->read_x_cmd[2] = 0; 1059 x->tx_buf = &packet->read_x_cmd[0]; 1060 x->rx_buf = &packet->tc.x_buf[0]; 1061 x->len = 3; 1062 spi_message_add_tail(x, m); 1063 } else { 1064 /* turn y- off, x+ on, then leave in lowpower */ 1065 x++; 1066 packet->read_x = READ_X(vref); 1067 x->tx_buf = &packet->read_x; 1068 x->len = 1; 1069 spi_message_add_tail(x, m); 1070 1071 x++; 1072 x->rx_buf = &packet->tc.x; 1073 x->len = 2; 1074 spi_message_add_tail(x, m); 1075 } 1076 1077 /* ... maybe discard first sample ... */ 1078 if (pdata->settle_delay_usecs) { 1079 x->delay_usecs = pdata->settle_delay_usecs; 1080 1081 x++; 1082 x->tx_buf = &packet->read_x; 1083 x->len = 1; 1084 spi_message_add_tail(x, m); 1085 1086 x++; 1087 x->rx_buf = &packet->tc.x; 1088 x->len = 2; 1089 spi_message_add_tail(x, m); 1090 } 1091 1092 /* turn y+ off, x- on; we'll use formula #2 */ 1093 if (ts->model == 7846) { 1094 ts->msg_count++; 1095 m++; 1096 spi_message_init(m); 1097 m->context = ts; 1098 1099 x++; 1100 packet->read_z1 = READ_Z1(vref); 1101 x->tx_buf = &packet->read_z1; 1102 x->len = 1; 1103 spi_message_add_tail(x, m); 1104 1105 x++; 1106 x->rx_buf = &packet->tc.z1; 1107 x->len = 2; 1108 spi_message_add_tail(x, m); 1109 1110 /* ... maybe discard first sample ... */ 1111 if (pdata->settle_delay_usecs) { 1112 x->delay_usecs = pdata->settle_delay_usecs; 1113 1114 x++; 1115 x->tx_buf = &packet->read_z1; 1116 x->len = 1; 1117 spi_message_add_tail(x, m); 1118 1119 x++; 1120 x->rx_buf = &packet->tc.z1; 1121 x->len = 2; 1122 spi_message_add_tail(x, m); 1123 } 1124 1125 ts->msg_count++; 1126 m++; 1127 spi_message_init(m); 1128 m->context = ts; 1129 1130 x++; 1131 packet->read_z2 = READ_Z2(vref); 1132 x->tx_buf = &packet->read_z2; 1133 x->len = 1; 1134 spi_message_add_tail(x, m); 1135 1136 x++; 1137 x->rx_buf = &packet->tc.z2; 1138 x->len = 2; 1139 spi_message_add_tail(x, m); 1140 1141 /* ... maybe discard first sample ... */ 1142 if (pdata->settle_delay_usecs) { 1143 x->delay_usecs = pdata->settle_delay_usecs; 1144 1145 x++; 1146 x->tx_buf = &packet->read_z2; 1147 x->len = 1; 1148 spi_message_add_tail(x, m); 1149 1150 x++; 1151 x->rx_buf = &packet->tc.z2; 1152 x->len = 2; 1153 spi_message_add_tail(x, m); 1154 } 1155 } 1156 1157 /* power down */ 1158 ts->msg_count++; 1159 m++; 1160 spi_message_init(m); 1161 m->context = ts; 1162 1163 if (ts->model == 7845) { 1164 x++; 1165 packet->pwrdown_cmd[0] = PWRDOWN; 1166 packet->pwrdown_cmd[1] = 0; 1167 packet->pwrdown_cmd[2] = 0; 1168 x->tx_buf = &packet->pwrdown_cmd[0]; 1169 x->len = 3; 1170 } else { 1171 x++; 1172 packet->pwrdown = PWRDOWN; 1173 x->tx_buf = &packet->pwrdown; 1174 x->len = 1; 1175 spi_message_add_tail(x, m); 1176 1177 x++; 1178 x->rx_buf = &packet->dummy; 1179 x->len = 2; 1180 } 1181 1182 CS_CHANGE(*x); 1183 spi_message_add_tail(x, m); 1184 } 1185 1186 static int __devinit ads7846_probe(struct spi_device *spi) 1187 { 1188 struct ads7846 *ts; 1189 struct ads7846_packet *packet; 1190 struct input_dev *input_dev; 1191 struct ads7846_platform_data *pdata = spi->dev.platform_data; 1192 unsigned long irq_flags; 1193 int err; 1194 1195 if (!spi->irq) { 1196 dev_dbg(&spi->dev, "no IRQ?\n"); 1197 return -ENODEV; 1198 } 1199 1200 if (!pdata) { 1201 dev_dbg(&spi->dev, "no platform data?\n"); 1202 return -ENODEV; 1203 } 1204 1205 /* don't exceed max specified sample rate */ 1206 if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) { 1207 dev_dbg(&spi->dev, "f(sample) %d KHz?\n", 1208 (spi->max_speed_hz/SAMPLE_BITS)/1000); 1209 return -EINVAL; 1210 } 1211 1212 /* We'd set TX word size 8 bits and RX word size to 13 bits ... except 1213 * that even if the hardware can do that, the SPI controller driver 1214 * may not. So we stick to very-portable 8 bit words, both RX and TX. 1215 */ 1216 spi->bits_per_word = 8; 1217 spi->mode = SPI_MODE_0; 1218 err = spi_setup(spi); 1219 if (err < 0) 1220 return err; 1221 1222 ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL); 1223 packet = kzalloc(sizeof(struct ads7846_packet), GFP_KERNEL); 1224 input_dev = input_allocate_device(); 1225 if (!ts || !packet || !input_dev) { 1226 err = -ENOMEM; 1227 goto err_free_mem; 1228 } 1229 1230 dev_set_drvdata(&spi->dev, ts); 1231 1232 ts->packet = packet; 1233 ts->spi = spi; 1234 ts->input = input_dev; 1235 ts->vref_mv = pdata->vref_mv; 1236 ts->swap_xy = pdata->swap_xy; 1237 1238 mutex_init(&ts->lock); 1239 init_waitqueue_head(&ts->wait); 1240 1241 ts->model = pdata->model ? : 7846; 1242 ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100; 1243 ts->x_plate_ohms = pdata->x_plate_ohms ? : 400; 1244 ts->pressure_max = pdata->pressure_max ? : ~0; 1245 1246 if (pdata->filter != NULL) { 1247 if (pdata->filter_init != NULL) { 1248 err = pdata->filter_init(pdata, &ts->filter_data); 1249 if (err < 0) 1250 goto err_free_mem; 1251 } 1252 ts->filter = pdata->filter; 1253 ts->filter_cleanup = pdata->filter_cleanup; 1254 } else if (pdata->debounce_max) { 1255 ts->debounce_max = pdata->debounce_max; 1256 if (ts->debounce_max < 2) 1257 ts->debounce_max = 2; 1258 ts->debounce_tol = pdata->debounce_tol; 1259 ts->debounce_rep = pdata->debounce_rep; 1260 ts->filter = ads7846_debounce_filter; 1261 ts->filter_data = ts; 1262 } else { 1263 ts->filter = ads7846_no_filter; 1264 } 1265 1266 err = ads7846_setup_pendown(spi, ts); 1267 if (err) 1268 goto err_cleanup_filter; 1269 1270 if (pdata->penirq_recheck_delay_usecs) 1271 ts->penirq_recheck_delay_usecs = 1272 pdata->penirq_recheck_delay_usecs; 1273 1274 ts->wait_for_sync = pdata->wait_for_sync ? : null_wait_for_sync; 1275 1276 snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&spi->dev)); 1277 snprintf(ts->name, sizeof(ts->name), "ADS%d Touchscreen", ts->model); 1278 1279 input_dev->name = ts->name; 1280 input_dev->phys = ts->phys; 1281 input_dev->dev.parent = &spi->dev; 1282 1283 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 1284 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 1285 input_set_abs_params(input_dev, ABS_X, 1286 pdata->x_min ? : 0, 1287 pdata->x_max ? : MAX_12BIT, 1288 0, 0); 1289 input_set_abs_params(input_dev, ABS_Y, 1290 pdata->y_min ? : 0, 1291 pdata->y_max ? : MAX_12BIT, 1292 0, 0); 1293 input_set_abs_params(input_dev, ABS_PRESSURE, 1294 pdata->pressure_min, pdata->pressure_max, 0, 0); 1295 1296 ads7846_setup_spi_msg(ts, pdata); 1297 1298 ts->reg = regulator_get(&spi->dev, "vcc"); 1299 if (IS_ERR(ts->reg)) { 1300 err = PTR_ERR(ts->reg); 1301 dev_err(&spi->dev, "unable to get regulator: %d\n", err); 1302 goto err_free_gpio; 1303 } 1304 1305 err = regulator_enable(ts->reg); 1306 if (err) { 1307 dev_err(&spi->dev, "unable to enable regulator: %d\n", err); 1308 goto err_put_regulator; 1309 } 1310 1311 irq_flags = pdata->irq_flags ? : IRQF_TRIGGER_FALLING; 1312 irq_flags |= IRQF_ONESHOT; 1313 1314 err = request_threaded_irq(spi->irq, ads7846_hard_irq, ads7846_irq, 1315 irq_flags, spi->dev.driver->name, ts); 1316 if (err && !pdata->irq_flags) { 1317 dev_info(&spi->dev, 1318 "trying pin change workaround on irq %d\n", spi->irq); 1319 irq_flags |= IRQF_TRIGGER_RISING; 1320 err = request_threaded_irq(spi->irq, 1321 ads7846_hard_irq, ads7846_irq, 1322 irq_flags, spi->dev.driver->name, ts); 1323 } 1324 1325 if (err) { 1326 dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq); 1327 goto err_disable_regulator; 1328 } 1329 1330 err = ads784x_hwmon_register(spi, ts); 1331 if (err) 1332 goto err_free_irq; 1333 1334 dev_info(&spi->dev, "touchscreen, irq %d\n", spi->irq); 1335 1336 /* 1337 * Take a first sample, leaving nPENIRQ active and vREF off; avoid 1338 * the touchscreen, in case it's not connected. 1339 */ 1340 if (ts->model == 7845) 1341 ads7845_read12_ser(&spi->dev, PWRDOWN); 1342 else 1343 (void) ads7846_read12_ser(&spi->dev, 1344 READ_12BIT_SER(vaux) | ADS_PD10_ALL_ON); 1345 1346 err = sysfs_create_group(&spi->dev.kobj, &ads784x_attr_group); 1347 if (err) 1348 goto err_remove_hwmon; 1349 1350 err = input_register_device(input_dev); 1351 if (err) 1352 goto err_remove_attr_group; 1353 1354 device_init_wakeup(&spi->dev, pdata->wakeup); 1355 1356 return 0; 1357 1358 err_remove_attr_group: 1359 sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group); 1360 err_remove_hwmon: 1361 ads784x_hwmon_unregister(spi, ts); 1362 err_free_irq: 1363 free_irq(spi->irq, ts); 1364 err_disable_regulator: 1365 regulator_disable(ts->reg); 1366 err_put_regulator: 1367 regulator_put(ts->reg); 1368 err_free_gpio: 1369 if (!ts->get_pendown_state) 1370 gpio_free(ts->gpio_pendown); 1371 err_cleanup_filter: 1372 if (ts->filter_cleanup) 1373 ts->filter_cleanup(ts->filter_data); 1374 err_free_mem: 1375 input_free_device(input_dev); 1376 kfree(packet); 1377 kfree(ts); 1378 return err; 1379 } 1380 1381 static int __devexit ads7846_remove(struct spi_device *spi) 1382 { 1383 struct ads7846 *ts = dev_get_drvdata(&spi->dev); 1384 1385 device_init_wakeup(&spi->dev, false); 1386 1387 sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group); 1388 1389 ads7846_disable(ts); 1390 free_irq(ts->spi->irq, ts); 1391 1392 input_unregister_device(ts->input); 1393 1394 ads784x_hwmon_unregister(spi, ts); 1395 1396 regulator_disable(ts->reg); 1397 regulator_put(ts->reg); 1398 1399 if (!ts->get_pendown_state) { 1400 /* 1401 * If we are not using specialized pendown method we must 1402 * have been relying on gpio we set up ourselves. 1403 */ 1404 gpio_free(ts->gpio_pendown); 1405 } 1406 1407 if (ts->filter_cleanup) 1408 ts->filter_cleanup(ts->filter_data); 1409 1410 kfree(ts->packet); 1411 kfree(ts); 1412 1413 dev_dbg(&spi->dev, "unregistered touchscreen\n"); 1414 1415 return 0; 1416 } 1417 1418 static struct spi_driver ads7846_driver = { 1419 .driver = { 1420 .name = "ads7846", 1421 .bus = &spi_bus_type, 1422 .owner = THIS_MODULE, 1423 .pm = &ads7846_pm, 1424 }, 1425 .probe = ads7846_probe, 1426 .remove = __devexit_p(ads7846_remove), 1427 }; 1428 1429 static int __init ads7846_init(void) 1430 { 1431 return spi_register_driver(&ads7846_driver); 1432 } 1433 module_init(ads7846_init); 1434 1435 static void __exit ads7846_exit(void) 1436 { 1437 spi_unregister_driver(&ads7846_driver); 1438 } 1439 module_exit(ads7846_exit); 1440 1441 MODULE_DESCRIPTION("ADS7846 TouchScreen Driver"); 1442 MODULE_LICENSE("GPL"); 1443 MODULE_ALIAS("spi:ads7846"); 1444