drivers/input/touchscreen/goodix.c

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