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