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