drivers/input/touchscreen/auo-pixcir-ts.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Driver for AUO in-cell touchscreens
   4  *
   5  * Copyright (c) 2011 Heiko Stuebner <heiko@sntech.de>
   6  *
   7  * loosely based on auo_touch.c from Dell Streak vendor-kernel
   8  *
   9  * Copyright (c) 2008 QUALCOMM Incorporated.
  10  * Copyright (c) 2008 QUALCOMM USA, INC.
  11  */
  12
  13 #include <linux/kernel.h>
  14 #include <linux/module.h>
  15 #include <linux/interrupt.h>
  16 #include <linux/slab.h>
  17 #include <linux/input.h>
  18 #include <linux/jiffies.h>
  19 #include <linux/i2c.h>
  20 #include <linux/mutex.h>
  21 #include <linux/delay.h>
  22 #include <linux/gpio.h>
  23 #include <linux/input/auo-pixcir-ts.h>
  24 #include <linux/of.h>
  25 #include <linux/of_gpio.h>
  26
  27 /*
  28  * Coordinate calculation:
  29  * X1 = X1_LSB + X1_MSB*256
  30  * Y1 = Y1_LSB + Y1_MSB*256
  31  * X2 = X2_LSB + X2_MSB*256
  32  * Y2 = Y2_LSB + Y2_MSB*256
  33  */
  34 #define AUO_PIXCIR_REG_X1_LSB           0x00
  35 #define AUO_PIXCIR_REG_X1_MSB           0x01
  36 #define AUO_PIXCIR_REG_Y1_LSB           0x02
  37 #define AUO_PIXCIR_REG_Y1_MSB           0x03
  38 #define AUO_PIXCIR_REG_X2_LSB           0x04
  39 #define AUO_PIXCIR_REG_X2_MSB           0x05
  40 #define AUO_PIXCIR_REG_Y2_LSB           0x06
  41 #define AUO_PIXCIR_REG_Y2_MSB           0x07
  42
  43 #define AUO_PIXCIR_REG_STRENGTH         0x0d
  44 #define AUO_PIXCIR_REG_STRENGTH_X1_LSB  0x0e
  45 #define AUO_PIXCIR_REG_STRENGTH_X1_MSB  0x0f
  46
  47 #define AUO_PIXCIR_REG_RAW_DATA_X       0x2b
  48 #define AUO_PIXCIR_REG_RAW_DATA_Y       0x4f
  49
  50 #define AUO_PIXCIR_REG_X_SENSITIVITY    0x6f
  51 #define AUO_PIXCIR_REG_Y_SENSITIVITY    0x70
  52 #define AUO_PIXCIR_REG_INT_SETTING      0x71
  53 #define AUO_PIXCIR_REG_INT_WIDTH        0x72
  54 #define AUO_PIXCIR_REG_POWER_MODE       0x73
  55
  56 #define AUO_PIXCIR_REG_VERSION          0x77
  57 #define AUO_PIXCIR_REG_CALIBRATE        0x78
  58
  59 #define AUO_PIXCIR_REG_TOUCHAREA_X1     0x1e
  60 #define AUO_PIXCIR_REG_TOUCHAREA_Y1     0x1f
  61 #define AUO_PIXCIR_REG_TOUCHAREA_X2     0x20
  62 #define AUO_PIXCIR_REG_TOUCHAREA_Y2     0x21
  63
  64 #define AUO_PIXCIR_REG_EEPROM_CALIB_X   0x42
  65 #define AUO_PIXCIR_REG_EEPROM_CALIB_Y   0xad
  66
  67 #define AUO_PIXCIR_INT_TPNUM_MASK       0xe0
  68 #define AUO_PIXCIR_INT_TPNUM_SHIFT      5
  69 #define AUO_PIXCIR_INT_RELEASE          (1 << 4)
  70 #define AUO_PIXCIR_INT_ENABLE           (1 << 3)
  71 #define AUO_PIXCIR_INT_POL_HIGH         (1 << 2)
  72 #define AUO_PIXCIR_INT_MODE_MASK        0x03
  73
  74 /*
  75  * Power modes:
  76  * active:      scan speed 60Hz
  77  * sleep:       scan speed 10Hz can be auto-activated, wakeup on 1st touch
  78  * deep sleep:  scan speed 1Hz can only be entered or left manually.
  79  */
  80 #define AUO_PIXCIR_POWER_ACTIVE         0x00
  81 #define AUO_PIXCIR_POWER_SLEEP          0x01
  82 #define AUO_PIXCIR_POWER_DEEP_SLEEP     0x02
  83 #define AUO_PIXCIR_POWER_MASK           0x03
  84
  85 #define AUO_PIXCIR_POWER_ALLOW_SLEEP    (1 << 2)
  86 #define AUO_PIXCIR_POWER_IDLE_TIME(ms)  ((ms & 0xf) << 4)
  87
  88 #define AUO_PIXCIR_CALIBRATE            0x03
  89
  90 #define AUO_PIXCIR_EEPROM_CALIB_X_LEN   62
  91 #define AUO_PIXCIR_EEPROM_CALIB_Y_LEN   36
  92
  93 #define AUO_PIXCIR_RAW_DATA_X_LEN       18
  94 #define AUO_PIXCIR_RAW_DATA_Y_LEN       11
  95
  96 #define AUO_PIXCIR_STRENGTH_ENABLE      (1 << 0)
  97
  98 /* Touchscreen absolute values */
  99 #define AUO_PIXCIR_REPORT_POINTS        2
 100 #define AUO_PIXCIR_MAX_AREA             0xff
 101 #define AUO_PIXCIR_PENUP_TIMEOUT_MS     10
 102
 103 struct auo_pixcir_ts {
 104         struct i2c_client       *client;
 105         struct input_dev        *input;
 106         const struct auo_pixcir_ts_platdata *pdata;
 107         char                    phys[32];
 108
 109         /* special handling for touch_indicate interupt mode */
 110         bool                    touch_ind_mode;
 111
 112         wait_queue_head_t       wait;
 113         bool                    stopped;
 114 };
 115
 116 struct auo_point_t {
 117         int     coord_x;
 118         int     coord_y;
 119         int     area_major;
 120         int     area_minor;
 121         int     orientation;
 122 };
 123
 124 static int auo_pixcir_collect_data(struct auo_pixcir_ts *ts,
 125                                    struct auo_point_t *point)
 126 {
 127         struct i2c_client *client = ts->client;
 128         const struct auo_pixcir_ts_platdata *pdata = ts->pdata;
 129         uint8_t raw_coord[8];
 130         uint8_t raw_area[4];
 131         int i, ret;
 132
 133         /* touch coordinates */
 134         ret = i2c_smbus_read_i2c_block_data(client, AUO_PIXCIR_REG_X1_LSB,
 135                                             8, raw_coord);
 136         if (ret < 0) {
 137                 dev_err(&client->dev, "failed to read coordinate, %d\n", ret);
 138                 return ret;
 139         }
 140
 141         /* touch area */
 142         ret = i2c_smbus_read_i2c_block_data(client, AUO_PIXCIR_REG_TOUCHAREA_X1,
 143                                             4, raw_area);
 144         if (ret < 0) {
 145                 dev_err(&client->dev, "could not read touch area, %d\n", ret);
 146                 return ret;
 147         }
 148
 149         for (i = 0; i < AUO_PIXCIR_REPORT_POINTS; i++) {
 150                 point[i].coord_x =
 151                         raw_coord[4 * i + 1] << 8 | raw_coord[4 * i];
 152                 point[i].coord_y =
 153                         raw_coord[4 * i + 3] << 8 | raw_coord[4 * i + 2];
 154
 155                 if (point[i].coord_x > pdata->x_max ||
 156                     point[i].coord_y > pdata->y_max) {
 157                         dev_warn(&client->dev, "coordinates (%d,%d) invalid\n",
 158                                 point[i].coord_x, point[i].coord_y);
 159                         point[i].coord_x = point[i].coord_y = 0;
 160                 }
 161
 162                 /* determine touch major, minor and orientation */
 163                 point[i].area_major = max(raw_area[2 * i], raw_area[2 * i + 1]);
 164                 point[i].area_minor = min(raw_area[2 * i], raw_area[2 * i + 1]);
 165                 point[i].orientation = raw_area[2 * i] > raw_area[2 * i + 1];
 166         }
 167
 168         return 0;
 169 }
 170
 171 static irqreturn_t auo_pixcir_interrupt(int irq, void *dev_id)
 172 {
 173         struct auo_pixcir_ts *ts = dev_id;
 174         const struct auo_pixcir_ts_platdata *pdata = ts->pdata;
 175         struct auo_point_t point[AUO_PIXCIR_REPORT_POINTS];
 176         int i;
 177         int ret;
 178         int fingers = 0;
 179         int abs = -1;
 180
 181         while (!ts->stopped) {
 182
 183                 /* check for up event in touch touch_ind_mode */
 184                 if (ts->touch_ind_mode) {
 185                         if (gpio_get_value(pdata->gpio_int) == 0) {
 186                                 input_mt_sync(ts->input);
 187                                 input_report_key(ts->input, BTN_TOUCH, 0);
 188                                 input_sync(ts->input);
 189                                 break;
 190                         }
 191                 }
 192
 193                 ret = auo_pixcir_collect_data(ts, point);
 194                 if (ret < 0) {
 195                         /* we want to loop only in touch_ind_mode */
 196                         if (!ts->touch_ind_mode)
 197                                 break;
 198
 199                         wait_event_timeout(ts->wait, ts->stopped,
 200                                 msecs_to_jiffies(AUO_PIXCIR_PENUP_TIMEOUT_MS));
 201                         continue;
 202                 }
 203
 204                 for (i = 0; i < AUO_PIXCIR_REPORT_POINTS; i++) {
 205                         if (point[i].coord_x > 0 || point[i].coord_y > 0) {
 206                                 input_report_abs(ts->input, ABS_MT_POSITION_X,
 207                                                  point[i].coord_x);
 208                                 input_report_abs(ts->input, ABS_MT_POSITION_Y,
 209                                                  point[i].coord_y);
 210                                 input_report_abs(ts->input, ABS_MT_TOUCH_MAJOR,
 211                                                  point[i].area_major);
 212                                 input_report_abs(ts->input, ABS_MT_TOUCH_MINOR,
 213                                                  point[i].area_minor);
 214                                 input_report_abs(ts->input, ABS_MT_ORIENTATION,
 215                                                  point[i].orientation);
 216                                 input_mt_sync(ts->input);
 217
 218                                 /* use first finger as source for singletouch */
 219                                 if (fingers == 0)
 220                                         abs = i;
 221
 222                                 /* number of touch points could also be queried
 223                                  * via i2c but would require an additional call
 224                                  */
 225                                 fingers++;
 226                         }
 227                 }
 228
 229                 input_report_key(ts->input, BTN_TOUCH, fingers > 0);
 230
 231                 if (abs > -1) {
 232                         input_report_abs(ts->input, ABS_X, point[abs].coord_x);
 233                         input_report_abs(ts->input, ABS_Y, point[abs].coord_y);
 234                 }
 235
 236                 input_sync(ts->input);
 237
 238                 /* we want to loop only in touch_ind_mode */
 239                 if (!ts->touch_ind_mode)
 240                         break;
 241
 242                 wait_event_timeout(ts->wait, ts->stopped,
 243                                  msecs_to_jiffies(AUO_PIXCIR_PENUP_TIMEOUT_MS));
 244         }
 245
 246         return IRQ_HANDLED;
 247 }
 248
 249 /*
 250  * Set the power mode of the device.
 251  * Valid modes are
 252  * - AUO_PIXCIR_POWER_ACTIVE
 253  * - AUO_PIXCIR_POWER_SLEEP - automatically left on first touch
 254  * - AUO_PIXCIR_POWER_DEEP_SLEEP
 255  */
 256 static int auo_pixcir_power_mode(struct auo_pixcir_ts *ts, int mode)
 257 {
 258         struct i2c_client *client = ts->client;
 259         int ret;
 260
 261         ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_POWER_MODE);
 262         if (ret < 0) {
 263                 dev_err(&client->dev, "unable to read reg %Xh, %d\n",
 264                         AUO_PIXCIR_REG_POWER_MODE, ret);
 265                 return ret;
 266         }
 267
 268         ret &= ~AUO_PIXCIR_POWER_MASK;
 269         ret |= mode;
 270
 271         ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_POWER_MODE, ret);
 272         if (ret) {
 273                 dev_err(&client->dev, "unable to write reg %Xh, %d\n",
 274                         AUO_PIXCIR_REG_POWER_MODE, ret);
 275                 return ret;
 276         }
 277
 278         return 0;
 279 }
 280
 281 static int auo_pixcir_int_config(struct auo_pixcir_ts *ts,
 282                                            int int_setting)
 283 {
 284         struct i2c_client *client = ts->client;
 285         const struct auo_pixcir_ts_platdata *pdata = ts->pdata;
 286         int ret;
 287
 288         ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_INT_SETTING);
 289         if (ret < 0) {
 290                 dev_err(&client->dev, "unable to read reg %Xh, %d\n",
 291                         AUO_PIXCIR_REG_INT_SETTING, ret);
 292                 return ret;
 293         }
 294
 295         ret &= ~AUO_PIXCIR_INT_MODE_MASK;
 296         ret |= int_setting;
 297         ret |= AUO_PIXCIR_INT_POL_HIGH; /* always use high for interrupts */
 298
 299         ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_INT_SETTING,
 300                                         ret);
 301         if (ret < 0) {
 302                 dev_err(&client->dev, "unable to write reg %Xh, %d\n",
 303                         AUO_PIXCIR_REG_INT_SETTING, ret);
 304                 return ret;
 305         }
 306
 307         ts->touch_ind_mode = pdata->int_setting == AUO_PIXCIR_INT_TOUCH_IND;
 308
 309         return 0;
 310 }
 311
 312 /* control the generation of interrupts on the device side */
 313 static int auo_pixcir_int_toggle(struct auo_pixcir_ts *ts, bool enable)
 314 {
 315         struct i2c_client *client = ts->client;
 316         int ret;
 317
 318         ret = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_INT_SETTING);
 319         if (ret < 0) {
 320                 dev_err(&client->dev, "unable to read reg %Xh, %d\n",
 321                         AUO_PIXCIR_REG_INT_SETTING, ret);
 322                 return ret;
 323         }
 324
 325         if (enable)
 326                 ret |= AUO_PIXCIR_INT_ENABLE;
 327         else
 328                 ret &= ~AUO_PIXCIR_INT_ENABLE;
 329
 330         ret = i2c_smbus_write_byte_data(client, AUO_PIXCIR_REG_INT_SETTING,
 331                                         ret);
 332         if (ret < 0) {
 333                 dev_err(&client->dev, "unable to write reg %Xh, %d\n",
 334                         AUO_PIXCIR_REG_INT_SETTING, ret);
 335                 return ret;
 336         }
 337
 338         return 0;
 339 }
 340
 341 static int auo_pixcir_start(struct auo_pixcir_ts *ts)
 342 {
 343         struct i2c_client *client = ts->client;
 344         int ret;
 345
 346         ret = auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_ACTIVE);
 347         if (ret < 0) {
 348                 dev_err(&client->dev, "could not set power mode, %d\n",
 349                         ret);
 350                 return ret;
 351         }
 352
 353         ts->stopped = false;
 354         mb();
 355         enable_irq(client->irq);
 356
 357         ret = auo_pixcir_int_toggle(ts, 1);
 358         if (ret < 0) {
 359                 dev_err(&client->dev, "could not enable interrupt, %d\n",
 360                         ret);
 361                 disable_irq(client->irq);
 362                 return ret;
 363         }
 364
 365         return 0;
 366 }
 367
 368 static int auo_pixcir_stop(struct auo_pixcir_ts *ts)
 369 {
 370         struct i2c_client *client = ts->client;
 371         int ret;
 372
 373         ret = auo_pixcir_int_toggle(ts, 0);
 374         if (ret < 0) {
 375                 dev_err(&client->dev, "could not disable interrupt, %d\n",
 376                         ret);
 377                 return ret;
 378         }
 379
 380         /* disable receiving of interrupts */
 381         disable_irq(client->irq);
 382         ts->stopped = true;
 383         mb();
 384         wake_up(&ts->wait);
 385
 386         return auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_DEEP_SLEEP);
 387 }
 388
 389 static int auo_pixcir_input_open(struct input_dev *dev)
 390 {
 391         struct auo_pixcir_ts *ts = input_get_drvdata(dev);
 392
 393         return auo_pixcir_start(ts);
 394 }
 395
 396 static void auo_pixcir_input_close(struct input_dev *dev)
 397 {
 398         struct auo_pixcir_ts *ts = input_get_drvdata(dev);
 399
 400         auo_pixcir_stop(ts);
 401 }
 402
 403 static int __maybe_unused auo_pixcir_suspend(struct device *dev)
 404 {
 405         struct i2c_client *client = to_i2c_client(dev);
 406         struct auo_pixcir_ts *ts = i2c_get_clientdata(client);
 407         struct input_dev *input = ts->input;
 408         int ret = 0;
 409
 410         mutex_lock(&input->mutex);
 411
 412         /* when configured as wakeup source, device should always wake system
 413          * therefore start device if necessary
 414          */
 415         if (device_may_wakeup(&client->dev)) {
 416                 /* need to start device if not open, to be wakeup source */
 417                 if (!input->users) {
 418                         ret = auo_pixcir_start(ts);
 419                         if (ret)
 420                                 goto unlock;
 421                 }
 422
 423                 enable_irq_wake(client->irq);
 424                 ret = auo_pixcir_power_mode(ts, AUO_PIXCIR_POWER_SLEEP);
 425         } else if (input->users) {
 426                 ret = auo_pixcir_stop(ts);
 427         }
 428
 429 unlock:
 430         mutex_unlock(&input->mutex);
 431
 432         return ret;
 433 }
 434
 435 static int __maybe_unused auo_pixcir_resume(struct device *dev)
 436 {
 437         struct i2c_client *client = to_i2c_client(dev);
 438         struct auo_pixcir_ts *ts = i2c_get_clientdata(client);
 439         struct input_dev *input = ts->input;
 440         int ret = 0;
 441
 442         mutex_lock(&input->mutex);
 443
 444         if (device_may_wakeup(&client->dev)) {
 445                 disable_irq_wake(client->irq);
 446
 447                 /* need to stop device if it was not open on suspend */
 448                 if (!input->users) {
 449                         ret = auo_pixcir_stop(ts);
 450                         if (ret)
 451                                 goto unlock;
 452                 }
 453
 454                 /* device wakes automatically from SLEEP */
 455         } else if (input->users) {
 456                 ret = auo_pixcir_start(ts);
 457         }
 458
 459 unlock:
 460         mutex_unlock(&input->mutex);
 461
 462         return ret;
 463 }
 464
 465 static SIMPLE_DEV_PM_OPS(auo_pixcir_pm_ops,
 466                          auo_pixcir_suspend, auo_pixcir_resume);
 467
 468 #ifdef CONFIG_OF
 469 static struct auo_pixcir_ts_platdata *auo_pixcir_parse_dt(struct device *dev)
 470 {
 471         struct auo_pixcir_ts_platdata *pdata;
 472         struct device_node *np = dev->of_node;
 473
 474         if (!np)
 475                 return ERR_PTR(-ENOENT);
 476
 477         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
 478         if (!pdata)
 479                 return ERR_PTR(-ENOMEM);
 480
 481         pdata->gpio_int = of_get_gpio(np, 0);
 482         if (!gpio_is_valid(pdata->gpio_int)) {
 483                 dev_err(dev, "failed to get interrupt gpio\n");
 484                 return ERR_PTR(-EINVAL);
 485         }
 486
 487         pdata->gpio_rst = of_get_gpio(np, 1);
 488         if (!gpio_is_valid(pdata->gpio_rst)) {
 489                 dev_err(dev, "failed to get reset gpio\n");
 490                 return ERR_PTR(-EINVAL);
 491         }
 492
 493         if (of_property_read_u32(np, "x-size", &pdata->x_max)) {
 494                 dev_err(dev, "failed to get x-size property\n");
 495                 return ERR_PTR(-EINVAL);
 496         }
 497
 498         if (of_property_read_u32(np, "y-size", &pdata->y_max)) {
 499                 dev_err(dev, "failed to get y-size property\n");
 500                 return ERR_PTR(-EINVAL);
 501         }
 502
 503         /* default to asserting the interrupt when the screen is touched */
 504         pdata->int_setting = AUO_PIXCIR_INT_TOUCH_IND;
 505
 506         return pdata;
 507 }
 508 #else
 509 static struct auo_pixcir_ts_platdata *auo_pixcir_parse_dt(struct device *dev)
 510 {
 511         return ERR_PTR(-EINVAL);
 512 }
 513 #endif
 514
 515 static void auo_pixcir_reset(void *data)
 516 {
 517         struct auo_pixcir_ts *ts = data;
 518
 519         gpio_set_value(ts->pdata->gpio_rst, 0);
 520 }
 521
 522 static int auo_pixcir_probe(struct i2c_client *client,
 523                             const struct i2c_device_id *id)
 524 {
 525         const struct auo_pixcir_ts_platdata *pdata;
 526         struct auo_pixcir_ts *ts;
 527         struct input_dev *input_dev;
 528         int version;
 529         int error;
 530
 531         pdata = dev_get_platdata(&client->dev);
 532         if (!pdata) {
 533                 pdata = auo_pixcir_parse_dt(&client->dev);
 534                 if (IS_ERR(pdata))
 535                         return PTR_ERR(pdata);
 536         }
 537
 538         ts = devm_kzalloc(&client->dev,
 539                           sizeof(struct auo_pixcir_ts), GFP_KERNEL);
 540         if (!ts)
 541                 return -ENOMEM;
 542
 543         input_dev = devm_input_allocate_device(&client->dev);
 544         if (!input_dev) {
 545                 dev_err(&client->dev, "could not allocate input device\n");
 546                 return -ENOMEM;
 547         }
 548
 549         ts->pdata = pdata;
 550         ts->client = client;
 551         ts->input = input_dev;
 552         ts->touch_ind_mode = 0;
 553         ts->stopped = true;
 554         init_waitqueue_head(&ts->wait);
 555
 556         snprintf(ts->phys, sizeof(ts->phys),
 557                  "%s/input0", dev_name(&client->dev));
 558
 559         input_dev->name = "AUO-Pixcir touchscreen";
 560         input_dev->phys = ts->phys;
 561         input_dev->id.bustype = BUS_I2C;
 562
 563         input_dev->open = auo_pixcir_input_open;
 564         input_dev->close = auo_pixcir_input_close;
 565
 566         __set_bit(EV_ABS, input_dev->evbit);
 567         __set_bit(EV_KEY, input_dev->evbit);
 568
 569         __set_bit(BTN_TOUCH, input_dev->keybit);
 570
 571         /* For single touch */
 572         input_set_abs_params(input_dev, ABS_X, 0, pdata->x_max, 0, 0);
 573         input_set_abs_params(input_dev, ABS_Y, 0, pdata->y_max, 0, 0);
 574
 575         /* For multi touch */
 576         input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0,
 577                              pdata->x_max, 0, 0);
 578         input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0,
 579                              pdata->y_max, 0, 0);
 580         input_set_abs_params(input_dev, ABS_MT_TOUCH_MAJOR, 0,
 581                              AUO_PIXCIR_MAX_AREA, 0, 0);
 582         input_set_abs_params(input_dev, ABS_MT_TOUCH_MINOR, 0,
 583                              AUO_PIXCIR_MAX_AREA, 0, 0);
 584         input_set_abs_params(input_dev, ABS_MT_ORIENTATION, 0, 1, 0, 0);
 585
 586         input_set_drvdata(ts->input, ts);
 587
 588         error = devm_gpio_request_one(&client->dev, pdata->gpio_int,
 589                                       GPIOF_DIR_IN, "auo_pixcir_ts_int");
 590         if (error) {
 591                 dev_err(&client->dev, "request of gpio %d failed, %d\n",
 592                         pdata->gpio_int, error);
 593                 return error;
 594         }
 595
 596         error = devm_gpio_request_one(&client->dev, pdata->gpio_rst,
 597                                       GPIOF_DIR_OUT | GPIOF_INIT_HIGH,
 598                                       "auo_pixcir_ts_rst");
 599         if (error) {
 600                 dev_err(&client->dev, "request of gpio %d failed, %d\n",
 601                         pdata->gpio_rst, error);
 602                 return error;
 603         }
 604
 605         error = devm_add_action_or_reset(&client->dev, auo_pixcir_reset, ts);
 606         if (error) {
 607                 dev_err(&client->dev, "failed to register reset action, %d\n",
 608                         error);
 609                 return error;
 610         }
 611
 612         msleep(200);
 613
 614         version = i2c_smbus_read_byte_data(client, AUO_PIXCIR_REG_VERSION);
 615         if (version < 0) {
 616                 error = version;
 617                 return error;
 618         }
 619
 620         dev_info(&client->dev, "firmware version 0x%X\n", version);
 621
 622         error = auo_pixcir_int_config(ts, pdata->int_setting);
 623         if (error)
 624                 return error;
 625
 626         error = devm_request_threaded_irq(&client->dev, client->irq,
 627                                           NULL, auo_pixcir_interrupt,
 628                                           IRQF_TRIGGER_RISING | IRQF_ONESHOT,
 629                                           input_dev->name, ts);
 630         if (error) {
 631                 dev_err(&client->dev, "irq %d requested failed, %d\n",
 632                         client->irq, error);
 633                 return error;
 634         }
 635
 636         /* stop device and put it into deep sleep until it is opened */
 637         error = auo_pixcir_stop(ts);
 638         if (error)
 639                 return error;
 640
 641         error = input_register_device(input_dev);
 642         if (error) {
 643                 dev_err(&client->dev, "could not register input device, %d\n",
 644                         error);
 645                 return error;
 646         }
 647
 648         i2c_set_clientdata(client, ts);
 649
 650         return 0;
 651 }
 652
 653 static const struct i2c_device_id auo_pixcir_idtable[] = {
 654         { "auo_pixcir_ts", 0 },
 655         { }
 656 };
 657 MODULE_DEVICE_TABLE(i2c, auo_pixcir_idtable);
 658
 659 #ifdef CONFIG_OF
 660 static const struct of_device_id auo_pixcir_ts_dt_idtable[] = {
 661         { .compatible = "auo,auo_pixcir_ts" },
 662         {},
 663 };
 664 MODULE_DEVICE_TABLE(of, auo_pixcir_ts_dt_idtable);
 665 #endif
 666
 667 static struct i2c_driver auo_pixcir_driver = {
 668         .driver = {
 669                 .name   = "auo_pixcir_ts",
 670                 .pm     = &auo_pixcir_pm_ops,
 671                 .of_match_table = of_match_ptr(auo_pixcir_ts_dt_idtable),
 672         },
 673         .probe          = auo_pixcir_probe,
 674         .id_table       = auo_pixcir_idtable,
 675 };
 676
 677 module_i2c_driver(auo_pixcir_driver);
 678
 679 MODULE_DESCRIPTION("AUO-PIXCIR touchscreen driver");
 680 MODULE_LICENSE("GPL v2");
 681 MODULE_AUTHOR("Heiko Stuebner <heiko@sntech.de>");