drivers/input/touchscreen/migor_ts.c

   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
  36 struct migor_ts_priv {
  37         struct i2c_client *client;
  38         struct input_dev *input;
  39         int irq;
  40 };
  41
  42 static const u_int8_t migor_ts_ena_seq[17] = { 0x33, 0x22, 0x11,
  43                                                0x01, 0x06, 0x07, };
  44 static const u_int8_t migor_ts_dis_seq[17] = { };
  45
  46 static 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
 102 static 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
 119 static 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
 132 static 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
 192 static 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
 205 static 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
 216 static 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
 227 static SIMPLE_DEV_PM_OPS(migor_ts_pm, migor_ts_suspend, migor_ts_resume);
 228
 229 static const struct i2c_device_id migor_ts_id[] = {
 230         { "migor_ts", 0 },
 231         { }
 232 };
 233 MODULE_DEVICE_TABLE(i2c, migor_ts);
 234
 235 static 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
 245 static int __init migor_ts_init(void)
 246 {
 247         return i2c_add_driver(&migor_ts_driver);
 248 }
 249
 250 static void __exit migor_ts_exit(void)
 251 {
 252         i2c_del_driver(&migor_ts_driver);
 253 }
 254
 255 MODULE_DESCRIPTION("MigoR Touchscreen driver");
 256 MODULE_AUTHOR("Magnus Damm <damm@opensource.se>");
 257 MODULE_LICENSE("GPL");
 258
 259 module_init(migor_ts_init);
 260 module_exit(migor_ts_exit);