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