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         /*
 271          * Bit 4 of the first byte reports the status of the capacitive
 272          * Windows/Home button.
 273          */
 274         input_report_key(ts->input_dev, KEY_LEFTMETA, point_data[0] & BIT(4));
 275
 276         for (i = 0; i < touch_num; i++)
 277                 goodix_ts_report_touch(ts,
 278                                 &point_data[1 + GOODIX_CONTACT_SIZE * i]);
 279
 280         input_mt_sync_frame(ts->input_dev);
 281         input_sync(ts->input_dev);
 282 }
 283
 284 /**
 285  * goodix_ts_irq_handler - The IRQ handler
 286  *
 287  * @irq: interrupt number.
 288  * @dev_id: private data pointer.
 289  */
 290 static irqreturn_t goodix_ts_irq_handler(int irq, void *dev_id)
 291 {
 292         struct goodix_ts_data *ts = dev_id;
 293
 294         goodix_process_events(ts);
 295
 296         if (goodix_i2c_write_u8(ts->client, GOODIX_READ_COOR_ADDR, 0) < 0)
 297                 dev_err(&ts->client->dev, "I2C write end_cmd error\n");
 298
 299         return IRQ_HANDLED;
 300 }
 301
 302 static void goodix_free_irq(struct goodix_ts_data *ts)
 303 {
 304         devm_free_irq(&ts->client->dev, ts->client->irq, ts);
 305 }
 306
 307 static int goodix_request_irq(struct goodix_ts_data *ts)
 308 {
 309         return devm_request_threaded_irq(&ts->client->dev, ts->client->irq,
 310                                          NULL, goodix_ts_irq_handler,
 311                                          ts->irq_flags, ts->client->name, ts);
 312 }
 313
 314 /**
 315  * goodix_check_cfg - Checks if config fw is valid
 316  *
 317  * @ts: goodix_ts_data pointer
 318  * @cfg: firmware config data
 319  */
 320 static int goodix_check_cfg(struct goodix_ts_data *ts,
 321                             const struct firmware *cfg)
 322 {
 323         int i, raw_cfg_len;
 324         u8 check_sum = 0;
 325
 326         if (cfg->size > GOODIX_CONFIG_MAX_LENGTH) {
 327                 dev_err(&ts->client->dev,
 328                         "The length of the config fw is not correct");
 329                 return -EINVAL;
 330         }
 331
 332         raw_cfg_len = cfg->size - 2;
 333         for (i = 0; i < raw_cfg_len; i++)
 334                 check_sum += cfg->data[i];
 335         check_sum = (~check_sum) + 1;
 336         if (check_sum != cfg->data[raw_cfg_len]) {
 337                 dev_err(&ts->client->dev,
 338                         "The checksum of the config fw is not correct");
 339                 return -EINVAL;
 340         }
 341
 342         if (cfg->data[raw_cfg_len + 1] != 1) {
 343                 dev_err(&ts->client->dev,
 344                         "Config fw must have Config_Fresh register set");
 345                 return -EINVAL;
 346         }
 347
 348         return 0;
 349 }
 350
 351 /**
 352  * goodix_send_cfg - Write fw config to device
 353  *
 354  * @ts: goodix_ts_data pointer
 355  * @cfg: config firmware to write to device
 356  */
 357 static int goodix_send_cfg(struct goodix_ts_data *ts,
 358                            const struct firmware *cfg)
 359 {
 360         int error;
 361
 362         error = goodix_check_cfg(ts, cfg);
 363         if (error)
 364                 return error;
 365
 366         error = goodix_i2c_write(ts->client, GOODIX_REG_CONFIG_DATA, cfg->data,
 367                                  cfg->size);
 368         if (error) {
 369                 dev_err(&ts->client->dev, "Failed to write config data: %d",
 370                         error);
 371                 return error;
 372         }
 373         dev_dbg(&ts->client->dev, "Config sent successfully.");
 374
 375         /* Let the firmware reconfigure itself, so sleep for 10ms */
 376         usleep_range(10000, 11000);
 377
 378         return 0;
 379 }
 380
 381 static int goodix_int_sync(struct goodix_ts_data *ts)
 382 {
 383         int error;
 384
 385         error = gpiod_direction_output(ts->gpiod_int, 0);
 386         if (error)
 387                 return error;
 388
 389         msleep(50);                             /* T5: 50ms */
 390
 391         error = gpiod_direction_input(ts->gpiod_int);
 392         if (error)
 393                 return error;
 394
 395         return 0;
 396 }
 397
 398 /**
 399  * goodix_reset - Reset device during power on
 400  *
 401  * @ts: goodix_ts_data pointer
 402  */
 403 static int goodix_reset(struct goodix_ts_data *ts)
 404 {
 405         int error;
 406
 407         /* begin select I2C slave addr */
 408         error = gpiod_direction_output(ts->gpiod_rst, 0);
 409         if (error)
 410                 return error;
 411
 412         msleep(20);                             /* T2: > 10ms */
 413
 414         /* HIGH: 0x28/0x29, LOW: 0xBA/0xBB */
 415         error = gpiod_direction_output(ts->gpiod_int, ts->client->addr == 0x14);
 416         if (error)
 417                 return error;
 418
 419         usleep_range(100, 2000);                /* T3: > 100us */
 420
 421         error = gpiod_direction_output(ts->gpiod_rst, 1);
 422         if (error)
 423                 return error;
 424
 425         usleep_range(6000, 10000);              /* T4: > 5ms */
 426
 427         /* end select I2C slave addr */
 428         error = gpiod_direction_input(ts->gpiod_rst);
 429         if (error)
 430                 return error;
 431
 432         error = goodix_int_sync(ts);
 433         if (error)
 434                 return error;
 435
 436         return 0;
 437 }
 438
 439 /**
 440  * goodix_get_gpio_config - Get GPIO config from ACPI/DT
 441  *
 442  * @ts: goodix_ts_data pointer
 443  */
 444 static int goodix_get_gpio_config(struct goodix_ts_data *ts)
 445 {
 446         int error;
 447         struct device *dev;
 448         struct gpio_desc *gpiod;
 449
 450         if (!ts->client)
 451                 return -EINVAL;
 452         dev = &ts->client->dev;
 453
 454         /* Get the interrupt GPIO pin number */
 455         gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_INT_NAME, GPIOD_IN);
 456         if (IS_ERR(gpiod)) {
 457                 error = PTR_ERR(gpiod);
 458                 if (error != -EPROBE_DEFER)
 459                         dev_dbg(dev, "Failed to get %s GPIO: %d\n",
 460                                 GOODIX_GPIO_INT_NAME, error);
 461                 return error;
 462         }
 463
 464         ts->gpiod_int = gpiod;
 465
 466         /* Get the reset line GPIO pin number */
 467         gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_RST_NAME, GPIOD_IN);
 468         if (IS_ERR(gpiod)) {
 469                 error = PTR_ERR(gpiod);
 470                 if (error != -EPROBE_DEFER)
 471                         dev_dbg(dev, "Failed to get %s GPIO: %d\n",
 472                                 GOODIX_GPIO_RST_NAME, error);
 473                 return error;
 474         }
 475
 476         ts->gpiod_rst = gpiod;
 477
 478         return 0;
 479 }
 480
 481 /**
 482  * goodix_read_config - Read the embedded configuration of the panel
 483  *
 484  * @ts: our goodix_ts_data pointer
 485  *
 486  * Must be called during probe
 487  */
 488 static void goodix_read_config(struct goodix_ts_data *ts)
 489 {
 490         u8 config[GOODIX_CONFIG_MAX_LENGTH];
 491         int error;
 492
 493         error = goodix_i2c_read(ts->client, GOODIX_REG_CONFIG_DATA,
 494                                 config, ts->cfg_len);
 495         if (error) {
 496                 dev_warn(&ts->client->dev,
 497                          "Error reading config (%d), using defaults\n",
 498                          error);
 499                 ts->abs_x_max = GOODIX_MAX_WIDTH;
 500                 ts->abs_y_max = GOODIX_MAX_HEIGHT;
 501                 if (ts->swapped_x_y)
 502                         swap(ts->abs_x_max, ts->abs_y_max);
 503                 ts->int_trigger_type = GOODIX_INT_TRIGGER;
 504                 ts->max_touch_num = GOODIX_MAX_CONTACTS;
 505                 return;
 506         }
 507
 508         ts->abs_x_max = get_unaligned_le16(&config[RESOLUTION_LOC]);
 509         ts->abs_y_max = get_unaligned_le16(&config[RESOLUTION_LOC + 2]);
 510         if (ts->swapped_x_y)
 511                 swap(ts->abs_x_max, ts->abs_y_max);
 512         ts->int_trigger_type = config[TRIGGER_LOC] & 0x03;
 513         ts->max_touch_num = config[MAX_CONTACTS_LOC] & 0x0f;
 514         if (!ts->abs_x_max || !ts->abs_y_max || !ts->max_touch_num) {
 515                 dev_err(&ts->client->dev,
 516                         "Invalid config, using defaults\n");
 517                 ts->abs_x_max = GOODIX_MAX_WIDTH;
 518                 ts->abs_y_max = GOODIX_MAX_HEIGHT;
 519                 if (ts->swapped_x_y)
 520                         swap(ts->abs_x_max, ts->abs_y_max);
 521                 ts->max_touch_num = GOODIX_MAX_CONTACTS;
 522         }
 523
 524         if (dmi_check_system(rotated_screen)) {
 525                 ts->inverted_x = true;
 526                 ts->inverted_y = true;
 527                 dev_dbg(&ts->client->dev,
 528                          "Applying '180 degrees rotated screen' quirk\n");
 529         }
 530 }
 531
 532 /**
 533  * goodix_read_version - Read goodix touchscreen version
 534  *
 535  * @ts: our goodix_ts_data pointer
 536  */
 537 static int goodix_read_version(struct goodix_ts_data *ts)
 538 {
 539         int error;
 540         u8 buf[6];
 541         char id_str[5];
 542
 543         error = goodix_i2c_read(ts->client, GOODIX_REG_ID, buf, sizeof(buf));
 544         if (error) {
 545                 dev_err(&ts->client->dev, "read version failed: %d\n", error);
 546                 return error;
 547         }
 548
 549         memcpy(id_str, buf, 4);
 550         id_str[4] = 0;
 551         if (kstrtou16(id_str, 10, &ts->id))
 552                 ts->id = 0x1001;
 553
 554         ts->version = get_unaligned_le16(&buf[4]);
 555
 556         dev_info(&ts->client->dev, "ID %d, version: %04x\n", ts->id,
 557                  ts->version);
 558
 559         return 0;
 560 }
 561
 562 /**
 563  * goodix_i2c_test - I2C test function to check if the device answers.
 564  *
 565  * @client: the i2c client
 566  */
 567 static int goodix_i2c_test(struct i2c_client *client)
 568 {
 569         int retry = 0;
 570         int error;
 571         u8 test;
 572
 573         while (retry++ < 2) {
 574                 error = goodix_i2c_read(client, GOODIX_REG_CONFIG_DATA,
 575                                         &test, 1);
 576                 if (!error)
 577                         return 0;
 578
 579                 dev_err(&client->dev, "i2c test failed attempt %d: %d\n",
 580                         retry, error);
 581                 msleep(20);
 582         }
 583
 584         return error;
 585 }
 586
 587 /**
 588  * goodix_request_input_dev - Allocate, populate and register the input device
 589  *
 590  * @ts: our goodix_ts_data pointer
 591  *
 592  * Must be called during probe
 593  */
 594 static int goodix_request_input_dev(struct goodix_ts_data *ts)
 595 {
 596         int error;
 597
 598         ts->input_dev = devm_input_allocate_device(&ts->client->dev);
 599         if (!ts->input_dev) {
 600                 dev_err(&ts->client->dev, "Failed to allocate input device.");
 601                 return -ENOMEM;
 602         }
 603
 604         input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X,
 605                              0, ts->abs_x_max, 0, 0);
 606         input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y,
 607                              0, ts->abs_y_max, 0, 0);
 608         input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
 609         input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
 610
 611         input_mt_init_slots(ts->input_dev, ts->max_touch_num,
 612                             INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
 613
 614         ts->input_dev->name = "Goodix Capacitive TouchScreen";
 615         ts->input_dev->phys = "input/ts";
 616         ts->input_dev->id.bustype = BUS_I2C;
 617         ts->input_dev->id.vendor = 0x0416;
 618         ts->input_dev->id.product = ts->id;
 619         ts->input_dev->id.version = ts->version;
 620
 621         /* Capacitive Windows/Home button on some devices */
 622         input_set_capability(ts->input_dev, EV_KEY, KEY_LEFTMETA);
 623
 624         error = input_register_device(ts->input_dev);
 625         if (error) {
 626                 dev_err(&ts->client->dev,
 627                         "Failed to register input device: %d", error);
 628                 return error;
 629         }
 630
 631         return 0;
 632 }
 633
 634 /**
 635  * goodix_configure_dev - Finish device initialization
 636  *
 637  * @ts: our goodix_ts_data pointer
 638  *
 639  * Must be called from probe to finish initialization of the device.
 640  * Contains the common initialization code for both devices that
 641  * declare gpio pins and devices that do not. It is either called
 642  * directly from probe or from request_firmware_wait callback.
 643  */
 644 static int goodix_configure_dev(struct goodix_ts_data *ts)
 645 {
 646         int error;
 647
 648         ts->swapped_x_y = device_property_read_bool(&ts->client->dev,
 649                                                     "touchscreen-swapped-x-y");
 650         ts->inverted_x = device_property_read_bool(&ts->client->dev,
 651                                                    "touchscreen-inverted-x");
 652         ts->inverted_y = device_property_read_bool(&ts->client->dev,
 653                                                    "touchscreen-inverted-y");
 654
 655         goodix_read_config(ts);
 656
 657         error = goodix_request_input_dev(ts);
 658         if (error)
 659                 return error;
 660
 661         ts->irq_flags = goodix_irq_flags[ts->int_trigger_type] | IRQF_ONESHOT;
 662         error = goodix_request_irq(ts);
 663         if (error) {
 664                 dev_err(&ts->client->dev, "request IRQ failed: %d\n", error);
 665                 return error;
 666         }
 667
 668         return 0;
 669 }
 670
 671 /**
 672  * goodix_config_cb - Callback to finish device init
 673  *
 674  * @ts: our goodix_ts_data pointer
 675  *
 676  * request_firmware_wait callback that finishes
 677  * initialization of the device.
 678  */
 679 static void goodix_config_cb(const struct firmware *cfg, void *ctx)
 680 {
 681         struct goodix_ts_data *ts = ctx;
 682         int error;
 683
 684         if (cfg) {
 685                 /* send device configuration to the firmware */
 686                 error = goodix_send_cfg(ts, cfg);
 687                 if (error)
 688                         goto err_release_cfg;
 689         }
 690
 691         goodix_configure_dev(ts);
 692
 693 err_release_cfg:
 694         release_firmware(cfg);
 695         complete_all(&ts->firmware_loading_complete);
 696 }
 697
 698 static int goodix_ts_probe(struct i2c_client *client,
 699                            const struct i2c_device_id *id)
 700 {
 701         struct goodix_ts_data *ts;
 702         int error;
 703
 704         dev_dbg(&client->dev, "I2C Address: 0x%02x\n", client->addr);
 705
 706         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
 707                 dev_err(&client->dev, "I2C check functionality failed.\n");
 708                 return -ENXIO;
 709         }
 710
 711         ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);
 712         if (!ts)
 713                 return -ENOMEM;
 714
 715         ts->client = client;
 716         i2c_set_clientdata(client, ts);
 717         init_completion(&ts->firmware_loading_complete);
 718
 719         error = goodix_get_gpio_config(ts);
 720         if (error)
 721                 return error;
 722
 723         if (ts->gpiod_int && ts->gpiod_rst) {
 724                 /* reset the controller */
 725                 error = goodix_reset(ts);
 726                 if (error) {
 727                         dev_err(&client->dev, "Controller reset failed.\n");
 728                         return error;
 729                 }
 730         }
 731
 732         error = goodix_i2c_test(client);
 733         if (error) {
 734                 dev_err(&client->dev, "I2C communication failure: %d\n", error);
 735                 return error;
 736         }
 737
 738         error = goodix_read_version(ts);
 739         if (error) {
 740                 dev_err(&client->dev, "Read version failed.\n");
 741                 return error;
 742         }
 743
 744         ts->cfg_len = goodix_get_cfg_len(ts->id);
 745
 746         if (ts->gpiod_int && ts->gpiod_rst) {
 747                 /* update device config */
 748                 ts->cfg_name = devm_kasprintf(&client->dev, GFP_KERNEL,
 749                                               "goodix_%d_cfg.bin", ts->id);
 750                 if (!ts->cfg_name)
 751                         return -ENOMEM;
 752
 753                 error = request_firmware_nowait(THIS_MODULE, true, ts->cfg_name,
 754                                                 &client->dev, GFP_KERNEL, ts,
 755                                                 goodix_config_cb);
 756                 if (error) {
 757                         dev_err(&client->dev,
 758                                 "Failed to invoke firmware loader: %d\n",
 759                                 error);
 760                         return error;
 761                 }
 762
 763                 return 0;
 764         } else {
 765                 error = goodix_configure_dev(ts);
 766                 if (error)
 767                         return error;
 768         }
 769
 770         return 0;
 771 }
 772
 773 static int goodix_ts_remove(struct i2c_client *client)
 774 {
 775         struct goodix_ts_data *ts = i2c_get_clientdata(client);
 776
 777         if (ts->gpiod_int && ts->gpiod_rst)
 778                 wait_for_completion(&ts->firmware_loading_complete);
 779
 780         return 0;
 781 }
 782
 783 static int __maybe_unused goodix_suspend(struct device *dev)
 784 {
 785         struct i2c_client *client = to_i2c_client(dev);
 786         struct goodix_ts_data *ts = i2c_get_clientdata(client);
 787         int error;
 788
 789         /* We need gpio pins to suspend/resume */
 790         if (!ts->gpiod_int || !ts->gpiod_rst)
 791                 return 0;
 792
 793         wait_for_completion(&ts->firmware_loading_complete);
 794
 795         /* Free IRQ as IRQ pin is used as output in the suspend sequence */
 796         goodix_free_irq(ts);
 797
 798         /* Output LOW on the INT pin for 5 ms */
 799         error = gpiod_direction_output(ts->gpiod_int, 0);
 800         if (error) {
 801                 goodix_request_irq(ts);
 802                 return error;
 803         }
 804
 805         usleep_range(5000, 6000);
 806
 807         error = goodix_i2c_write_u8(ts->client, GOODIX_REG_COMMAND,
 808                                     GOODIX_CMD_SCREEN_OFF);
 809         if (error) {
 810                 dev_err(&ts->client->dev, "Screen off command failed\n");
 811                 gpiod_direction_input(ts->gpiod_int);
 812                 goodix_request_irq(ts);
 813                 return -EAGAIN;
 814         }
 815
 816         /*
 817          * The datasheet specifies that the interval between sending screen-off
 818          * command and wake-up should be longer than 58 ms. To avoid waking up
 819          * sooner, delay 58ms here.
 820          */
 821         msleep(58);
 822         return 0;
 823 }
 824
 825 static int __maybe_unused goodix_resume(struct device *dev)
 826 {
 827         struct i2c_client *client = to_i2c_client(dev);
 828         struct goodix_ts_data *ts = i2c_get_clientdata(client);
 829         int error;
 830
 831         if (!ts->gpiod_int || !ts->gpiod_rst)
 832                 return 0;
 833
 834         /*
 835          * Exit sleep mode by outputting HIGH level to INT pin
 836          * for 2ms~5ms.
 837          */
 838         error = gpiod_direction_output(ts->gpiod_int, 1);
 839         if (error)
 840                 return error;
 841
 842         usleep_range(2000, 5000);
 843
 844         error = goodix_int_sync(ts);
 845         if (error)
 846                 return error;
 847
 848         error = goodix_request_irq(ts);
 849         if (error)
 850                 return error;
 851
 852         return 0;
 853 }
 854
 855 static SIMPLE_DEV_PM_OPS(goodix_pm_ops, goodix_suspend, goodix_resume);
 856
 857 static const struct i2c_device_id goodix_ts_id[] = {
 858         { "GDIX1001:00", 0 },
 859         { }
 860 };
 861 MODULE_DEVICE_TABLE(i2c, goodix_ts_id);
 862
 863 #ifdef CONFIG_ACPI
 864 static const struct acpi_device_id goodix_acpi_match[] = {
 865         { "GDIX1001", 0 },
 866         { }
 867 };
 868 MODULE_DEVICE_TABLE(acpi, goodix_acpi_match);
 869 #endif
 870
 871 #ifdef CONFIG_OF
 872 static const struct of_device_id goodix_of_match[] = {
 873         { .compatible = "goodix,gt911" },
 874         { .compatible = "goodix,gt9110" },
 875         { .compatible = "goodix,gt912" },
 876         { .compatible = "goodix,gt927" },
 877         { .compatible = "goodix,gt9271" },
 878         { .compatible = "goodix,gt928" },
 879         { .compatible = "goodix,gt967" },
 880         { }
 881 };
 882 MODULE_DEVICE_TABLE(of, goodix_of_match);
 883 #endif
 884
 885 static struct i2c_driver goodix_ts_driver = {
 886         .probe = goodix_ts_probe,
 887         .remove = goodix_ts_remove,
 888         .id_table = goodix_ts_id,
 889         .driver = {
 890                 .name = "Goodix-TS",
 891                 .acpi_match_table = ACPI_PTR(goodix_acpi_match),
 892                 .of_match_table = of_match_ptr(goodix_of_match),
 893                 .pm = &goodix_pm_ops,
 894         },
 895 };
 896 module_i2c_driver(goodix_ts_driver);
 897
 898 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
 899 MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
 900 MODULE_DESCRIPTION("Goodix touchscreen driver");
 901 MODULE_LICENSE("GPL v2");