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