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 #include <linux/of_device.h>
  30 #include <linux/of.h>
  31 #include <linux/of_gpio.h>
  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
  73         struct i2c_client       *client;
  74
  75         u16                     model;
  76         u16                     x_plate_ohms;
  77         u16                     max_rt;
  78         unsigned long           poll_delay;
  79         unsigned long           poll_period;
  80         int                     fuzzx;
  81         int                     fuzzy;
  82         int                     fuzzz;
  83         char                    of;
  84
  85         unsigned                gpio;
  86         int                     irq;
  87
  88         wait_queue_head_t       wait;
  89         bool                    stopped;
  90
  91         int                     (*get_pendown_state)(void);
  92         void                    (*clear_penirq)(void);
  93 };
  94
  95 static int tsc2007_get_pendown_state_dt(struct tsc2007 *ts)
  96 {
  97         return !gpio_get_value(ts->gpio);
  98 }
  99
 100 static inline int tsc2007_xfer(struct tsc2007 *tsc, u8 cmd)
 101 {
 102         s32 data;
 103         u16 val;
 104
 105         data = i2c_smbus_read_word_data(tsc->client, cmd);
 106         if (data < 0) {
 107                 dev_err(&tsc->client->dev, "i2c io error: %d\n", data);
 108                 return data;
 109         }
 110
 111         /* The protocol and raw data format from i2c interface:
 112          * S Addr Wr [A] Comm [A] S Addr Rd [A] [DataLow] A [DataHigh] NA P
 113          * Where DataLow has [D11-D4], DataHigh has [D3-D0 << 4 | Dummy 4bit].
 114          */
 115         val = swab16(data) >> 4;
 116
 117         dev_dbg(&tsc->client->dev, "data: 0x%x, val: 0x%x\n", data, val);
 118
 119         return val;
 120 }
 121
 122 static void tsc2007_read_values(struct tsc2007 *tsc, struct ts_event *tc)
 123 {
 124         /* y- still on; turn on only y+ (and ADC) */
 125         tc->y = tsc2007_xfer(tsc, READ_Y);
 126
 127         /* turn y- off, x+ on, then leave in lowpower */
 128         tc->x = tsc2007_xfer(tsc, READ_X);
 129
 130         /* turn y+ off, x- on; we'll use formula #1 */
 131         tc->z1 = tsc2007_xfer(tsc, READ_Z1);
 132         tc->z2 = tsc2007_xfer(tsc, READ_Z2);
 133
 134         /* Prepare for next touch reading - power down ADC, enable PENIRQ */
 135         tsc2007_xfer(tsc, PWRDOWN);
 136 }
 137
 138 static u32 tsc2007_calculate_pressure(struct tsc2007 *tsc, struct ts_event *tc)
 139 {
 140         u32 rt = 0;
 141
 142         /* range filtering */
 143         if (tc->x == MAX_12BIT)
 144                 tc->x = 0;
 145
 146         if (likely(tc->x && tc->z1)) {
 147                 /* compute touch pressure resistance using equation #1 */
 148                 rt = tc->z2 - tc->z1;
 149                 rt *= tc->x;
 150                 rt *= tsc->x_plate_ohms;
 151                 rt /= tc->z1;
 152                 rt = (rt + 2047) >> 12;
 153         }
 154
 155         return rt;
 156 }
 157
 158 static bool tsc2007_is_pen_down_valid(struct tsc2007 *ts)
 159 {
 160         if (ts->of)
 161                 return gpio_is_valid(ts->gpio);
 162         else
 163                 return ts->get_pendown_state ? true : false;
 164 }
 165
 166 static bool tsc2007_is_pen_down(struct tsc2007 *ts)
 167 {
 168         /*
 169          * NOTE: We can't rely on the pressure to determine the pen down
 170          * state, even though this controller has a pressure sensor.
 171          * The pressure value can fluctuate for quite a while after
 172          * lifting the pen and in some cases may not even settle at the
 173          * expected value.
 174          *
 175          * The only safe way to check for the pen up condition is in the
 176          * work function by reading the pen signal state (it's a GPIO
 177          * and IRQ). Unfortunately such callback is not always available,
 178          * in that case we assume that the pen is down and expect caller
 179          * to fall back on the pressure reading.
 180          */
 181
 182         if (!tsc2007_is_pen_down_valid(ts))
 183                 return true;
 184
 185         if (ts->of)
 186                 return tsc2007_get_pendown_state_dt(ts);
 187         else
 188                 return ts->get_pendown_state();
 189 }
 190
 191 static irqreturn_t tsc2007_soft_irq(int irq, void *handle)
 192 {
 193         struct tsc2007 *ts = handle;
 194         struct input_dev *input = ts->input;
 195         struct ts_event tc;
 196         u32 rt;
 197
 198         while (!ts->stopped && tsc2007_is_pen_down(ts)) {
 199
 200                 /* pen is down, continue with the measurement */
 201                 tsc2007_read_values(ts, &tc);
 202
 203                 rt = tsc2007_calculate_pressure(ts, &tc);
 204
 205                 if (!rt && !tsc2007_is_pen_down_valid(ts)) {
 206                         /*
 207                          * If pressure reported is 0 and we don't have
 208                          * callback to check pendown state, we have to
 209                          * assume that pen was lifted up.
 210                          */
 211                         break;
 212                 }
 213
 214                 if (rt <= ts->max_rt) {
 215                         dev_dbg(&ts->client->dev,
 216                                 "DOWN point(%4d,%4d), pressure (%4u)\n",
 217                                 tc.x, tc.y, rt);
 218
 219                         input_report_key(input, BTN_TOUCH, 1);
 220                         input_report_abs(input, ABS_X, tc.x);
 221                         input_report_abs(input, ABS_Y, tc.y);
 222                         input_report_abs(input, ABS_PRESSURE, rt);
 223
 224                         input_sync(input);
 225
 226                 } else {
 227                         /*
 228                          * Sample found inconsistent by debouncing or pressure is
 229                          * beyond the maximum. Don't report it to user space,
 230                          * repeat at least once more the measurement.
 231                          */
 232                         dev_dbg(&ts->client->dev, "ignored pressure %d\n", rt);
 233                 }
 234
 235                 wait_event_timeout(ts->wait, ts->stopped,
 236                                    msecs_to_jiffies(ts->poll_period));
 237         }
 238
 239         dev_dbg(&ts->client->dev, "UP\n");
 240
 241         input_report_key(input, BTN_TOUCH, 0);
 242         input_report_abs(input, ABS_PRESSURE, 0);
 243         input_sync(input);
 244
 245         if (ts->clear_penirq)
 246                 ts->clear_penirq();
 247
 248         return IRQ_HANDLED;
 249 }
 250
 251 static irqreturn_t tsc2007_hard_irq(int irq, void *handle)
 252 {
 253         struct tsc2007 *ts = handle;
 254
 255         if (tsc2007_is_pen_down(ts))
 256                 return IRQ_WAKE_THREAD;
 257
 258         if (ts->clear_penirq)
 259                 ts->clear_penirq();
 260
 261         return IRQ_HANDLED;
 262 }
 263
 264 static void tsc2007_stop(struct tsc2007 *ts)
 265 {
 266         ts->stopped = true;
 267         mb();
 268         wake_up(&ts->wait);
 269
 270         disable_irq(ts->irq);
 271 }
 272
 273 static int tsc2007_open(struct input_dev *input_dev)
 274 {
 275         struct tsc2007 *ts = input_get_drvdata(input_dev);
 276         int err;
 277
 278         ts->stopped = false;
 279         mb();
 280
 281         enable_irq(ts->irq);
 282
 283         /* Prepare for touch readings - power down ADC and enable PENIRQ */
 284         err = tsc2007_xfer(ts, PWRDOWN);
 285         if (err < 0) {
 286                 tsc2007_stop(ts);
 287                 return err;
 288         }
 289
 290         return 0;
 291 }
 292
 293 static void tsc2007_close(struct input_dev *input_dev)
 294 {
 295         struct tsc2007 *ts = input_get_drvdata(input_dev);
 296
 297         tsc2007_stop(ts);
 298 }
 299
 300 #ifdef CONFIG_OF
 301 static int tsc2007_probe_dt(struct i2c_client *client, struct tsc2007 *ts,
 302                             struct device_node *np)
 303 {
 304         int err = 0;
 305         u32 val32;
 306         u64 val64;
 307
 308         if (!of_property_read_u32(np, "ti,max-rt", &val32))
 309                 ts->max_rt = val32;
 310         else
 311                 ts->max_rt = MAX_12BIT;
 312
 313         if (!of_property_read_u32(np, "ti,fuzzx", &val32))
 314                 ts->fuzzx = val32;
 315
 316         if (!of_property_read_u32(np, "ti,fuzzy", &val32))
 317                 ts->fuzzy = val32;
 318
 319         if (!of_property_read_u32(np, "ti,fuzzz", &val32))
 320                 ts->fuzzz = val32;
 321
 322         if (!of_property_read_u64(np, "ti,poll-period", &val64))
 323                 ts->poll_period = val64;
 324         else
 325                 ts->poll_period = 1;
 326
 327         if (!of_property_read_u32(np, "ti,x-plate-ohms", &val32)) {
 328                 ts->x_plate_ohms = val32;
 329         } else {
 330                 dev_err(&client->dev,
 331                         "Error: lacking ti,x-plate-ohms devicetree property. (err %d).",
 332                         err);
 333                 return -EINVAL;
 334         }
 335
 336         ts->gpio = of_get_gpio(np, 0);
 337         if (!gpio_is_valid(ts->gpio))
 338                 dev_err(&client->dev,
 339                         "GPIO not found (of_get_gpio returned %d)\n",
 340                         ts->gpio);
 341
 342         /* Used to detect if it is probed trough the device tree,
 343          * in order to be able to use that information in the IRQ handler.
 344          */
 345         ts->of = 1;
 346
 347         return 0;
 348 }
 349 #else
 350 static int tsc2007_probe_dt(struct i2c_client *client, struct tsc2007 *ts,
 351                             struct device_node *np)
 352 {
 353         return -ENODEV;
 354 }
 355 #endif
 356
 357 static int tsc2007_probe_pdev(struct i2c_client *client, struct tsc2007 *ts,
 358                               struct tsc2007_platform_data *pdata,
 359                               const struct i2c_device_id *id)
 360 {
 361         if (!pdata) {
 362                 dev_err(&client->dev, "platform data is required!\n");
 363                 return -EINVAL;
 364         }
 365
 366         ts->model             = pdata->model;
 367         ts->x_plate_ohms      = pdata->x_plate_ohms;
 368         ts->max_rt            = pdata->max_rt ? : MAX_12BIT;
 369         ts->poll_delay        = pdata->poll_delay ? : 1;
 370         ts->poll_period       = pdata->poll_period ? : 1;
 371         ts->get_pendown_state = pdata->get_pendown_state;
 372         ts->clear_penirq      = pdata->clear_penirq;
 373         ts->fuzzx             = pdata->fuzzx;
 374         ts->fuzzy             = pdata->fuzzy;
 375         ts->fuzzz             = pdata->fuzzz;
 376
 377         if (pdata->x_plate_ohms == 0) {
 378                 dev_err(&client->dev, "x_plate_ohms is not set up in platform data");
 379                 return -EINVAL;
 380         }
 381
 382         /* Used to detect if it is probed trough the device tree,
 383          * in order to be able to use that information in the IRQ handler.
 384          */
 385         ts->of = 0;
 386
 387         return 0;
 388 }
 389
 390 static int tsc2007_probe(struct i2c_client *client,
 391                          const struct i2c_device_id *id)
 392 {
 393         struct device_node *np = client->dev.of_node;
 394         struct tsc2007_platform_data *pdata = client->dev.platform_data;
 395         struct tsc2007 *ts;
 396         struct input_dev *input_dev;
 397         int err = 0;
 398
 399         ts = devm_kzalloc(&client->dev, sizeof(struct tsc2007), GFP_KERNEL);
 400         if (!ts)
 401                 return -ENOMEM;
 402
 403         if (np)
 404                 err = tsc2007_probe_dt(client, ts, np);
 405         else
 406                 err = tsc2007_probe_pdev(client, ts, pdata, id);
 407
 408         if (err)
 409                 return err;
 410
 411         if (!i2c_check_functionality(client->adapter,
 412                                      I2C_FUNC_SMBUS_READ_WORD_DATA))
 413                 return -EIO;
 414
 415         input_dev = input_allocate_device();
 416         if (!input_dev) {
 417                 err = -ENOMEM;
 418                 goto err_free_input;
 419         };
 420
 421         ts->client = client;
 422         ts->irq = client->irq;
 423         ts->input = input_dev;
 424         init_waitqueue_head(&ts->wait);
 425
 426         snprintf(ts->phys, sizeof(ts->phys),
 427                  "%s/input0", dev_name(&client->dev));
 428
 429         input_dev->name = "TSC2007 Touchscreen";
 430         input_dev->phys = ts->phys;
 431         input_dev->id.bustype = BUS_I2C;
 432
 433         input_dev->open = tsc2007_open;
 434         input_dev->close = tsc2007_close;
 435
 436         input_set_drvdata(input_dev, ts);
 437
 438         input_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS);
 439         input_dev->keybit[BIT_WORD(BTN_TOUCH)] = BIT_MASK(BTN_TOUCH);
 440
 441         input_set_abs_params(input_dev, ABS_X, 0, MAX_12BIT, ts->fuzzx, 0);
 442         input_set_abs_params(input_dev, ABS_Y, 0, MAX_12BIT, ts->fuzzy, 0);
 443         input_set_abs_params(input_dev, ABS_PRESSURE, 0, MAX_12BIT,
 444                              ts->fuzzz, 0);
 445
 446         if (!np) {
 447                 if (pdata->init_platform_hw)
 448                         pdata->init_platform_hw();
 449         }
 450
 451         err = request_threaded_irq(ts->irq, tsc2007_hard_irq, tsc2007_soft_irq,
 452                                    IRQF_ONESHOT, client->dev.driver->name, ts);
 453         if (err < 0) {
 454                 dev_err(&client->dev, "irq %d busy?\n", ts->irq);
 455                 goto err_free_input;
 456         }
 457
 458         tsc2007_stop(ts);
 459
 460         err = input_register_device(input_dev);
 461         if (err)
 462                 goto err_free_irq;
 463
 464         i2c_set_clientdata(client, ts);
 465
 466         return 0;
 467
 468  err_free_irq:
 469         free_irq(ts->irq, ts);
 470         if (!np) {
 471                 if (pdata->exit_platform_hw)
 472                         pdata->exit_platform_hw();
 473         }
 474  err_free_input:
 475         input_free_device(input_dev);
 476         return err;
 477 }
 478
 479 static int tsc2007_remove(struct i2c_client *client)
 480 {
 481         struct device_node *np = client->dev.of_node;
 482         struct tsc2007  *ts = i2c_get_clientdata(client);
 483         struct tsc2007_platform_data *pdata = client->dev.platform_data;
 484
 485         free_irq(ts->irq, ts);
 486
 487         if (!np) {
 488                 if (pdata->exit_platform_hw)
 489                         pdata->exit_platform_hw();
 490         }
 491
 492         input_unregister_device(ts->input);
 493         kfree(ts);
 494
 495         return 0;
 496 }
 497
 498 static const struct i2c_device_id tsc2007_idtable[] = {
 499         { "tsc2007", 0 },
 500         { }
 501 };
 502
 503 MODULE_DEVICE_TABLE(i2c, tsc2007_idtable);
 504
 505 #ifdef CONFIG_OF
 506 static const struct of_device_id tsc2007_of_match[] = {
 507         { .compatible = "ti,tsc2007" },
 508         { /* sentinel */ }
 509 };
 510 MODULE_DEVICE_TABLE(of, tsc2007_of_match);
 511 #endif
 512
 513 static struct i2c_driver tsc2007_driver = {
 514         .driver = {
 515                 .owner  = THIS_MODULE,
 516                 .name   = "tsc2007",
 517                 .of_match_table = of_match_ptr(tsc2007_of_match),
 518         },
 519         .id_table       = tsc2007_idtable,
 520         .probe          = tsc2007_probe,
 521         .remove         = tsc2007_remove,
 522 };
 523
 524 module_i2c_driver(tsc2007_driver);
 525
 526 MODULE_AUTHOR("Kwangwoo Lee <kwlee@mtekvision.com>");
 527 MODULE_DESCRIPTION("TSC2007 TouchScreen Driver");
 528 MODULE_LICENSE("GPL");