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