SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/input/touchscreen/tsc2007.c

   1 /*
   2  * drivers/input/touchscreen/tsc2007.c
   3  *
   4  * Copyright (c) 2008 MtekVision Co., Ltd.
   5  *      Kwangwoo Lee <kwlee@mtekvision.com>
   6  *
   7  * Using code from:
   8  *  - ads7846.c
   9  *      Copyright (c) 2005 David Brownell
  10  *      Copyright (c) 2006 Nokia Corporation
  11  *  - corgi_ts.c
  12  *      Copyright (C) 2004-2005 Richard Purdie
  13  *  - omap_ts.[hc], ads7846.h, ts_osk.c
  14  *      Copyright (C) 2002 MontaVista Software
  15  *      Copyright (C) 2004 Texas Instruments
  16  *      Copyright (C) 2005 Dirk Behme
  17  *
  18  *  This program is free software; you can redistribute it and/or modify
  19  *  it under the terms of the GNU General Public License version 2 as
  20  *  published by the Free Software Foundation.
  21  */
  22
  23 #include <linux/module.h>
  24 #include <linux/slab.h>
  25 #include <linux/input.h>
  26 #include <linux/interrupt.h>
  27 #include <linux/i2c.h>
  28 #include <linux/i2c/tsc2007.h>
  29
  30 #define TS_POLL_DELAY                   1 /* ms delay between samples */
  31 #define TS_POLL_PERIOD                  1 /* ms delay between samples */
  32
  33 #define TSC2007_MEASURE_TEMP0           (0x0 << 4)
  34 #define TSC2007_MEASURE_AUX             (0x2 << 4)
  35 #define TSC2007_MEASURE_TEMP1           (0x4 << 4)
  36 #define TSC2007_ACTIVATE_XN             (0x8 << 4)
  37 #define TSC2007_ACTIVATE_YN             (0x9 << 4)
  38 #define TSC2007_ACTIVATE_YP_XN          (0xa << 4)
  39 #define TSC2007_SETUP                   (0xb << 4)
  40 #define TSC2007_MEASURE_X               (0xc << 4)
  41 #define TSC2007_MEASURE_Y               (0xd << 4)
  42 #define TSC2007_MEASURE_Z1              (0xe << 4)
  43 #define TSC2007_MEASURE_Z2              (0xf << 4)
  44
  45 #define TSC2007_POWER_OFF_IRQ_EN        (0x0 << 2)
  46 #define TSC2007_ADC_ON_IRQ_DIS0         (0x1 << 2)
  47 #define TSC2007_ADC_OFF_IRQ_EN          (0x2 << 2)
  48 #define TSC2007_ADC_ON_IRQ_DIS1         (0x3 << 2)
  49
  50 #define TSC2007_12BIT                   (0x0 << 1)
  51 #define TSC2007_8BIT                    (0x1 << 1)
  52
  53 #define MAX_12BIT                       ((1 << 12) - 1)
  54
  55 #define ADC_ON_12BIT    (TSC2007_12BIT | TSC2007_ADC_ON_IRQ_DIS0)
  56
  57 #define READ_Y          (ADC_ON_12BIT | TSC2007_MEASURE_Y)
  58 #define READ_Z1         (ADC_ON_12BIT | TSC2007_MEASURE_Z1)
  59 #define READ_Z2         (ADC_ON_12BIT | TSC2007_MEASURE_Z2)
  60 #define READ_X          (ADC_ON_12BIT | TSC2007_MEASURE_X)
  61 #define PWRDOWN         (TSC2007_12BIT | TSC2007_POWER_OFF_IRQ_EN)
  62
  63 struct ts_event {
  64         u16     x;
  65         u16     y;
  66         u16     z1, z2;
  67 };
  68
  69 struct tsc2007 {
  70         struct input_dev        *input;
  71         char                    phys[32];
  72         struct delayed_work     work;
  73         struct ts_event         tc;
  74
  75         struct i2c_client       *client;
  76
  77         u16                     model;
  78         u16                     x_plate_ohms;
  79
  80         bool                    pendown;
  81         int                     irq;
  82
  83         int                     (*get_pendown_state)(void);
  84         void                    (*clear_penirq)(void);
  85 };
  86
  87 static inline int tsc2007_xfer(struct tsc2007 *tsc, u8 cmd)
  88 {
  89         s32 data;
  90         u16 val;
  91
  92         data = i2c_smbus_read_word_data(tsc->client, cmd);
  93         if (data < 0) {
  94                 dev_err(&tsc->client->dev, "i2c io error: %d\n", data);
  95                 return data;
  96         }
  97
  98         /* The protocol and raw data format from i2c interface:
  99          * S Addr Wr [A] Comm [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P
 100          * Where DataLow has [D11-D4], DataHigh has [D3-D0 << 4 | Dummy 4bit].
 101          */
 102         val = swab16(data) >> 4;
 103
 104         dev_dbg(&tsc->client->dev, "data: 0x%x, val: 0x%x\n", data, val);
 105
 106         return val;
 107 }
 108
 109 static void tsc2007_send_event(void *tsc)
 110 {
 111         struct tsc2007  *ts = tsc;
 112         u32             rt;
 113         u16             x, y, z1, z2;
 114
 115         x = ts->tc.x;
 116         y = ts->tc.y;
 117         z1 = ts->tc.z1;
 118         z2 = ts->tc.z2;
 119
 120         /* range filtering */
 121         if (x == MAX_12BIT)
 122                 x = 0;
 123
 124         if (likely(x && z1)) {
 125                 /* compute touch pressure resistance using equation #1 */
 126                 rt = z2;
 127                 rt -= z1;
 128                 rt *= x;
 129                 rt *= ts->x_plate_ohms;
 130                 rt /= z1;
 131                 rt = (rt + 2047) >> 12;
 132         } else
 133                 rt = 0;
 134
 135         /*
 136          * Sample found inconsistent by debouncing or pressure is beyond
 137          * the maximum. Don't report it to user space, repeat at least
 138          * once more the measurement
 139          */
 140         if (rt > MAX_12BIT) {
 141                 dev_dbg(&ts->client->dev, "ignored pressure %d\n", rt);
 142                 return;
 143         }
 144
 145         /*
 146          * NOTE: We can't rely on the pressure to determine the pen down
 147          * state, even this controller has a pressure sensor.  The pressure
 148          * value can fluctuate for quite a while after lifting the pen and
 149          * in some cases may not even settle at the expected value.
 150          *
 151          * The only safe way to check for the pen up condition is in the
 152          * work function by reading the pen signal state (it's a GPIO and IRQ).
 153          */
 154         if (rt) {
 155                 struct input_dev *input = ts->input;
 156
 157                 if (!ts->pendown) {
 158                         dev_dbg(&ts->client->dev, "DOWN\n");
 159
 160                         input_report_key(input, BTN_TOUCH, 1);
 161                         ts->pendown = true;
 162                 }
 163
 164                 input_report_abs(input, ABS_X, x);
 165                 input_report_abs(input, ABS_Y, y);
 166                 input_report_abs(input, ABS_PRESSURE, rt);
 167
 168                 input_sync(input);
 169
 170                 dev_dbg(&ts->client->dev, "point(%4d,%4d), pressure (%4u)\n",
 171                         x, y, rt);
 172         }
 173 }
 174
 175 static int tsc2007_read_values(struct tsc2007 *tsc)
 176 {
 177         /* y- still on; turn on only y+ (and ADC) */
 178         tsc->tc.y = tsc2007_xfer(tsc, READ_Y);
 179
 180         /* turn y- off, x+ on, then leave in lowpower */
 181         tsc->tc.x = tsc2007_xfer(tsc, READ_X);
 182
 183         /* turn y+ off, x- on; we'll use formula #1 */
 184         tsc->tc.z1 = tsc2007_xfer(tsc, READ_Z1);
 185         tsc->tc.z2 = tsc2007_xfer(tsc, READ_Z2);
 186
 187         /* power down */
 188         tsc2007_xfer(tsc, PWRDOWN);
 189
 190         return 0;
 191 }
 192
 193 static void tsc2007_work(struct work_struct *work)
 194 {
 195         struct tsc2007 *ts =
 196                 container_of(to_delayed_work(work), struct tsc2007, work);
 197
 198         if (unlikely(!ts->get_pendown_state() && ts->pendown)) {
 199                 struct input_dev *input = ts->input;
 200
 201                 dev_dbg(&ts->client->dev, "UP\n");
 202
 203                 input_report_key(input, BTN_TOUCH, 0);
 204                 input_report_abs(input, ABS_PRESSURE, 0);
 205                 input_sync(input);
 206
 207                 ts->pendown = false;
 208                 enable_irq(ts->irq);
 209         } else {
 210                 /* pen is still down, continue with the measurement */
 211                 dev_dbg(&ts->client->dev, "pen is still down\n");
 212
 213                 tsc2007_read_values(ts);
 214                 tsc2007_send_event(ts);
 215
 216                 schedule_delayed_work(&ts->work,
 217                                       msecs_to_jiffies(TS_POLL_PERIOD));
 218         }
 219 }
 220
 221 static irqreturn_t tsc2007_irq(int irq, void *handle)
 222 {
 223         struct tsc2007 *ts = handle;
 224
 225         if (likely(ts->get_pendown_state())) {
 226                 disable_irq_nosync(ts->irq);
 227                 schedule_delayed_work(&ts->work,
 228                                       msecs_to_jiffies(TS_POLL_DELAY));
 229         }
 230
 231         if (ts->clear_penirq)
 232                 ts->clear_penirq();
 233
 234         return IRQ_HANDLED;
 235 }
 236
 237 static void tsc2007_free_irq(struct tsc2007 *ts)
 238 {
 239         free_irq(ts->irq, ts);
 240         if (cancel_delayed_work_sync(&ts->work)) {
 241                 /*
 242                  * Work was pending, therefore we need to enable
 243                  * IRQ here to balance the disable_irq() done in the
 244                  * interrupt handler.
 245                  */
 246                 enable_irq(ts->irq);
 247         }
 248 }
 249
 250 static int __devinit tsc2007_probe(struct i2c_client *client,
 251                                    const struct i2c_device_id *id)
 252 {
 253         struct tsc2007 *ts;
 254         struct tsc2007_platform_data *pdata = pdata = client->dev.platform_data;
 255         struct input_dev *input_dev;
 256         int err;
 257
 258         if (!pdata || !pdata->get_pendown_state) {
 259                 dev_err(&client->dev, "platform data is required!\n");
 260                 return -EINVAL;
 261         }
 262
 263         if (!i2c_check_functionality(client->adapter,
 264                                      I2C_FUNC_SMBUS_READ_WORD_DATA))
 265                 return -EIO;
 266
 267         ts = kzalloc(sizeof(struct tsc2007), GFP_KERNEL);
 268         input_dev = input_allocate_device();
 269         if (!ts || !input_dev) {
 270                 err = -ENOMEM;
 271                 goto err_free_mem;
 272         }
 273
 274         ts->client = client;
 275         ts->irq = client->irq;
 276         ts->input = input_dev;
 277         INIT_DELAYED_WORK(&ts->work, tsc2007_work);
 278
 279         ts->model             = pdata->model;
 280         ts->x_plate_ohms      = pdata->x_plate_ohms;
 281         ts->get_pendown_state = pdata->get_pendown_state;
 282         ts->clear_penirq      = pdata->clear_penirq;
 283
 284         snprintf(ts->phys, sizeof(ts->phys),
 285                  "%s/input0", dev_name(&client->dev));
 286
 287         input_dev->name = "TSC2007 Touchscreen";
 288         input_dev->phys = ts->phys;
 289         input_dev->id.bustype = BUS_I2C;
 290
 291         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 292         input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
 293
 294         input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, 0, 0);
 295         input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, 0, 0);
 296         input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_12BIT, 0, 0);
 297
 298         if (pdata->init_platform_hw)
 299                 pdata->init_platform_hw();
 300
 301         err = request_irq(ts->irq, tsc2007_irq, 0,
 302                         client->dev.driver->name, ts);
 303         if (err < 0) {
 304                 dev_err(&client->dev, "irq %d busy?\n", ts->irq);
 305                 goto err_free_mem;
 306         }
 307
 308         err = input_register_device(input_dev);
 309         if (err)
 310                 goto err_free_irq;
 311
 312         i2c_set_clientdata(client, ts);
 313
 314         tsc2007_read_values(ts);
 315
 316         return 0;
 317
 318  err_free_irq:
 319         tsc2007_free_irq(ts);
 320         if (pdata->exit_platform_hw)
 321                 pdata->exit_platform_hw();
 322  err_free_mem:
 323         input_free_device(input_dev);
 324         kfree(ts);
 325         return err;
 326 }
 327
 328 static int __devexit tsc2007_remove(struct i2c_client *client)
 329 {
 330         struct tsc2007  *ts = i2c_get_clientdata(client);
 331         struct tsc2007_platform_data *pdata = client->dev.platform_data;
 332
 333         tsc2007_free_irq(ts);
 334
 335         if (pdata->exit_platform_hw)
 336                 pdata->exit_platform_hw();
 337
 338         input_unregister_device(ts->input);
 339         kfree(ts);
 340
 341         return 0;
 342 }
 343
 344 static struct i2c_device_id tsc2007_idtable[] = {
 345         { "tsc2007", 0 },
 346         { }
 347 };
 348
 349 MODULE_DEVICE_TABLE(i2c, tsc2007_idtable);
 350
 351 static struct i2c_driver tsc2007_driver = {
 352         .driver = {
 353                 .owner  = THIS_MODULE,
 354                 .name   = "tsc2007"
 355         },
 356         .id_table       = tsc2007_idtable,
 357         .probe          = tsc2007_probe,
 358         .remove         = __devexit_p(tsc2007_remove),
 359 };
 360
 361 static int __init tsc2007_init(void)
 362 {
 363         return i2c_add_driver(&tsc2007_driver);
 364 }
 365
 366 static void __exit tsc2007_exit(void)
 367 {
 368         i2c_del_driver(&tsc2007_driver);
 369 }
 370
 371 module_init(tsc2007_init);
 372 module_exit(tsc2007_exit);
 373
 374 MODULE_AUTHOR("Kwangwoo Lee <kwlee@mtekvision.com>");
 375 MODULE_DESCRIPTION("TSC2007 TouchScreen Driver");
 376 MODULE_LICENSE("GPL");