linux/drivers/input/touchscreen/migor_ts.c
<<
>>
Prefs
   1/*
   2 * Touch Screen driver for Renesas MIGO-R Platform
   3 *
   4 * Copyright (c) 2008 Magnus Damm
   5 * Copyright (c) 2007 Ujjwal Pande <ujjwal@kenati.com>,
   6 *  Kenati Technologies Pvt Ltd.
   7 *
   8 * This file is free software; you can redistribute it and/or
   9 * modify it under the terms of the GNU  General Public
  10 * License as published by the Free Software Foundation; either
  11 * version 2 of the License, or (at your option) any later version.
  12 *
  13 * This file is distributed in the hope that it will be useful,
  14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 *  General Public License for more details.
  17 *
  18 * You should have received a copy of the GNU General Public
  19 * License along with this library; if not, write to the Free Software
  20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21 */
  22#include <linux/module.h>
  23#include <linux/kernel.h>
  24#include <linux/input.h>
  25#include <linux/interrupt.h>
  26#include <linux/pm.h>
  27#include <linux/slab.h>
  28#include <asm/io.h>
  29#include <linux/i2c.h>
  30#include <linux/timer.h>
  31
  32#define EVENT_PENDOWN 1
  33#define EVENT_REPEAT  2
  34#define EVENT_PENUP   3
  35
  36struct migor_ts_priv {
  37        struct i2c_client *client;
  38        struct input_dev *input;
  39        int irq;
  40};
  41
  42static const u_int8_t migor_ts_ena_seq[17] = { 0x33, 0x22, 0x11,
  43                                               0x01, 0x06, 0x07, };
  44static const u_int8_t migor_ts_dis_seq[17] = { };
  45
  46static irqreturn_t migor_ts_isr(int irq, void *dev_id)
  47{
  48        struct migor_ts_priv *priv = dev_id;
  49        unsigned short xpos, ypos;
  50        unsigned char event;
  51        u_int8_t buf[16];
  52
  53        /*
  54         * The touch screen controller chip is hooked up to the CPU
  55         * using I2C and a single interrupt line. The interrupt line
  56         * is pulled low whenever someone taps the screen. To deassert
  57         * the interrupt line we need to acknowledge the interrupt by
  58         * communicating with the controller over the slow i2c bus.
  59         *
  60         * Since I2C bus controller may sleep we are using threaded
  61         * IRQ here.
  62         */
  63
  64        memset(buf, 0, sizeof(buf));
  65
  66        /* Set Index 0 */
  67        buf[0] = 0;
  68        if (i2c_master_send(priv->client, buf, 1) != 1) {
  69                dev_err(&priv->client->dev, "Unable to write i2c index\n");
  70                goto out;
  71        }
  72
  73        /* Now do Page Read */
  74        if (i2c_master_recv(priv->client, buf, sizeof(buf)) != sizeof(buf)) {
  75                dev_err(&priv->client->dev, "Unable to read i2c page\n");
  76                goto out;
  77        }
  78
  79        ypos = ((buf[9] & 0x03) << 8 | buf[8]);
  80        xpos = ((buf[11] & 0x03) << 8 | buf[10]);
  81        event = buf[12];
  82
  83        switch (event) {
  84        case EVENT_PENDOWN:
  85        case EVENT_REPEAT:
  86                input_report_key(priv->input, BTN_TOUCH, 1);
  87                input_report_abs(priv->input, ABS_X, ypos); /*X-Y swap*/
  88                input_report_abs(priv->input, ABS_Y, xpos);
  89                input_sync(priv->input);
  90                break;
  91
  92        case EVENT_PENUP:
  93                input_report_key(priv->input, BTN_TOUCH, 0);
  94                input_sync(priv->input);
  95                break;
  96        }
  97
  98 out:
  99        return IRQ_HANDLED;
 100}
 101
 102static int migor_ts_open(struct input_dev *dev)
 103{
 104        struct migor_ts_priv *priv = input_get_drvdata(dev);
 105        struct i2c_client *client = priv->client;
 106        int count;
 107
 108        /* enable controller */
 109        count = i2c_master_send(client, migor_ts_ena_seq,
 110                                sizeof(migor_ts_ena_seq));
 111        if (count != sizeof(migor_ts_ena_seq)) {
 112                dev_err(&client->dev, "Unable to enable touchscreen.\n");
 113                return -ENXIO;
 114        }
 115
 116        return 0;
 117}
 118
 119static void migor_ts_close(struct input_dev *dev)
 120{
 121        struct migor_ts_priv *priv = input_get_drvdata(dev);
 122        struct i2c_client *client = priv->client;
 123
 124        disable_irq(priv->irq);
 125
 126        /* disable controller */
 127        i2c_master_send(client, migor_ts_dis_seq, sizeof(migor_ts_dis_seq));
 128
 129        enable_irq(priv->irq);
 130}
 131
 132static int migor_ts_probe(struct i2c_client *client,
 133                          const struct i2c_device_id *idp)
 134{
 135        struct migor_ts_priv *priv;
 136        struct input_dev *input;
 137        int error;
 138
 139        priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 140        input = input_allocate_device();
 141        if (!priv || !input) {
 142                dev_err(&client->dev, "failed to allocate memory\n");
 143                error = -ENOMEM;
 144                goto err_free_mem;
 145        }
 146
 147        priv->client = client;
 148        priv->input = input;
 149        priv->irq = client->irq;
 150
 151        input->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 152
 153        __set_bit(BTN_TOUCH, input->keybit);
 154
 155        input_set_abs_params(input, ABS_X, 95, 955, 0, 0);
 156        input_set_abs_params(input, ABS_Y, 85, 935, 0, 0);
 157
 158        input->name = client->name;
 159        input->id.bustype = BUS_I2C;
 160        input->dev.parent = &client->dev;
 161
 162        input->open = migor_ts_open;
 163        input->close = migor_ts_close;
 164
 165        input_set_drvdata(input, priv);
 166
 167        error = request_threaded_irq(priv->irq, NULL, migor_ts_isr,
 168                                     IRQF_TRIGGER_LOW | IRQF_ONESHOT,
 169                                     client->name, priv);
 170        if (error) {
 171                dev_err(&client->dev, "Unable to request touchscreen IRQ.\n");
 172                goto err_free_mem;
 173        }
 174
 175        error = input_register_device(input);
 176        if (error)
 177                goto err_free_irq;
 178
 179        i2c_set_clientdata(client, priv);
 180        device_init_wakeup(&client->dev, 1);
 181
 182        return 0;
 183
 184 err_free_irq:
 185        free_irq(priv->irq, priv);
 186 err_free_mem:
 187        input_free_device(input);
 188        kfree(priv);
 189        return error;
 190}
 191
 192static int migor_ts_remove(struct i2c_client *client)
 193{
 194        struct migor_ts_priv *priv = i2c_get_clientdata(client);
 195
 196        free_irq(priv->irq, priv);
 197        input_unregister_device(priv->input);
 198        kfree(priv);
 199
 200        dev_set_drvdata(&client->dev, NULL);
 201
 202        return 0;
 203}
 204
 205static int migor_ts_suspend(struct device *dev)
 206{
 207        struct i2c_client *client = to_i2c_client(dev);
 208        struct migor_ts_priv *priv = i2c_get_clientdata(client);
 209
 210        if (device_may_wakeup(&client->dev))
 211                enable_irq_wake(priv->irq);
 212
 213        return 0;
 214}
 215
 216static int migor_ts_resume(struct device *dev)
 217{
 218        struct i2c_client *client = to_i2c_client(dev);
 219        struct migor_ts_priv *priv = i2c_get_clientdata(client);
 220
 221        if (device_may_wakeup(&client->dev))
 222                disable_irq_wake(priv->irq);
 223
 224        return 0;
 225}
 226
 227static SIMPLE_DEV_PM_OPS(migor_ts_pm, migor_ts_suspend, migor_ts_resume);
 228
 229static const struct i2c_device_id migor_ts_id[] = {
 230        { "migor_ts", 0 },
 231        { }
 232};
 233MODULE_DEVICE_TABLE(i2c, migor_ts);
 234
 235static struct i2c_driver migor_ts_driver = {
 236        .driver = {
 237                .name = "migor_ts",
 238                .pm = &migor_ts_pm,
 239        },
 240        .probe = migor_ts_probe,
 241        .remove = migor_ts_remove,
 242        .id_table = migor_ts_id,
 243};
 244
 245module_i2c_driver(migor_ts_driver);
 246
 247MODULE_DESCRIPTION("MigoR Touchscreen driver");
 248MODULE_AUTHOR("Magnus Damm <damm@opensource.se>");
 249MODULE_LICENSE("GPL");
 250