1 /* 2 * Copyright (C) 2006-2008 Michael Hennerich, Analog Devices Inc. 3 * 4 * Description: AD7877 based touchscreen, sensor (ADCs), DAC and GPIO driver 5 * Based on: ads7846.c 6 * 7 * Bugs: Enter bugs at http://blackfin.uclinux.org/ 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * This program is distributed in the hope that it will be useful, 15 * but WITHOUT ANY WARRANTY; without even the implied warranty of 16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 17 * GNU General Public License for more details. 18 * 19 * You should have received a copy of the GNU General Public License 20 * along with this program; if not, see the file COPYING, or write 21 * to the Free Software Foundation, Inc., 22 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 23 * 24 * History: 25 * Copyright (c) 2005 David Brownell 26 * Copyright (c) 2006 Nokia Corporation 27 * Various changes: Imre Deak <imre.deak@nokia.com> 28 * 29 * Using code from: 30 * - corgi_ts.c 31 * Copyright (C) 2004-2005 Richard Purdie 32 * - omap_ts.[hc], ads7846.h, ts_osk.c 33 * Copyright (C) 2002 MontaVista Software 34 * Copyright (C) 2004 Texas Instruments 35 * Copyright (C) 2005 Dirk Behme 36 */ 37 38 39 #include <linux/device.h> 40 #include <linux/init.h> 41 #include <linux/delay.h> 42 #include <linux/input.h> 43 #include <linux/interrupt.h> 44 #include <linux/pm.h> 45 #include <linux/slab.h> 46 #include <linux/spi/spi.h> 47 #include <linux/spi/ad7877.h> 48 #include <linux/module.h> 49 #include <asm/irq.h> 50 51 #define TS_PEN_UP_TIMEOUT msecs_to_jiffies(100) 52 53 #define MAX_SPI_FREQ_HZ 20000000 54 #define MAX_12BIT ((1<<12)-1) 55 56 #define AD7877_REG_ZEROS 0 57 #define AD7877_REG_CTRL1 1 58 #define AD7877_REG_CTRL2 2 59 #define AD7877_REG_ALERT 3 60 #define AD7877_REG_AUX1HIGH 4 61 #define AD7877_REG_AUX1LOW 5 62 #define AD7877_REG_BAT1HIGH 6 63 #define AD7877_REG_BAT1LOW 7 64 #define AD7877_REG_BAT2HIGH 8 65 #define AD7877_REG_BAT2LOW 9 66 #define AD7877_REG_TEMP1HIGH 10 67 #define AD7877_REG_TEMP1LOW 11 68 #define AD7877_REG_SEQ0 12 69 #define AD7877_REG_SEQ1 13 70 #define AD7877_REG_DAC 14 71 #define AD7877_REG_NONE1 15 72 #define AD7877_REG_EXTWRITE 15 73 #define AD7877_REG_XPLUS 16 74 #define AD7877_REG_YPLUS 17 75 #define AD7877_REG_Z2 18 76 #define AD7877_REG_aux1 19 77 #define AD7877_REG_aux2 20 78 #define AD7877_REG_aux3 21 79 #define AD7877_REG_bat1 22 80 #define AD7877_REG_bat2 23 81 #define AD7877_REG_temp1 24 82 #define AD7877_REG_temp2 25 83 #define AD7877_REG_Z1 26 84 #define AD7877_REG_GPIOCTRL1 27 85 #define AD7877_REG_GPIOCTRL2 28 86 #define AD7877_REG_GPIODATA 29 87 #define AD7877_REG_NONE2 30 88 #define AD7877_REG_NONE3 31 89 90 #define AD7877_SEQ_YPLUS_BIT (1<<11) 91 #define AD7877_SEQ_XPLUS_BIT (1<<10) 92 #define AD7877_SEQ_Z2_BIT (1<<9) 93 #define AD7877_SEQ_AUX1_BIT (1<<8) 94 #define AD7877_SEQ_AUX2_BIT (1<<7) 95 #define AD7877_SEQ_AUX3_BIT (1<<6) 96 #define AD7877_SEQ_BAT1_BIT (1<<5) 97 #define AD7877_SEQ_BAT2_BIT (1<<4) 98 #define AD7877_SEQ_TEMP1_BIT (1<<3) 99 #define AD7877_SEQ_TEMP2_BIT (1<<2) 100 #define AD7877_SEQ_Z1_BIT (1<<1) 101 102 enum { 103 AD7877_SEQ_YPOS = 0, 104 AD7877_SEQ_XPOS = 1, 105 AD7877_SEQ_Z2 = 2, 106 AD7877_SEQ_AUX1 = 3, 107 AD7877_SEQ_AUX2 = 4, 108 AD7877_SEQ_AUX3 = 5, 109 AD7877_SEQ_BAT1 = 6, 110 AD7877_SEQ_BAT2 = 7, 111 AD7877_SEQ_TEMP1 = 8, 112 AD7877_SEQ_TEMP2 = 9, 113 AD7877_SEQ_Z1 = 10, 114 AD7877_NR_SENSE = 11, 115 }; 116 117 /* DAC Register Default RANGE 0 to Vcc, Volatge Mode, DAC On */ 118 #define AD7877_DAC_CONF 0x1 119 120 /* If gpio3 is set AUX3/GPIO3 acts as GPIO Output */ 121 #define AD7877_EXTW_GPIO_3_CONF 0x1C4 122 #define AD7877_EXTW_GPIO_DATA 0x200 123 124 /* Control REG 2 */ 125 #define AD7877_TMR(x) ((x & 0x3) << 0) 126 #define AD7877_REF(x) ((x & 0x1) << 2) 127 #define AD7877_POL(x) ((x & 0x1) << 3) 128 #define AD7877_FCD(x) ((x & 0x3) << 4) 129 #define AD7877_PM(x) ((x & 0x3) << 6) 130 #define AD7877_ACQ(x) ((x & 0x3) << 8) 131 #define AD7877_AVG(x) ((x & 0x3) << 10) 132 133 /* Control REG 1 */ 134 #define AD7877_SER (1 << 11) /* non-differential */ 135 #define AD7877_DFR (0 << 11) /* differential */ 136 137 #define AD7877_MODE_NOC (0) /* Do not convert */ 138 #define AD7877_MODE_SCC (1) /* Single channel conversion */ 139 #define AD7877_MODE_SEQ0 (2) /* Sequence 0 in Slave Mode */ 140 #define AD7877_MODE_SEQ1 (3) /* Sequence 1 in Master Mode */ 141 142 #define AD7877_CHANADD(x) ((x&0xF)<<7) 143 #define AD7877_READADD(x) ((x)<<2) 144 #define AD7877_WRITEADD(x) ((x)<<12) 145 146 #define AD7877_READ_CHAN(x) (AD7877_WRITEADD(AD7877_REG_CTRL1) | AD7877_SER | \ 147 AD7877_MODE_SCC | AD7877_CHANADD(AD7877_REG_ ## x) | \ 148 AD7877_READADD(AD7877_REG_ ## x)) 149 150 #define AD7877_MM_SEQUENCE (AD7877_SEQ_YPLUS_BIT | AD7877_SEQ_XPLUS_BIT | \ 151 AD7877_SEQ_Z2_BIT | AD7877_SEQ_Z1_BIT) 152 153 /* 154 * Non-touchscreen sensors only use single-ended conversions. 155 */ 156 157 struct ser_req { 158 u16 reset; 159 u16 ref_on; 160 u16 command; 161 struct spi_message msg; 162 struct spi_transfer xfer[6]; 163 164 /* 165 * DMA (thus cache coherency maintenance) requires the 166 * transfer buffers to live in their own cache lines. 167 */ 168 u16 sample ____cacheline_aligned; 169 }; 170 171 struct ad7877 { 172 struct input_dev *input; 173 char phys[32]; 174 175 struct spi_device *spi; 176 u16 model; 177 u16 vref_delay_usecs; 178 u16 x_plate_ohms; 179 u16 pressure_max; 180 181 u16 cmd_crtl1; 182 u16 cmd_crtl2; 183 u16 cmd_dummy; 184 u16 dac; 185 186 u8 stopacq_polarity; 187 u8 first_conversion_delay; 188 u8 acquisition_time; 189 u8 averaging; 190 u8 pen_down_acc_interval; 191 192 struct spi_transfer xfer[AD7877_NR_SENSE + 2]; 193 struct spi_message msg; 194 195 struct mutex mutex; 196 bool disabled; /* P: mutex */ 197 bool gpio3; /* P: mutex */ 198 bool gpio4; /* P: mutex */ 199 200 spinlock_t lock; 201 struct timer_list timer; /* P: lock */ 202 203 /* 204 * DMA (thus cache coherency maintenance) requires the 205 * transfer buffers to live in their own cache lines. 206 */ 207 u16 conversion_data[AD7877_NR_SENSE] ____cacheline_aligned; 208 }; 209 210 static bool gpio3; 211 module_param(gpio3, bool, 0); 212 MODULE_PARM_DESC(gpio3, "If gpio3 is set to 1 AUX3 acts as GPIO3"); 213 214 /* 215 * ad7877_read/write are only used for initial setup and for sysfs controls. 216 * The main traffic is done using spi_async() in the interrupt handler. 217 */ 218 219 static int ad7877_read(struct spi_device *spi, u16 reg) 220 { 221 struct ser_req *req; 222 int status, ret; 223 224 req = kzalloc(sizeof *req, GFP_KERNEL); 225 if (!req) 226 return -ENOMEM; 227 228 spi_message_init(&req->msg); 229 230 req->command = (u16) (AD7877_WRITEADD(AD7877_REG_CTRL1) | 231 AD7877_READADD(reg)); 232 req->xfer[0].tx_buf = &req->command; 233 req->xfer[0].len = 2; 234 req->xfer[0].cs_change = 1; 235 236 req->xfer[1].rx_buf = &req->sample; 237 req->xfer[1].len = 2; 238 239 spi_message_add_tail(&req->xfer[0], &req->msg); 240 spi_message_add_tail(&req->xfer[1], &req->msg); 241 242 status = spi_sync(spi, &req->msg); 243 ret = status ? : req->sample; 244 245 kfree(req); 246 247 return ret; 248 } 249 250 static int ad7877_write(struct spi_device *spi, u16 reg, u16 val) 251 { 252 struct ser_req *req; 253 int status; 254 255 req = kzalloc(sizeof *req, GFP_KERNEL); 256 if (!req) 257 return -ENOMEM; 258 259 spi_message_init(&req->msg); 260 261 req->command = (u16) (AD7877_WRITEADD(reg) | (val & MAX_12BIT)); 262 req->xfer[0].tx_buf = &req->command; 263 req->xfer[0].len = 2; 264 265 spi_message_add_tail(&req->xfer[0], &req->msg); 266 267 status = spi_sync(spi, &req->msg); 268 269 kfree(req); 270 271 return status; 272 } 273 274 static int ad7877_read_adc(struct spi_device *spi, unsigned command) 275 { 276 struct ad7877 *ts = spi_get_drvdata(spi); 277 struct ser_req *req; 278 int status; 279 int sample; 280 int i; 281 282 req = kzalloc(sizeof *req, GFP_KERNEL); 283 if (!req) 284 return -ENOMEM; 285 286 spi_message_init(&req->msg); 287 288 /* activate reference, so it has time to settle; */ 289 req->ref_on = AD7877_WRITEADD(AD7877_REG_CTRL2) | 290 AD7877_POL(ts->stopacq_polarity) | 291 AD7877_AVG(0) | AD7877_PM(2) | AD7877_TMR(0) | 292 AD7877_ACQ(ts->acquisition_time) | AD7877_FCD(0); 293 294 req->reset = AD7877_WRITEADD(AD7877_REG_CTRL1) | AD7877_MODE_NOC; 295 296 req->command = (u16) command; 297 298 req->xfer[0].tx_buf = &req->reset; 299 req->xfer[0].len = 2; 300 req->xfer[0].cs_change = 1; 301 302 req->xfer[1].tx_buf = &req->ref_on; 303 req->xfer[1].len = 2; 304 req->xfer[1].delay_usecs = ts->vref_delay_usecs; 305 req->xfer[1].cs_change = 1; 306 307 req->xfer[2].tx_buf = &req->command; 308 req->xfer[2].len = 2; 309 req->xfer[2].delay_usecs = ts->vref_delay_usecs; 310 req->xfer[2].cs_change = 1; 311 312 req->xfer[3].rx_buf = &req->sample; 313 req->xfer[3].len = 2; 314 req->xfer[3].cs_change = 1; 315 316 req->xfer[4].tx_buf = &ts->cmd_crtl2; /*REF OFF*/ 317 req->xfer[4].len = 2; 318 req->xfer[4].cs_change = 1; 319 320 req->xfer[5].tx_buf = &ts->cmd_crtl1; /*DEFAULT*/ 321 req->xfer[5].len = 2; 322 323 /* group all the transfers together, so we can't interfere with 324 * reading touchscreen state; disable penirq while sampling 325 */ 326 for (i = 0; i < 6; i++) 327 spi_message_add_tail(&req->xfer[i], &req->msg); 328 329 status = spi_sync(spi, &req->msg); 330 sample = req->sample; 331 332 kfree(req); 333 334 return status ? : sample; 335 } 336 337 static int ad7877_process_data(struct ad7877 *ts) 338 { 339 struct input_dev *input_dev = ts->input; 340 unsigned Rt; 341 u16 x, y, z1, z2; 342 343 x = ts->conversion_data[AD7877_SEQ_XPOS] & MAX_12BIT; 344 y = ts->conversion_data[AD7877_SEQ_YPOS] & MAX_12BIT; 345 z1 = ts->conversion_data[AD7877_SEQ_Z1] & MAX_12BIT; 346 z2 = ts->conversion_data[AD7877_SEQ_Z2] & MAX_12BIT; 347 348 /* 349 * The samples processed here are already preprocessed by the AD7877. 350 * The preprocessing function consists of an averaging filter. 351 * The combination of 'first conversion delay' and averaging provides a robust solution, 352 * discarding the spurious noise in the signal and keeping only the data of interest. 353 * The size of the averaging filter is programmable. (dev.platform_data, see linux/spi/ad7877.h) 354 * Other user-programmable conversion controls include variable acquisition time, 355 * and first conversion delay. Up to 16 averages can be taken per conversion. 356 */ 357 358 if (likely(x && z1)) { 359 /* compute touch pressure resistance using equation #1 */ 360 Rt = (z2 - z1) * x * ts->x_plate_ohms; 361 Rt /= z1; 362 Rt = (Rt + 2047) >> 12; 363 364 /* 365 * Sample found inconsistent, pressure is beyond 366 * the maximum. Don't report it to user space. 367 */ 368 if (Rt > ts->pressure_max) 369 return -EINVAL; 370 371 if (!timer_pending(&ts->timer)) 372 input_report_key(input_dev, BTN_TOUCH, 1); 373 374 input_report_abs(input_dev, ABS_X, x); 375 input_report_abs(input_dev, ABS_Y, y); 376 input_report_abs(input_dev, ABS_PRESSURE, Rt); 377 input_sync(input_dev); 378 379 return 0; 380 } 381 382 return -EINVAL; 383 } 384 385 static inline void ad7877_ts_event_release(struct ad7877 *ts) 386 { 387 struct input_dev *input_dev = ts->input; 388 389 input_report_abs(input_dev, ABS_PRESSURE, 0); 390 input_report_key(input_dev, BTN_TOUCH, 0); 391 input_sync(input_dev); 392 } 393 394 static void ad7877_timer(unsigned long handle) 395 { 396 struct ad7877 *ts = (void *)handle; 397 unsigned long flags; 398 399 spin_lock_irqsave(&ts->lock, flags); 400 ad7877_ts_event_release(ts); 401 spin_unlock_irqrestore(&ts->lock, flags); 402 } 403 404 static irqreturn_t ad7877_irq(int irq, void *handle) 405 { 406 struct ad7877 *ts = handle; 407 unsigned long flags; 408 int error; 409 410 error = spi_sync(ts->spi, &ts->msg); 411 if (error) { 412 dev_err(&ts->spi->dev, "spi_sync --> %d\n", error); 413 goto out; 414 } 415 416 spin_lock_irqsave(&ts->lock, flags); 417 error = ad7877_process_data(ts); 418 if (!error) 419 mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT); 420 spin_unlock_irqrestore(&ts->lock, flags); 421 422 out: 423 return IRQ_HANDLED; 424 } 425 426 static void ad7877_disable(struct ad7877 *ts) 427 { 428 mutex_lock(&ts->mutex); 429 430 if (!ts->disabled) { 431 ts->disabled = true; 432 disable_irq(ts->spi->irq); 433 434 if (del_timer_sync(&ts->timer)) 435 ad7877_ts_event_release(ts); 436 } 437 438 /* 439 * We know the chip's in lowpower mode since we always 440 * leave it that way after every request 441 */ 442 443 mutex_unlock(&ts->mutex); 444 } 445 446 static void ad7877_enable(struct ad7877 *ts) 447 { 448 mutex_lock(&ts->mutex); 449 450 if (ts->disabled) { 451 ts->disabled = false; 452 enable_irq(ts->spi->irq); 453 } 454 455 mutex_unlock(&ts->mutex); 456 } 457 458 #define SHOW(name) static ssize_t \ 459 name ## _show(struct device *dev, struct device_attribute *attr, char *buf) \ 460 { \ 461 struct ad7877 *ts = dev_get_drvdata(dev); \ 462 ssize_t v = ad7877_read_adc(ts->spi, \ 463 AD7877_READ_CHAN(name)); \ 464 if (v < 0) \ 465 return v; \ 466 return sprintf(buf, "%u\n", (unsigned) v); \ 467 } \ 468 static DEVICE_ATTR(name, S_IRUGO, name ## _show, NULL); 469 470 SHOW(aux1) 471 SHOW(aux2) 472 SHOW(aux3) 473 SHOW(bat1) 474 SHOW(bat2) 475 SHOW(temp1) 476 SHOW(temp2) 477 478 static ssize_t ad7877_disable_show(struct device *dev, 479 struct device_attribute *attr, char *buf) 480 { 481 struct ad7877 *ts = dev_get_drvdata(dev); 482 483 return sprintf(buf, "%u\n", ts->disabled); 484 } 485 486 static ssize_t ad7877_disable_store(struct device *dev, 487 struct device_attribute *attr, 488 const char *buf, size_t count) 489 { 490 struct ad7877 *ts = dev_get_drvdata(dev); 491 unsigned int val; 492 int error; 493 494 error = kstrtouint(buf, 10, &val); 495 if (error) 496 return error; 497 498 if (val) 499 ad7877_disable(ts); 500 else 501 ad7877_enable(ts); 502 503 return count; 504 } 505 506 static DEVICE_ATTR(disable, 0664, ad7877_disable_show, ad7877_disable_store); 507 508 static ssize_t ad7877_dac_show(struct device *dev, 509 struct device_attribute *attr, char *buf) 510 { 511 struct ad7877 *ts = dev_get_drvdata(dev); 512 513 return sprintf(buf, "%u\n", ts->dac); 514 } 515 516 static ssize_t ad7877_dac_store(struct device *dev, 517 struct device_attribute *attr, 518 const char *buf, size_t count) 519 { 520 struct ad7877 *ts = dev_get_drvdata(dev); 521 unsigned int val; 522 int error; 523 524 error = kstrtouint(buf, 10, &val); 525 if (error) 526 return error; 527 528 mutex_lock(&ts->mutex); 529 ts->dac = val & 0xFF; 530 ad7877_write(ts->spi, AD7877_REG_DAC, (ts->dac << 4) | AD7877_DAC_CONF); 531 mutex_unlock(&ts->mutex); 532 533 return count; 534 } 535 536 static DEVICE_ATTR(dac, 0664, ad7877_dac_show, ad7877_dac_store); 537 538 static ssize_t ad7877_gpio3_show(struct device *dev, 539 struct device_attribute *attr, char *buf) 540 { 541 struct ad7877 *ts = dev_get_drvdata(dev); 542 543 return sprintf(buf, "%u\n", ts->gpio3); 544 } 545 546 static ssize_t ad7877_gpio3_store(struct device *dev, 547 struct device_attribute *attr, 548 const char *buf, size_t count) 549 { 550 struct ad7877 *ts = dev_get_drvdata(dev); 551 unsigned int val; 552 int error; 553 554 error = kstrtouint(buf, 10, &val); 555 if (error) 556 return error; 557 558 mutex_lock(&ts->mutex); 559 ts->gpio3 = !!val; 560 ad7877_write(ts->spi, AD7877_REG_EXTWRITE, AD7877_EXTW_GPIO_DATA | 561 (ts->gpio4 << 4) | (ts->gpio3 << 5)); 562 mutex_unlock(&ts->mutex); 563 564 return count; 565 } 566 567 static DEVICE_ATTR(gpio3, 0664, ad7877_gpio3_show, ad7877_gpio3_store); 568 569 static ssize_t ad7877_gpio4_show(struct device *dev, 570 struct device_attribute *attr, char *buf) 571 { 572 struct ad7877 *ts = dev_get_drvdata(dev); 573 574 return sprintf(buf, "%u\n", ts->gpio4); 575 } 576 577 static ssize_t ad7877_gpio4_store(struct device *dev, 578 struct device_attribute *attr, 579 const char *buf, size_t count) 580 { 581 struct ad7877 *ts = dev_get_drvdata(dev); 582 unsigned int val; 583 int error; 584 585 error = kstrtouint(buf, 10, &val); 586 if (error) 587 return error; 588 589 mutex_lock(&ts->mutex); 590 ts->gpio4 = !!val; 591 ad7877_write(ts->spi, AD7877_REG_EXTWRITE, AD7877_EXTW_GPIO_DATA | 592 (ts->gpio4 << 4) | (ts->gpio3 << 5)); 593 mutex_unlock(&ts->mutex); 594 595 return count; 596 } 597 598 static DEVICE_ATTR(gpio4, 0664, ad7877_gpio4_show, ad7877_gpio4_store); 599 600 static struct attribute *ad7877_attributes[] = { 601 &dev_attr_temp1.attr, 602 &dev_attr_temp2.attr, 603 &dev_attr_aux1.attr, 604 &dev_attr_aux2.attr, 605 &dev_attr_aux3.attr, 606 &dev_attr_bat1.attr, 607 &dev_attr_bat2.attr, 608 &dev_attr_disable.attr, 609 &dev_attr_dac.attr, 610 &dev_attr_gpio3.attr, 611 &dev_attr_gpio4.attr, 612 NULL 613 }; 614 615 static umode_t ad7877_attr_is_visible(struct kobject *kobj, 616 struct attribute *attr, int n) 617 { 618 umode_t mode = attr->mode; 619 620 if (attr == &dev_attr_aux3.attr) { 621 if (gpio3) 622 mode = 0; 623 } else if (attr == &dev_attr_gpio3.attr) { 624 if (!gpio3) 625 mode = 0; 626 } 627 628 return mode; 629 } 630 631 static const struct attribute_group ad7877_attr_group = { 632 .is_visible = ad7877_attr_is_visible, 633 .attrs = ad7877_attributes, 634 }; 635 636 static void ad7877_setup_ts_def_msg(struct spi_device *spi, struct ad7877 *ts) 637 { 638 struct spi_message *m; 639 int i; 640 641 ts->cmd_crtl2 = AD7877_WRITEADD(AD7877_REG_CTRL2) | 642 AD7877_POL(ts->stopacq_polarity) | 643 AD7877_AVG(ts->averaging) | AD7877_PM(1) | 644 AD7877_TMR(ts->pen_down_acc_interval) | 645 AD7877_ACQ(ts->acquisition_time) | 646 AD7877_FCD(ts->first_conversion_delay); 647 648 ad7877_write(spi, AD7877_REG_CTRL2, ts->cmd_crtl2); 649 650 ts->cmd_crtl1 = AD7877_WRITEADD(AD7877_REG_CTRL1) | 651 AD7877_READADD(AD7877_REG_XPLUS-1) | 652 AD7877_MODE_SEQ1 | AD7877_DFR; 653 654 ad7877_write(spi, AD7877_REG_CTRL1, ts->cmd_crtl1); 655 656 ts->cmd_dummy = 0; 657 658 m = &ts->msg; 659 660 spi_message_init(m); 661 662 m->context = ts; 663 664 ts->xfer[0].tx_buf = &ts->cmd_crtl1; 665 ts->xfer[0].len = 2; 666 ts->xfer[0].cs_change = 1; 667 668 spi_message_add_tail(&ts->xfer[0], m); 669 670 ts->xfer[1].tx_buf = &ts->cmd_dummy; /* Send ZERO */ 671 ts->xfer[1].len = 2; 672 ts->xfer[1].cs_change = 1; 673 674 spi_message_add_tail(&ts->xfer[1], m); 675 676 for (i = 0; i < AD7877_NR_SENSE; i++) { 677 ts->xfer[i + 2].rx_buf = &ts->conversion_data[AD7877_SEQ_YPOS + i]; 678 ts->xfer[i + 2].len = 2; 679 if (i < (AD7877_NR_SENSE - 1)) 680 ts->xfer[i + 2].cs_change = 1; 681 spi_message_add_tail(&ts->xfer[i + 2], m); 682 } 683 } 684 685 static int ad7877_probe(struct spi_device *spi) 686 { 687 struct ad7877 *ts; 688 struct input_dev *input_dev; 689 struct ad7877_platform_data *pdata = spi->dev.platform_data; 690 int err; 691 u16 verify; 692 693 if (!spi->irq) { 694 dev_dbg(&spi->dev, "no IRQ?\n"); 695 return -ENODEV; 696 } 697 698 if (!pdata) { 699 dev_dbg(&spi->dev, "no platform data?\n"); 700 return -ENODEV; 701 } 702 703 /* don't exceed max specified SPI CLK frequency */ 704 if (spi->max_speed_hz > MAX_SPI_FREQ_HZ) { 705 dev_dbg(&spi->dev, "SPI CLK %d Hz?\n",spi->max_speed_hz); 706 return -EINVAL; 707 } 708 709 spi->bits_per_word = 16; 710 err = spi_setup(spi); 711 if (err) { 712 dev_dbg(&spi->dev, "spi master doesn't support 16 bits/word\n"); 713 return err; 714 } 715 716 ts = kzalloc(sizeof(struct ad7877), GFP_KERNEL); 717 input_dev = input_allocate_device(); 718 if (!ts || !input_dev) { 719 err = -ENOMEM; 720 goto err_free_mem; 721 } 722 723 spi_set_drvdata(spi, ts); 724 ts->spi = spi; 725 ts->input = input_dev; 726 727 setup_timer(&ts->timer, ad7877_timer, (unsigned long) ts); 728 mutex_init(&ts->mutex); 729 spin_lock_init(&ts->lock); 730 731 ts->model = pdata->model ? : 7877; 732 ts->vref_delay_usecs = pdata->vref_delay_usecs ? : 100; 733 ts->x_plate_ohms = pdata->x_plate_ohms ? : 400; 734 ts->pressure_max = pdata->pressure_max ? : ~0; 735 736 ts->stopacq_polarity = pdata->stopacq_polarity; 737 ts->first_conversion_delay = pdata->first_conversion_delay; 738 ts->acquisition_time = pdata->acquisition_time; 739 ts->averaging = pdata->averaging; 740 ts->pen_down_acc_interval = pdata->pen_down_acc_interval; 741 742 snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(&spi->dev)); 743 744 input_dev->name = "AD7877 Touchscreen"; 745 input_dev->phys = ts->phys; 746 input_dev->dev.parent = &spi->dev; 747 748 __set_bit(EV_KEY, input_dev->evbit); 749 __set_bit(BTN_TOUCH, input_dev->keybit); 750 __set_bit(EV_ABS, input_dev->evbit); 751 __set_bit(ABS_X, input_dev->absbit); 752 __set_bit(ABS_Y, input_dev->absbit); 753 __set_bit(ABS_PRESSURE, input_dev->absbit); 754 755 input_set_abs_params(input_dev, ABS_X, 756 pdata->x_min ? : 0, 757 pdata->x_max ? : MAX_12BIT, 758 0, 0); 759 input_set_abs_params(input_dev, ABS_Y, 760 pdata->y_min ? : 0, 761 pdata->y_max ? : MAX_12BIT, 762 0, 0); 763 input_set_abs_params(input_dev, ABS_PRESSURE, 764 pdata->pressure_min, pdata->pressure_max, 0, 0); 765 766 ad7877_write(spi, AD7877_REG_SEQ1, AD7877_MM_SEQUENCE); 767 768 verify = ad7877_read(spi, AD7877_REG_SEQ1); 769 770 if (verify != AD7877_MM_SEQUENCE){ 771 dev_err(&spi->dev, "%s: Failed to probe %s\n", 772 dev_name(&spi->dev), input_dev->name); 773 err = -ENODEV; 774 goto err_free_mem; 775 } 776 777 if (gpio3) 778 ad7877_write(spi, AD7877_REG_EXTWRITE, AD7877_EXTW_GPIO_3_CONF); 779 780 ad7877_setup_ts_def_msg(spi, ts); 781 782 /* Request AD7877 /DAV GPIO interrupt */ 783 784 err = request_threaded_irq(spi->irq, NULL, ad7877_irq, 785 IRQF_TRIGGER_FALLING | IRQF_ONESHOT, 786 spi->dev.driver->name, ts); 787 if (err) { 788 dev_dbg(&spi->dev, "irq %d busy?\n", spi->irq); 789 goto err_free_mem; 790 } 791 792 err = sysfs_create_group(&spi->dev.kobj, &ad7877_attr_group); 793 if (err) 794 goto err_free_irq; 795 796 err = input_register_device(input_dev); 797 if (err) 798 goto err_remove_attr_group; 799 800 return 0; 801 802 err_remove_attr_group: 803 sysfs_remove_group(&spi->dev.kobj, &ad7877_attr_group); 804 err_free_irq: 805 free_irq(spi->irq, ts); 806 err_free_mem: 807 input_free_device(input_dev); 808 kfree(ts); 809 return err; 810 } 811 812 static int ad7877_remove(struct spi_device *spi) 813 { 814 struct ad7877 *ts = spi_get_drvdata(spi); 815 816 sysfs_remove_group(&spi->dev.kobj, &ad7877_attr_group); 817 818 ad7877_disable(ts); 819 free_irq(ts->spi->irq, ts); 820 821 input_unregister_device(ts->input); 822 kfree(ts); 823 824 dev_dbg(&spi->dev, "unregistered touchscreen\n"); 825 826 return 0; 827 } 828 829 #ifdef CONFIG_PM_SLEEP 830 static int ad7877_suspend(struct device *dev) 831 { 832 struct ad7877 *ts = dev_get_drvdata(dev); 833 834 ad7877_disable(ts); 835 836 return 0; 837 } 838 839 static int ad7877_resume(struct device *dev) 840 { 841 struct ad7877 *ts = dev_get_drvdata(dev); 842 843 ad7877_enable(ts); 844 845 return 0; 846 } 847 #endif 848 849 static SIMPLE_DEV_PM_OPS(ad7877_pm, ad7877_suspend, ad7877_resume); 850 851 static struct spi_driver ad7877_driver = { 852 .driver = { 853 .name = "ad7877", 854 .owner = THIS_MODULE, 855 .pm = &ad7877_pm, 856 }, 857 .probe = ad7877_probe, 858 .remove = ad7877_remove, 859 }; 860 861 module_spi_driver(ad7877_driver); 862 863 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>"); 864 MODULE_DESCRIPTION("AD7877 touchscreen Driver"); 865 MODULE_LICENSE("GPL"); 866 MODULE_ALIAS("spi:ad7877"); 867