ad7879.c

Go to the documentation of this file.

/*
 * AD7879/AD7889 based touchscreen and GPIO driver
 *
 * Copyright (C) 2008-2010 Michael Hennerich, Analog Devices Inc.
 *
 * Licensed under the GPL-2 or later.
 *
 * History:
 * Copyright (c) 2005 David Brownell
 * Copyright (c) 2006 Nokia Corporation
 * Various changes: Imre Deak <[email protected]>
 *
 * Using code from:
 *  - corgi_ts.c
 *  Copyright (C) 2004-2005 Richard Purdie
 *  - omap_ts.[hc], ads7846.h, ts_osk.c
 *  Copyright (C) 2002 MontaVista Software
 *  Copyright (C) 2004 Texas Instruments
 *  Copyright (C) 2005 Dirk Behme
 *  - ad7877.c
 *  Copyright (C) 2006-2008 Analog Devices Inc.
 */

#include <linux/device.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/input.h>
#include <linux/interrupt.h>
#include <linux/irq.h>
#include <linux/slab.h>
#include <linux/spi/spi.h>
#include <linux/i2c.h>
#include <linux/gpio.h>

#include <linux/spi/ad7879.h>
#include <linux/module.h>
#include "ad7879.h"

#define AD7879_REG_ZEROS        0
#define AD7879_REG_CTRL1        1
#define AD7879_REG_CTRL2        2
#define AD7879_REG_CTRL3        3
#define AD7879_REG_AUX1HIGH     4
#define AD7879_REG_AUX1LOW      5
#define AD7879_REG_TEMP1HIGH        6
#define AD7879_REG_TEMP1LOW     7
#define AD7879_REG_XPLUS        8
#define AD7879_REG_YPLUS        9
#define AD7879_REG_Z1           10
#define AD7879_REG_Z2           11
#define AD7879_REG_AUXVBAT      12
#define AD7879_REG_TEMP         13
#define AD7879_REG_REVID        14

/* Control REG 1 */
#define AD7879_TMR(x)           ((x & 0xFF) << 0)
#define AD7879_ACQ(x)           ((x & 0x3) << 8)
#define AD7879_MODE_NOC         (0 << 10)   /* Do not convert */
#define AD7879_MODE_SCC         (1 << 10)   /* Single channel conversion */
#define AD7879_MODE_SEQ0        (2 << 10)   /* Sequence 0 in Slave Mode */
#define AD7879_MODE_SEQ1        (3 << 10)   /* Sequence 1 in Master Mode */
#define AD7879_MODE_INT         (1 << 15)   /* PENIRQ disabled INT enabled */

/* Control REG 2 */
#define AD7879_FCD(x)           ((x & 0x3) << 0)
#define AD7879_RESET            (1 << 4)
#define AD7879_MFS(x)           ((x & 0x3) << 5)
#define AD7879_AVG(x)           ((x & 0x3) << 7)
#define AD7879_SER          (1 << 9)    /* non-differential */
#define AD7879_DFR          (0 << 9)    /* differential */
#define AD7879_GPIOPOL          (1 << 10)
#define AD7879_GPIODIR          (1 << 11)
#define AD7879_GPIO_DATA        (1 << 12)
#define AD7879_GPIO_EN          (1 << 13)
#define AD7879_PM(x)            ((x & 0x3) << 14)
#define AD7879_PM_SHUTDOWN      (0)
#define AD7879_PM_DYN           (1)
#define AD7879_PM_FULLON        (2)

/* Control REG 3 */
#define AD7879_TEMPMASK_BIT     (1<<15)
#define AD7879_AUXVBATMASK_BIT      (1<<14)
#define AD7879_INTMODE_BIT      (1<<13)
#define AD7879_GPIOALERTMASK_BIT    (1<<12)
#define AD7879_AUXLOW_BIT       (1<<11)
#define AD7879_AUXHIGH_BIT      (1<<10)
#define AD7879_TEMPLOW_BIT      (1<<9)
#define AD7879_TEMPHIGH_BIT     (1<<8)
#define AD7879_YPLUS_BIT        (1<<7)
#define AD7879_XPLUS_BIT        (1<<6)
#define AD7879_Z1_BIT           (1<<5)
#define AD7879_Z2_BIT           (1<<4)
#define AD7879_AUX_BIT          (1<<3)
#define AD7879_VBAT_BIT         (1<<2)
#define AD7879_TEMP_BIT         (1<<1)

enum {
    AD7879_SEQ_XPOS  = 0,
    AD7879_SEQ_YPOS  = 1,
    AD7879_SEQ_Z1    = 2,
    AD7879_SEQ_Z2    = 3,
    AD7879_NR_SENSE  = 4,
};

#define MAX_12BIT           ((1<<12)-1)
#define TS_PEN_UP_TIMEOUT       msecs_to_jiffies(50)

struct ad7879 {
    const struct ad7879_bus_ops *bops;

    struct device       *dev;
    struct input_dev    *input;
    struct timer_list   timer;
#ifdef CONFIG_GPIOLIB
    struct gpio_chip    gc;
    struct mutex        mutex;
#endif
    unsigned int        irq;
    bool            disabled;   /* P: input->mutex */
    bool            suspended;  /* P: input->mutex */
    bool            swap_xy;
    u16         conversion_data[AD7879_NR_SENSE];
    char            phys[32];
    u8          first_conversion_delay;
    u8          acquisition_time;
    u8          averaging;
    u8          pen_down_acc_interval;
    u8          median;
    u16         x_plate_ohms;
    u16         pressure_max;
    u16         cmd_crtl1;
    u16         cmd_crtl2;
    u16         cmd_crtl3;
    int         x;
    int         y;
    int         Rt;
};

static int ad7879_read(struct ad7879 *ts, u8 reg)
{
    return ts->bops->read(ts->dev, reg);
}

static int ad7879_multi_read(struct ad7879 *ts, u8 first_reg, u8 count, u16 *buf)
{
    return ts->bops->multi_read(ts->dev, first_reg, count, buf);
}

static int ad7879_write(struct ad7879 *ts, u8 reg, u16 val)
{
    return ts->bops->write(ts->dev, reg, val);
}

static int ad7879_report(struct ad7879 *ts)
{
    struct input_dev *input_dev = ts->input;
    unsigned Rt;
    u16 x, y, z1, z2;

    x = ts->conversion_data[AD7879_SEQ_XPOS] & MAX_12BIT;
    y = ts->conversion_data[AD7879_SEQ_YPOS] & MAX_12BIT;
    z1 = ts->conversion_data[AD7879_SEQ_Z1] & MAX_12BIT;
    z2 = ts->conversion_data[AD7879_SEQ_Z2] & MAX_12BIT;

    if (ts->swap_xy)
        swap(x, y);

    /*
     * The samples processed here are already preprocessed by the AD7879.
     * The preprocessing function consists of a median and an averaging
     * filter.  The combination of these two techniques provides a robust
     * solution, discarding the spurious noise in the signal and keeping
     * only the data of interest.  The size of both filters is
     * programmable. (dev.platform_data, see linux/spi/ad7879.h) Other
     * user-programmable conversion controls include variable acquisition
     * time, and first conversion delay. Up to 16 averages can be taken
     * per conversion.
     */

    if (likely(x && z1)) {
        /* compute touch pressure resistance using equation #1 */
        Rt = (z2 - z1) * x * ts->x_plate_ohms;
        Rt /= z1;
        Rt = (Rt + 2047) >> 12;

        /*
         * Sample found inconsistent, pressure is beyond
         * the maximum. Don't report it to user space.
         */
        if (Rt > ts->pressure_max)
            return -EINVAL;

        /*
         * Note that we delay reporting events by one sample.
         * This is done to avoid reporting last sample of the
         * touch sequence, which may be incomplete if finger
         * leaves the surface before last reading is taken.
         */
        if (timer_pending(&ts->timer)) {
            /* Touch continues */
            input_report_key(input_dev, BTN_TOUCH, 1);
            input_report_abs(input_dev, ABS_X, ts->x);
            input_report_abs(input_dev, ABS_Y, ts->y);
            input_report_abs(input_dev, ABS_PRESSURE, ts->Rt);
            input_sync(input_dev);
        }

        ts->x = x;
        ts->y = y;
        ts->Rt = Rt;

        return 0;
    }

    return -EINVAL;
}

static void ad7879_ts_event_release(struct ad7879 *ts)
{
    struct input_dev *input_dev = ts->input;

    input_report_abs(input_dev, ABS_PRESSURE, 0);
    input_report_key(input_dev, BTN_TOUCH, 0);
    input_sync(input_dev);
}

static void ad7879_timer(unsigned long handle)
{
    struct ad7879 *ts = (void *)handle;

    ad7879_ts_event_release(ts);
}

static irqreturn_t ad7879_irq(int irq, void *handle)
{
    struct ad7879 *ts = handle;

    ad7879_multi_read(ts, AD7879_REG_XPLUS, AD7879_NR_SENSE, ts->conversion_data);

    if (!ad7879_report(ts))
        mod_timer(&ts->timer, jiffies + TS_PEN_UP_TIMEOUT);

    return IRQ_HANDLED;
}

static void __ad7879_enable(struct ad7879 *ts)
{
    ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
    ad7879_write(ts, AD7879_REG_CTRL3, ts->cmd_crtl3);
    ad7879_write(ts, AD7879_REG_CTRL1, ts->cmd_crtl1);

    enable_irq(ts->irq);
}

static void __ad7879_disable(struct ad7879 *ts)
{
    u16 reg = (ts->cmd_crtl2 & ~AD7879_PM(-1)) |
        AD7879_PM(AD7879_PM_SHUTDOWN);
    disable_irq(ts->irq);

    if (del_timer_sync(&ts->timer))
        ad7879_ts_event_release(ts);

    ad7879_write(ts, AD7879_REG_CTRL2, reg);
}


static int ad7879_open(struct input_dev *input)
{
    struct ad7879 *ts = input_get_drvdata(input);

    /* protected by input->mutex */
    if (!ts->disabled && !ts->suspended)
        __ad7879_enable(ts);

    return 0;
}

static void ad7879_close(struct input_dev* input)
{
    struct ad7879 *ts = input_get_drvdata(input);

    /* protected by input->mutex */
    if (!ts->disabled && !ts->suspended)
        __ad7879_disable(ts);
}

#ifdef CONFIG_PM_SLEEP
static int ad7879_suspend(struct device *dev)
{
    struct ad7879 *ts = dev_get_drvdata(dev);

    mutex_lock(&ts->input->mutex);

    if (!ts->suspended && !ts->disabled && ts->input->users)
        __ad7879_disable(ts);

    ts->suspended = true;

    mutex_unlock(&ts->input->mutex);

    return 0;
}

static int ad7879_resume(struct device *dev)
{
    struct ad7879 *ts = dev_get_drvdata(dev);

    mutex_lock(&ts->input->mutex);

    if (ts->suspended && !ts->disabled && ts->input->users)
        __ad7879_enable(ts);

    ts->suspended = false;

    mutex_unlock(&ts->input->mutex);

    return 0;
}
#endif

SIMPLE_DEV_PM_OPS(ad7879_pm_ops, ad7879_suspend, ad7879_resume);
EXPORT_SYMBOL(ad7879_pm_ops);

static void ad7879_toggle(struct ad7879 *ts, bool disable)
{
    mutex_lock(&ts->input->mutex);

    if (!ts->suspended && ts->input->users != 0) {

        if (disable) {
            if (ts->disabled)
                __ad7879_enable(ts);
        } else {
            if (!ts->disabled)
                __ad7879_disable(ts);
        }
    }

    ts->disabled = disable;

    mutex_unlock(&ts->input->mutex);
}

static ssize_t ad7879_disable_show(struct device *dev,
                     struct device_attribute *attr, char *buf)
{
    struct ad7879 *ts = dev_get_drvdata(dev);

    return sprintf(buf, "%u\n", ts->disabled);
}

static ssize_t ad7879_disable_store(struct device *dev,
                     struct device_attribute *attr,
                     const char *buf, size_t count)
{
    struct ad7879 *ts = dev_get_drvdata(dev);
    unsigned int val;
    int error;

    error = kstrtouint(buf, 10, &val);
    if (error)
        return error;

    ad7879_toggle(ts, val);

    return count;
}

static DEVICE_ATTR(disable, 0664, ad7879_disable_show, ad7879_disable_store);

static struct attribute *ad7879_attributes[] = {
    &dev_attr_disable.attr,
    NULL
};

static const struct attribute_group ad7879_attr_group = {
    .attrs = ad7879_attributes,
};

#ifdef CONFIG_GPIOLIB
static int ad7879_gpio_direction_input(struct gpio_chip *chip,
                    unsigned gpio)
{
    struct ad7879 *ts = container_of(chip, struct ad7879, gc);
    int err;

    mutex_lock(&ts->mutex);
    ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIODIR | AD7879_GPIOPOL;
    err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
    mutex_unlock(&ts->mutex);

    return err;
}

static int ad7879_gpio_direction_output(struct gpio_chip *chip,
                    unsigned gpio, int level)
{
    struct ad7879 *ts = container_of(chip, struct ad7879, gc);
    int err;

    mutex_lock(&ts->mutex);
    ts->cmd_crtl2 &= ~AD7879_GPIODIR;
    ts->cmd_crtl2 |= AD7879_GPIO_EN | AD7879_GPIOPOL;
    if (level)
        ts->cmd_crtl2 |= AD7879_GPIO_DATA;
    else
        ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;

    err = ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
    mutex_unlock(&ts->mutex);

    return err;
}

static int ad7879_gpio_get_value(struct gpio_chip *chip, unsigned gpio)
{
    struct ad7879 *ts = container_of(chip, struct ad7879, gc);
    u16 val;

    mutex_lock(&ts->mutex);
    val = ad7879_read(ts, AD7879_REG_CTRL2);
    mutex_unlock(&ts->mutex);

    return !!(val & AD7879_GPIO_DATA);
}

static void ad7879_gpio_set_value(struct gpio_chip *chip,
                  unsigned gpio, int value)
{
    struct ad7879 *ts = container_of(chip, struct ad7879, gc);

    mutex_lock(&ts->mutex);
    if (value)
        ts->cmd_crtl2 |= AD7879_GPIO_DATA;
    else
        ts->cmd_crtl2 &= ~AD7879_GPIO_DATA;

    ad7879_write(ts, AD7879_REG_CTRL2, ts->cmd_crtl2);
    mutex_unlock(&ts->mutex);
}

static int ad7879_gpio_add(struct ad7879 *ts,
               const struct ad7879_platform_data *pdata)
{
    int ret = 0;

    mutex_init(&ts->mutex);

    if (pdata->gpio_export) {
        ts->gc.direction_input = ad7879_gpio_direction_input;
        ts->gc.direction_output = ad7879_gpio_direction_output;
        ts->gc.get = ad7879_gpio_get_value;
        ts->gc.set = ad7879_gpio_set_value;
        ts->gc.can_sleep = 1;
        ts->gc.base = pdata->gpio_base;
        ts->gc.ngpio = 1;
        ts->gc.label = "AD7879-GPIO";
        ts->gc.owner = THIS_MODULE;
        ts->gc.dev = ts->dev;

        ret = gpiochip_add(&ts->gc);
        if (ret)
            dev_err(ts->dev, "failed to register gpio %d\n",
                ts->gc.base);
    }

    return ret;
}

static void ad7879_gpio_remove(struct ad7879 *ts)
{
    const struct ad7879_platform_data *pdata = ts->dev->platform_data;
    int ret;

    if (pdata->gpio_export) {
        ret = gpiochip_remove(&ts->gc);
        if (ret)
            dev_err(ts->dev, "failed to remove gpio %d\n",
                ts->gc.base);
    }
}
#else
static inline int ad7879_gpio_add(struct ad7879 *ts,
                  const struct ad7879_platform_data *pdata)
{
    return 0;
}

static inline void ad7879_gpio_remove(struct ad7879 *ts)
{
}
#endif

struct ad7879 *ad7879_probe(struct device *dev, u8 devid, unsigned int irq,
                const struct ad7879_bus_ops *bops)
{
    struct ad7879_platform_data *pdata = dev->platform_data;
    struct ad7879 *ts;
    struct input_dev *input_dev;
    int err;
    u16 revid;

    if (!irq) {
        dev_err(dev, "no IRQ?\n");
        err = -EINVAL;
        goto err_out;
    }

    if (!pdata) {
        dev_err(dev, "no platform data?\n");
        err = -EINVAL;
        goto err_out;
    }

    ts = kzalloc(sizeof(*ts), GFP_KERNEL);
    input_dev = input_allocate_device();
    if (!ts || !input_dev) {
        err = -ENOMEM;
        goto err_free_mem;
    }

    ts->bops = bops;
    ts->dev = dev;
    ts->input = input_dev;
    ts->irq = irq;
    ts->swap_xy = pdata->swap_xy;

    setup_timer(&ts->timer, ad7879_timer, (unsigned long) ts);

    ts->x_plate_ohms = pdata->x_plate_ohms ? : 400;
    ts->pressure_max = pdata->pressure_max ? : ~0;

    ts->first_conversion_delay = pdata->first_conversion_delay;
    ts->acquisition_time = pdata->acquisition_time;
    ts->averaging = pdata->averaging;
    ts->pen_down_acc_interval = pdata->pen_down_acc_interval;
    ts->median = pdata->median;

    snprintf(ts->phys, sizeof(ts->phys), "%s/input0", dev_name(dev));

    input_dev->name = "AD7879 Touchscreen";
    input_dev->phys = ts->phys;
    input_dev->dev.parent = dev;
    input_dev->id.bustype = bops->bustype;

    input_dev->open = ad7879_open;
    input_dev->close = ad7879_close;

    input_set_drvdata(input_dev, ts);

    __set_bit(EV_ABS, input_dev->evbit);
    __set_bit(ABS_X, input_dev->absbit);
    __set_bit(ABS_Y, input_dev->absbit);
    __set_bit(ABS_PRESSURE, input_dev->absbit);

    __set_bit(EV_KEY, input_dev->evbit);
    __set_bit(BTN_TOUCH, input_dev->keybit);

    input_set_abs_params(input_dev, ABS_X,
            pdata->x_min ? : 0,
            pdata->x_max ? : MAX_12BIT,
            0, 0);
    input_set_abs_params(input_dev, ABS_Y,
            pdata->y_min ? : 0,
            pdata->y_max ? : MAX_12BIT,
            0, 0);
    input_set_abs_params(input_dev, ABS_PRESSURE,
            pdata->pressure_min, pdata->pressure_max, 0, 0);

    err = ad7879_write(ts, AD7879_REG_CTRL2, AD7879_RESET);
    if (err < 0) {
        dev_err(dev, "Failed to write %s\n", input_dev->name);
        goto err_free_mem;
    }

    revid = ad7879_read(ts, AD7879_REG_REVID);
    input_dev->id.product = (revid & 0xff);
    input_dev->id.version = revid >> 8;
    if (input_dev->id.product != devid) {
        dev_err(dev, "Failed to probe %s (%x vs %x)\n",
            input_dev->name, devid, revid);
        err = -ENODEV;
        goto err_free_mem;
    }

    ts->cmd_crtl3 = AD7879_YPLUS_BIT |
            AD7879_XPLUS_BIT |
            AD7879_Z2_BIT |
            AD7879_Z1_BIT |
            AD7879_TEMPMASK_BIT |
            AD7879_AUXVBATMASK_BIT |
            AD7879_GPIOALERTMASK_BIT;

    ts->cmd_crtl2 = AD7879_PM(AD7879_PM_DYN) | AD7879_DFR |
            AD7879_AVG(ts->averaging) |
            AD7879_MFS(ts->median) |
            AD7879_FCD(ts->first_conversion_delay);

    ts->cmd_crtl1 = AD7879_MODE_INT | AD7879_MODE_SEQ1 |
            AD7879_ACQ(ts->acquisition_time) |
            AD7879_TMR(ts->pen_down_acc_interval);

    err = request_threaded_irq(ts->irq, NULL, ad7879_irq,
                   IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
                   dev_name(dev), ts);
    if (err) {
        dev_err(dev, "irq %d busy?\n", ts->irq);
        goto err_free_mem;
    }

    __ad7879_disable(ts);

    err = sysfs_create_group(&dev->kobj, &ad7879_attr_group);
    if (err)
        goto err_free_irq;

    err = ad7879_gpio_add(ts, pdata);
    if (err)
        goto err_remove_attr;

    err = input_register_device(input_dev);
    if (err)
        goto err_remove_gpio;

    return ts;

err_remove_gpio:
    ad7879_gpio_remove(ts);
err_remove_attr:
    sysfs_remove_group(&dev->kobj, &ad7879_attr_group);
err_free_irq:
    free_irq(ts->irq, ts);
err_free_mem:
    input_free_device(input_dev);
    kfree(ts);
err_out:
    return ERR_PTR(err);
}
EXPORT_SYMBOL(ad7879_probe);

void ad7879_remove(struct ad7879 *ts)
{
    ad7879_gpio_remove(ts);
    sysfs_remove_group(&ts->dev->kobj, &ad7879_attr_group);
    free_irq(ts->irq, ts);
    input_unregister_device(ts->input);
    kfree(ts);
}
EXPORT_SYMBOL(ad7879_remove);

MODULE_AUTHOR("Michael Hennerich <[email protected]>");
MODULE_DESCRIPTION("AD7879(-1) touchscreen Driver");
MODULE_LICENSE("GPL");