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 <[email protected]>
   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
 521 static struct attribute_group stmfts_attribute_group = {
 522         .attrs = stmfts_sysfs_attrs
 523 };
 524
 525 static int stmfts_power_on(struct stmfts_data *sdata)
 526 {
 527         int err;
 528         u8 reg[8];
 529
 530         err = regulator_bulk_enable(ARRAY_SIZE(sdata->regulators),
 531                                     sdata->regulators);
 532         if (err)
 533                 return err;
 534
 535         /*
 536          * The datasheet does not specify the power on time, but considering
 537          * that the reset time is < 10ms, I sleep 20ms to be sure
 538          */
 539         msleep(20);
 540
 541         err = i2c_smbus_read_i2c_block_data(sdata->client, STMFTS_READ_INFO,
 542                                             sizeof(reg), reg);
 543         if (err < 0)
 544                 return err;
 545         if (err != sizeof(reg))
 546                 return -EIO;
 547
 548         sdata->chip_id = be16_to_cpup((__be16 *)&reg[6]);
 549         sdata->chip_ver = reg[0];
 550         sdata->fw_ver = be16_to_cpup((__be16 *)&reg[2]);
 551         sdata->config_id = reg[4];
 552         sdata->config_ver = reg[5];
 553
 554         enable_irq(sdata->client->irq);
 555
 556         msleep(50);
 557
 558         err = stmfts_command(sdata, STMFTS_SYSTEM_RESET);
 559         if (err)
 560                 return err;
 561
 562         err = stmfts_command(sdata, STMFTS_SLEEP_OUT);
 563         if (err)
 564                 return err;
 565
 566         /* optional tuning */
 567         err = stmfts_command(sdata, STMFTS_MS_CX_TUNING);
 568         if (err)
 569                 dev_warn(&sdata->client->dev,
 570                          "failed to perform mutual auto tune: %d\n", err);
 571
 572         /* optional tuning */
 573         err = stmfts_command(sdata, STMFTS_SS_CX_TUNING);
 574         if (err)
 575                 dev_warn(&sdata->client->dev,
 576                          "failed to perform self auto tune: %d\n", err);
 577
 578         err = stmfts_command(sdata, STMFTS_FULL_FORCE_CALIBRATION);
 579         if (err)
 580                 return err;
 581
 582         /*
 583          * At this point no one is using the touchscreen
 584          * and I don't really care about the return value
 585          */
 586         (void) i2c_smbus_write_byte(sdata->client, STMFTS_SLEEP_IN);
 587
 588         return 0;
 589 }
 590
 591 static void stmfts_power_off(void *data)
 592 {
 593         struct stmfts_data *sdata = data;
 594
 595         disable_irq(sdata->client->irq);
 596         regulator_bulk_disable(ARRAY_SIZE(sdata->regulators),
 597                                                 sdata->regulators);
 598 }
 599
 600 /* This function is void because I don't want to prevent using the touch key
 601  * only because the LEDs don't get registered
 602  */
 603 static int stmfts_enable_led(struct stmfts_data *sdata)
 604 {
 605         int err;
 606
 607         /* get the regulator for powering the leds on */
 608         sdata->ledvdd = devm_regulator_get(&sdata->client->dev, "ledvdd");
 609         if (IS_ERR(sdata->ledvdd))
 610                 return PTR_ERR(sdata->ledvdd);
 611
 612         sdata->led_cdev.name = STMFTS_DEV_NAME;
 613         sdata->led_cdev.max_brightness = LED_ON;
 614         sdata->led_cdev.brightness = LED_OFF;
 615         sdata->led_cdev.brightness_set_blocking = stmfts_brightness_set;
 616         sdata->led_cdev.brightness_get = stmfts_brightness_get;
 617
 618         err = devm_led_classdev_register(&sdata->client->dev, &sdata->led_cdev);
 619         if (err) {
 620                 devm_regulator_put(sdata->ledvdd);
 621                 return err;
 622         }
 623
 624         return 0;
 625 }
 626
 627 static int stmfts_probe(struct i2c_client *client)
 628 {
 629         int err;
 630         struct stmfts_data *sdata;
 631
 632         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C |
 633                                                 I2C_FUNC_SMBUS_BYTE_DATA |
 634                                                 I2C_FUNC_SMBUS_I2C_BLOCK))
 635                 return -ENODEV;
 636
 637         sdata = devm_kzalloc(&client->dev, sizeof(*sdata), GFP_KERNEL);
 638         if (!sdata)
 639                 return -ENOMEM;
 640
 641         i2c_set_clientdata(client, sdata);
 642
 643         sdata->client = client;
 644         mutex_init(&sdata->mutex);
 645         init_completion(&sdata->cmd_done);
 646
 647         sdata->regulators[STMFTS_REGULATOR_VDD].supply = "vdd";
 648         sdata->regulators[STMFTS_REGULATOR_AVDD].supply = "avdd";
 649         err = devm_regulator_bulk_get(&client->dev,
 650                                       ARRAY_SIZE(sdata->regulators),
 651                                       sdata->regulators);
 652         if (err)
 653                 return err;
 654
 655         sdata->input = devm_input_allocate_device(&client->dev);
 656         if (!sdata->input)
 657                 return -ENOMEM;
 658
 659         sdata->input->name = STMFTS_DEV_NAME;
 660         sdata->input->id.bustype = BUS_I2C;
 661         sdata->input->open = stmfts_input_open;
 662         sdata->input->close = stmfts_input_close;
 663
 664         input_set_capability(sdata->input, EV_ABS, ABS_MT_POSITION_X);
 665         input_set_capability(sdata->input, EV_ABS, ABS_MT_POSITION_Y);
 666         touchscreen_parse_properties(sdata->input, true, &sdata->prop);
 667
 668         input_set_abs_params(sdata->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
 669         input_set_abs_params(sdata->input, ABS_MT_TOUCH_MINOR, 0, 255, 0, 0);
 670         input_set_abs_params(sdata->input, ABS_MT_ORIENTATION, 0, 255, 0, 0);
 671         input_set_abs_params(sdata->input, ABS_MT_PRESSURE, 0, 255, 0, 0);
 672         input_set_abs_params(sdata->input, ABS_DISTANCE, 0, 255, 0, 0);
 673
 674         sdata->use_key = device_property_read_bool(&client->dev,
 675                                                    "touch-key-connected");
 676         if (sdata->use_key) {
 677                 input_set_capability(sdata->input, EV_KEY, KEY_MENU);
 678                 input_set_capability(sdata->input, EV_KEY, KEY_BACK);
 679         }
 680
 681         err = input_mt_init_slots(sdata->input,
 682                                   STMFTS_MAX_FINGERS, INPUT_MT_DIRECT);
 683         if (err)
 684                 return err;
 685
 686         input_set_drvdata(sdata->input, sdata);
 687
 688         /*
 689          * stmfts_power_on expects interrupt to be disabled, but
 690          * at this point the device is still off and I do not trust
 691          * the status of the irq line that can generate some spurious
 692          * interrupts. To be on the safe side it's better to not enable
 693          * the interrupts during their request.
 694          */
 695         err = devm_request_threaded_irq(&client->dev, client->irq,
 696                                         NULL, stmfts_irq_handler,
 697                                         IRQF_ONESHOT | IRQF_NO_AUTOEN,
 698                                         "stmfts_irq", sdata);
 699         if (err)
 700                 return err;
 701
 702         dev_dbg(&client->dev, "initializing ST-Microelectronics FTS...\n");
 703
 704         err = stmfts_power_on(sdata);
 705         if (err)
 706                 return err;
 707
 708         err = devm_add_action_or_reset(&client->dev, stmfts_power_off, sdata);
 709         if (err)
 710                 return err;
 711
 712         err = input_register_device(sdata->input);
 713         if (err)
 714                 return err;
 715
 716         if (sdata->use_key) {
 717                 err = stmfts_enable_led(sdata);
 718                 if (err) {
 719                         /*
 720                          * Even if the LEDs have failed to be initialized and
 721                          * used in the driver, I can still use the device even
 722                          * without LEDs. The ledvdd regulator pointer will be
 723                          * used as a flag.
 724                          */
 725                         dev_warn(&client->dev, "unable to use touchkey leds\n");
 726                         sdata->ledvdd = NULL;
 727                 }
 728         }
 729
 730         err = devm_device_add_group(&client->dev, &stmfts_attribute_group);
 731         if (err)
 732                 return err;
 733
 734         pm_runtime_enable(&client->dev);
 735         device_enable_async_suspend(&client->dev);
 736
 737         return 0;
 738 }
 739
 740 static void stmfts_remove(struct i2c_client *client)
 741 {
 742         pm_runtime_disable(&client->dev);
 743 }
 744
 745 static int stmfts_runtime_suspend(struct device *dev)
 746 {
 747         struct stmfts_data *sdata = dev_get_drvdata(dev);
 748         int ret;
 749
 750         ret = i2c_smbus_write_byte(sdata->client, STMFTS_SLEEP_IN);
 751         if (ret)
 752                 dev_warn(dev, "failed to suspend device: %d\n", ret);
 753
 754         return ret;
 755 }
 756
 757 static int stmfts_runtime_resume(struct device *dev)
 758 {
 759         struct stmfts_data *sdata = dev_get_drvdata(dev);
 760         int ret;
 761
 762         ret = i2c_smbus_write_byte(sdata->client, STMFTS_SLEEP_OUT);
 763         if (ret)
 764                 dev_err(dev, "failed to resume device: %d\n", ret);
 765
 766         return ret;
 767 }
 768
 769 static int stmfts_suspend(struct device *dev)
 770 {
 771         struct stmfts_data *sdata = dev_get_drvdata(dev);
 772
 773         stmfts_power_off(sdata);
 774
 775         return 0;
 776 }
 777
 778 static int stmfts_resume(struct device *dev)
 779 {
 780         struct stmfts_data *sdata = dev_get_drvdata(dev);
 781
 782         return stmfts_power_on(sdata);
 783 }
 784
 785 static const struct dev_pm_ops stmfts_pm_ops = {
 786         SYSTEM_SLEEP_PM_OPS(stmfts_suspend, stmfts_resume)
 787         RUNTIME_PM_OPS(stmfts_runtime_suspend, stmfts_runtime_resume, NULL)
 788 };
 789
 790 #ifdef CONFIG_OF
 791 static const struct of_device_id stmfts_of_match[] = {
 792         { .compatible = "st,stmfts", },
 793         { },
 794 };
 795 MODULE_DEVICE_TABLE(of, stmfts_of_match);
 796 #endif
 797
 798 static const struct i2c_device_id stmfts_id[] = {
 799         { "stmfts", 0 },
 800         { },
 801 };
 802 MODULE_DEVICE_TABLE(i2c, stmfts_id);
 803
 804 static struct i2c_driver stmfts_driver = {
 805         .driver = {
 806                 .name = STMFTS_DEV_NAME,
 807                 .of_match_table = of_match_ptr(stmfts_of_match),
 808                 .pm = pm_ptr(&stmfts_pm_ops),
 809                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
 810         },
 811         .probe = stmfts_probe,
 812         .remove = stmfts_remove,
 813         .id_table = stmfts_id,
 814 };
 815
 816 module_i2c_driver(stmfts_driver);
 817
 818 MODULE_AUTHOR("Andi Shyti <[email protected]>");
 819 MODULE_DESCRIPTION("STMicroelectronics FTS Touch Screen");
 820 MODULE_LICENSE("GPL v2");