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