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 = "Teclast X89",
  94                 .matches = {
  95                         /* tPAD is too generic, also match on bios date */
  96                         DMI_MATCH(DMI_BOARD_VENDOR, "TECLAST"),
  97                         DMI_MATCH(DMI_BOARD_NAME, "tPAD"),
  98                         DMI_MATCH(DMI_BIOS_DATE, "12/19/2014"),
  99                 },
 100         },
 101         {
 102                 .ident = "WinBook TW100",
 103                 .matches = {
 104                         DMI_MATCH(DMI_SYS_VENDOR, "WinBook"),
 105                         DMI_MATCH(DMI_PRODUCT_NAME, "TW100")
 106                 }
 107         },
 108         {
 109                 .ident = "WinBook TW700",
 110                 .matches = {
 111                         DMI_MATCH(DMI_SYS_VENDOR, "WinBook"),
 112                         DMI_MATCH(DMI_PRODUCT_NAME, "TW700")
 113                 },
 114         },
 115 #endif
 116         {}
 117 };
 118
 119 /**
 120  * goodix_i2c_read - read data from a register of the i2c slave device.
 121  *
 122  * @client: i2c device.
 123  * @reg: the register to read from.
 124  * @buf: raw write data buffer.
 125  * @len: length of the buffer to write
 126  */
 127 static int goodix_i2c_read(struct i2c_client *client,
 128                            u16 reg, u8 *buf, int len)
 129 {
 130         struct i2c_msg msgs[2];
 131         u16 wbuf = cpu_to_be16(reg);
 132         int ret;
 133
 134         msgs[0].flags = 0;
 135         msgs[0].addr  = client->addr;
 136         msgs[0].len   = 2;
 137         msgs[0].buf   = (u8 *)&wbuf;
 138
 139         msgs[1].flags = I2C_M_RD;
 140         msgs[1].addr  = client->addr;
 141         msgs[1].len   = len;
 142         msgs[1].buf   = buf;
 143
 144         ret = i2c_transfer(client->adapter, msgs, 2);
 145         return ret < 0 ? ret : (ret != ARRAY_SIZE(msgs) ? -EIO : 0);
 146 }
 147
 148 /**
 149  * goodix_i2c_write - write data to a register of the i2c slave device.
 150  *
 151  * @client: i2c device.
 152  * @reg: the register to write to.
 153  * @buf: raw data buffer to write.
 154  * @len: length of the buffer to write
 155  */
 156 static int goodix_i2c_write(struct i2c_client *client, u16 reg, const u8 *buf,
 157                             unsigned len)
 158 {
 159         u8 *addr_buf;
 160         struct i2c_msg msg;
 161         int ret;
 162
 163         addr_buf = kmalloc(len + 2, GFP_KERNEL);
 164         if (!addr_buf)
 165                 return -ENOMEM;
 166
 167         addr_buf[0] = reg >> 8;
 168         addr_buf[1] = reg & 0xFF;
 169         memcpy(&addr_buf[2], buf, len);
 170
 171         msg.flags = 0;
 172         msg.addr = client->addr;
 173         msg.buf = addr_buf;
 174         msg.len = len + 2;
 175
 176         ret = i2c_transfer(client->adapter, &msg, 1);
 177         kfree(addr_buf);
 178         return ret < 0 ? ret : (ret != 1 ? -EIO : 0);
 179 }
 180
 181 static int goodix_i2c_write_u8(struct i2c_client *client, u16 reg, u8 value)
 182 {
 183         return goodix_i2c_write(client, reg, &value, sizeof(value));
 184 }
 185
 186 static int goodix_get_cfg_len(u16 id)
 187 {
 188         switch (id) {
 189         case 911:
 190         case 9271:
 191         case 9110:
 192         case 927:
 193         case 928:
 194                 return GOODIX_CONFIG_911_LENGTH;
 195
 196         case 912:
 197         case 967:
 198                 return GOODIX_CONFIG_967_LENGTH;
 199
 200         default:
 201                 return GOODIX_CONFIG_MAX_LENGTH;
 202         }
 203 }
 204
 205 static int goodix_ts_read_input_report(struct goodix_ts_data *ts, u8 *data)
 206 {
 207         int touch_num;
 208         int error;
 209
 210         error = goodix_i2c_read(ts->client, GOODIX_READ_COOR_ADDR, data,
 211                                 GOODIX_CONTACT_SIZE + 1);
 212         if (error) {
 213                 dev_err(&ts->client->dev, "I2C transfer error: %d\n", error);
 214                 return error;
 215         }
 216
 217         if (!(data[0] & 0x80))
 218                 return -EAGAIN;
 219
 220         touch_num = data[0] & 0x0f;
 221         if (touch_num > ts->max_touch_num)
 222                 return -EPROTO;
 223
 224         if (touch_num > 1) {
 225                 data += 1 + GOODIX_CONTACT_SIZE;
 226                 error = goodix_i2c_read(ts->client,
 227                                         GOODIX_READ_COOR_ADDR +
 228                                                 1 + GOODIX_CONTACT_SIZE,
 229                                         data,
 230                                         GOODIX_CONTACT_SIZE * (touch_num - 1));
 231                 if (error)
 232                         return error;
 233         }
 234
 235         return touch_num;
 236 }
 237
 238 static void goodix_ts_report_touch(struct goodix_ts_data *ts, u8 *coor_data)
 239 {
 240         int id = coor_data[0] & 0x0F;
 241         int input_x = get_unaligned_le16(&coor_data[1]);
 242         int input_y = get_unaligned_le16(&coor_data[3]);
 243         int input_w = get_unaligned_le16(&coor_data[5]);
 244
 245         /* Inversions have to happen before axis swapping */
 246         if (ts->inverted_x)
 247                 input_x = ts->abs_x_max - input_x;
 248         if (ts->inverted_y)
 249                 input_y = ts->abs_y_max - input_y;
 250         if (ts->swapped_x_y)
 251                 swap(input_x, input_y);
 252
 253         input_mt_slot(ts->input_dev, id);
 254         input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
 255         input_report_abs(ts->input_dev, ABS_MT_POSITION_X, input_x);
 256         input_report_abs(ts->input_dev, ABS_MT_POSITION_Y, input_y);
 257         input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);
 258         input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);
 259 }
 260
 261 /**
 262  * goodix_process_events - Process incoming events
 263  *
 264  * @ts: our goodix_ts_data pointer
 265  *
 266  * Called when the IRQ is triggered. Read the current device state, and push
 267  * the input events to the user space.
 268  */
 269 static void goodix_process_events(struct goodix_ts_data *ts)
 270 {
 271         u8  point_data[1 + GOODIX_CONTACT_SIZE * GOODIX_MAX_CONTACTS];
 272         int touch_num;
 273         int i;
 274
 275         touch_num = goodix_ts_read_input_report(ts, point_data);
 276         if (touch_num < 0)
 277                 return;
 278
 279         for (i = 0; i < touch_num; i++)
 280                 goodix_ts_report_touch(ts,
 281                                 &point_data[1 + GOODIX_CONTACT_SIZE * i]);
 282
 283         input_mt_sync_frame(ts->input_dev);
 284         input_sync(ts->input_dev);
 285 }
 286
 287 /**
 288  * goodix_ts_irq_handler - The IRQ handler
 289  *
 290  * @irq: interrupt number.
 291  * @dev_id: private data pointer.
 292  */
 293 static irqreturn_t goodix_ts_irq_handler(int irq, void *dev_id)
 294 {
 295         struct goodix_ts_data *ts = dev_id;
 296
 297         goodix_process_events(ts);
 298
 299         if (goodix_i2c_write_u8(ts->client, GOODIX_READ_COOR_ADDR, 0) < 0)
 300                 dev_err(&ts->client->dev, "I2C write end_cmd error\n");
 301
 302         return IRQ_HANDLED;
 303 }
 304
 305 static void goodix_free_irq(struct goodix_ts_data *ts)
 306 {
 307         devm_free_irq(&ts->client->dev, ts->client->irq, ts);
 308 }
 309
 310 static int goodix_request_irq(struct goodix_ts_data *ts)
 311 {
 312         return devm_request_threaded_irq(&ts->client->dev, ts->client->irq,
 313                                          NULL, goodix_ts_irq_handler,
 314                                          ts->irq_flags, ts->client->name, ts);
 315 }
 316
 317 /**
 318  * goodix_check_cfg - Checks if config fw is valid
 319  *
 320  * @ts: goodix_ts_data pointer
 321  * @cfg: firmware config data
 322  */
 323 static int goodix_check_cfg(struct goodix_ts_data *ts,
 324                             const struct firmware *cfg)
 325 {
 326         int i, raw_cfg_len;
 327         u8 check_sum = 0;
 328
 329         if (cfg->size > GOODIX_CONFIG_MAX_LENGTH) {
 330                 dev_err(&ts->client->dev,
 331                         "The length of the config fw is not correct");
 332                 return -EINVAL;
 333         }
 334
 335         raw_cfg_len = cfg->size - 2;
 336         for (i = 0; i < raw_cfg_len; i++)
 337                 check_sum += cfg->data[i];
 338         check_sum = (~check_sum) + 1;
 339         if (check_sum != cfg->data[raw_cfg_len]) {
 340                 dev_err(&ts->client->dev,
 341                         "The checksum of the config fw is not correct");
 342                 return -EINVAL;
 343         }
 344
 345         if (cfg->data[raw_cfg_len + 1] != 1) {
 346                 dev_err(&ts->client->dev,
 347                         "Config fw must have Config_Fresh register set");
 348                 return -EINVAL;
 349         }
 350
 351         return 0;
 352 }
 353
 354 /**
 355  * goodix_send_cfg - Write fw config to device
 356  *
 357  * @ts: goodix_ts_data pointer
 358  * @cfg: config firmware to write to device
 359  */
 360 static int goodix_send_cfg(struct goodix_ts_data *ts,
 361                            const struct firmware *cfg)
 362 {
 363         int error;
 364
 365         error = goodix_check_cfg(ts, cfg);
 366         if (error)
 367                 return error;
 368
 369         error = goodix_i2c_write(ts->client, GOODIX_REG_CONFIG_DATA, cfg->data,
 370                                  cfg->size);
 371         if (error) {
 372                 dev_err(&ts->client->dev, "Failed to write config data: %d",
 373                         error);
 374                 return error;
 375         }
 376         dev_dbg(&ts->client->dev, "Config sent successfully.");
 377
 378         /* Let the firmware reconfigure itself, so sleep for 10ms */
 379         usleep_range(10000, 11000);
 380
 381         return 0;
 382 }
 383
 384 static int goodix_int_sync(struct goodix_ts_data *ts)
 385 {
 386         int error;
 387
 388         error = gpiod_direction_output(ts->gpiod_int, 0);
 389         if (error)
 390                 return error;
 391
 392         msleep(50);                             /* T5: 50ms */
 393
 394         error = gpiod_direction_input(ts->gpiod_int);
 395         if (error)
 396                 return error;
 397
 398         return 0;
 399 }
 400
 401 /**
 402  * goodix_reset - Reset device during power on
 403  *
 404  * @ts: goodix_ts_data pointer
 405  */
 406 static int goodix_reset(struct goodix_ts_data *ts)
 407 {
 408         int error;
 409
 410         /* begin select I2C slave addr */
 411         error = gpiod_direction_output(ts->gpiod_rst, 0);
 412         if (error)
 413                 return error;
 414
 415         msleep(20);                             /* T2: > 10ms */
 416
 417         /* HIGH: 0x28/0x29, LOW: 0xBA/0xBB */
 418         error = gpiod_direction_output(ts->gpiod_int, ts->client->addr == 0x14);
 419         if (error)
 420                 return error;
 421
 422         usleep_range(100, 2000);                /* T3: > 100us */
 423
 424         error = gpiod_direction_output(ts->gpiod_rst, 1);
 425         if (error)
 426                 return error;
 427
 428         usleep_range(6000, 10000);              /* T4: > 5ms */
 429
 430         /* end select I2C slave addr */
 431         error = gpiod_direction_input(ts->gpiod_rst);
 432         if (error)
 433                 return error;
 434
 435         error = goodix_int_sync(ts);
 436         if (error)
 437                 return error;
 438
 439         return 0;
 440 }
 441
 442 /**
 443  * goodix_get_gpio_config - Get GPIO config from ACPI/DT
 444  *
 445  * @ts: goodix_ts_data pointer
 446  */
 447 static int goodix_get_gpio_config(struct goodix_ts_data *ts)
 448 {
 449         int error;
 450         struct device *dev;
 451         struct gpio_desc *gpiod;
 452
 453         if (!ts->client)
 454                 return -EINVAL;
 455         dev = &ts->client->dev;
 456
 457         /* Get the interrupt GPIO pin number */
 458         gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_INT_NAME, GPIOD_IN);
 459         if (IS_ERR(gpiod)) {
 460                 error = PTR_ERR(gpiod);
 461                 if (error != -EPROBE_DEFER)
 462                         dev_dbg(dev, "Failed to get %s GPIO: %d\n",
 463                                 GOODIX_GPIO_INT_NAME, error);
 464                 return error;
 465         }
 466
 467         ts->gpiod_int = gpiod;
 468
 469         /* Get the reset line GPIO pin number */
 470         gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_RST_NAME, GPIOD_IN);
 471         if (IS_ERR(gpiod)) {
 472                 error = PTR_ERR(gpiod);
 473                 if (error != -EPROBE_DEFER)
 474                         dev_dbg(dev, "Failed to get %s GPIO: %d\n",
 475                                 GOODIX_GPIO_RST_NAME, error);
 476                 return error;
 477         }
 478
 479         ts->gpiod_rst = gpiod;
 480
 481         return 0;
 482 }
 483
 484 /**
 485  * goodix_read_config - Read the embedded configuration of the panel
 486  *
 487  * @ts: our goodix_ts_data pointer
 488  *
 489  * Must be called during probe
 490  */
 491 static void goodix_read_config(struct goodix_ts_data *ts)
 492 {
 493         u8 config[GOODIX_CONFIG_MAX_LENGTH];
 494         int error;
 495
 496         error = goodix_i2c_read(ts->client, GOODIX_REG_CONFIG_DATA,
 497                                 config, ts->cfg_len);
 498         if (error) {
 499                 dev_warn(&ts->client->dev,
 500                          "Error reading config (%d), using defaults\n",
 501                          error);
 502                 ts->abs_x_max = GOODIX_MAX_WIDTH;
 503                 ts->abs_y_max = GOODIX_MAX_HEIGHT;
 504                 if (ts->swapped_x_y)
 505                         swap(ts->abs_x_max, ts->abs_y_max);
 506                 ts->int_trigger_type = GOODIX_INT_TRIGGER;
 507                 ts->max_touch_num = GOODIX_MAX_CONTACTS;
 508                 return;
 509         }
 510
 511         ts->abs_x_max = get_unaligned_le16(&config[RESOLUTION_LOC]);
 512         ts->abs_y_max = get_unaligned_le16(&config[RESOLUTION_LOC + 2]);
 513         if (ts->swapped_x_y)
 514                 swap(ts->abs_x_max, ts->abs_y_max);
 515         ts->int_trigger_type = config[TRIGGER_LOC] & 0x03;
 516         ts->max_touch_num = config[MAX_CONTACTS_LOC] & 0x0f;
 517         if (!ts->abs_x_max || !ts->abs_y_max || !ts->max_touch_num) {
 518                 dev_err(&ts->client->dev,
 519                         "Invalid config, using defaults\n");
 520                 ts->abs_x_max = GOODIX_MAX_WIDTH;
 521                 ts->abs_y_max = GOODIX_MAX_HEIGHT;
 522                 if (ts->swapped_x_y)
 523                         swap(ts->abs_x_max, ts->abs_y_max);
 524                 ts->max_touch_num = GOODIX_MAX_CONTACTS;
 525         }
 526
 527         if (dmi_check_system(rotated_screen)) {
 528                 ts->inverted_x = true;
 529                 ts->inverted_y = true;
 530                 dev_dbg(&ts->client->dev,
 531                          "Applying '180 degrees rotated screen' quirk\n");
 532         }
 533 }
 534
 535 /**
 536  * goodix_read_version - Read goodix touchscreen version
 537  *
 538  * @ts: our goodix_ts_data pointer
 539  */
 540 static int goodix_read_version(struct goodix_ts_data *ts)
 541 {
 542         int error;
 543         u8 buf[6];
 544         char id_str[5];
 545
 546         error = goodix_i2c_read(ts->client, GOODIX_REG_ID, buf, sizeof(buf));
 547         if (error) {
 548                 dev_err(&ts->client->dev, "read version failed: %d\n", error);
 549                 return error;
 550         }
 551
 552         memcpy(id_str, buf, 4);
 553         id_str[4] = 0;
 554         if (kstrtou16(id_str, 10, &ts->id))
 555                 ts->id = 0x1001;
 556
 557         ts->version = get_unaligned_le16(&buf[4]);
 558
 559         dev_info(&ts->client->dev, "ID %d, version: %04x\n", ts->id,
 560                  ts->version);
 561
 562         return 0;
 563 }
 564
 565 /**
 566  * goodix_i2c_test - I2C test function to check if the device answers.
 567  *
 568  * @client: the i2c client
 569  */
 570 static int goodix_i2c_test(struct i2c_client *client)
 571 {
 572         int retry = 0;
 573         int error;
 574         u8 test;
 575
 576         while (retry++ < 2) {
 577                 error = goodix_i2c_read(client, GOODIX_REG_CONFIG_DATA,
 578                                         &test, 1);
 579                 if (!error)
 580                         return 0;
 581
 582                 dev_err(&client->dev, "i2c test failed attempt %d: %d\n",
 583                         retry, error);
 584                 msleep(20);
 585         }
 586
 587         return error;
 588 }
 589
 590 /**
 591  * goodix_request_input_dev - Allocate, populate and register the input device
 592  *
 593  * @ts: our goodix_ts_data pointer
 594  *
 595  * Must be called during probe
 596  */
 597 static int goodix_request_input_dev(struct goodix_ts_data *ts)
 598 {
 599         int error;
 600
 601         ts->input_dev = devm_input_allocate_device(&ts->client->dev);
 602         if (!ts->input_dev) {
 603                 dev_err(&ts->client->dev, "Failed to allocate input device.");
 604                 return -ENOMEM;
 605         }
 606
 607         input_set_abs_params(ts->input_dev, ABS_MT_POSITION_X,
 608                              0, ts->abs_x_max, 0, 0);
 609         input_set_abs_params(ts->input_dev, ABS_MT_POSITION_Y,
 610                              0, ts->abs_y_max, 0, 0);
 611         input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
 612         input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
 613
 614         input_mt_init_slots(ts->input_dev, ts->max_touch_num,
 615                             INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
 616
 617         ts->input_dev->name = "Goodix Capacitive TouchScreen";
 618         ts->input_dev->phys = "input/ts";
 619         ts->input_dev->id.bustype = BUS_I2C;
 620         ts->input_dev->id.vendor = 0x0416;
 621         ts->input_dev->id.product = ts->id;
 622         ts->input_dev->id.version = ts->version;
 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                 disable_irq(client->irq);
 792                 return 0;
 793         }
 794
 795         wait_for_completion(&ts->firmware_loading_complete);
 796
 797         /* Free IRQ as IRQ pin is used as output in the suspend sequence */
 798         goodix_free_irq(ts);
 799
 800         /* Output LOW on the INT pin for 5 ms */
 801         error = gpiod_direction_output(ts->gpiod_int, 0);
 802         if (error) {
 803                 goodix_request_irq(ts);
 804                 return error;
 805         }
 806
 807         usleep_range(5000, 6000);
 808
 809         error = goodix_i2c_write_u8(ts->client, GOODIX_REG_COMMAND,
 810                                     GOODIX_CMD_SCREEN_OFF);
 811         if (error) {
 812                 dev_err(&ts->client->dev, "Screen off command failed\n");
 813                 gpiod_direction_input(ts->gpiod_int);
 814                 goodix_request_irq(ts);
 815                 return -EAGAIN;
 816         }
 817
 818         /*
 819          * The datasheet specifies that the interval between sending screen-off
 820          * command and wake-up should be longer than 58 ms. To avoid waking up
 821          * sooner, delay 58ms here.
 822          */
 823         msleep(58);
 824         return 0;
 825 }
 826
 827 static int __maybe_unused goodix_resume(struct device *dev)
 828 {
 829         struct i2c_client *client = to_i2c_client(dev);
 830         struct goodix_ts_data *ts = i2c_get_clientdata(client);
 831         int error;
 832
 833         if (!ts->gpiod_int || !ts->gpiod_rst) {
 834                 enable_irq(client->irq);
 835                 return 0;
 836         }
 837
 838         /*
 839          * Exit sleep mode by outputting HIGH level to INT pin
 840          * for 2ms~5ms.
 841          */
 842         error = gpiod_direction_output(ts->gpiod_int, 1);
 843         if (error)
 844                 return error;
 845
 846         usleep_range(2000, 5000);
 847
 848         error = goodix_int_sync(ts);
 849         if (error)
 850                 return error;
 851
 852         error = goodix_request_irq(ts);
 853         if (error)
 854                 return error;
 855
 856         return 0;
 857 }
 858
 859 static SIMPLE_DEV_PM_OPS(goodix_pm_ops, goodix_suspend, goodix_resume);
 860
 861 static const struct i2c_device_id goodix_ts_id[] = {
 862         { "GDIX1001:00", 0 },
 863         { }
 864 };
 865 MODULE_DEVICE_TABLE(i2c, goodix_ts_id);
 866
 867 #ifdef CONFIG_ACPI
 868 static const struct acpi_device_id goodix_acpi_match[] = {
 869         { "GDIX1001", 0 },
 870         { "GDIX1002", 0 },
 871         { }
 872 };
 873 MODULE_DEVICE_TABLE(acpi, goodix_acpi_match);
 874 #endif
 875
 876 #ifdef CONFIG_OF
 877 static const struct of_device_id goodix_of_match[] = {
 878         { .compatible = "goodix,gt911" },
 879         { .compatible = "goodix,gt9110" },
 880         { .compatible = "goodix,gt912" },
 881         { .compatible = "goodix,gt927" },
 882         { .compatible = "goodix,gt9271" },
 883         { .compatible = "goodix,gt928" },
 884         { .compatible = "goodix,gt967" },
 885         { }
 886 };
 887 MODULE_DEVICE_TABLE(of, goodix_of_match);
 888 #endif
 889
 890 static struct i2c_driver goodix_ts_driver = {
 891         .probe = goodix_ts_probe,
 892         .remove = goodix_ts_remove,
 893         .id_table = goodix_ts_id,
 894         .driver = {
 895                 .name = "Goodix-TS",
 896                 .acpi_match_table = ACPI_PTR(goodix_acpi_match),
 897                 .of_match_table = of_match_ptr(goodix_of_match),
 898                 .pm = &goodix_pm_ops,
 899         },
 900 };
 901 module_i2c_driver(goodix_ts_driver);
 902
 903 MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
 904 MODULE_AUTHOR("Bastien Nocera <hadess@hadess.net>");
 905 MODULE_DESCRIPTION("Goodix touchscreen driver");
 906 MODULE_LICENSE("GPL v2");