1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Driver for Goodix Touchscreens 4 * 5 * Copyright (c) 2014 Red Hat Inc. 6 * Copyright (c) 2015 K. Merker <merker@debian.org> 7 * 8 * This code is based on gt9xx.c authored by andrew@goodix.com: 9 * 10 * 2010 - 2012 Goodix Technology. 11 */ 12 13 14 #include <linux/kernel.h> 15 #include <linux/dmi.h> 16 #include <linux/firmware.h> 17 #include <linux/gpio/consumer.h> 18 #include <linux/i2c.h> 19 #include <linux/input.h> 20 #include <linux/input/mt.h> 21 #include <linux/input/touchscreen.h> 22 #include <linux/module.h> 23 #include <linux/delay.h> 24 #include <linux/irq.h> 25 #include <linux/interrupt.h> 26 #include <linux/regulator/consumer.h> 27 #include <linux/slab.h> 28 #include <linux/acpi.h> 29 #include <linux/of.h> 30 #include <asm/unaligned.h> 31 32 struct goodix_ts_data; 33 34 struct goodix_chip_data { 35 u16 config_addr; 36 int config_len; 37 int (*check_config)(struct goodix_ts_data *, const struct firmware *); 38 }; 39 40 struct goodix_ts_data { 41 struct i2c_client *client; 42 struct input_dev *input_dev; 43 const struct goodix_chip_data *chip; 44 struct touchscreen_properties prop; 45 unsigned int max_touch_num; 46 unsigned int int_trigger_type; 47 struct regulator *avdd28; 48 struct regulator *vddio; 49 struct gpio_desc *gpiod_int; 50 struct gpio_desc *gpiod_rst; 51 u16 id; 52 u16 version; 53 const char *cfg_name; 54 struct completion firmware_loading_complete; 55 unsigned long irq_flags; 56 unsigned int contact_size; 57 }; 58 59 #define GOODIX_GPIO_INT_NAME "irq" 60 #define GOODIX_GPIO_RST_NAME "reset" 61 62 #define GOODIX_MAX_HEIGHT 4096 63 #define GOODIX_MAX_WIDTH 4096 64 #define GOODIX_INT_TRIGGER 1 65 #define GOODIX_CONTACT_SIZE 8 66 #define GOODIX_MAX_CONTACT_SIZE 9 67 #define GOODIX_MAX_CONTACTS 10 68 69 #define GOODIX_CONFIG_MAX_LENGTH 240 70 #define GOODIX_CONFIG_911_LENGTH 186 71 #define GOODIX_CONFIG_967_LENGTH 228 72 73 /* Register defines */ 74 #define GOODIX_REG_COMMAND 0x8040 75 #define GOODIX_CMD_SCREEN_OFF 0x05 76 77 #define GOODIX_READ_COOR_ADDR 0x814E 78 #define GOODIX_GT1X_REG_CONFIG_DATA 0x8050 79 #define GOODIX_GT9X_REG_CONFIG_DATA 0x8047 80 #define GOODIX_REG_ID 0x8140 81 82 #define GOODIX_BUFFER_STATUS_READY BIT(7) 83 #define GOODIX_BUFFER_STATUS_TIMEOUT 20 84 85 #define RESOLUTION_LOC 1 86 #define MAX_CONTACTS_LOC 5 87 #define TRIGGER_LOC 6 88 89 static int goodix_check_cfg_8(struct goodix_ts_data *ts, 90 const struct firmware *cfg); 91 static int goodix_check_cfg_16(struct goodix_ts_data *ts, 92 const struct firmware *cfg); 93 94 static const struct goodix_chip_data gt1x_chip_data = { 95 .config_addr = GOODIX_GT1X_REG_CONFIG_DATA, 96 .config_len = GOODIX_CONFIG_MAX_LENGTH, 97 .check_config = goodix_check_cfg_16, 98 }; 99 100 static const struct goodix_chip_data gt911_chip_data = { 101 .config_addr = GOODIX_GT9X_REG_CONFIG_DATA, 102 .config_len = GOODIX_CONFIG_911_LENGTH, 103 .check_config = goodix_check_cfg_8, 104 }; 105 106 static const struct goodix_chip_data gt967_chip_data = { 107 .config_addr = GOODIX_GT9X_REG_CONFIG_DATA, 108 .config_len = GOODIX_CONFIG_967_LENGTH, 109 .check_config = goodix_check_cfg_8, 110 }; 111 112 static const struct goodix_chip_data gt9x_chip_data = { 113 .config_addr = GOODIX_GT9X_REG_CONFIG_DATA, 114 .config_len = GOODIX_CONFIG_MAX_LENGTH, 115 .check_config = goodix_check_cfg_8, 116 }; 117 118 static const unsigned long goodix_irq_flags[] = { 119 IRQ_TYPE_EDGE_RISING, 120 IRQ_TYPE_EDGE_FALLING, 121 IRQ_TYPE_LEVEL_LOW, 122 IRQ_TYPE_LEVEL_HIGH, 123 }; 124 125 /* 126 * Those tablets have their coordinates origin at the bottom right 127 * of the tablet, as if rotated 180 degrees 128 */ 129 static const struct dmi_system_id rotated_screen[] = { 130 #if defined(CONFIG_DMI) && defined(CONFIG_X86) 131 { 132 .ident = "WinBook TW100", 133 .matches = { 134 DMI_MATCH(DMI_SYS_VENDOR, "WinBook"), 135 DMI_MATCH(DMI_PRODUCT_NAME, "TW100") 136 } 137 }, 138 { 139 .ident = "WinBook TW700", 140 .matches = { 141 DMI_MATCH(DMI_SYS_VENDOR, "WinBook"), 142 DMI_MATCH(DMI_PRODUCT_NAME, "TW700") 143 }, 144 }, 145 #endif 146 {} 147 }; 148 149 static const struct dmi_system_id nine_bytes_report[] = { 150 #if defined(CONFIG_DMI) && defined(CONFIG_X86) 151 { 152 .ident = "Lenovo YogaBook", 153 /* YB1-X91L/F and YB1-X90L/F */ 154 .matches = { 155 DMI_MATCH(DMI_PRODUCT_NAME, "Lenovo YB1-X9") 156 } 157 }, 158 #endif 159 {} 160 }; 161 162 /** 163 * goodix_i2c_read - read data from a register of the i2c slave device. 164 * 165 * @client: i2c device. 166 * @reg: the register to read from. 167 * @buf: raw write data buffer. 168 * @len: length of the buffer to write 169 */ 170 static int goodix_i2c_read(struct i2c_client *client, 171 u16 reg, u8 *buf, int len) 172 { 173 struct i2c_msg msgs[2]; 174 __be16 wbuf = cpu_to_be16(reg); 175 int ret; 176 177 msgs[0].flags = 0; 178 msgs[0].addr = client->addr; 179 msgs[0].len = 2; 180 msgs[0].buf = (u8 *)&wbuf; 181 182 msgs[1].flags = I2C_M_RD; 183 msgs[1].addr = client->addr; 184 msgs[1].len = len; 185 msgs[1].buf = buf; 186 187 ret = i2c_transfer(client->adapter, msgs, 2); 188 return ret < 0 ? ret : (ret != ARRAY_SIZE(msgs) ? -EIO : 0); 189 } 190 191 /** 192 * goodix_i2c_write - write data to a register of the i2c slave device. 193 * 194 * @client: i2c device. 195 * @reg: the register to write to. 196 * @buf: raw data buffer to write. 197 * @len: length of the buffer to write 198 */ 199 static int goodix_i2c_write(struct i2c_client *client, u16 reg, const u8 *buf, 200 unsigned len) 201 { 202 u8 *addr_buf; 203 struct i2c_msg msg; 204 int ret; 205 206 addr_buf = kmalloc(len + 2, GFP_KERNEL); 207 if (!addr_buf) 208 return -ENOMEM; 209 210 addr_buf[0] = reg >> 8; 211 addr_buf[1] = reg & 0xFF; 212 memcpy(&addr_buf[2], buf, len); 213 214 msg.flags = 0; 215 msg.addr = client->addr; 216 msg.buf = addr_buf; 217 msg.len = len + 2; 218 219 ret = i2c_transfer(client->adapter, &msg, 1); 220 kfree(addr_buf); 221 return ret < 0 ? ret : (ret != 1 ? -EIO : 0); 222 } 223 224 static int goodix_i2c_write_u8(struct i2c_client *client, u16 reg, u8 value) 225 { 226 return goodix_i2c_write(client, reg, &value, sizeof(value)); 227 } 228 229 static const struct goodix_chip_data *goodix_get_chip_data(u16 id) 230 { 231 switch (id) { 232 case 1151: 233 case 5663: 234 case 5688: 235 return >1x_chip_data; 236 237 case 911: 238 case 9271: 239 case 9110: 240 case 927: 241 case 928: 242 return >911_chip_data; 243 244 case 912: 245 case 967: 246 return >967_chip_data; 247 248 default: 249 return >9x_chip_data; 250 } 251 } 252 253 static int goodix_ts_read_input_report(struct goodix_ts_data *ts, u8 *data) 254 { 255 unsigned long max_timeout; 256 int touch_num; 257 int error; 258 259 /* 260 * The 'buffer status' bit, which indicates that the data is valid, is 261 * not set as soon as the interrupt is raised, but slightly after. 262 * This takes around 10 ms to happen, so we poll for 20 ms. 263 */ 264 max_timeout = jiffies + msecs_to_jiffies(GOODIX_BUFFER_STATUS_TIMEOUT); 265 do { 266 error = goodix_i2c_read(ts->client, GOODIX_READ_COOR_ADDR, 267 data, ts->contact_size + 1); 268 if (error) { 269 dev_err(&ts->client->dev, "I2C transfer error: %d\n", 270 error); 271 return error; 272 } 273 274 if (data[0] & GOODIX_BUFFER_STATUS_READY) { 275 touch_num = data[0] & 0x0f; 276 if (touch_num > ts->max_touch_num) 277 return -EPROTO; 278 279 if (touch_num > 1) { 280 data += 1 + ts->contact_size; 281 error = goodix_i2c_read(ts->client, 282 GOODIX_READ_COOR_ADDR + 283 1 + ts->contact_size, 284 data, 285 ts->contact_size * 286 (touch_num - 1)); 287 if (error) 288 return error; 289 } 290 291 return touch_num; 292 } 293 294 usleep_range(1000, 2000); /* Poll every 1 - 2 ms */ 295 } while (time_before(jiffies, max_timeout)); 296 297 /* 298 * The Goodix panel will send spurious interrupts after a 299 * 'finger up' event, which will always cause a timeout. 300 */ 301 return 0; 302 } 303 304 static void goodix_ts_report_touch_8b(struct goodix_ts_data *ts, u8 *coor_data) 305 { 306 int id = coor_data[0] & 0x0F; 307 int input_x = get_unaligned_le16(&coor_data[1]); 308 int input_y = get_unaligned_le16(&coor_data[3]); 309 int input_w = get_unaligned_le16(&coor_data[5]); 310 311 input_mt_slot(ts->input_dev, id); 312 input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true); 313 touchscreen_report_pos(ts->input_dev, &ts->prop, 314 input_x, input_y, true); 315 input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w); 316 input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w); 317 } 318 319 static void goodix_ts_report_touch_9b(struct goodix_ts_data *ts, u8 *coor_data) 320 { 321 int id = coor_data[1] & 0x0F; 322 int input_x = get_unaligned_le16(&coor_data[3]); 323 int input_y = get_unaligned_le16(&coor_data[5]); 324 int input_w = get_unaligned_le16(&coor_data[7]); 325 326 input_mt_slot(ts->input_dev, id); 327 input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true); 328 touchscreen_report_pos(ts->input_dev, &ts->prop, 329 input_x, input_y, true); 330 input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w); 331 input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w); 332 } 333 334 /** 335 * goodix_process_events - Process incoming events 336 * 337 * @ts: our goodix_ts_data pointer 338 * 339 * Called when the IRQ is triggered. Read the current device state, and push 340 * the input events to the user space. 341 */ 342 static void goodix_process_events(struct goodix_ts_data *ts) 343 { 344 u8 point_data[1 + GOODIX_MAX_CONTACT_SIZE * GOODIX_MAX_CONTACTS]; 345 int touch_num; 346 int i; 347 348 touch_num = goodix_ts_read_input_report(ts, point_data); 349 if (touch_num < 0) 350 return; 351 352 /* 353 * Bit 4 of the first byte reports the status of the capacitive 354 * Windows/Home button. 355 */ 356 input_report_key(ts->input_dev, KEY_LEFTMETA, point_data[0] & BIT(4)); 357 358 for (i = 0; i < touch_num; i++) 359 if (ts->contact_size == 9) 360 goodix_ts_report_touch_9b(ts, 361 &point_data[1 + ts->contact_size * i]); 362 else 363 goodix_ts_report_touch_8b(ts, 364 &point_data[1 + ts->contact_size * i]); 365 366 input_mt_sync_frame(ts->input_dev); 367 input_sync(ts->input_dev); 368 } 369 370 /** 371 * goodix_ts_irq_handler - The IRQ handler 372 * 373 * @irq: interrupt number. 374 * @dev_id: private data pointer. 375 */ 376 static irqreturn_t goodix_ts_irq_handler(int irq, void *dev_id) 377 { 378 struct goodix_ts_data *ts = dev_id; 379 380 goodix_process_events(ts); 381 382 if (goodix_i2c_write_u8(ts->client, GOODIX_READ_COOR_ADDR, 0) < 0) 383 dev_err(&ts->client->dev, "I2C write end_cmd error\n"); 384 385 return IRQ_HANDLED; 386 } 387 388 static void goodix_free_irq(struct goodix_ts_data *ts) 389 { 390 devm_free_irq(&ts->client->dev, ts->client->irq, ts); 391 } 392 393 static int goodix_request_irq(struct goodix_ts_data *ts) 394 { 395 return devm_request_threaded_irq(&ts->client->dev, ts->client->irq, 396 NULL, goodix_ts_irq_handler, 397 ts->irq_flags, ts->client->name, ts); 398 } 399 400 static int goodix_check_cfg_8(struct goodix_ts_data *ts, 401 const struct firmware *cfg) 402 { 403 int i, raw_cfg_len = cfg->size - 2; 404 u8 check_sum = 0; 405 406 for (i = 0; i < raw_cfg_len; i++) 407 check_sum += cfg->data[i]; 408 check_sum = (~check_sum) + 1; 409 if (check_sum != cfg->data[raw_cfg_len]) { 410 dev_err(&ts->client->dev, 411 "The checksum of the config fw is not correct"); 412 return -EINVAL; 413 } 414 415 if (cfg->data[raw_cfg_len + 1] != 1) { 416 dev_err(&ts->client->dev, 417 "Config fw must have Config_Fresh register set"); 418 return -EINVAL; 419 } 420 421 return 0; 422 } 423 424 static int goodix_check_cfg_16(struct goodix_ts_data *ts, 425 const struct firmware *cfg) 426 { 427 int i, raw_cfg_len = cfg->size - 3; 428 u16 check_sum = 0; 429 430 for (i = 0; i < raw_cfg_len; i += 2) 431 check_sum += get_unaligned_be16(&cfg->data[i]); 432 check_sum = (~check_sum) + 1; 433 if (check_sum != get_unaligned_be16(&cfg->data[raw_cfg_len])) { 434 dev_err(&ts->client->dev, 435 "The checksum of the config fw is not correct"); 436 return -EINVAL; 437 } 438 439 if (cfg->data[raw_cfg_len + 2] != 1) { 440 dev_err(&ts->client->dev, 441 "Config fw must have Config_Fresh register set"); 442 return -EINVAL; 443 } 444 445 return 0; 446 } 447 448 /** 449 * goodix_check_cfg - Checks if config fw is valid 450 * 451 * @ts: goodix_ts_data pointer 452 * @cfg: firmware config data 453 */ 454 static int goodix_check_cfg(struct goodix_ts_data *ts, 455 const struct firmware *cfg) 456 { 457 if (cfg->size > GOODIX_CONFIG_MAX_LENGTH) { 458 dev_err(&ts->client->dev, 459 "The length of the config fw is not correct"); 460 return -EINVAL; 461 } 462 463 return ts->chip->check_config(ts, cfg); 464 } 465 466 /** 467 * goodix_send_cfg - Write fw config to device 468 * 469 * @ts: goodix_ts_data pointer 470 * @cfg: config firmware to write to device 471 */ 472 static int goodix_send_cfg(struct goodix_ts_data *ts, 473 const struct firmware *cfg) 474 { 475 int error; 476 477 error = goodix_check_cfg(ts, cfg); 478 if (error) 479 return error; 480 481 error = goodix_i2c_write(ts->client, ts->chip->config_addr, cfg->data, 482 cfg->size); 483 if (error) { 484 dev_err(&ts->client->dev, "Failed to write config data: %d", 485 error); 486 return error; 487 } 488 dev_dbg(&ts->client->dev, "Config sent successfully."); 489 490 /* Let the firmware reconfigure itself, so sleep for 10ms */ 491 usleep_range(10000, 11000); 492 493 return 0; 494 } 495 496 static int goodix_int_sync(struct goodix_ts_data *ts) 497 { 498 int error; 499 500 error = gpiod_direction_output(ts->gpiod_int, 0); 501 if (error) 502 return error; 503 504 msleep(50); /* T5: 50ms */ 505 506 error = gpiod_direction_input(ts->gpiod_int); 507 if (error) 508 return error; 509 510 return 0; 511 } 512 513 /** 514 * goodix_reset - Reset device during power on 515 * 516 * @ts: goodix_ts_data pointer 517 */ 518 static int goodix_reset(struct goodix_ts_data *ts) 519 { 520 int error; 521 522 /* begin select I2C slave addr */ 523 error = gpiod_direction_output(ts->gpiod_rst, 0); 524 if (error) 525 return error; 526 527 msleep(20); /* T2: > 10ms */ 528 529 /* HIGH: 0x28/0x29, LOW: 0xBA/0xBB */ 530 error = gpiod_direction_output(ts->gpiod_int, ts->client->addr == 0x14); 531 if (error) 532 return error; 533 534 usleep_range(100, 2000); /* T3: > 100us */ 535 536 error = gpiod_direction_output(ts->gpiod_rst, 1); 537 if (error) 538 return error; 539 540 usleep_range(6000, 10000); /* T4: > 5ms */ 541 542 /* end select I2C slave addr */ 543 error = gpiod_direction_input(ts->gpiod_rst); 544 if (error) 545 return error; 546 547 error = goodix_int_sync(ts); 548 if (error) 549 return error; 550 551 return 0; 552 } 553 554 /** 555 * goodix_get_gpio_config - Get GPIO config from ACPI/DT 556 * 557 * @ts: goodix_ts_data pointer 558 */ 559 static int goodix_get_gpio_config(struct goodix_ts_data *ts) 560 { 561 int error; 562 struct device *dev; 563 struct gpio_desc *gpiod; 564 565 if (!ts->client) 566 return -EINVAL; 567 dev = &ts->client->dev; 568 569 ts->avdd28 = devm_regulator_get(dev, "AVDD28"); 570 if (IS_ERR(ts->avdd28)) { 571 error = PTR_ERR(ts->avdd28); 572 if (error != -EPROBE_DEFER) 573 dev_err(dev, 574 "Failed to get AVDD28 regulator: %d\n", error); 575 return error; 576 } 577 578 ts->vddio = devm_regulator_get(dev, "VDDIO"); 579 if (IS_ERR(ts->vddio)) { 580 error = PTR_ERR(ts->vddio); 581 if (error != -EPROBE_DEFER) 582 dev_err(dev, 583 "Failed to get VDDIO regulator: %d\n", error); 584 return error; 585 } 586 587 /* Get the interrupt GPIO pin number */ 588 gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_INT_NAME, GPIOD_IN); 589 if (IS_ERR(gpiod)) { 590 error = PTR_ERR(gpiod); 591 if (error != -EPROBE_DEFER) 592 dev_dbg(dev, "Failed to get %s GPIO: %d\n", 593 GOODIX_GPIO_INT_NAME, error); 594 return error; 595 } 596 597 ts->gpiod_int = gpiod; 598 599 /* Get the reset line GPIO pin number */ 600 gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_RST_NAME, GPIOD_IN); 601 if (IS_ERR(gpiod)) { 602 error = PTR_ERR(gpiod); 603 if (error != -EPROBE_DEFER) 604 dev_dbg(dev, "Failed to get %s GPIO: %d\n", 605 GOODIX_GPIO_RST_NAME, error); 606 return error; 607 } 608 609 ts->gpiod_rst = gpiod; 610 611 return 0; 612 } 613 614 /** 615 * goodix_read_config - Read the embedded configuration of the panel 616 * 617 * @ts: our goodix_ts_data pointer 618 * 619 * Must be called during probe 620 */ 621 static void goodix_read_config(struct goodix_ts_data *ts) 622 { 623 u8 config[GOODIX_CONFIG_MAX_LENGTH]; 624 int x_max, y_max; 625 int error; 626 627 error = goodix_i2c_read(ts->client, ts->chip->config_addr, 628 config, ts->chip->config_len); 629 if (error) { 630 dev_warn(&ts->client->dev, "Error reading config: %d\n", 631 error); 632 ts->int_trigger_type = GOODIX_INT_TRIGGER; 633 ts->max_touch_num = GOODIX_MAX_CONTACTS; 634 return; 635 } 636 637 ts->int_trigger_type = config[TRIGGER_LOC] & 0x03; 638 ts->max_touch_num = config[MAX_CONTACTS_LOC] & 0x0f; 639 640 x_max = get_unaligned_le16(&config[RESOLUTION_LOC]); 641 y_max = get_unaligned_le16(&config[RESOLUTION_LOC + 2]); 642 if (x_max && y_max) { 643 input_abs_set_max(ts->input_dev, ABS_MT_POSITION_X, x_max - 1); 644 input_abs_set_max(ts->input_dev, ABS_MT_POSITION_Y, y_max - 1); 645 } 646 } 647 648 /** 649 * goodix_read_version - Read goodix touchscreen version 650 * 651 * @ts: our goodix_ts_data pointer 652 */ 653 static int goodix_read_version(struct goodix_ts_data *ts) 654 { 655 int error; 656 u8 buf[6]; 657 char id_str[5]; 658 659 error = goodix_i2c_read(ts->client, GOODIX_REG_ID, buf, sizeof(buf)); 660 if (error) { 661 dev_err(&ts->client->dev, "read version failed: %d\n", error); 662 return error; 663 } 664 665 memcpy(id_str, buf, 4); 666 id_str[4] = 0; 667 if (kstrtou16(id_str, 10, &ts->id)) 668 ts->id = 0x1001; 669 670 ts->version = get_unaligned_le16(&buf[4]); 671 672 dev_info(&ts->client->dev, "ID %d, version: %04x\n", ts->id, 673 ts->version); 674 675 return 0; 676 } 677 678 /** 679 * goodix_i2c_test - I2C test function to check if the device answers. 680 * 681 * @client: the i2c client 682 */ 683 static int goodix_i2c_test(struct i2c_client *client) 684 { 685 int retry = 0; 686 int error; 687 u8 test; 688 689 while (retry++ < 2) { 690 error = goodix_i2c_read(client, GOODIX_REG_ID, 691 &test, 1); 692 if (!error) 693 return 0; 694 695 dev_err(&client->dev, "i2c test failed attempt %d: %d\n", 696 retry, error); 697 msleep(20); 698 } 699 700 return error; 701 } 702 703 /** 704 * goodix_configure_dev - Finish device initialization 705 * 706 * @ts: our goodix_ts_data pointer 707 * 708 * Must be called from probe to finish initialization of the device. 709 * Contains the common initialization code for both devices that 710 * declare gpio pins and devices that do not. It is either called 711 * directly from probe or from request_firmware_wait callback. 712 */ 713 static int goodix_configure_dev(struct goodix_ts_data *ts) 714 { 715 int error; 716 717 ts->int_trigger_type = GOODIX_INT_TRIGGER; 718 ts->max_touch_num = GOODIX_MAX_CONTACTS; 719 720 ts->input_dev = devm_input_allocate_device(&ts->client->dev); 721 if (!ts->input_dev) { 722 dev_err(&ts->client->dev, "Failed to allocate input device."); 723 return -ENOMEM; 724 } 725 726 ts->input_dev->name = "Goodix Capacitive TouchScreen"; 727 ts->input_dev->phys = "input/ts"; 728 ts->input_dev->id.bustype = BUS_I2C; 729 ts->input_dev->id.vendor = 0x0416; 730 ts->input_dev->id.product = ts->id; 731 ts->input_dev->id.version = ts->version; 732 733 /* Capacitive Windows/Home button on some devices */ 734 input_set_capability(ts->input_dev, EV_KEY, KEY_LEFTMETA); 735 736 input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_X); 737 input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_Y); 738 input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0); 739 input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0); 740 741 /* Read configuration and apply touchscreen parameters */ 742 goodix_read_config(ts); 743 744 /* Try overriding touchscreen parameters via device properties */ 745 touchscreen_parse_properties(ts->input_dev, true, &ts->prop); 746 747 if (!ts->prop.max_x || !ts->prop.max_y || !ts->max_touch_num) { 748 dev_err(&ts->client->dev, 749 "Invalid config (%d, %d, %d), using defaults\n", 750 ts->prop.max_x, ts->prop.max_y, ts->max_touch_num); 751 ts->prop.max_x = GOODIX_MAX_WIDTH - 1; 752 ts->prop.max_y = GOODIX_MAX_HEIGHT - 1; 753 ts->max_touch_num = GOODIX_MAX_CONTACTS; 754 input_abs_set_max(ts->input_dev, 755 ABS_MT_POSITION_X, ts->prop.max_x); 756 input_abs_set_max(ts->input_dev, 757 ABS_MT_POSITION_Y, ts->prop.max_y); 758 } 759 760 if (dmi_check_system(rotated_screen)) { 761 ts->prop.invert_x = true; 762 ts->prop.invert_y = true; 763 dev_dbg(&ts->client->dev, 764 "Applying '180 degrees rotated screen' quirk\n"); 765 } 766 767 if (dmi_check_system(nine_bytes_report)) { 768 ts->contact_size = 9; 769 770 dev_dbg(&ts->client->dev, 771 "Non-standard 9-bytes report format quirk\n"); 772 } 773 774 error = input_mt_init_slots(ts->input_dev, ts->max_touch_num, 775 INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED); 776 if (error) { 777 dev_err(&ts->client->dev, 778 "Failed to initialize MT slots: %d", error); 779 return error; 780 } 781 782 error = input_register_device(ts->input_dev); 783 if (error) { 784 dev_err(&ts->client->dev, 785 "Failed to register input device: %d", error); 786 return error; 787 } 788 789 ts->irq_flags = goodix_irq_flags[ts->int_trigger_type] | IRQF_ONESHOT; 790 error = goodix_request_irq(ts); 791 if (error) { 792 dev_err(&ts->client->dev, "request IRQ failed: %d\n", error); 793 return error; 794 } 795 796 return 0; 797 } 798 799 /** 800 * goodix_config_cb - Callback to finish device init 801 * 802 * @ts: our goodix_ts_data pointer 803 * 804 * request_firmware_wait callback that finishes 805 * initialization of the device. 806 */ 807 static void goodix_config_cb(const struct firmware *cfg, void *ctx) 808 { 809 struct goodix_ts_data *ts = ctx; 810 int error; 811 812 if (cfg) { 813 /* send device configuration to the firmware */ 814 error = goodix_send_cfg(ts, cfg); 815 if (error) 816 goto err_release_cfg; 817 } 818 819 goodix_configure_dev(ts); 820 821 err_release_cfg: 822 release_firmware(cfg); 823 complete_all(&ts->firmware_loading_complete); 824 } 825 826 static void goodix_disable_regulators(void *arg) 827 { 828 struct goodix_ts_data *ts = arg; 829 830 regulator_disable(ts->vddio); 831 regulator_disable(ts->avdd28); 832 } 833 834 static int goodix_ts_probe(struct i2c_client *client, 835 const struct i2c_device_id *id) 836 { 837 struct goodix_ts_data *ts; 838 int error; 839 840 dev_dbg(&client->dev, "I2C Address: 0x%02x\n", client->addr); 841 842 if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) { 843 dev_err(&client->dev, "I2C check functionality failed.\n"); 844 return -ENXIO; 845 } 846 847 ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL); 848 if (!ts) 849 return -ENOMEM; 850 851 ts->client = client; 852 i2c_set_clientdata(client, ts); 853 init_completion(&ts->firmware_loading_complete); 854 ts->contact_size = GOODIX_CONTACT_SIZE; 855 856 error = goodix_get_gpio_config(ts); 857 if (error) 858 return error; 859 860 /* power up the controller */ 861 error = regulator_enable(ts->avdd28); 862 if (error) { 863 dev_err(&client->dev, 864 "Failed to enable AVDD28 regulator: %d\n", 865 error); 866 return error; 867 } 868 869 error = regulator_enable(ts->vddio); 870 if (error) { 871 dev_err(&client->dev, 872 "Failed to enable VDDIO regulator: %d\n", 873 error); 874 regulator_disable(ts->avdd28); 875 return error; 876 } 877 878 error = devm_add_action_or_reset(&client->dev, 879 goodix_disable_regulators, ts); 880 if (error) 881 return error; 882 883 if (ts->gpiod_int && ts->gpiod_rst) { 884 /* reset the controller */ 885 error = goodix_reset(ts); 886 if (error) { 887 dev_err(&client->dev, "Controller reset failed.\n"); 888 return error; 889 } 890 } 891 892 error = goodix_i2c_test(client); 893 if (error) { 894 dev_err(&client->dev, "I2C communication failure: %d\n", error); 895 return error; 896 } 897 898 error = goodix_read_version(ts); 899 if (error) { 900 dev_err(&client->dev, "Read version failed.\n"); 901 return error; 902 } 903 904 ts->chip = goodix_get_chip_data(ts->id); 905 906 if (ts->gpiod_int && ts->gpiod_rst) { 907 /* update device config */ 908 ts->cfg_name = devm_kasprintf(&client->dev, GFP_KERNEL, 909 "goodix_%d_cfg.bin", ts->id); 910 if (!ts->cfg_name) 911 return -ENOMEM; 912 913 error = request_firmware_nowait(THIS_MODULE, true, ts->cfg_name, 914 &client->dev, GFP_KERNEL, ts, 915 goodix_config_cb); 916 if (error) { 917 dev_err(&client->dev, 918 "Failed to invoke firmware loader: %d\n", 919 error); 920 return error; 921 } 922 923 return 0; 924 } else { 925 error = goodix_configure_dev(ts); 926 if (error) 927 return error; 928 } 929 930 return 0; 931 } 932 933 static int goodix_ts_remove(struct i2c_client *client) 934 { 935 struct goodix_ts_data *ts = i2c_get_clientdata(client); 936 937 if (ts->gpiod_int && ts->gpiod_rst) 938 wait_for_completion(&ts->firmware_loading_complete); 939 940 return 0; 941 } 942 943 static int __maybe_unused goodix_suspend(struct device *dev) 944 { 945 struct i2c_client *client = to_i2c_client(dev); 946 struct goodix_ts_data *ts = i2c_get_clientdata(client); 947 int error; 948 949 /* We need gpio pins to suspend/resume */ 950 if (!ts->gpiod_int || !ts->gpiod_rst) { 951 disable_irq(client->irq); 952 return 0; 953 } 954 955 wait_for_completion(&ts->firmware_loading_complete); 956 957 /* Free IRQ as IRQ pin is used as output in the suspend sequence */ 958 goodix_free_irq(ts); 959 960 /* Output LOW on the INT pin for 5 ms */ 961 error = gpiod_direction_output(ts->gpiod_int, 0); 962 if (error) { 963 goodix_request_irq(ts); 964 return error; 965 } 966 967 usleep_range(5000, 6000); 968 969 error = goodix_i2c_write_u8(ts->client, GOODIX_REG_COMMAND, 970 GOODIX_CMD_SCREEN_OFF); 971 if (error) { 972 dev_err(&ts->client->dev, "Screen off command failed\n"); 973 gpiod_direction_input(ts->gpiod_int); 974 goodix_request_irq(ts); 975 return -EAGAIN; 976 } 977 978 /* 979 * The datasheet specifies that the interval between sending screen-off 980 * command and wake-up should be longer than 58 ms. To avoid waking up 981 * sooner, delay 58ms here. 982 */ 983 msleep(58); 984 return 0; 985 } 986 987 static int __maybe_unused goodix_resume(struct device *dev) 988 { 989 struct i2c_client *client = to_i2c_client(dev); 990 struct goodix_ts_data *ts = i2c_get_clientdata(client); 991 int error; 992 993 if (!ts->gpiod_int || !ts->gpiod_rst) { 994 enable_irq(client->irq); 995 return 0; 996 } 997 998 /* 999 * Exit sleep mode by outputting HIGH level to INT pin 1000 * for 2ms~5ms. 1001 */ 1002 error = gpiod_direction_output(ts->gpiod_int, 1); 1003 if (error) 1004 return error; 1005 1006 usleep_range(2000, 5000); 1007 1008 error = goodix_int_sync(ts); 1009 if (error) 1010 return error; 1011 1012 error = goodix_request_irq(ts); 1013 if (error) 1014 return error; 1015 1016 return 0; 1017 } 1018 1019 static SIMPLE_DEV_PM_OPS(goodix_pm_ops, goodix_suspend, goodix_resume); 1020 1021 static const struct i2c_device_id goodix_ts_id[] = { 1022 { "GDIX1001:00", 0 }, 1023 { } 1024 }; 1025 MODULE_DEVICE_TABLE(i2c, goodix_ts_id); 1026 1027 #ifdef CONFIG_ACPI 1028 static const struct acpi_device_id goodix_acpi_match[] = { 1029 { "GDIX1001", 0 }, 1030 { "GDIX1002", 0 }, 1031 { } 1032 }; 1033 MODULE_DEVICE_TABLE(acpi, goodix_acpi_match); 1034 #endif 1035 1036 #ifdef CONFIG_OF 1037 static const struct of_device_id goodix_of_match[] = { 1038 { .compatible = "goodix,gt1151" }, 1039 { .compatible = "goodix,gt5663" }, 1040 { .compatible = "goodix,gt5688" }, 1041 { .compatible = "goodix,gt911" }, 1042 { .compatible = "goodix,gt9110" }, 1043 { .compatible = "goodix,gt912" }, 1044 { .compatible = "goodix,gt927" }, 1045 { .compatible = "goodix,gt9271" }, 1046 { .compatible = "goodix,gt928" }, 1047 { .compatible = "goodix,gt967" }, 1048 { } 1049 }; 1050 MODULE_DEVICE_TABLE(of, goodix_of_match); 1051 #endif 1052 1053 static struct i2c_driver goodix_ts_driver = { 1054 .probe = goodix_ts_probe, 1055 .remove = goodix_ts_remove, 1056 .id_table = goodix_ts_id, 1057 .driver = { 1058 .name = "Goodix-TS", 1059 .acpi_match_table = ACPI_PTR(goodix_acpi_match), 1060 .of_match_table = of_match_ptr(goodix_of_match), 1061 .pm = &goodix_pm_ops, 1062 }, 1063 }; 1064 module_i2c_driver(goodix_ts_driver); 1065 1066 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>"); 1067 MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>"); 1068 MODULE_DESCRIPTION("Goodix touchscreen driver"); 1069 MODULE_LICENSE("GPL v2"); 1070