drivers/input/touchscreen/stmfts.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 // STMicroelectronics FTS Touchscreen device driver
   3 //
   4 // Copyright (c) 2017 Samsung Electronics Co., Ltd.
   5 // Copyright (c) 2017 Andi Shyti <andi@etezian.org>
   6
   7 #include <linux/delay.h>
   8 #include <linux/i2c.h>
   9 #include <linux/input/mt.h>
  10 #include <linux/input/touchscreen.h>
  11 #include <linux/interrupt.h>
  12 #include <linux/irq.h>
  13 #include <linux/leds.h>
  14 #include <linux/module.h>
  15 #include <linux/pm_runtime.h>
  16 #include <linux/regulator/consumer.h>
  17
  18 /* I2C commands */
  19 #define STMFTS_READ_INFO                        0x80
  20 #define STMFTS_READ_STATUS                      0x84
  21 #define STMFTS_READ_ONE_EVENT                   0x85
  22 #define STMFTS_READ_ALL_EVENT                   0x86
  23 #define STMFTS_LATEST_EVENT                     0x87
  24 #define STMFTS_SLEEP_IN                         0x90
  25 #define STMFTS_SLEEP_OUT                        0x91
  26 #define STMFTS_MS_MT_SENSE_OFF                  0x92
  27 #define STMFTS_MS_MT_SENSE_ON                   0x93
  28 #define STMFTS_SS_HOVER_SENSE_OFF               0x94
  29 #define STMFTS_SS_HOVER_SENSE_ON                0x95
  30 #define STMFTS_MS_KEY_SENSE_OFF                 0x9a
  31 #define STMFTS_MS_KEY_SENSE_ON                  0x9b
  32 #define STMFTS_SYSTEM_RESET                     0xa0
  33 #define STMFTS_CLEAR_EVENT_STACK                0xa1
  34 #define STMFTS_FULL_FORCE_CALIBRATION           0xa2
  35 #define STMFTS_MS_CX_TUNING                     0xa3
  36 #define STMFTS_SS_CX_TUNING                     0xa4
  37
  38 /* events */
  39 #define STMFTS_EV_NO_EVENT                      0x00
  40 #define STMFTS_EV_MULTI_TOUCH_DETECTED          0x02
  41 #define STMFTS_EV_MULTI_TOUCH_ENTER             0x03
  42 #define STMFTS_EV_MULTI_TOUCH_LEAVE             0x04
  43 #define STMFTS_EV_MULTI_TOUCH_MOTION            0x05
  44 #define STMFTS_EV_HOVER_ENTER                   0x07
  45 #define STMFTS_EV_HOVER_LEAVE                   0x08
  46 #define STMFTS_EV_HOVER_MOTION                  0x09
  47 #define STMFTS_EV_KEY_STATUS                    0x0e
  48 #define STMFTS_EV_ERROR                         0x0f
  49 #define STMFTS_EV_CONTROLLER_READY              0x10
  50 #define STMFTS_EV_SLEEP_OUT_CONTROLLER_READY    0x11
  51 #define STMFTS_EV_STATUS                        0x16
  52 #define STMFTS_EV_DEBUG                         0xdb
  53
  54 /* multi touch related event masks */
  55 #define STMFTS_MASK_EVENT_ID                    0x0f
  56 #define STMFTS_MASK_TOUCH_ID                    0xf0
  57 #define STMFTS_MASK_LEFT_EVENT                  0x0f
  58 #define STMFTS_MASK_X_MSB                       0x0f
  59 #define STMFTS_MASK_Y_LSB                       0xf0
  60
  61 /* key related event masks */
  62 #define STMFTS_MASK_KEY_NO_TOUCH                0x00
  63 #define STMFTS_MASK_KEY_MENU                    0x01
  64 #define STMFTS_MASK_KEY_BACK                    0x02
  65
  66 #define STMFTS_EVENT_SIZE       8
  67 #define STMFTS_STACK_DEPTH      32
  68 #define STMFTS_DATA_MAX_SIZE    (STMFTS_EVENT_SIZE * STMFTS_STACK_DEPTH)
  69 #define STMFTS_MAX_FINGERS      10
  70 #define STMFTS_DEV_NAME         "stmfts"
  71
  72 enum stmfts_regulators {
  73         STMFTS_REGULATOR_VDD,
  74         STMFTS_REGULATOR_AVDD,
  75 };
  76
  77 struct stmfts_data {
  78         struct i2c_client *client;
  79         struct input_dev *input;
  80         struct led_classdev led_cdev;
  81         struct mutex mutex;
  82
  83         struct touchscreen_properties prop;
  84
  85         struct regulator_bulk_data regulators[2];
  86
  87         /*
  88          * Presence of ledvdd will be used also to check
  89          * whether the LED is supported.
  90          */
  91         struct regulator *ledvdd;
  92
  93         u16 chip_id;
  94         u8 chip_ver;
  95         u16 fw_ver;
  96         u8 config_id;
  97         u8 config_ver;
  98
  99         u8 data[STMFTS_DATA_MAX_SIZE];
 100
 101         struct completion cmd_done;
 102
 103         bool use_key;
 104         bool led_status;
 105         bool hover_enabled;
 106         bool running;
 107 };
 108
 109 static int stmfts_brightness_set(struct led_classdev *led_cdev,
 110                                         enum led_brightness value)
 111 {
 112         struct stmfts_data *sdata = container_of(led_cdev,
 113                                         struct stmfts_data, led_cdev);
 114         int err;
 115
 116         if (value != sdata->led_status && sdata->ledvdd) {
 117                 if (!value) {
 118                         regulator_disable(sdata->ledvdd);
 119                 } else {
 120                         err = regulator_enable(sdata->ledvdd);
 121                         if (err) {
 122                                 dev_warn(&sdata->client->dev,
 123                                          "failed to disable ledvdd regulator: %d\n",
 124                                          err);
 125                                 return err;
 126                         }
 127                 }
 128                 sdata->led_status = value;
 129         }
 130
 131         return 0;
 132 }
 133
 134 static enum led_brightness stmfts_brightness_get(struct led_classdev *led_cdev)
 135 {
 136         struct stmfts_data *sdata = container_of(led_cdev,
 137                                                 struct stmfts_data, led_cdev);
 138
 139         return !!regulator_is_enabled(sdata->ledvdd);
 140 }
 141
 142 /*
 143  * We can't simply use i2c_smbus_read_i2c_block_data because we
 144  * need to read more than 255 bytes (
 145  */
 146 static int stmfts_read_events(struct stmfts_data *sdata)
 147 {
 148         u8 cmd = STMFTS_READ_ALL_EVENT;
 149         struct i2c_msg msgs[2] = {
 150                 {
 151                         .addr   = sdata->client->addr,
 152                         .len    = 1,
 153                         .buf    = &cmd,
 154                 },
 155                 {
 156                         .addr   = sdata->client->addr,
 157                         .flags  = I2C_M_RD,
 158                         .len    = STMFTS_DATA_MAX_SIZE,
 159                         .buf    = sdata->data,
 160                 },
 161         };
 162         int ret;
 163
 164         ret = i2c_transfer(sdata->client->adapter, msgs, ARRAY_SIZE(msgs));
 165         if (ret < 0)
 166                 return ret;
 167
 168         return ret == ARRAY_SIZE(msgs) ? 0 : -EIO;
 169 }
 170
 171 static void stmfts_report_contact_event(struct stmfts_data *sdata,
 172                                         const u8 event[])
 173 {
 174         u8 slot_id = (event[0] & STMFTS_MASK_TOUCH_ID) >> 4;
 175         u16 x = event[1] | ((event[2] & STMFTS_MASK_X_MSB) << 8);
 176         u16 y = (event[2] >> 4) | (event[3] << 4);
 177         u8 maj = event[4];
 178         u8 min = event[5];
 179         u8 orientation = event[6];
 180         u8 area = event[7];
 181
 182         input_mt_slot(sdata->input, slot_id);
 183
 184         input_mt_report_slot_state(sdata->input, MT_TOOL_FINGER, true);
 185         input_report_abs(sdata->input, ABS_MT_POSITION_X, x);
 186         input_report_abs(sdata->input, ABS_MT_POSITION_Y, y);
 187         input_report_abs(sdata->input, ABS_MT_TOUCH_MAJOR, maj);
 188         input_report_abs(sdata->input, ABS_MT_TOUCH_MINOR, min);
 189         input_report_abs(sdata->input, ABS_MT_PRESSURE, area);
 190         input_report_abs(sdata->input, ABS_MT_ORIENTATION, orientation);
 191
 192         input_sync(sdata->input);
 193 }
 194
 195 static void stmfts_report_contact_release(struct stmfts_data *sdata,
 196                                           const u8 event[])
 197 {
 198         u8 slot_id = (event[0] & STMFTS_MASK_TOUCH_ID) >> 4;
 199
 200         input_mt_slot(sdata->input, slot_id);
 201         input_mt_report_slot_inactive(sdata->input);
 202
 203         input_sync(sdata->input);
 204 }
 205
 206 static void stmfts_report_hover_event(struct stmfts_data *sdata,
 207                                       const u8 event[])
 208 {
 209         u16 x = (event[2] << 4) | (event[4] >> 4);
 210         u16 y = (event[3] << 4) | (event[4] & STMFTS_MASK_Y_LSB);
 211         u8 z = event[5];
 212
 213         input_report_abs(sdata->input, ABS_X, x);
 214         input_report_abs(sdata->input, ABS_Y, y);
 215         input_report_abs(sdata->input, ABS_DISTANCE, z);
 216
 217         input_sync(sdata->input);
 218 }
 219
 220 static void stmfts_report_key_event(struct stmfts_data *sdata, const u8 event[])
 221 {
 222         switch (event[2]) {
 223         case 0:
 224                 input_report_key(sdata->input, KEY_BACK, 0);
 225                 input_report_key(sdata->input, KEY_MENU, 0);
 226                 break;
 227
 228         case STMFTS_MASK_KEY_BACK:
 229                 input_report_key(sdata->input, KEY_BACK, 1);
 230                 break;
 231
 232         case STMFTS_MASK_KEY_MENU:
 233                 input_report_key(sdata->input, KEY_MENU, 1);
 234                 break;
 235
 236         default:
 237                 dev_warn(&sdata->client->dev,
 238                          "unknown key event: %#02x\n", event[2]);
 239                 break;
 240         }
 241
 242         input_sync(sdata->input);
 243 }
 244
 245 static void stmfts_parse_events(struct stmfts_data *sdata)
 246 {
 247         int i;
 248
 249         for (i = 0; i < STMFTS_STACK_DEPTH; i++) {
 250                 u8 *event = &sdata->data[i * STMFTS_EVENT_SIZE];
 251
 252                 switch (event[0]) {
 253
 254                 case STMFTS_EV_CONTROLLER_READY:
 255                 case STMFTS_EV_SLEEP_OUT_CONTROLLER_READY:
 256                 case STMFTS_EV_STATUS:
 257                         complete(&sdata->cmd_done);
 258                         fallthrough;
 259
 260                 case STMFTS_EV_NO_EVENT:
 261                 case STMFTS_EV_DEBUG:
 262                         return;
 263                 }
 264
 265                 switch (event[0] & STMFTS_MASK_EVENT_ID) {
 266
 267                 case STMFTS_EV_MULTI_TOUCH_ENTER:
 268                 case STMFTS_EV_MULTI_TOUCH_MOTION:
 269                         stmfts_report_contact_event(sdata, event);
 270                         break;
 271
 272                 case STMFTS_EV_MULTI_TOUCH_LEAVE:
 273                         stmfts_report_contact_release(sdata, event);
 274                         break;
 275
 276                 case STMFTS_EV_HOVER_ENTER:
 277                 case STMFTS_EV_HOVER_LEAVE:
 278                 case STMFTS_EV_HOVER_MOTION:
 279                         stmfts_report_hover_event(sdata, event);
 280                         break;
 281
 282                 case STMFTS_EV_KEY_STATUS:
 283                         stmfts_report_key_event(sdata, event);
 284                         break;
 285
 286                 case STMFTS_EV_ERROR:
 287                         dev_warn(&sdata->client->dev,
 288                                         "error code: 0x%x%x%x%x%x%x",
 289                                         event[6], event[5], event[4],
 290                                         event[3], event[2], event[1]);
 291                         break;
 292
 293                 default:
 294                         dev_err(&sdata->client->dev,
 295                                 "unknown event %#02x\n", event[0]);
 296                 }
 297         }
 298 }
 299
 300 static irqreturn_t stmfts_irq_handler(int irq, void *dev)
 301 {
 302         struct stmfts_data *sdata = dev;
 303         int err;
 304
 305         mutex_lock(&sdata->mutex);
 306
 307         err = stmfts_read_events(sdata);
 308         if (unlikely(err))
 309                 dev_err(&sdata->client->dev,
 310                         "failed to read events: %d\n", err);
 311         else
 312                 stmfts_parse_events(sdata);
 313
 314         mutex_unlock(&sdata->mutex);
 315         return IRQ_HANDLED;
 316 }
 317
 318 static int stmfts_command(struct stmfts_data *sdata, const u8 cmd)
 319 {
 320         int err;
 321
 322         reinit_completion(&sdata->cmd_done);
 323
 324         err = i2c_smbus_write_byte(sdata->client, cmd);
 325         if (err)
 326                 return err;
 327
 328         if (!wait_for_completion_timeout(&sdata->cmd_done,
 329                                          msecs_to_jiffies(1000)))
 330                 return -ETIMEDOUT;
 331
 332         return 0;
 333 }
 334
 335 static int stmfts_input_open(struct input_dev *dev)
 336 {
 337         struct stmfts_data *sdata = input_get_drvdata(dev);
 338         int err;
 339
 340         err = pm_runtime_resume_and_get(&sdata->client->dev);
 341         if (err)
 342                 return err;
 343
 344         err = i2c_smbus_write_byte(sdata->client, STMFTS_MS_MT_SENSE_ON);
 345         if (err) {
 346                 pm_runtime_put_sync(&sdata->client->dev);
 347                 return err;
 348         }
 349
 350         mutex_lock(&sdata->mutex);
 351         sdata->running = true;
 352
 353         if (sdata->hover_enabled) {
 354                 err = i2c_smbus_write_byte(sdata->client,
 355                                            STMFTS_SS_HOVER_SENSE_ON);
 356                 if (err)
 357                         dev_warn(&sdata->client->dev,
 358                                  "failed to enable hover\n");
 359         }
 360         mutex_unlock(&sdata->mutex);
 361
 362         if (sdata->use_key) {
 363                 err = i2c_smbus_write_byte(sdata->client,
 364                                            STMFTS_MS_KEY_SENSE_ON);
 365                 if (err)
 366                         /* I can still use only the touch screen */
 367                         dev_warn(&sdata->client->dev,
 368                                  "failed to enable touchkey\n");
 369         }
 370
 371         return 0;
 372 }
 373
 374 static void stmfts_input_close(struct input_dev *dev)
 375 {
 376         struct stmfts_data *sdata = input_get_drvdata(dev);
 377         int err;
 378
 379         err = i2c_smbus_write_byte(sdata->client, STMFTS_MS_MT_SENSE_OFF);
 380         if (err)
 381                 dev_warn(&sdata->client->dev,
 382                          "failed to disable touchscreen: %d\n", err);
 383
 384         mutex_lock(&sdata->mutex);
 385
 386         sdata->running = false;
 387
 388         if (sdata->hover_enabled) {
 389                 err = i2c_smbus_write_byte(sdata->client,
 390                                            STMFTS_SS_HOVER_SENSE_OFF);
 391                 if (err)
 392                         dev_warn(&sdata->client->dev,
 393                                  "failed to disable hover: %d\n", err);
 394         }
 395         mutex_unlock(&sdata->mutex);
 396
 397         if (sdata->use_key) {
 398                 err = i2c_smbus_write_byte(sdata->client,
 399                                            STMFTS_MS_KEY_SENSE_OFF);
 400                 if (err)
 401                         dev_warn(&sdata->client->dev,
 402                                  "failed to disable touchkey: %d\n", err);
 403         }
 404
 405         pm_runtime_put_sync(&sdata->client->dev);
 406 }
 407
 408 static ssize_t stmfts_sysfs_chip_id(struct device *dev,
 409                                 struct device_attribute *attr, char *buf)
 410 {
 411         struct stmfts_data *sdata = dev_get_drvdata(dev);
 412
 413         return sprintf(buf, "%#x\n", sdata->chip_id);
 414 }
 415
 416 static ssize_t stmfts_sysfs_chip_version(struct device *dev,
 417                                 struct device_attribute *attr, char *buf)
 418 {
 419         struct stmfts_data *sdata = dev_get_drvdata(dev);
 420
 421         return sprintf(buf, "%u\n", sdata->chip_ver);
 422 }
 423
 424 static ssize_t stmfts_sysfs_fw_ver(struct device *dev,
 425                                 struct device_attribute *attr, char *buf)
 426 {
 427         struct stmfts_data *sdata = dev_get_drvdata(dev);
 428
 429         return sprintf(buf, "%u\n", sdata->fw_ver);
 430 }
 431
 432 static ssize_t stmfts_sysfs_config_id(struct device *dev,
 433                                 struct device_attribute *attr, char *buf)
 434 {
 435         struct stmfts_data *sdata = dev_get_drvdata(dev);
 436
 437         return sprintf(buf, "%#x\n", sdata->config_id);
 438 }
 439
 440 static ssize_t stmfts_sysfs_config_version(struct device *dev,
 441                                 struct device_attribute *attr, char *buf)
 442 {
 443         struct stmfts_data *sdata = dev_get_drvdata(dev);
 444
 445         return sprintf(buf, "%u\n", sdata->config_ver);
 446 }
 447
 448 static ssize_t stmfts_sysfs_read_status(struct device *dev,
 449                                 struct device_attribute *attr, char *buf)
 450 {
 451         struct stmfts_data *sdata = dev_get_drvdata(dev);
 452         u8 status[4];
 453         int err;
 454
 455         err = i2c_smbus_read_i2c_block_data(sdata->client, STMFTS_READ_STATUS,
 456                                             sizeof(status), status);
 457         if (err)
 458                 return err;
 459
 460         return sprintf(buf, "%#02x\n", status[0]);
 461 }
 462
 463 static ssize_t stmfts_sysfs_hover_enable_read(struct device *dev,
 464                                 struct device_attribute *attr, char *buf)
 465 {
 466         struct stmfts_data *sdata = dev_get_drvdata(dev);
 467
 468         return sprintf(buf, "%u\n", sdata->hover_enabled);
 469 }
 470
 471 static ssize_t stmfts_sysfs_hover_enable_write(struct device *dev,
 472                                 struct device_attribute *attr,
 473                                 const char *buf, size_t len)
 474 {
 475         struct stmfts_data *sdata = dev_get_drvdata(dev);
 476         unsigned long value;
 477         int err = 0;
 478
 479         if (kstrtoul(buf, 0, &value))
 480                 return -EINVAL;
 481
 482         mutex_lock(&sdata->mutex);
 483
 484         if (value && sdata->hover_enabled)
 485                 goto out;
 486
 487         if (sdata->running)
 488                 err = i2c_smbus_write_byte(sdata->client,
 489                                            value ? STMFTS_SS_HOVER_SENSE_ON :
 490                                                    STMFTS_SS_HOVER_SENSE_OFF);
 491
 492         if (!err)
 493                 sdata->hover_enabled = !!value;
 494
 495 out:
 496         mutex_unlock(&sdata->mutex);
 497
 498         return len;
 499 }
 500
 501 static DEVICE_ATTR(chip_id, 0444, stmfts_sysfs_chip_id, NULL);
 502 static DEVICE_ATTR(chip_version, 0444, stmfts_sysfs_chip_version, NULL);
 503 static DEVICE_ATTR(fw_ver, 0444, stmfts_sysfs_fw_ver, NULL);
 504 static DEVICE_ATTR(config_id, 0444, stmfts_sysfs_config_id, NULL);
 505 static DEVICE_ATTR(config_version, 0444, stmfts_sysfs_config_version, NULL);
 506 static DEVICE_ATTR(status, 0444, stmfts_sysfs_read_status, NULL);
 507 static DEVICE_ATTR(hover_enable, 0644, stmfts_sysfs_hover_enable_read,
 508                                         stmfts_sysfs_hover_enable_write);
 509
 510 static struct attribute *stmfts_sysfs_attrs[] = {
 511         &dev_attr_chip_id.attr,
 512         &dev_attr_chip_version.attr,
 513         &dev_attr_fw_ver.attr,
 514         &dev_attr_config_id.attr,
 515         &dev_attr_config_version.attr,
 516         &dev_attr_status.attr,
 517         &dev_attr_hover_enable.attr,
 518         NULL
 519 };
 520 ATTRIBUTE_GROUPS(stmfts_sysfs);
 521
 522 static int stmfts_power_on(struct stmfts_data *sdata)
 523 {
 524         int err;
 525         u8 reg[8];
 526
 527         err = regulator_bulk_enable(ARRAY_SIZE(sdata->regulators),
 528                                     sdata->regulators);
 529         if (err)
 530                 return err;
 531
 532         /*
 533          * The datasheet does not specify the power on time, but considering
 534          * that the reset time is < 10ms, I sleep 20ms to be sure
 535          */
 536         msleep(20);
 537
 538         err = i2c_smbus_read_i2c_block_data(sdata->client, STMFTS_READ_INFO,
 539                                             sizeof(reg), reg);
 540         if (err < 0)
 541                 return err;
 542         if (err != sizeof(reg))
 543                 return -EIO;
 544
 545         sdata->chip_id = be16_to_cpup((__be16 *)&reg[6]);
 546         sdata->chip_ver = reg[0];
 547         sdata->fw_ver = be16_to_cpup((__be16 *)&reg[2]);
 548         sdata->config_id = reg[4];
 549         sdata->config_ver = reg[5];
 550
 551         enable_irq(sdata->client->irq);
 552
 553         msleep(50);
 554
 555         err = stmfts_command(sdata, STMFTS_SYSTEM_RESET);
 556         if (err)
 557                 return err;
 558
 559         err = stmfts_command(sdata, STMFTS_SLEEP_OUT);
 560         if (err)
 561                 return err;
 562
 563         /* optional tuning */
 564         err = stmfts_command(sdata, STMFTS_MS_CX_TUNING);
 565         if (err)
 566                 dev_warn(&sdata->client->dev,
 567                          "failed to perform mutual auto tune: %d\n", err);
 568
 569         /* optional tuning */
 570         err = stmfts_command(sdata, STMFTS_SS_CX_TUNING);
 571         if (err)
 572                 dev_warn(&sdata->client->dev,
 573                          "failed to perform self auto tune: %d\n", err);
 574
 575         err = stmfts_command(sdata, STMFTS_FULL_FORCE_CALIBRATION);
 576         if (err)
 577                 return err;
 578
 579         /*
 580          * At this point no one is using the touchscreen
 581          * and I don't really care about the return value
 582          */
 583         (void) i2c_smbus_write_byte(sdata->client, STMFTS_SLEEP_IN);
 584
 585         return 0;
 586 }
 587
 588 static void stmfts_power_off(void *data)
 589 {
 590         struct stmfts_data *sdata = data;
 591
 592         disable_irq(sdata->client->irq);
 593         regulator_bulk_disable(ARRAY_SIZE(sdata->regulators),
 594                                                 sdata->regulators);
 595 }
 596
 597 /* This function is void because I don't want to prevent using the touch key
 598  * only because the LEDs don't get registered
 599  */
 600 static int stmfts_enable_led(struct stmfts_data *sdata)
 601 {
 602         int err;
 603
 604         /* get the regulator for powering the leds on */
 605         sdata->ledvdd = devm_regulator_get(&sdata->client->dev, "ledvdd");
 606         if (IS_ERR(sdata->ledvdd))
 607                 return PTR_ERR(sdata->ledvdd);
 608
 609         sdata->led_cdev.name = STMFTS_DEV_NAME;
 610         sdata->led_cdev.max_brightness = LED_ON;
 611         sdata->led_cdev.brightness = LED_OFF;
 612         sdata->led_cdev.brightness_set_blocking = stmfts_brightness_set;
 613         sdata->led_cdev.brightness_get = stmfts_brightness_get;
 614
 615         err = devm_led_classdev_register(&sdata->client->dev, &sdata->led_cdev);
 616         if (err) {
 617                 devm_regulator_put(sdata->ledvdd);
 618                 return err;
 619         }
 620
 621         return 0;
 622 }
 623
 624 static int stmfts_probe(struct i2c_client *client)
 625 {
 626         int err;
 627         struct stmfts_data *sdata;
 628
 629         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
 630                                                 I2C_FUNC_SMBUS_BYTE_DATA |
 631                                                 I2C_FUNC_SMBUS_I2C_BLOCK))
 632                 return -ENODEV;
 633
 634         sdata = devm_kzalloc(&client->dev, sizeof(*sdata), GFP_KERNEL);
 635         if (!sdata)
 636                 return -ENOMEM;
 637
 638         i2c_set_clientdata(client, sdata);
 639
 640         sdata->client = client;
 641         mutex_init(&sdata->mutex);
 642         init_completion(&sdata->cmd_done);
 643
 644         sdata->regulators[STMFTS_REGULATOR_VDD].supply = "vdd";
 645         sdata->regulators[STMFTS_REGULATOR_AVDD].supply = "avdd";
 646         err = devm_regulator_bulk_get(&client->dev,
 647                                       ARRAY_SIZE(sdata->regulators),
 648                                       sdata->regulators);
 649         if (err)
 650                 return err;
 651
 652         sdata->input = devm_input_allocate_device(&client->dev);
 653         if (!sdata->input)
 654                 return -ENOMEM;
 655
 656         sdata->input->name = STMFTS_DEV_NAME;
 657         sdata->input->id.bustype = BUS_I2C;
 658         sdata->input->open = stmfts_input_open;
 659         sdata->input->close = stmfts_input_close;
 660
 661         input_set_capability(sdata->input, EV_ABS, ABS_MT_POSITION_X);
 662         input_set_capability(sdata->input, EV_ABS, ABS_MT_POSITION_Y);
 663         touchscreen_parse_properties(sdata->input, true, &sdata->prop);
 664
 665         input_set_abs_params(sdata->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
 666         input_set_abs_params(sdata->input, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0);
 667         input_set_abs_params(sdata->input, ABS_MT_ORIENTATION, 0, 255, 0, 0);
 668         input_set_abs_params(sdata->input, ABS_MT_PRESSURE, 0, 255, 0, 0);
 669         input_set_abs_params(sdata->input, ABS_DISTANCE, 0, 255, 0, 0);
 670
 671         sdata->use_key = device_property_read_bool(&client->dev,
 672                                                    "touch-key-connected");
 673         if (sdata->use_key) {
 674                 input_set_capability(sdata->input, EV_KEY, KEY_MENU);
 675                 input_set_capability(sdata->input, EV_KEY, KEY_BACK);
 676         }
 677
 678         err = input_mt_init_slots(sdata->input,
 679                                   STMFTS_MAX_FINGERS, INPUT_MT_DIRECT);
 680         if (err)
 681                 return err;
 682
 683         input_set_drvdata(sdata->input, sdata);
 684
 685         /*
 686          * stmfts_power_on expects interrupt to be disabled, but
 687          * at this point the device is still off and I do not trust
 688          * the status of the irq line that can generate some spurious
 689          * interrupts. To be on the safe side it's better to not enable
 690          * the interrupts during their request.
 691          */
 692         err = devm_request_threaded_irq(&client->dev, client->irq,
 693                                         NULL, stmfts_irq_handler,
 694                                         IRQF_ONESHOT | IRQF_NO_AUTOEN,
 695                                         "stmfts_irq", sdata);
 696         if (err)
 697                 return err;
 698
 699         dev_dbg(&client->dev, "initializing ST-Microelectronics FTS...\n");
 700
 701         err = stmfts_power_on(sdata);
 702         if (err)
 703                 return err;
 704
 705         err = devm_add_action_or_reset(&client->dev, stmfts_power_off, sdata);
 706         if (err)
 707                 return err;
 708
 709         err = input_register_device(sdata->input);
 710         if (err)
 711                 return err;
 712
 713         if (sdata->use_key) {
 714                 err = stmfts_enable_led(sdata);
 715                 if (err) {
 716                         /*
 717                          * Even if the LEDs have failed to be initialized and
 718                          * used in the driver, I can still use the device even
 719                          * without LEDs. The ledvdd regulator pointer will be
 720                          * used as a flag.
 721                          */
 722                         dev_warn(&client->dev, "unable to use touchkey leds\n");
 723                         sdata->ledvdd = NULL;
 724                 }
 725         }
 726
 727         pm_runtime_enable(&client->dev);
 728         device_enable_async_suspend(&client->dev);
 729
 730         return 0;
 731 }
 732
 733 static void stmfts_remove(struct i2c_client *client)
 734 {
 735         pm_runtime_disable(&client->dev);
 736 }
 737
 738 static int stmfts_runtime_suspend(struct device *dev)
 739 {
 740         struct stmfts_data *sdata = dev_get_drvdata(dev);
 741         int ret;
 742
 743         ret = i2c_smbus_write_byte(sdata->client, STMFTS_SLEEP_IN);
 744         if (ret)
 745                 dev_warn(dev, "failed to suspend device: %d\n", ret);
 746
 747         return ret;
 748 }
 749
 750 static int stmfts_runtime_resume(struct device *dev)
 751 {
 752         struct stmfts_data *sdata = dev_get_drvdata(dev);
 753         int ret;
 754
 755         ret = i2c_smbus_write_byte(sdata->client, STMFTS_SLEEP_OUT);
 756         if (ret)
 757                 dev_err(dev, "failed to resume device: %d\n", ret);
 758
 759         return ret;
 760 }
 761
 762 static int stmfts_suspend(struct device *dev)
 763 {
 764         struct stmfts_data *sdata = dev_get_drvdata(dev);
 765
 766         stmfts_power_off(sdata);
 767
 768         return 0;
 769 }
 770
 771 static int stmfts_resume(struct device *dev)
 772 {
 773         struct stmfts_data *sdata = dev_get_drvdata(dev);
 774
 775         return stmfts_power_on(sdata);
 776 }
 777
 778 static const struct dev_pm_ops stmfts_pm_ops = {
 779         SYSTEM_SLEEP_PM_OPS(stmfts_suspend, stmfts_resume)
 780         RUNTIME_PM_OPS(stmfts_runtime_suspend, stmfts_runtime_resume, NULL)
 781 };
 782
 783 #ifdef CONFIG_OF
 784 static const struct of_device_id stmfts_of_match[] = {
 785         { .compatible = "st,stmfts", },
 786         { },
 787 };
 788 MODULE_DEVICE_TABLE(of, stmfts_of_match);
 789 #endif
 790
 791 static const struct i2c_device_id stmfts_id[] = {
 792         { "stmfts" },
 793         { }
 794 };
 795 MODULE_DEVICE_TABLE(i2c, stmfts_id);
 796
 797 static struct i2c_driver stmfts_driver = {
 798         .driver = {
 799                 .name = STMFTS_DEV_NAME,
 800                 .dev_groups = stmfts_sysfs_groups,
 801                 .of_match_table = of_match_ptr(stmfts_of_match),
 802                 .pm = pm_ptr(&stmfts_pm_ops),
 803                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 804         },
 805         .probe = stmfts_probe,
 806         .remove = stmfts_remove,
 807         .id_table = stmfts_id,
 808 };
 809
 810 module_i2c_driver(stmfts_driver);
 811
 812 MODULE_AUTHOR("Andi Shyti <andi.shyti@samsung.com>");
 813 MODULE_DESCRIPTION("STMicroelectronics FTS Touch Screen");
 814 MODULE_LICENSE("GPL v2");