drivers/input/touchscreen/ad7879.c

   1 /*
   2  * AD7879/AD7889 based touchscreen and GPIO driver
   3  *
   4  * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc.
   5  *
   6  * Licensed under the GPL-2 or later.
   7  *
   8  * History:
   9  * Copyright (c) 2005 David Brownell
  10  * Copyright (c) 2006 Nokia Corporation
  11  * Various changes: Imre Deak <imre.deak@nokia.com>
  12  *
  13  * Using code from:
  14  *  - corgi_ts.c
  15  *      Copyright (C) 2004-2005 Richard Purdie
  16  *  - omap_ts.[hc], ads7846.h, ts_osk.c
  17  *      Copyright (C) 2002 MontaVista Software
  18  *      Copyright (C) 2004 Texas Instruments
  19  *      Copyright (C) 2005 Dirk Behme
  20  *  - ad7877.c
  21  *      Copyright (C) 2006-2008 Analog Devices Inc.
  22  */
  23
  24 #include <linux/device.h>
  25 #include <linux/init.h>
  26 #include <linux/delay.h>
  27 #include <linux/input.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/irq.h>
  30 #include <linux/slab.h>
  31 #include <linux/spi/spi.h>
  32 #include <linux/i2c.h>
  33 #include <linux/gpio.h>
  34
  35 #include <linux/spi/ad7879.h>
  36 #include "ad7879.h"
  37
  38 #define AD7879_REG_ZEROS                0
  39 #define AD7879_REG_CTRL1                1
  40 #define AD7879_REG_CTRL2                2
  41 #define AD7879_REG_CTRL3                3
  42 #define AD7879_REG_AUX1HIGH             4
  43 #define AD7879_REG_AUX1LOW              5
  44 #define AD7879_REG_TEMP1HIGH            6
  45 #define AD7879_REG_TEMP1LOW             7
  46 #define AD7879_REG_XPLUS                8
  47 #define AD7879_REG_YPLUS                9
  48 #define AD7879_REG_Z1                   10
  49 #define AD7879_REG_Z2                   11
  50 #define AD7879_REG_AUXVBAT              12
  51 #define AD7879_REG_TEMP                 13
  52 #define AD7879_REG_REVID                14
  53
  54 /* Control REG 1 */
  55 #define AD7879_TMR(x)                   ((x & 0xFF) << 0)
  56 #define AD7879_ACQ(x)                   ((x & 0x3) << 8)
  57 #define AD7879_MODE_NOC                 (0 << 10)       /* Do not convert */
  58 #define AD7879_MODE_SCC                 (1 << 10)       /* Single channel conversion */
  59 #define AD7879_MODE_SEQ0                (2 << 10)       /* Sequence 0 in Slave Mode */
  60 #define AD7879_MODE_SEQ1                (3 << 10)       /* Sequence 1 in Master Mode */
  61 #define AD7879_MODE_INT                 (1 << 15)       /* PENIRQ disabled INT enabled */
  62
  63 /* Control REG 2 */
  64 #define AD7879_FCD(x)                   ((x & 0x3) << 0)
  65 #define AD7879_RESET                    (1 << 4)
  66 #define AD7879_MFS(x)                   ((x & 0x3) << 5)
  67 #define AD7879_AVG(x)                   ((x & 0x3) << 7)
  68 #define AD7879_SER                      (1 << 9)        /* non-differential */
  69 #define AD7879_DFR                      (0 << 9)        /* differential */
  70 #define AD7879_GPIOPOL                  (1 << 10)
  71 #define AD7879_GPIODIR                  (1 << 11)
  72 #define AD7879_GPIO_DATA                (1 << 12)
  73 #define AD7879_GPIO_EN                  (1 << 13)
  74 #define AD7879_PM(x)                    ((x & 0x3) << 14)
  75 #define AD7879_PM_SHUTDOWN              (0)
  76 #define AD7879_PM_DYN                   (1)
  77 #define AD7879_PM_FULLON                (2)
  78
  79 /* Control REG 3 */
  80 #define AD7879_TEMPMASK_BIT             (1<<15)
  81 #define AD7879_AUXVBATMASK_BIT          (1<<14)
  82 #define AD7879_INTMODE_BIT              (1<<13)
  83 #define AD7879_GPIOALERTMASK_BIT        (1<<12)
  84 #define AD7879_AUXLOW_BIT               (1<<11)
  85 #define AD7879_AUXHIGH_BIT              (1<<10)
  86 #define AD7879_TEMPLOW_BIT              (1<<9)
  87 #define AD7879_TEMPHIGH_BIT             (1<<8)
  88 #define AD7879_YPLUS_BIT                (1<<7)
  89 #define AD7879_XPLUS_BIT                (1<<6)
  90 #define AD7879_Z1_BIT                   (1<<5)
  91 #define AD7879_Z2_BIT                   (1<<4)
  92 #define AD7879_AUX_BIT                  (1<<3)
  93 #define AD7879_VBAT_BIT                 (1<<2)
  94 #define AD7879_TEMP_BIT                 (1<<1)
  95
  96 enum {
  97         AD7879_SEQ_XPOS  = 0,
  98         AD7879_SEQ_YPOS  = 1,
  99         AD7879_SEQ_Z1    = 2,
 100         AD7879_SEQ_Z2    = 3,
 101         AD7879_NR_SENSE  = 4,
 102 };
 103
 104 #define MAX_12BIT                       ((1<<12)-1)
 105 #define TS_PEN_UP_TIMEOUT               msecs_to_jiffies(50)
 106
 107 struct ad7879 {
 108         const struct ad7879_bus_ops *bops;
 109
 110         struct device           *dev;
 111         struct input_dev        *input;
 112         struct timer_list       timer;
 113 #ifdef CONFIG_GPIOLIB
 114         struct gpio_chip        gc;
 115 #endif
 116         unsigned int            irq;
 117         struct mutex            mutex;
 118         bool                    disabled;       /* P: mutex */
 119         u16                     conversion_data[AD7879_NR_SENSE];
 120         char                    phys[32];
 121         u8                      first_conversion_delay;
 122         u8                      acquisition_time;
 123         u8                      averaging;
 124         u8                      pen_down_acc_interval;
 125         u8                      median;
 126         u16                     x_plate_ohms;
 127         u16                     pressure_max;
 128         u16                     cmd_crtl1;
 129         u16                     cmd_crtl2;
 130         u16                     cmd_crtl3;
 131 };
 132
 133 static int ad7879_read(struct ad7879 *ts, u8 reg)
 134 {
 135         return ts->bops->read(ts->dev, reg);
 136 }
 137
 138 static int ad7879_multi_read(struct ad7879 *ts, u8 first_reg, u8 count, u16 *buf)
 139 {
 140         return ts->bops->multi_read(ts->dev, first_reg, count, buf);
 141 }
 142
 143 static int ad7879_write(struct ad7879 *ts, u8 reg, u16 val)
 144 {
 145         return ts->bops->write(ts->dev, reg, val);
 146 }
 147
 148 static void ad7879_report(struct ad7879 *ts)
 149 {
 150         struct input_dev *input_dev = ts->input;
 151         unsigned Rt;
 152         u16 x, y, z1, z2;
 153
 154         x = ts->conversion_data[AD7879_SEQ_XPOS] & MAX_12BIT;
 155         y = ts->conversion_data[AD7879_SEQ_YPOS] & MAX_12BIT;
 156         z1 = ts->conversion_data[AD7879_SEQ_Z1] & MAX_12BIT;
 157         z2 = ts->conversion_data[AD7879_SEQ_Z2] & MAX_12BIT;
 158
 159         /*
 160          * The samples processed here are already preprocessed by the AD7879.
 161          * The preprocessing function consists of a median and an averaging
 162          * filter.  The combination of these two techniques provides a robust
 163          * solution, discarding the spurious noise in the signal and keeping
 164          * only the data of interest.  The size of both filters is
 165          * programmable. (dev.platform_data, see linux/spi/ad7879.h) Other
 166          * user-programmable conversion controls include variable acquisition
 167          * time, and first conversion delay. Up to 16 averages can be taken
 168          * per conversion.
 169          */
 170
 171         if (likely(x && z1)) {
 172                 /* compute touch pressure resistance using equation #1 */
 173                 Rt = (z2 - z1) * x * ts->x_plate_ohms;
 174                 Rt /= z1;
 175                 Rt = (Rt + 2047) >> 12;
 176
 177                 input_report_abs(input_dev, ABS_X, x);
 178                 input_report_abs(input_dev, ABS_Y, y);
 179                 input_report_abs(input_dev, ABS_PRESSURE, Rt);
 180                 input_sync(input_dev);
 181         }
 182 }
 183
 184 static void ad7879_ts_event_release(struct ad7879 *ts)
 185 {
 186         struct input_dev *input_dev = ts->input;
 187
 188         input_report_abs(input_dev, ABS_PRESSURE, 0);
 189         input_sync(input_dev);
 190 }
 191
 192 static void ad7879_timer(unsigned long handle)
 193 {
 194         struct ad7879 *ts = (void *)handle;
 195
 196         ad7879_ts_event_release(ts);
 197 }
 198
 199 static irqreturn_t ad7879_irq(int irq, void *handle)
 200 {
 201         struct ad7879 *ts = handle;
 202
 203         ad7879_multi_read(ts, AD7879_REG_XPLUS, AD7879_NR_SENSE, ts->conversion_data);
 204         ad7879_report(ts);
 205
 206         mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT);
 207
 208         return IRQ_HANDLED;
 209 }
 210
 211 static void ad7879_setup(struct ad7879 *ts)
 212 {
 213         ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
 214         ad7879_write(ts, AD7879_REG_CTRL3, ts->cmd_crtl3);
 215         ad7879_write(ts, AD7879_REG_CTRL1, ts->cmd_crtl1);
 216 }
 217
 218 void ad7879_disable(struct ad7879 *ts)
 219 {
 220         mutex_lock(&ts->mutex);
 221
 222         if (!ts->disabled) {
 223
 224                 ts->disabled = true;
 225                 disable_irq(ts->irq);
 226
 227                 if (del_timer_sync(&ts->timer))
 228                         ad7879_ts_event_release(ts);
 229
 230                 ad7879_write(ts, AD7879_REG_CTRL2,
 231                              AD7879_PM(AD7879_PM_SHUTDOWN));
 232         }
 233
 234         mutex_unlock(&ts->mutex);
 235 }
 236 EXPORT_SYMBOL(ad7879_disable);
 237
 238 void ad7879_enable(struct ad7879 *ts)
 239 {
 240         mutex_lock(&ts->mutex);
 241
 242         if (ts->disabled) {
 243                 ad7879_setup(ts);
 244                 ts->disabled = false;
 245                 enable_irq(ts->irq);
 246         }
 247
 248         mutex_unlock(&ts->mutex);
 249 }
 250 EXPORT_SYMBOL(ad7879_enable);
 251
 252 static ssize_t ad7879_disable_show(struct device *dev,
 253                                      struct device_attribute *attr, char *buf)
 254 {
 255         struct ad7879 *ts = dev_get_drvdata(dev);
 256
 257         return sprintf(buf, "%u\n", ts->disabled);
 258 }
 259
 260 static ssize_t ad7879_disable_store(struct device *dev,
 261                                      struct device_attribute *attr,
 262                                      const char *buf, size_t count)
 263 {
 264         struct ad7879 *ts = dev_get_drvdata(dev);
 265         unsigned long val;
 266         int error;
 267
 268         error = strict_strtoul(buf, 10, &val);
 269         if (error)
 270                 return error;
 271
 272         if (val)
 273                 ad7879_disable(ts);
 274         else
 275                 ad7879_enable(ts);
 276
 277         return count;
 278 }
 279
 280 static DEVICE_ATTR(disable, 0664, ad7879_disable_show, ad7879_disable_store);
 281
 282 static struct attribute *ad7879_attributes[] = {
 283         &dev_attr_disable.attr,
 284         NULL
 285 };
 286
 287 static const struct attribute_group ad7879_attr_group = {
 288         .attrs = ad7879_attributes,
 289 };
 290
 291 #ifdef CONFIG_GPIOLIB
 292 static int ad7879_gpio_direction_input(struct gpio_chip *chip,
 293                                         unsigned gpio)
 294 {
 295         struct ad7879 *ts = container_of(chip, struct ad7879, gc);
 296         int err;
 297
 298         mutex_lock(&ts->mutex);
 299         ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIODIR | AD7879_GPIOPOL;
 300         err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
 301         mutex_unlock(&ts->mutex);
 302
 303         return err;
 304 }
 305
 306 static int ad7879_gpio_direction_output(struct gpio_chip *chip,
 307                                         unsigned gpio, int level)
 308 {
 309         struct ad7879 *ts = container_of(chip, struct ad7879, gc);
 310         int err;
 311
 312         mutex_lock(&ts->mutex);
 313         ts->cmd_crtl2 &= ~AD7879_GPIODIR;
 314         ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIOPOL;
 315         if (level)
 316                 ts->cmd_crtl2 |= AD7879_GPIO_DATA;
 317         else
 318                 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
 319
 320         err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
 321         mutex_unlock(&ts->mutex);
 322
 323         return err;
 324 }
 325
 326 static int ad7879_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
 327 {
 328         struct ad7879 *ts = container_of(chip, struct ad7879, gc);
 329         u16 val;
 330
 331         mutex_lock(&ts->mutex);
 332         val = ad7879_read(ts, AD7879_REG_CTRL2);
 333         mutex_unlock(&ts->mutex);
 334
 335         return !!(val & AD7879_GPIO_DATA);
 336 }
 337
 338 static void ad7879_gpio_set_value(struct gpio_chip *chip,
 339                                   unsigned gpio, int value)
 340 {
 341         struct ad7879 *ts = container_of(chip, struct ad7879, gc);
 342
 343         mutex_lock(&ts->mutex);
 344         if (value)
 345                 ts->cmd_crtl2 |= AD7879_GPIO_DATA;
 346         else
 347                 ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;
 348
 349         ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
 350         mutex_unlock(&ts->mutex);
 351 }
 352
 353 static int ad7879_gpio_add(struct ad7879 *ts,
 354                            const struct ad7879_platform_data *pdata)
 355 {
 356         int ret = 0;
 357
 358         if (pdata->gpio_export) {
 359                 ts->gc.direction_input = ad7879_gpio_direction_input;
 360                 ts->gc.direction_output = ad7879_gpio_direction_output;
 361                 ts->gc.get = ad7879_gpio_get_value;
 362                 ts->gc.set = ad7879_gpio_set_value;
 363                 ts->gc.can_sleep = 1;
 364                 ts->gc.base = pdata->gpio_base;
 365                 ts->gc.ngpio = 1;
 366                 ts->gc.label = "AD7879-GPIO";
 367                 ts->gc.owner = THIS_MODULE;
 368                 ts->gc.dev = ts->dev;
 369
 370                 ret = gpiochip_add(&ts->gc);
 371                 if (ret)
 372                         dev_err(ts->dev, "failed to register gpio %d\n",
 373                                 ts->gc.base);
 374         }
 375
 376         return ret;
 377 }
 378
 379 static void ad7879_gpio_remove(struct ad7879 *ts)
 380 {
 381         const struct ad7879_platform_data *pdata = ts->dev->platform_data;
 382         int ret;
 383
 384         if (pdata->gpio_export) {
 385                 ret = gpiochip_remove(&ts->gc);
 386                 if (ret)
 387                         dev_err(ts->dev, "failed to remove gpio %d\n",
 388                                 ts->gc.base);
 389         }
 390 }
 391 #else
 392 static inline int ad7879_gpio_add(struct ad7879 *ts,
 393                                   const struct ad7879_platform_data *pdata)
 394 {
 395         return 0;
 396 }
 397
 398 static inline void ad7879_gpio_remove(struct ad7879 *ts)
 399 {
 400 }
 401 #endif
 402
 403 struct ad7879 *ad7879_probe(struct device *dev, u8 devid, unsigned int irq,
 404                             const struct ad7879_bus_ops *bops)
 405 {
 406         struct ad7879_platform_data *pdata = dev->platform_data;
 407         struct ad7879 *ts;
 408         struct input_dev *input_dev;
 409         int err;
 410         u16 revid;
 411
 412         if (!irq) {
 413                 dev_err(dev, "no IRQ?\n");
 414                 err = -EINVAL;
 415                 goto err_out;
 416         }
 417
 418         if (!pdata) {
 419                 dev_err(dev, "no platform data?\n");
 420                 err = -EINVAL;
 421                 goto err_out;
 422         }
 423
 424         ts = kzalloc(sizeof(*ts), GFP_KERNEL);
 425         input_dev = input_allocate_device();
 426         if (!ts || !input_dev) {
 427                 err = -ENOMEM;
 428                 goto err_free_mem;
 429         }
 430
 431         ts->bops = bops;
 432         ts->dev = dev;
 433         ts->input = input_dev;
 434
 435         setup_timer(&ts->timer, ad7879_timer, (unsigned long) ts);
 436         mutex_init(&ts->mutex);
 437
 438         ts->irq = irq;
 439
 440         ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
 441         ts->pressure_max = pdata->pressure_max ? : ~0;
 442
 443         ts->first_conversion_delay = pdata->first_conversion_delay;
 444         ts->acquisition_time = pdata->acquisition_time;
 445         ts->averaging = pdata->averaging;
 446         ts->pen_down_acc_interval = pdata->pen_down_acc_interval;
 447         ts->median = pdata->median;
 448
 449         snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));
 450
 451         input_dev->name = "AD7879 Touchscreen";
 452         input_dev->phys = ts->phys;
 453         input_dev->dev.parent = dev;
 454         input_dev->id.bustype = bops->bustype;
 455
 456         __set_bit(EV_ABS, input_dev->evbit);
 457         __set_bit(ABS_X, input_dev->absbit);
 458         __set_bit(ABS_Y, input_dev->absbit);
 459         __set_bit(ABS_PRESSURE, input_dev->absbit);
 460
 461         input_set_abs_params(input_dev, ABS_X,
 462                         pdata->x_min ? : 0,
 463                         pdata->x_max ? : MAX_12BIT,
 464                         0, 0);
 465         input_set_abs_params(input_dev, ABS_Y,
 466                         pdata->y_min ? : 0,
 467                         pdata->y_max ? : MAX_12BIT,
 468                         0, 0);
 469         input_set_abs_params(input_dev, ABS_PRESSURE,
 470                         pdata->pressure_min, pdata->pressure_max, 0, 0);
 471
 472         err = ad7879_write(ts, AD7879_REG_CTRL2, AD7879_RESET);
 473         if (err < 0) {
 474                 dev_err(dev, "Failed to write %s\n", input_dev->name);
 475                 goto err_free_mem;
 476         }
 477
 478         revid = ad7879_read(ts, AD7879_REG_REVID);
 479         input_dev->id.product = (revid & 0xff);
 480         input_dev->id.version = revid >> 8;
 481         if (input_dev->id.product != devid) {
 482                 dev_err(dev, "Failed to probe %s (%x vs %x)\n",
 483                         input_dev->name, devid, revid);
 484                 err = -ENODEV;
 485                 goto err_free_mem;
 486         }
 487
 488         ts->cmd_crtl3 = AD7879_YPLUS_BIT |
 489                         AD7879_XPLUS_BIT |
 490                         AD7879_Z2_BIT |
 491                         AD7879_Z1_BIT |
 492                         AD7879_TEMPMASK_BIT |
 493                         AD7879_AUXVBATMASK_BIT |
 494                         AD7879_GPIOALERTMASK_BIT;
 495
 496         ts->cmd_crtl2 = AD7879_PM(AD7879_PM_DYN) | AD7879_DFR |
 497                         AD7879_AVG(ts->averaging) |
 498                         AD7879_MFS(ts->median) |
 499                         AD7879_FCD(ts->first_conversion_delay);
 500
 501         ts->cmd_crtl1 = AD7879_MODE_INT | AD7879_MODE_SEQ1 |
 502                         AD7879_ACQ(ts->acquisition_time) |
 503                         AD7879_TMR(ts->pen_down_acc_interval);
 504
 505         ad7879_setup(ts);
 506
 507         err = request_threaded_irq(ts->irq, NULL, ad7879_irq,
 508                                    IRQF_TRIGGER_FALLING,
 509                                    dev_name(dev), ts);
 510         if (err) {
 511                 dev_err(dev, "irq %d busy?\n", ts->irq);
 512                 goto err_free_mem;
 513         }
 514
 515         err = sysfs_create_group(&dev->kobj, &ad7879_attr_group);
 516         if (err)
 517                 goto err_free_irq;
 518
 519         err = ad7879_gpio_add(ts, pdata);
 520         if (err)
 521                 goto err_remove_attr;
 522
 523         err = input_register_device(input_dev);
 524         if (err)
 525                 goto err_remove_gpio;
 526
 527         return ts;
 528
 529 err_remove_gpio:
 530         ad7879_gpio_remove(ts);
 531 err_remove_attr:
 532         sysfs_remove_group(&dev->kobj, &ad7879_attr_group);
 533 err_free_irq:
 534         free_irq(ts->irq, ts);
 535 err_free_mem:
 536         input_free_device(input_dev);
 537         kfree(ts);
 538 err_out:
 539         return ERR_PTR(err);
 540 }
 541 EXPORT_SYMBOL(ad7879_probe);
 542
 543 void ad7879_remove(struct ad7879 *ts)
 544 {
 545         ad7879_gpio_remove(ts);
 546         ad7879_disable(ts);
 547         sysfs_remove_group(&ts->dev->kobj, &ad7879_attr_group);
 548         free_irq(ts->irq, ts);
 549         input_unregister_device(ts->input);
 550         kfree(ts);
 551 }
 552 EXPORT_SYMBOL(ad7879_remove);
 553
 554 MODULE_AUTHOR("Michael Hennerich <hennerich@blackfin.uclinux.org>");
 555 MODULE_DESCRIPTION("AD7879(-1) touchscreen Driver");
 556 MODULE_LICENSE("GPL");