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