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(pdata->gpio_pendown, "ads7846_pendown"); 971 if (err) { 972 dev_err(&spi->dev, "failed to request pendown GPIO%d\n", 973 pdata->gpio_pendown); 974 return err; 975 } 976 err = gpio_direction_input(pdata->gpio_pendown); 977 if (err) { 978 dev_err(&spi->dev, "failed to setup pendown GPIO%d\n", 979 pdata->gpio_pendown); 980 gpio_free(pdata->gpio_pendown); 981 return err; 982 } 983 984 ts->gpio_pendown = pdata->gpio_pendown; 985 986 } else { 987 dev_err(&spi->dev, "no get_pendown_state nor gpio_pendown?\n"); 988 return -EINVAL; 989 } 990 991 return 0; 992 } 993 994 /* 995 * Set up the transfers to read touchscreen state; this assumes we 996 * use formula #2 for pressure, not #3. 997 */ 998 static void __devinit ads7846_setup_spi_msg(struct ads7846 *ts, 999 const struct ads7846_platform_data *pdata) 1000 { 1001 struct spi_message *m = &ts->msg[0]; 1002 struct spi_transfer *x = ts->xfer; 1003 struct ads7846_packet *packet = ts->packet; 1004 int vref = pdata->keep_vref_on; 1005 1006 if (ts->model == 7873) { 1007 /* 1008 * The AD7873 is almost identical to the ADS7846 1009 * keep VREF off during differential/ratiometric 1010 * conversion modes. 1011 */ 1012 ts->model = 7846; 1013 vref = 0; 1014 } 1015 1016 ts->msg_count = 1; 1017 spi_message_init(m); 1018 m->context = ts; 1019 1020 if (ts->model == 7845) { 1021 packet->read_y_cmd[0] = READ_Y(vref); 1022 packet->read_y_cmd[1] = 0; 1023 packet->read_y_cmd[2] = 0; 1024 x->tx_buf = &packet->read_y_cmd[0]; 1025 x->rx_buf = &packet->tc.y_buf[0]; 1026 x->len = 3; 1027 spi_message_add_tail(x, m); 1028 } else { 1029 /* y- still on; turn on only y+ (and ADC) */ 1030 packet->read_y = READ_Y(vref); 1031 x->tx_buf = &packet->read_y; 1032 x->len = 1; 1033 spi_message_add_tail(x, m); 1034 1035 x++; 1036 x->rx_buf = &packet->tc.y; 1037 x->len = 2; 1038 spi_message_add_tail(x, m); 1039 } 1040 1041 /* 1042 * The first sample after switching drivers can be low quality; 1043 * optionally discard it, using a second one after the signals 1044 * have had enough time to stabilize. 1045 */ 1046 if (pdata->settle_delay_usecs) { 1047 x->delay_usecs = pdata->settle_delay_usecs; 1048 1049 x++; 1050 x->tx_buf = &packet->read_y; 1051 x->len = 1; 1052 spi_message_add_tail(x, m); 1053 1054 x++; 1055 x->rx_buf = &packet->tc.y; 1056 x->len = 2; 1057 spi_message_add_tail(x, m); 1058 } 1059 1060 ts->msg_count++; 1061 m++; 1062 spi_message_init(m); 1063 m->context = ts; 1064 1065 if (ts->model == 7845) { 1066 x++; 1067 packet->read_x_cmd[0] = READ_X(vref); 1068 packet->read_x_cmd[1] = 0; 1069 packet->read_x_cmd[2] = 0; 1070 x->tx_buf = &packet->read_x_cmd[0]; 1071 x->rx_buf = &packet->tc.x_buf[0]; 1072 x->len = 3; 1073 spi_message_add_tail(x, m); 1074 } else { 1075 /* turn y- off, x+ on, then leave in lowpower */ 1076 x++; 1077 packet->read_x = READ_X(vref); 1078 x->tx_buf = &packet->read_x; 1079 x->len = 1; 1080 spi_message_add_tail(x, m); 1081 1082 x++; 1083 x->rx_buf = &packet->tc.x; 1084 x->len = 2; 1085 spi_message_add_tail(x, m); 1086 } 1087 1088 /* ... maybe discard first sample ... */ 1089 if (pdata->settle_delay_usecs) { 1090 x->delay_usecs = pdata->settle_delay_usecs; 1091 1092 x++; 1093 x->tx_buf = &packet->read_x; 1094 x->len = 1; 1095 spi_message_add_tail(x, m); 1096 1097 x++; 1098 x->rx_buf = &packet->tc.x; 1099 x->len = 2; 1100 spi_message_add_tail(x, m); 1101 } 1102 1103 /* turn y+ off, x- on; we'll use formula #2 */ 1104 if (ts->model == 7846) { 1105 ts->msg_count++; 1106 m++; 1107 spi_message_init(m); 1108 m->context = ts; 1109 1110 x++; 1111 packet->read_z1 = READ_Z1(vref); 1112 x->tx_buf = &packet->read_z1; 1113 x->len = 1; 1114 spi_message_add_tail(x, m); 1115 1116 x++; 1117 x->rx_buf = &packet->tc.z1; 1118 x->len = 2; 1119 spi_message_add_tail(x, m); 1120 1121 /* ... maybe discard first sample ... */ 1122 if (pdata->settle_delay_usecs) { 1123 x->delay_usecs = pdata->settle_delay_usecs; 1124 1125 x++; 1126 x->tx_buf = &packet->read_z1; 1127 x->len = 1; 1128 spi_message_add_tail(x, m); 1129 1130 x++; 1131 x->rx_buf = &packet->tc.z1; 1132 x->len = 2; 1133 spi_message_add_tail(x, m); 1134 } 1135 1136 ts->msg_count++; 1137 m++; 1138 spi_message_init(m); 1139 m->context = ts; 1140 1141 x++; 1142 packet->read_z2 = READ_Z2(vref); 1143 x->tx_buf = &packet->read_z2; 1144 x->len = 1; 1145 spi_message_add_tail(x, m); 1146 1147 x++; 1148 x->rx_buf = &packet->tc.z2; 1149 x->len = 2; 1150 spi_message_add_tail(x, m); 1151 1152 /* ... maybe discard first sample ... */ 1153 if (pdata->settle_delay_usecs) { 1154 x->delay_usecs = pdata->settle_delay_usecs; 1155 1156 x++; 1157 x->tx_buf = &packet->read_z2; 1158 x->len = 1; 1159 spi_message_add_tail(x, m); 1160 1161 x++; 1162 x->rx_buf = &packet->tc.z2; 1163 x->len = 2; 1164 spi_message_add_tail(x, m); 1165 } 1166 } 1167 1168 /* power down */ 1169 ts->msg_count++; 1170 m++; 1171 spi_message_init(m); 1172 m->context = ts; 1173 1174 if (ts->model == 7845) { 1175 x++; 1176 packet->pwrdown_cmd[0] = PWRDOWN; 1177 packet->pwrdown_cmd[1] = 0; 1178 packet->pwrdown_cmd[2] = 0; 1179 x->tx_buf = &packet->pwrdown_cmd[0]; 1180 x->len = 3; 1181 } else { 1182 x++; 1183 packet->pwrdown = PWRDOWN; 1184 x->tx_buf = &packet->pwrdown; 1185 x->len = 1; 1186 spi_message_add_tail(x, m); 1187 1188 x++; 1189 x->rx_buf = &packet->dummy; 1190 x->len = 2; 1191 } 1192 1193 CS_CHANGE(*x); 1194 spi_message_add_tail(x, m); 1195 } 1196 1197 static int __devinit ads7846_probe(struct spi_device *spi) 1198 { 1199 struct ads7846 *ts; 1200 struct ads7846_packet *packet; 1201 struct input_dev *input_dev; 1202 struct ads7846_platform_data *pdata = spi->dev.platform_data; 1203 unsigned long irq_flags; 1204 int err; 1205 1206 if (!spi->irq) { 1207 dev_dbg(&spi->dev, "no IRQ?\n"); 1208 return -ENODEV; 1209 } 1210 1211 if (!pdata) { 1212 dev_dbg(&spi->dev, "no platform data?\n"); 1213 return -ENODEV; 1214 } 1215 1216 /* don't exceed max specified sample rate */ 1217 if (spi->max_speed_hz > (125000 * SAMPLE_BITS)) { 1218 dev_dbg(&spi->dev, "f(sample) %d KHz?\n", 1219 (spi->max_speed_hz/SAMPLE_BITS)/1000); 1220 return -EINVAL; 1221 } 1222 1223 /* We'd set TX word size 8 bits and RX word size to 13 bits ... except 1224 * that even if the hardware can do that, the SPI controller driver 1225 * may not. So we stick to very-portable 8 bit words, both RX and TX. 1226 */ 1227 spi->bits_per_word = 8; 1228 spi->mode = SPI_MODE_0; 1229 err = spi_setup(spi); 1230 if (err < 0) 1231 return err; 1232 1233 ts = kzalloc(sizeof(struct ads7846), GFP_KERNEL); 1234 packet = kzalloc(sizeof(struct ads7846_packet), GFP_KERNEL); 1235 input_dev = input_allocate_device(); 1236 if (!ts || !packet || !input_dev) { 1237 err = -ENOMEM; 1238 goto err_free_mem; 1239 } 1240 1241 dev_set_drvdata(&spi->dev, ts); 1242 1243 ts->packet = packet; 1244 ts->spi = spi; 1245 ts->input = input_dev; 1246 ts->vref_mv = pdata->vref_mv; 1247 ts->swap_xy = pdata->swap_xy; 1248 1249 mutex_init(&ts->lock); 1250 init_waitqueue_head(&ts->wait); 1251 1252 ts->model = pdata->model ? : 7846; 1253 ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100; 1254 ts->x_plate_ohms = pdata->x_plate_ohms ? : 400; 1255 ts->pressure_max = pdata->pressure_max ? : ~0; 1256 1257 if (pdata->filter != NULL) { 1258 if (pdata->filter_init != NULL) { 1259 err = pdata->filter_init(pdata, &ts->filter_data); 1260 if (err < 0) 1261 goto err_free_mem; 1262 } 1263 ts->filter = pdata->filter; 1264 ts->filter_cleanup = pdata->filter_cleanup; 1265 } else if (pdata->debounce_max) { 1266 ts->debounce_max = pdata->debounce_max; 1267 if (ts->debounce_max < 2) 1268 ts->debounce_max = 2; 1269 ts->debounce_tol = pdata->debounce_tol; 1270 ts->debounce_rep = pdata->debounce_rep; 1271 ts->filter = ads7846_debounce_filter; 1272 ts->filter_data = ts; 1273 } else { 1274 ts->filter = ads7846_no_filter; 1275 } 1276 1277 err = ads7846_setup_pendown(spi, ts); 1278 if (err) 1279 goto err_cleanup_filter; 1280 1281 if (pdata->penirq_recheck_delay_usecs) 1282 ts->penirq_recheck_delay_usecs = 1283 pdata->penirq_recheck_delay_usecs; 1284 1285 ts->wait_for_sync = pdata->wait_for_sync ? : null_wait_for_sync; 1286 1287 snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&spi->dev)); 1288 snprintf(ts->name, sizeof(ts->name), "ADS%d Touchscreen", ts->model); 1289 1290 input_dev->name = ts->name; 1291 input_dev->phys = ts->phys; 1292 input_dev->dev.parent = &spi->dev; 1293 1294 input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); 1295 input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH); 1296 input_set_abs_params(input_dev, ABS_X, 1297 pdata->x_min ? : 0, 1298 pdata->x_max ? : MAX_12BIT, 1299 0, 0); 1300 input_set_abs_params(input_dev, ABS_Y, 1301 pdata->y_min ? : 0, 1302 pdata->y_max ? : MAX_12BIT, 1303 0, 0); 1304 input_set_abs_params(input_dev, ABS_PRESSURE, 1305 pdata->pressure_min, pdata->pressure_max, 0, 0); 1306 1307 ads7846_setup_spi_msg(ts, pdata); 1308 1309 ts->reg = regulator_get(&spi->dev, "vcc"); 1310 if (IS_ERR(ts->reg)) { 1311 err = PTR_ERR(ts->reg); 1312 dev_err(&spi->dev, "unable to get regulator: %d\n", err); 1313 goto err_free_gpio; 1314 } 1315 1316 err = regulator_enable(ts->reg); 1317 if (err) { 1318 dev_err(&spi->dev, "unable to enable regulator: %d\n", err); 1319 goto err_put_regulator; 1320 } 1321 1322 irq_flags = pdata->irq_flags ? : IRQF_TRIGGER_FALLING; 1323 irq_flags |= IRQF_ONESHOT; 1324 1325 err = request_threaded_irq(spi->irq, ads7846_hard_irq, ads7846_irq, 1326 irq_flags, spi->dev.driver->name, ts); 1327 if (err && !pdata->irq_flags) { 1328 dev_info(&spi->dev, 1329 "trying pin change workaround on irq %d\n", spi->irq); 1330 irq_flags |= IRQF_TRIGGER_RISING; 1331 err = request_threaded_irq(spi->irq, 1332 ads7846_hard_irq, ads7846_irq, 1333 irq_flags, spi->dev.driver->name, ts); 1334 } 1335 1336 if (err) { 1337 dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq); 1338 goto err_disable_regulator; 1339 } 1340 1341 err = ads784x_hwmon_register(spi, ts); 1342 if (err) 1343 goto err_free_irq; 1344 1345 dev_info(&spi->dev, "touchscreen, irq %d\n", spi->irq); 1346 1347 /* 1348 * Take a first sample, leaving nPENIRQ active and vREF off; avoid 1349 * the touchscreen, in case it's not connected. 1350 */ 1351 if (ts->model == 7845) 1352 ads7845_read12_ser(&spi->dev, PWRDOWN); 1353 else 1354 (void) ads7846_read12_ser(&spi->dev, READ_12BIT_SER(vaux)); 1355 1356 err = sysfs_create_group(&spi->dev.kobj, &ads784x_attr_group); 1357 if (err) 1358 goto err_remove_hwmon; 1359 1360 err = input_register_device(input_dev); 1361 if (err) 1362 goto err_remove_attr_group; 1363 1364 device_init_wakeup(&spi->dev, pdata->wakeup); 1365 1366 return 0; 1367 1368 err_remove_attr_group: 1369 sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group); 1370 err_remove_hwmon: 1371 ads784x_hwmon_unregister(spi, ts); 1372 err_free_irq: 1373 free_irq(spi->irq, ts); 1374 err_disable_regulator: 1375 regulator_disable(ts->reg); 1376 err_put_regulator: 1377 regulator_put(ts->reg); 1378 err_free_gpio: 1379 if (!ts->get_pendown_state) 1380 gpio_free(ts->gpio_pendown); 1381 err_cleanup_filter: 1382 if (ts->filter_cleanup) 1383 ts->filter_cleanup(ts->filter_data); 1384 err_free_mem: 1385 input_free_device(input_dev); 1386 kfree(packet); 1387 kfree(ts); 1388 return err; 1389 } 1390 1391 static int __devexit ads7846_remove(struct spi_device *spi) 1392 { 1393 struct ads7846 *ts = dev_get_drvdata(&spi->dev); 1394 1395 device_init_wakeup(&spi->dev, false); 1396 1397 sysfs_remove_group(&spi->dev.kobj, &ads784x_attr_group); 1398 1399 ads7846_disable(ts); 1400 free_irq(ts->spi->irq, ts); 1401 1402 input_unregister_device(ts->input); 1403 1404 ads784x_hwmon_unregister(spi, ts); 1405 1406 regulator_disable(ts->reg); 1407 regulator_put(ts->reg); 1408 1409 if (!ts->get_pendown_state) { 1410 /* 1411 * If we are not using specialized pendown method we must 1412 * have been relying on gpio we set up ourselves. 1413 */ 1414 gpio_free(ts->gpio_pendown); 1415 } 1416 1417 if (ts->filter_cleanup) 1418 ts->filter_cleanup(ts->filter_data); 1419 1420 kfree(ts->packet); 1421 kfree(ts); 1422 1423 dev_dbg(&spi->dev, "unregistered touchscreen\n"); 1424 1425 return 0; 1426 } 1427 1428 static struct spi_driver ads7846_driver = { 1429 .driver = { 1430 .name = "ads7846", 1431 .bus = &spi_bus_type, 1432 .owner = THIS_MODULE, 1433 .pm = &ads7846_pm, 1434 }, 1435 .probe = ads7846_probe, 1436 .remove = __devexit_p(ads7846_remove), 1437 }; 1438 1439 static int __init ads7846_init(void) 1440 { 1441 return spi_register_driver(&ads7846_driver); 1442 } 1443 module_init(ads7846_init); 1444 1445 static void __exit ads7846_exit(void) 1446 { 1447 spi_unregister_driver(&ads7846_driver); 1448 } 1449 module_exit(ads7846_exit); 1450 1451 MODULE_DESCRIPTION("ADS7846 TouchScreen Driver"); 1452 MODULE_LICENSE("GPL"); 1453 MODULE_ALIAS("spi:ads7846"); 1454