drivers/input/touchscreen/goodix.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  *  Driver for Goodix Touchscreens
   4  *
   5  *  Copyright (c) 2014 Red Hat Inc.
   6  *  Copyright (c) 2015 K. Merker <[email protected]>
   7  *
   8  *  This code is based on gt9xx.c authored by [email protected]:
   9  *
  10  *  2010 - 2012 Goodix Technology.
  11  */
  12
  13
  14 #include <linux/kernel.h>
  15 #include <linux/dmi.h>
  16 #include <linux/firmware.h>
  17 #include <linux/gpio/consumer.h>
  18 #include <linux/i2c.h>
  19 #include <linux/input.h>
  20 #include <linux/input/mt.h>
  21 #include <linux/input/touchscreen.h>
  22 #include <linux/module.h>
  23 #include <linux/delay.h>
  24 #include <linux/irq.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/regulator/consumer.h>
  27 #include <linux/slab.h>
  28 #include <linux/acpi.h>
  29 #include <linux/of.h>
  30 #include <asm/unaligned.h>
  31
  32 #define GOODIX_GPIO_INT_NAME            "irq"
  33 #define GOODIX_GPIO_RST_NAME            "reset"
  34
  35 #define GOODIX_MAX_HEIGHT               4096
  36 #define GOODIX_MAX_WIDTH                4096
  37 #define GOODIX_INT_TRIGGER              1
  38 #define GOODIX_CONTACT_SIZE             8
  39 #define GOODIX_MAX_CONTACT_SIZE         9
  40 #define GOODIX_MAX_CONTACTS             10
  41 #define GOODIX_MAX_KEYS                 7
  42
  43 #define GOODIX_CONFIG_MIN_LENGTH        186
  44 #define GOODIX_CONFIG_911_LENGTH        186
  45 #define GOODIX_CONFIG_967_LENGTH        228
  46 #define GOODIX_CONFIG_GT9X_LENGTH       240
  47 #define GOODIX_CONFIG_MAX_LENGTH        240
  48
  49 /* Register defines */
  50 #define GOODIX_REG_COMMAND              0x8040
  51 #define GOODIX_CMD_SCREEN_OFF           0x05
  52
  53 #define GOODIX_READ_COOR_ADDR           0x814E
  54 #define GOODIX_GT1X_REG_CONFIG_DATA     0x8050
  55 #define GOODIX_GT9X_REG_CONFIG_DATA     0x8047
  56 #define GOODIX_REG_ID                   0x8140
  57
  58 #define GOODIX_BUFFER_STATUS_READY      BIT(7)
  59 #define GOODIX_HAVE_KEY                 BIT(4)
  60 #define GOODIX_BUFFER_STATUS_TIMEOUT    20
  61
  62 #define RESOLUTION_LOC          1
  63 #define MAX_CONTACTS_LOC        5
  64 #define TRIGGER_LOC             6
  65
  66 /* Our special handling for GPIO accesses through ACPI is x86 specific */
  67 #if defined CONFIG_X86 && defined CONFIG_ACPI
  68 #define ACPI_GPIO_SUPPORT
  69 #endif
  70
  71 struct goodix_ts_data;
  72
  73 enum goodix_irq_pin_access_method {
  74         IRQ_PIN_ACCESS_NONE,
  75         IRQ_PIN_ACCESS_GPIO,
  76         IRQ_PIN_ACCESS_ACPI_GPIO,
  77         IRQ_PIN_ACCESS_ACPI_METHOD,
  78 };
  79
  80 struct goodix_chip_data {
  81         u16 config_addr;
  82         int config_len;
  83         int (*check_config)(struct goodix_ts_data *ts, const u8 *cfg, int len);
  84         void (*calc_config_checksum)(struct goodix_ts_data *ts);
  85 };
  86
  87 struct goodix_chip_id {
  88         const char *id;
  89         const struct goodix_chip_data *data;
  90 };
  91
  92 #define GOODIX_ID_MAX_LEN       4
  93
  94 struct goodix_ts_data {
  95         struct i2c_client *client;
  96         struct input_dev *input_dev;
  97         const struct goodix_chip_data *chip;
  98         struct touchscreen_properties prop;
  99         unsigned int max_touch_num;
 100         unsigned int int_trigger_type;
 101         struct regulator *avdd28;
 102         struct regulator *vddio;
 103         struct gpio_desc *gpiod_int;
 104         struct gpio_desc *gpiod_rst;
 105         int gpio_count;
 106         int gpio_int_idx;
 107         char id[GOODIX_ID_MAX_LEN + 1];
 108         u16 version;
 109         const char *cfg_name;
 110         bool reset_controller_at_probe;
 111         bool load_cfg_from_disk;
 112         struct completion firmware_loading_complete;
 113         unsigned long irq_flags;
 114         enum goodix_irq_pin_access_method irq_pin_access_method;
 115         unsigned int contact_size;
 116         u8 config[GOODIX_CONFIG_MAX_LENGTH];
 117         unsigned short keymap[GOODIX_MAX_KEYS];
 118 };
 119
 120 static int goodix_check_cfg_8(struct goodix_ts_data *ts,
 121                               const u8 *cfg, int len);
 122 static int goodix_check_cfg_16(struct goodix_ts_data *ts,
 123                                const u8 *cfg, int len);
 124 static void goodix_calc_cfg_checksum_8(struct goodix_ts_data *ts);
 125 static void goodix_calc_cfg_checksum_16(struct goodix_ts_data *ts);
 126
 127 static const struct goodix_chip_data gt1x_chip_data = {
 128         .config_addr            = GOODIX_GT1X_REG_CONFIG_DATA,
 129         .config_len             = GOODIX_CONFIG_GT9X_LENGTH,
 130         .check_config           = goodix_check_cfg_16,
 131         .calc_config_checksum   = goodix_calc_cfg_checksum_16,
 132 };
 133
 134 static const struct goodix_chip_data gt911_chip_data = {
 135         .config_addr            = GOODIX_GT9X_REG_CONFIG_DATA,
 136         .config_len             = GOODIX_CONFIG_911_LENGTH,
 137         .check_config           = goodix_check_cfg_8,
 138         .calc_config_checksum   = goodix_calc_cfg_checksum_8,
 139 };
 140
 141 static const struct goodix_chip_data gt967_chip_data = {
 142         .config_addr            = GOODIX_GT9X_REG_CONFIG_DATA,
 143         .config_len             = GOODIX_CONFIG_967_LENGTH,
 144         .check_config           = goodix_check_cfg_8,
 145         .calc_config_checksum   = goodix_calc_cfg_checksum_8,
 146 };
 147
 148 static const struct goodix_chip_data gt9x_chip_data = {
 149         .config_addr            = GOODIX_GT9X_REG_CONFIG_DATA,
 150         .config_len             = GOODIX_CONFIG_GT9X_LENGTH,
 151         .check_config           = goodix_check_cfg_8,
 152         .calc_config_checksum   = goodix_calc_cfg_checksum_8,
 153 };
 154
 155 static const struct goodix_chip_id goodix_chip_ids[] = {
 156         { .id = "1151", .data = &gt1x_chip_data },
 157         { .id = "5663", .data = &gt1x_chip_data },
 158         { .id = "5688", .data = &gt1x_chip_data },
 159         { .id = "917S", .data = &gt1x_chip_data },
 160
 161         { .id = "911", .data = &gt911_chip_data },
 162         { .id = "9271", .data = &gt911_chip_data },
 163         { .id = "9110", .data = &gt911_chip_data },
 164         { .id = "927", .data = &gt911_chip_data },
 165         { .id = "928", .data = &gt911_chip_data },
 166
 167         { .id = "912", .data = &gt967_chip_data },
 168         { .id = "9147", .data = &gt967_chip_data },
 169         { .id = "967", .data = &gt967_chip_data },
 170         { }
 171 };
 172
 173 static const unsigned long goodix_irq_flags[] = {
 174         IRQ_TYPE_EDGE_RISING,
 175         IRQ_TYPE_EDGE_FALLING,
 176         IRQ_TYPE_LEVEL_LOW,
 177         IRQ_TYPE_LEVEL_HIGH,
 178 };
 179
 180 /*
 181  * Those tablets have their coordinates origin at the bottom right
 182  * of the tablet, as if rotated 180 degrees
 183  */
 184 static const struct dmi_system_id rotated_screen[] = {
 185 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
 186         {
 187                 .ident = "Teclast X89",
 188                 .matches = {
 189                         /* tPAD is too generic, also match on bios date */
 190                         DMI_MATCH(DMI_BOARD_VENDOR, "TECLAST"),
 191                         DMI_MATCH(DMI_BOARD_NAME, "tPAD"),
 192                         DMI_MATCH(DMI_BIOS_DATE, "12/19/2014"),
 193                 },
 194         },
 195         {
 196                 .ident = "WinBook TW100",
 197                 .matches = {
 198                         DMI_MATCH(DMI_SYS_VENDOR, "WinBook"),
 199                         DMI_MATCH(DMI_PRODUCT_NAME, "TW100")
 200                 }
 201         },
 202         {
 203                 .ident = "WinBook TW700",
 204                 .matches = {
 205                         DMI_MATCH(DMI_SYS_VENDOR, "WinBook"),
 206                         DMI_MATCH(DMI_PRODUCT_NAME, "TW700")
 207                 },
 208         },
 209 #endif
 210         {}
 211 };
 212
 213 static const struct dmi_system_id nine_bytes_report[] = {
 214 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
 215         {
 216                 .ident = "Lenovo YogaBook",
 217                 /* YB1-X91L/F and YB1-X90L/F */
 218                 .matches = {
 219                         DMI_MATCH(DMI_PRODUCT_NAME, "Lenovo YB1-X9")
 220                 }
 221         },
 222 #endif
 223         {}
 224 };
 225
 226 /*
 227  * Those tablets have their x coordinate inverted
 228  */
 229 static const struct dmi_system_id inverted_x_screen[] = {
 230 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
 231         {
 232                 .ident = "Cube I15-TC",
 233                 .matches = {
 234                         DMI_MATCH(DMI_SYS_VENDOR, "Cube"),
 235                         DMI_MATCH(DMI_PRODUCT_NAME, "I15-TC")
 236                 },
 237         },
 238 #endif
 239         {}
 240 };
 241
 242 /**
 243  * goodix_i2c_read - read data from a register of the i2c slave device.
 244  *
 245  * @client: i2c device.
 246  * @reg: the register to read from.
 247  * @buf: raw write data buffer.
 248  * @len: length of the buffer to write
 249  */
 250 static int goodix_i2c_read(struct i2c_client *client,
 251                            u16 reg, u8 *buf, int len)
 252 {
 253         struct i2c_msg msgs[2];
 254         __be16 wbuf = cpu_to_be16(reg);
 255         int ret;
 256
 257         msgs[0].flags = 0;
 258         msgs[0].addr  = client->addr;
 259         msgs[0].len   = 2;
 260         msgs[0].buf   = (u8 *)&wbuf;
 261
 262         msgs[1].flags = I2C_M_RD;
 263         msgs[1].addr  = client->addr;
 264         msgs[1].len   = len;
 265         msgs[1].buf   = buf;
 266
 267         ret = i2c_transfer(client->adapter, msgs, 2);
 268         return ret < 0 ? ret : (ret != ARRAY_SIZE(msgs) ? -EIO : 0);
 269 }
 270
 271 /**
 272  * goodix_i2c_write - write data to a register of the i2c slave device.
 273  *
 274  * @client: i2c device.
 275  * @reg: the register to write to.
 276  * @buf: raw data buffer to write.
 277  * @len: length of the buffer to write
 278  */
 279 static int goodix_i2c_write(struct i2c_client *client, u16 reg, const u8 *buf,
 280                             unsigned len)
 281 {
 282         u8 *addr_buf;
 283         struct i2c_msg msg;
 284         int ret;
 285
 286         addr_buf = kmalloc(len + 2, GFP_KERNEL);
 287         if (!addr_buf)
 288                 return -ENOMEM;
 289
 290         addr_buf[0] = reg >> 8;
 291         addr_buf[1] = reg & 0xFF;
 292         memcpy(&addr_buf[2], buf, len);
 293
 294         msg.flags = 0;
 295         msg.addr = client->addr;
 296         msg.buf = addr_buf;
 297         msg.len = len + 2;
 298
 299         ret = i2c_transfer(client->adapter, &msg, 1);
 300         kfree(addr_buf);
 301         return ret < 0 ? ret : (ret != 1 ? -EIO : 0);
 302 }
 303
 304 static int goodix_i2c_write_u8(struct i2c_client *client, u16 reg, u8 value)
 305 {
 306         return goodix_i2c_write(client, reg, &value, sizeof(value));
 307 }
 308
 309 static const struct goodix_chip_data *goodix_get_chip_data(const char *id)
 310 {
 311         unsigned int i;
 312
 313         for (i = 0; goodix_chip_ids[i].id; i++) {
 314                 if (!strcmp(goodix_chip_ids[i].id, id))
 315                         return goodix_chip_ids[i].data;
 316         }
 317
 318         return &gt9x_chip_data;
 319 }
 320
 321 static int goodix_ts_read_input_report(struct goodix_ts_data *ts, u8 *data)
 322 {
 323         unsigned long max_timeout;
 324         int touch_num;
 325         int error;
 326         u16 addr = GOODIX_READ_COOR_ADDR;
 327         /*
 328          * We are going to read 1-byte header,
 329          * ts->contact_size * max(1, touch_num) bytes of coordinates
 330          * and 1-byte footer which contains the touch-key code.
 331          */
 332         const int header_contact_keycode_size = 1 + ts->contact_size + 1;
 333
 334         /*
 335          * The 'buffer status' bit, which indicates that the data is valid, is
 336          * not set as soon as the interrupt is raised, but slightly after.
 337          * This takes around 10 ms to happen, so we poll for 20 ms.
 338          */
 339         max_timeout = jiffies + msecs_to_jiffies(GOODIX_BUFFER_STATUS_TIMEOUT);
 340         do {
 341                 error = goodix_i2c_read(ts->client, addr, data,
 342                                         header_contact_keycode_size);
 343                 if (error) {
 344                         dev_err(&ts->client->dev, "I2C transfer error: %d\n",
 345                                         error);
 346                         return error;
 347                 }
 348
 349                 if (data[0] & GOODIX_BUFFER_STATUS_READY) {
 350                         touch_num = data[0] & 0x0f;
 351                         if (touch_num > ts->max_touch_num)
 352                                 return -EPROTO;
 353
 354                         if (touch_num > 1) {
 355                                 addr += header_contact_keycode_size;
 356                                 data += header_contact_keycode_size;
 357                                 error = goodix_i2c_read(ts->client,
 358                                                 addr, data,
 359                                                 ts->contact_size *
 360                                                         (touch_num - 1));
 361                                 if (error)
 362                                         return error;
 363                         }
 364
 365                         return touch_num;
 366                 }
 367
 368                 usleep_range(1000, 2000); /* Poll every 1 - 2 ms */
 369         } while (time_before(jiffies, max_timeout));
 370
 371         /*
 372          * The Goodix panel will send spurious interrupts after a
 373          * 'finger up' event, which will always cause a timeout.
 374          */
 375         return -ENOMSG;
 376 }
 377
 378 static void goodix_ts_report_touch_8b(struct goodix_ts_data *ts, u8 *coor_data)
 379 {
 380         int id = coor_data[0] & 0x0F;
 381         int input_x = get_unaligned_le16(&coor_data[1]);
 382         int input_y = get_unaligned_le16(&coor_data[3]);
 383         int input_w = get_unaligned_le16(&coor_data[5]);
 384
 385         input_mt_slot(ts->input_dev, id);
 386         input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
 387         touchscreen_report_pos(ts->input_dev, &ts->prop,
 388                                input_x, input_y, true);
 389         input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);
 390         input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);
 391 }
 392
 393 static void goodix_ts_report_touch_9b(struct goodix_ts_data *ts, u8 *coor_data)
 394 {
 395         int id = coor_data[1] & 0x0F;
 396         int input_x = get_unaligned_le16(&coor_data[3]);
 397         int input_y = get_unaligned_le16(&coor_data[5]);
 398         int input_w = get_unaligned_le16(&coor_data[7]);
 399
 400         input_mt_slot(ts->input_dev, id);
 401         input_mt_report_slot_state(ts->input_dev, MT_TOOL_FINGER, true);
 402         touchscreen_report_pos(ts->input_dev, &ts->prop,
 403                                input_x, input_y, true);
 404         input_report_abs(ts->input_dev, ABS_MT_TOUCH_MAJOR, input_w);
 405         input_report_abs(ts->input_dev, ABS_MT_WIDTH_MAJOR, input_w);
 406 }
 407
 408 static void goodix_ts_report_key(struct goodix_ts_data *ts, u8 *data)
 409 {
 410         int touch_num;
 411         u8 key_value;
 412         int i;
 413
 414         if (data[0] & GOODIX_HAVE_KEY) {
 415                 touch_num = data[0] & 0x0f;
 416                 key_value = data[1 + ts->contact_size * touch_num];
 417                 for (i = 0; i < GOODIX_MAX_KEYS; i++)
 418                         if (key_value & BIT(i))
 419                                 input_report_key(ts->input_dev,
 420                                                  ts->keymap[i], 1);
 421         } else {
 422                 for (i = 0; i < GOODIX_MAX_KEYS; i++)
 423                         input_report_key(ts->input_dev, ts->keymap[i], 0);
 424         }
 425 }
 426
 427 /**
 428  * goodix_process_events - Process incoming events
 429  *
 430  * @ts: our goodix_ts_data pointer
 431  *
 432  * Called when the IRQ is triggered. Read the current device state, and push
 433  * the input events to the user space.
 434  */
 435 static void goodix_process_events(struct goodix_ts_data *ts)
 436 {
 437         u8  point_data[2 + GOODIX_MAX_CONTACT_SIZE * GOODIX_MAX_CONTACTS];
 438         int touch_num;
 439         int i;
 440
 441         touch_num = goodix_ts_read_input_report(ts, point_data);
 442         if (touch_num < 0)
 443                 return;
 444
 445         goodix_ts_report_key(ts, point_data);
 446
 447         for (i = 0; i < touch_num; i++)
 448                 if (ts->contact_size == 9)
 449                         goodix_ts_report_touch_9b(ts,
 450                                 &point_data[1 + ts->contact_size * i]);
 451                 else
 452                         goodix_ts_report_touch_8b(ts,
 453                                 &point_data[1 + ts->contact_size * i]);
 454
 455         input_mt_sync_frame(ts->input_dev);
 456         input_sync(ts->input_dev);
 457 }
 458
 459 /**
 460  * goodix_ts_irq_handler - The IRQ handler
 461  *
 462  * @irq: interrupt number.
 463  * @dev_id: private data pointer.
 464  */
 465 static irqreturn_t goodix_ts_irq_handler(int irq, void *dev_id)
 466 {
 467         struct goodix_ts_data *ts = dev_id;
 468
 469         goodix_process_events(ts);
 470
 471         if (goodix_i2c_write_u8(ts->client, GOODIX_READ_COOR_ADDR, 0) < 0)
 472                 dev_err(&ts->client->dev, "I2C write end_cmd error\n");
 473
 474         return IRQ_HANDLED;
 475 }
 476
 477 static void goodix_free_irq(struct goodix_ts_data *ts)
 478 {
 479         devm_free_irq(&ts->client->dev, ts->client->irq, ts);
 480 }
 481
 482 static int goodix_request_irq(struct goodix_ts_data *ts)
 483 {
 484         return devm_request_threaded_irq(&ts->client->dev, ts->client->irq,
 485                                          NULL, goodix_ts_irq_handler,
 486                                          ts->irq_flags, ts->client->name, ts);
 487 }
 488
 489 static int goodix_check_cfg_8(struct goodix_ts_data *ts, const u8 *cfg, int len)
 490 {
 491         int i, raw_cfg_len = len - 2;
 492         u8 check_sum = 0;
 493
 494         for (i = 0; i < raw_cfg_len; i++)
 495                 check_sum += cfg[i];
 496         check_sum = (~check_sum) + 1;
 497         if (check_sum != cfg[raw_cfg_len]) {
 498                 dev_err(&ts->client->dev,
 499                         "The checksum of the config fw is not correct");
 500                 return -EINVAL;
 501         }
 502
 503         if (cfg[raw_cfg_len + 1] != 1) {
 504                 dev_err(&ts->client->dev,
 505                         "Config fw must have Config_Fresh register set");
 506                 return -EINVAL;
 507         }
 508
 509         return 0;
 510 }
 511
 512 static void goodix_calc_cfg_checksum_8(struct goodix_ts_data *ts)
 513 {
 514         int i, raw_cfg_len = ts->chip->config_len - 2;
 515         u8 check_sum = 0;
 516
 517         for (i = 0; i < raw_cfg_len; i++)
 518                 check_sum += ts->config[i];
 519         check_sum = (~check_sum) + 1;
 520
 521         ts->config[raw_cfg_len] = check_sum;
 522         ts->config[raw_cfg_len + 1] = 1; /* Set "config_fresh" bit */
 523 }
 524
 525 static int goodix_check_cfg_16(struct goodix_ts_data *ts, const u8 *cfg,
 526                                int len)
 527 {
 528         int i, raw_cfg_len = len - 3;
 529         u16 check_sum = 0;
 530
 531         for (i = 0; i < raw_cfg_len; i += 2)
 532                 check_sum += get_unaligned_be16(&cfg[i]);
 533         check_sum = (~check_sum) + 1;
 534         if (check_sum != get_unaligned_be16(&cfg[raw_cfg_len])) {
 535                 dev_err(&ts->client->dev,
 536                         "The checksum of the config fw is not correct");
 537                 return -EINVAL;
 538         }
 539
 540         if (cfg[raw_cfg_len + 2] != 1) {
 541                 dev_err(&ts->client->dev,
 542                         "Config fw must have Config_Fresh register set");
 543                 return -EINVAL;
 544         }
 545
 546         return 0;
 547 }
 548
 549 static void goodix_calc_cfg_checksum_16(struct goodix_ts_data *ts)
 550 {
 551         int i, raw_cfg_len = ts->chip->config_len - 3;
 552         u16 check_sum = 0;
 553
 554         for (i = 0; i < raw_cfg_len; i += 2)
 555                 check_sum += get_unaligned_be16(&ts->config[i]);
 556         check_sum = (~check_sum) + 1;
 557
 558         put_unaligned_be16(check_sum, &ts->config[raw_cfg_len]);
 559         ts->config[raw_cfg_len + 2] = 1; /* Set "config_fresh" bit */
 560 }
 561
 562 /**
 563  * goodix_check_cfg - Checks if config fw is valid
 564  *
 565  * @ts: goodix_ts_data pointer
 566  * @cfg: firmware config data
 567  */
 568 static int goodix_check_cfg(struct goodix_ts_data *ts, const u8 *cfg, int len)
 569 {
 570         if (len < GOODIX_CONFIG_MIN_LENGTH ||
 571             len > GOODIX_CONFIG_MAX_LENGTH) {
 572                 dev_err(&ts->client->dev,
 573                         "The length of the config fw is not correct");
 574                 return -EINVAL;
 575         }
 576
 577         return ts->chip->check_config(ts, cfg, len);
 578 }
 579
 580 /**
 581  * goodix_send_cfg - Write fw config to device
 582  *
 583  * @ts: goodix_ts_data pointer
 584  * @cfg: config firmware to write to device
 585  */
 586 static int goodix_send_cfg(struct goodix_ts_data *ts, const u8 *cfg, int len)
 587 {
 588         int error;
 589
 590         error = goodix_check_cfg(ts, cfg, len);
 591         if (error)
 592                 return error;
 593
 594         error = goodix_i2c_write(ts->client, ts->chip->config_addr, cfg, len);
 595         if (error) {
 596                 dev_err(&ts->client->dev, "Failed to write config data: %d",
 597                         error);
 598                 return error;
 599         }
 600         dev_dbg(&ts->client->dev, "Config sent successfully.");
 601
 602         /* Let the firmware reconfigure itself, so sleep for 10ms */
 603         usleep_range(10000, 11000);
 604
 605         return 0;
 606 }
 607
 608 #ifdef ACPI_GPIO_SUPPORT
 609 static int goodix_pin_acpi_direction_input(struct goodix_ts_data *ts)
 610 {
 611         acpi_handle handle = ACPI_HANDLE(&ts->client->dev);
 612         acpi_status status;
 613
 614         status = acpi_evaluate_object(handle, "INTI", NULL, NULL);
 615         return ACPI_SUCCESS(status) ? 0 : -EIO;
 616 }
 617
 618 static int goodix_pin_acpi_output_method(struct goodix_ts_data *ts, int value)
 619 {
 620         acpi_handle handle = ACPI_HANDLE(&ts->client->dev);
 621         acpi_status status;
 622
 623         status = acpi_execute_simple_method(handle, "INTO", value);
 624         return ACPI_SUCCESS(status) ? 0 : -EIO;
 625 }
 626 #else
 627 static int goodix_pin_acpi_direction_input(struct goodix_ts_data *ts)
 628 {
 629         dev_err(&ts->client->dev,
 630                 "%s called on device without ACPI support\n", __func__);
 631         return -EINVAL;
 632 }
 633
 634 static int goodix_pin_acpi_output_method(struct goodix_ts_data *ts, int value)
 635 {
 636         dev_err(&ts->client->dev,
 637                 "%s called on device without ACPI support\n", __func__);
 638         return -EINVAL;
 639 }
 640 #endif
 641
 642 static int goodix_irq_direction_output(struct goodix_ts_data *ts, int value)
 643 {
 644         switch (ts->irq_pin_access_method) {
 645         case IRQ_PIN_ACCESS_NONE:
 646                 dev_err(&ts->client->dev,
 647                         "%s called without an irq_pin_access_method set\n",
 648                         __func__);
 649                 return -EINVAL;
 650         case IRQ_PIN_ACCESS_GPIO:
 651                 return gpiod_direction_output(ts->gpiod_int, value);
 652         case IRQ_PIN_ACCESS_ACPI_GPIO:
 653                 /*
 654                  * The IRQ pin triggers on a falling edge, so its gets marked
 655                  * as active-low, use output_raw to avoid the value inversion.
 656                  */
 657                 return gpiod_direction_output_raw(ts->gpiod_int, value);
 658         case IRQ_PIN_ACCESS_ACPI_METHOD:
 659                 return goodix_pin_acpi_output_method(ts, value);
 660         }
 661
 662         return -EINVAL; /* Never reached */
 663 }
 664
 665 static int goodix_irq_direction_input(struct goodix_ts_data *ts)
 666 {
 667         switch (ts->irq_pin_access_method) {
 668         case IRQ_PIN_ACCESS_NONE:
 669                 dev_err(&ts->client->dev,
 670                         "%s called without an irq_pin_access_method set\n",
 671                         __func__);
 672                 return -EINVAL;
 673         case IRQ_PIN_ACCESS_GPIO:
 674                 return gpiod_direction_input(ts->gpiod_int);
 675         case IRQ_PIN_ACCESS_ACPI_GPIO:
 676                 return gpiod_direction_input(ts->gpiod_int);
 677         case IRQ_PIN_ACCESS_ACPI_METHOD:
 678                 return goodix_pin_acpi_direction_input(ts);
 679         }
 680
 681         return -EINVAL; /* Never reached */
 682 }
 683
 684 static int goodix_int_sync(struct goodix_ts_data *ts)
 685 {
 686         int error;
 687
 688         error = goodix_irq_direction_output(ts, 0);
 689         if (error)
 690                 return error;
 691
 692         msleep(50);                             /* T5: 50ms */
 693
 694         error = goodix_irq_direction_input(ts);
 695         if (error)
 696                 return error;
 697
 698         return 0;
 699 }
 700
 701 /**
 702  * goodix_reset - Reset device during power on
 703  *
 704  * @ts: goodix_ts_data pointer
 705  */
 706 static int goodix_reset(struct goodix_ts_data *ts)
 707 {
 708         int error;
 709
 710         /* begin select I2C slave addr */
 711         error = gpiod_direction_output(ts->gpiod_rst, 0);
 712         if (error)
 713                 return error;
 714
 715         msleep(20);                             /* T2: > 10ms */
 716
 717         /* HIGH: 0x28/0x29, LOW: 0xBA/0xBB */
 718         error = goodix_irq_direction_output(ts, ts->client->addr == 0x14);
 719         if (error)
 720                 return error;
 721
 722         usleep_range(100, 2000);                /* T3: > 100us */
 723
 724         error = gpiod_direction_output(ts->gpiod_rst, 1);
 725         if (error)
 726                 return error;
 727
 728         usleep_range(6000, 10000);              /* T4: > 5ms */
 729
 730         /* end select I2C slave addr */
 731         error = gpiod_direction_input(ts->gpiod_rst);
 732         if (error)
 733                 return error;
 734
 735         error = goodix_int_sync(ts);
 736         if (error)
 737                 return error;
 738
 739         return 0;
 740 }
 741
 742 #ifdef ACPI_GPIO_SUPPORT
 743 #include <asm/cpu_device_id.h>
 744 #include <asm/intel-family.h>
 745
 746 static const struct x86_cpu_id baytrail_cpu_ids[] = {
 747         { X86_VENDOR_INTEL, 6, INTEL_FAM6_ATOM_SILVERMONT, X86_FEATURE_ANY, },
 748         {}
 749 };
 750
 751 static inline bool is_byt(void)
 752 {
 753         const struct x86_cpu_id *id = x86_match_cpu(baytrail_cpu_ids);
 754
 755         return !!id;
 756 }
 757
 758 static const struct acpi_gpio_params first_gpio = { 0, 0, false };
 759 static const struct acpi_gpio_params second_gpio = { 1, 0, false };
 760
 761 static const struct acpi_gpio_mapping acpi_goodix_int_first_gpios[] = {
 762         { GOODIX_GPIO_INT_NAME "-gpios", &first_gpio, 1 },
 763         { GOODIX_GPIO_RST_NAME "-gpios", &second_gpio, 1 },
 764         { },
 765 };
 766
 767 static const struct acpi_gpio_mapping acpi_goodix_int_last_gpios[] = {
 768         { GOODIX_GPIO_RST_NAME "-gpios", &first_gpio, 1 },
 769         { GOODIX_GPIO_INT_NAME "-gpios", &second_gpio, 1 },
 770         { },
 771 };
 772
 773 static const struct acpi_gpio_mapping acpi_goodix_reset_only_gpios[] = {
 774         { GOODIX_GPIO_RST_NAME "-gpios", &first_gpio, 1 },
 775         { },
 776 };
 777
 778 static int goodix_resource(struct acpi_resource *ares, void *data)
 779 {
 780         struct goodix_ts_data *ts = data;
 781         struct device *dev = &ts->client->dev;
 782         struct acpi_resource_gpio *gpio;
 783
 784         switch (ares->type) {
 785         case ACPI_RESOURCE_TYPE_GPIO:
 786                 gpio = &ares->data.gpio;
 787                 if (gpio->connection_type == ACPI_RESOURCE_GPIO_TYPE_INT) {
 788                         if (ts->gpio_int_idx == -1) {
 789                                 ts->gpio_int_idx = ts->gpio_count;
 790                         } else {
 791                                 dev_err(dev, "More then one GpioInt resource, ignoring ACPI GPIO resources\n");
 792                                 ts->gpio_int_idx = -2;
 793                         }
 794                 }
 795                 ts->gpio_count++;
 796                 break;
 797         default:
 798                 break;
 799         }
 800
 801         return 0;
 802 }
 803
 804 /*
 805  * This function gets called in case we fail to get the irq GPIO directly
 806  * because the ACPI tables lack GPIO-name to APCI _CRS index mappings
 807  * (no _DSD UUID daffd814-6eba-4d8c-8a91-bc9bbf4aa301 data).
 808  * In that case we add our own mapping and then goodix_get_gpio_config()
 809  * retries to get the GPIOs based on the added mapping.
 810  */
 811 static int goodix_add_acpi_gpio_mappings(struct goodix_ts_data *ts)
 812 {
 813         const struct acpi_gpio_mapping *gpio_mapping = NULL;
 814         struct device *dev = &ts->client->dev;
 815         LIST_HEAD(resources);
 816         int ret;
 817
 818         ts->gpio_count = 0;
 819         ts->gpio_int_idx = -1;
 820         ret = acpi_dev_get_resources(ACPI_COMPANION(dev), &resources,
 821                                      goodix_resource, ts);
 822         if (ret < 0) {
 823                 dev_err(dev, "Error getting ACPI resources: %d\n", ret);
 824                 return ret;
 825         }
 826
 827         acpi_dev_free_resource_list(&resources);
 828
 829         if (ts->gpio_count == 2 && ts->gpio_int_idx == 0) {
 830                 ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_GPIO;
 831                 gpio_mapping = acpi_goodix_int_first_gpios;
 832         } else if (ts->gpio_count == 2 && ts->gpio_int_idx == 1) {
 833                 ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_GPIO;
 834                 gpio_mapping = acpi_goodix_int_last_gpios;
 835         } else if (ts->gpio_count == 1 && ts->gpio_int_idx == -1 &&
 836                    acpi_has_method(ACPI_HANDLE(dev), "INTI") &&
 837                    acpi_has_method(ACPI_HANDLE(dev), "INTO")) {
 838                 dev_info(dev, "Using ACPI INTI and INTO methods for IRQ pin access\n");
 839                 ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_METHOD;
 840                 gpio_mapping = acpi_goodix_reset_only_gpios;
 841         } else if (is_byt() && ts->gpio_count == 2 && ts->gpio_int_idx == -1) {
 842                 dev_info(dev, "No ACPI GpioInt resource, assuming that the GPIO order is reset, int\n");
 843                 ts->irq_pin_access_method = IRQ_PIN_ACCESS_ACPI_GPIO;
 844                 gpio_mapping = acpi_goodix_int_last_gpios;
 845         } else {
 846                 dev_warn(dev, "Unexpected ACPI resources: gpio_count %d, gpio_int_idx %d\n",
 847                          ts->gpio_count, ts->gpio_int_idx);
 848                 return -EINVAL;
 849         }
 850
 851         return devm_acpi_dev_add_driver_gpios(dev, gpio_mapping);
 852 }
 853 #else
 854 static int goodix_add_acpi_gpio_mappings(struct goodix_ts_data *ts)
 855 {
 856         return -EINVAL;
 857 }
 858 #endif /* CONFIG_X86 && CONFIG_ACPI */
 859
 860 /**
 861  * goodix_get_gpio_config - Get GPIO config from ACPI/DT
 862  *
 863  * @ts: goodix_ts_data pointer
 864  */
 865 static int goodix_get_gpio_config(struct goodix_ts_data *ts)
 866 {
 867         int error;
 868         struct device *dev;
 869         struct gpio_desc *gpiod;
 870         bool added_acpi_mappings = false;
 871
 872         if (!ts->client)
 873                 return -EINVAL;
 874         dev = &ts->client->dev;
 875
 876         ts->avdd28 = devm_regulator_get(dev, "AVDD28");
 877         if (IS_ERR(ts->avdd28)) {
 878                 error = PTR_ERR(ts->avdd28);
 879                 if (error != -EPROBE_DEFER)
 880                         dev_err(dev,
 881                                 "Failed to get AVDD28 regulator: %d\n", error);
 882                 return error;
 883         }
 884
 885         ts->vddio = devm_regulator_get(dev, "VDDIO");
 886         if (IS_ERR(ts->vddio)) {
 887                 error = PTR_ERR(ts->vddio);
 888                 if (error != -EPROBE_DEFER)
 889                         dev_err(dev,
 890                                 "Failed to get VDDIO regulator: %d\n", error);
 891                 return error;
 892         }
 893
 894 retry_get_irq_gpio:
 895         /* Get the interrupt GPIO pin number */
 896         gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_INT_NAME, GPIOD_IN);
 897         if (IS_ERR(gpiod)) {
 898                 error = PTR_ERR(gpiod);
 899                 if (error != -EPROBE_DEFER)
 900                         dev_dbg(dev, "Failed to get %s GPIO: %d\n",
 901                                 GOODIX_GPIO_INT_NAME, error);
 902                 return error;
 903         }
 904         if (!gpiod && has_acpi_companion(dev) && !added_acpi_mappings) {
 905                 added_acpi_mappings = true;
 906                 if (goodix_add_acpi_gpio_mappings(ts) == 0)
 907                         goto retry_get_irq_gpio;
 908         }
 909
 910         ts->gpiod_int = gpiod;
 911
 912         /* Get the reset line GPIO pin number */
 913         gpiod = devm_gpiod_get_optional(dev, GOODIX_GPIO_RST_NAME, GPIOD_IN);
 914         if (IS_ERR(gpiod)) {
 915                 error = PTR_ERR(gpiod);
 916                 if (error != -EPROBE_DEFER)
 917                         dev_dbg(dev, "Failed to get %s GPIO: %d\n",
 918                                 GOODIX_GPIO_RST_NAME, error);
 919                 return error;
 920         }
 921
 922         ts->gpiod_rst = gpiod;
 923
 924         switch (ts->irq_pin_access_method) {
 925         case IRQ_PIN_ACCESS_ACPI_GPIO:
 926                 /*
 927                  * We end up here if goodix_add_acpi_gpio_mappings() has
 928                  * called devm_acpi_dev_add_driver_gpios() because the ACPI
 929                  * tables did not contain name to index mappings.
 930                  * Check that we successfully got both GPIOs after we've
 931                  * added our own acpi_gpio_mapping and if we did not get both
 932                  * GPIOs reset irq_pin_access_method to IRQ_PIN_ACCESS_NONE.
 933                  */
 934                 if (!ts->gpiod_int || !ts->gpiod_rst)
 935                         ts->irq_pin_access_method = IRQ_PIN_ACCESS_NONE;
 936                 break;
 937         case IRQ_PIN_ACCESS_ACPI_METHOD:
 938                 if (!ts->gpiod_rst)
 939                         ts->irq_pin_access_method = IRQ_PIN_ACCESS_NONE;
 940                 break;
 941         default:
 942                 if (ts->gpiod_int && ts->gpiod_rst) {
 943                         ts->reset_controller_at_probe = true;
 944                         ts->load_cfg_from_disk = true;
 945                         ts->irq_pin_access_method = IRQ_PIN_ACCESS_GPIO;
 946                 }
 947         }
 948
 949         return 0;
 950 }
 951
 952 /**
 953  * goodix_read_config - Read the embedded configuration of the panel
 954  *
 955  * @ts: our goodix_ts_data pointer
 956  *
 957  * Must be called during probe
 958  */
 959 static void goodix_read_config(struct goodix_ts_data *ts)
 960 {
 961         int x_max, y_max;
 962         int error;
 963
 964         error = goodix_i2c_read(ts->client, ts->chip->config_addr,
 965                                 ts->config, ts->chip->config_len);
 966         if (error) {
 967                 dev_warn(&ts->client->dev, "Error reading config: %d\n",
 968                          error);
 969                 ts->int_trigger_type = GOODIX_INT_TRIGGER;
 970                 ts->max_touch_num = GOODIX_MAX_CONTACTS;
 971                 return;
 972         }
 973
 974         ts->int_trigger_type = ts->config[TRIGGER_LOC] & 0x03;
 975         ts->max_touch_num = ts->config[MAX_CONTACTS_LOC] & 0x0f;
 976
 977         x_max = get_unaligned_le16(&ts->config[RESOLUTION_LOC]);
 978         y_max = get_unaligned_le16(&ts->config[RESOLUTION_LOC + 2]);
 979         if (x_max && y_max) {
 980                 input_abs_set_max(ts->input_dev, ABS_MT_POSITION_X, x_max - 1);
 981                 input_abs_set_max(ts->input_dev, ABS_MT_POSITION_Y, y_max - 1);
 982         }
 983
 984         ts->chip->calc_config_checksum(ts);
 985 }
 986
 987 /**
 988  * goodix_read_version - Read goodix touchscreen version
 989  *
 990  * @ts: our goodix_ts_data pointer
 991  */
 992 static int goodix_read_version(struct goodix_ts_data *ts)
 993 {
 994         int error;
 995         u8 buf[6];
 996         char id_str[GOODIX_ID_MAX_LEN + 1];
 997
 998         error = goodix_i2c_read(ts->client, GOODIX_REG_ID, buf, sizeof(buf));
 999         if (error) {
1000                 dev_err(&ts->client->dev, "read version failed: %d\n", error);
1001                 return error;
1002         }
1003
1004         memcpy(id_str, buf, GOODIX_ID_MAX_LEN);
1005         id_str[GOODIX_ID_MAX_LEN] = 0;
1006         strscpy(ts->id, id_str, GOODIX_ID_MAX_LEN + 1);
1007
1008         ts->version = get_unaligned_le16(&buf[4]);
1009
1010         dev_info(&ts->client->dev, "ID %s, version: %04x\n", ts->id,
1011                  ts->version);
1012
1013         return 0;
1014 }
1015
1016 /**
1017  * goodix_i2c_test - I2C test function to check if the device answers.
1018  *
1019  * @client: the i2c client
1020  */
1021 static int goodix_i2c_test(struct i2c_client *client)
1022 {
1023         int retry = 0;
1024         int error;
1025         u8 test;
1026
1027         while (retry++ < 2) {
1028                 error = goodix_i2c_read(client, GOODIX_REG_ID,
1029                                         &test, 1);
1030                 if (!error)
1031                         return 0;
1032
1033                 dev_err(&client->dev, "i2c test failed attempt %d: %d\n",
1034                         retry, error);
1035                 msleep(20);
1036         }
1037
1038         return error;
1039 }
1040
1041 /**
1042  * goodix_configure_dev - Finish device initialization
1043  *
1044  * @ts: our goodix_ts_data pointer
1045  *
1046  * Must be called from probe to finish initialization of the device.
1047  * Contains the common initialization code for both devices that
1048  * declare gpio pins and devices that do not. It is either called
1049  * directly from probe or from request_firmware_wait callback.
1050  */
1051 static int goodix_configure_dev(struct goodix_ts_data *ts)
1052 {
1053         int error;
1054         int i;
1055
1056         ts->int_trigger_type = GOODIX_INT_TRIGGER;
1057         ts->max_touch_num = GOODIX_MAX_CONTACTS;
1058
1059         ts->input_dev = devm_input_allocate_device(&ts->client->dev);
1060         if (!ts->input_dev) {
1061                 dev_err(&ts->client->dev, "Failed to allocate input device.");
1062                 return -ENOMEM;
1063         }
1064
1065         ts->input_dev->name = "Goodix Capacitive TouchScreen";
1066         ts->input_dev->phys = "input/ts";
1067         ts->input_dev->id.bustype = BUS_I2C;
1068         ts->input_dev->id.vendor = 0x0416;
1069         if (kstrtou16(ts->id, 10, &ts->input_dev->id.product))
1070                 ts->input_dev->id.product = 0x1001;
1071         ts->input_dev->id.version = ts->version;
1072
1073         ts->input_dev->keycode = ts->keymap;
1074         ts->input_dev->keycodesize = sizeof(ts->keymap[0]);
1075         ts->input_dev->keycodemax = GOODIX_MAX_KEYS;
1076
1077         /* Capacitive Windows/Home button on some devices */
1078         for (i = 0; i < GOODIX_MAX_KEYS; ++i) {
1079                 if (i == 0)
1080                         ts->keymap[i] = KEY_LEFTMETA;
1081                 else
1082                         ts->keymap[i] = KEY_F1 + (i - 1);
1083
1084                 input_set_capability(ts->input_dev, EV_KEY, ts->keymap[i]);
1085         }
1086
1087         input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_X);
1088         input_set_capability(ts->input_dev, EV_ABS, ABS_MT_POSITION_Y);
1089         input_set_abs_params(ts->input_dev, ABS_MT_WIDTH_MAJOR, 0, 255, 0, 0);
1090         input_set_abs_params(ts->input_dev, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
1091
1092         /* Read configuration and apply touchscreen parameters */
1093         goodix_read_config(ts);
1094
1095         /* Try overriding touchscreen parameters via device properties */
1096         touchscreen_parse_properties(ts->input_dev, true, &ts->prop);
1097
1098         if (!ts->prop.max_x || !ts->prop.max_y || !ts->max_touch_num) {
1099                 dev_err(&ts->client->dev,
1100                         "Invalid config (%d, %d, %d), using defaults\n",
1101                         ts->prop.max_x, ts->prop.max_y, ts->max_touch_num);
1102                 ts->prop.max_x = GOODIX_MAX_WIDTH - 1;
1103                 ts->prop.max_y = GOODIX_MAX_HEIGHT - 1;
1104                 ts->max_touch_num = GOODIX_MAX_CONTACTS;
1105                 input_abs_set_max(ts->input_dev,
1106                                   ABS_MT_POSITION_X, ts->prop.max_x);
1107                 input_abs_set_max(ts->input_dev,
1108                                   ABS_MT_POSITION_Y, ts->prop.max_y);
1109         }
1110
1111         if (dmi_check_system(rotated_screen)) {
1112                 ts->prop.invert_x = true;
1113                 ts->prop.invert_y = true;
1114                 dev_dbg(&ts->client->dev,
1115                         "Applying '180 degrees rotated screen' quirk\n");
1116         }
1117
1118         if (dmi_check_system(nine_bytes_report)) {
1119                 ts->contact_size = 9;
1120
1121                 dev_dbg(&ts->client->dev,
1122                         "Non-standard 9-bytes report format quirk\n");
1123         }
1124
1125         if (dmi_check_system(inverted_x_screen)) {
1126                 ts->prop.invert_x = true;
1127                 dev_dbg(&ts->client->dev,
1128                         "Applying 'inverted x screen' quirk\n");
1129         }
1130
1131         error = input_mt_init_slots(ts->input_dev, ts->max_touch_num,
1132                                     INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
1133         if (error) {
1134                 dev_err(&ts->client->dev,
1135                         "Failed to initialize MT slots: %d", error);
1136                 return error;
1137         }
1138
1139         error = input_register_device(ts->input_dev);
1140         if (error) {
1141                 dev_err(&ts->client->dev,
1142                         "Failed to register input device: %d", error);
1143                 return error;
1144         }
1145
1146         ts->irq_flags = goodix_irq_flags[ts->int_trigger_type] | IRQF_ONESHOT;
1147         error = goodix_request_irq(ts);
1148         if (error) {
1149                 dev_err(&ts->client->dev, "request IRQ failed: %d\n", error);
1150                 return error;
1151         }
1152
1153         return 0;
1154 }
1155
1156 /**
1157  * goodix_config_cb - Callback to finish device init
1158  *
1159  * @ts: our goodix_ts_data pointer
1160  *
1161  * request_firmware_wait callback that finishes
1162  * initialization of the device.
1163  */
1164 static void goodix_config_cb(const struct firmware *cfg, void *ctx)
1165 {
1166         struct goodix_ts_data *ts = ctx;
1167         int error;
1168
1169         if (cfg) {
1170                 /* send device configuration to the firmware */
1171                 error = goodix_send_cfg(ts, cfg->data, cfg->size);
1172                 if (error)
1173                         goto err_release_cfg;
1174         }
1175
1176         goodix_configure_dev(ts);
1177
1178 err_release_cfg:
1179         release_firmware(cfg);
1180         complete_all(&ts->firmware_loading_complete);
1181 }
1182
1183 static void goodix_disable_regulators(void *arg)
1184 {
1185         struct goodix_ts_data *ts = arg;
1186
1187         regulator_disable(ts->vddio);
1188         regulator_disable(ts->avdd28);
1189 }
1190
1191 static int goodix_ts_probe(struct i2c_client *client,
1192                            const struct i2c_device_id *id)
1193 {
1194         struct goodix_ts_data *ts;
1195         int error;
1196
1197         dev_dbg(&client->dev, "I2C Address: 0x%02x\n", client->addr);
1198
1199         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1200                 dev_err(&client->dev, "I2C check functionality failed.\n");
1201                 return -ENXIO;
1202         }
1203
1204         ts = devm_kzalloc(&client->dev, sizeof(*ts), GFP_KERNEL);
1205         if (!ts)
1206                 return -ENOMEM;
1207
1208         ts->client = client;
1209         i2c_set_clientdata(client, ts);
1210         init_completion(&ts->firmware_loading_complete);
1211         ts->contact_size = GOODIX_CONTACT_SIZE;
1212
1213         error = goodix_get_gpio_config(ts);
1214         if (error)
1215                 return error;
1216
1217         /* power up the controller */
1218         error = regulator_enable(ts->avdd28);
1219         if (error) {
1220                 dev_err(&client->dev,
1221                         "Failed to enable AVDD28 regulator: %d\n",
1222                         error);
1223                 return error;
1224         }
1225
1226         error = regulator_enable(ts->vddio);
1227         if (error) {
1228                 dev_err(&client->dev,
1229                         "Failed to enable VDDIO regulator: %d\n",
1230                         error);
1231                 regulator_disable(ts->avdd28);
1232                 return error;
1233         }
1234
1235         error = devm_add_action_or_reset(&client->dev,
1236                                          goodix_disable_regulators, ts);
1237         if (error)
1238                 return error;
1239
1240 reset:
1241         if (ts->reset_controller_at_probe) {
1242                 /* reset the controller */
1243                 error = goodix_reset(ts);
1244                 if (error) {
1245                         dev_err(&client->dev, "Controller reset failed.\n");
1246                         return error;
1247                 }
1248         }
1249
1250         error = goodix_i2c_test(client);
1251         if (error) {
1252                 if (!ts->reset_controller_at_probe &&
1253                     ts->irq_pin_access_method != IRQ_PIN_ACCESS_NONE) {
1254                         /* Retry after a controller reset */
1255                         ts->reset_controller_at_probe = true;
1256                         goto reset;
1257                 }
1258                 dev_err(&client->dev, "I2C communication failure: %d\n", error);
1259                 return error;
1260         }
1261
1262         error = goodix_read_version(ts);
1263         if (error) {
1264                 dev_err(&client->dev, "Read version failed.\n");
1265                 return error;
1266         }
1267
1268         ts->chip = goodix_get_chip_data(ts->id);
1269
1270         if (ts->load_cfg_from_disk) {
1271                 /* update device config */
1272                 ts->cfg_name = devm_kasprintf(&client->dev, GFP_KERNEL,
1273                                               "goodix_%s_cfg.bin", ts->id);
1274                 if (!ts->cfg_name)
1275                         return -ENOMEM;
1276
1277                 error = request_firmware_nowait(THIS_MODULE, true, ts->cfg_name,
1278                                                 &client->dev, GFP_KERNEL, ts,
1279                                                 goodix_config_cb);
1280                 if (error) {
1281                         dev_err(&client->dev,
1282                                 "Failed to invoke firmware loader: %d\n",
1283                                 error);
1284                         return error;
1285                 }
1286
1287                 return 0;
1288         } else {
1289                 error = goodix_configure_dev(ts);
1290                 if (error)
1291                         return error;
1292         }
1293
1294         return 0;
1295 }
1296
1297 static int goodix_ts_remove(struct i2c_client *client)
1298 {
1299         struct goodix_ts_data *ts = i2c_get_clientdata(client);
1300
1301         if (ts->load_cfg_from_disk)
1302                 wait_for_completion(&ts->firmware_loading_complete);
1303
1304         return 0;
1305 }
1306
1307 static int __maybe_unused goodix_suspend(struct device *dev)
1308 {
1309         struct i2c_client *client = to_i2c_client(dev);
1310         struct goodix_ts_data *ts = i2c_get_clientdata(client);
1311         int error;
1312
1313         if (ts->load_cfg_from_disk)
1314                 wait_for_completion(&ts->firmware_loading_complete);
1315
1316         /* We need gpio pins to suspend/resume */
1317         if (ts->irq_pin_access_method == IRQ_PIN_ACCESS_NONE) {
1318                 disable_irq(client->irq);
1319                 return 0;
1320         }
1321
1322         /* Free IRQ as IRQ pin is used as output in the suspend sequence */
1323         goodix_free_irq(ts);
1324
1325         /* Output LOW on the INT pin for 5 ms */
1326         error = goodix_irq_direction_output(ts, 0);
1327         if (error) {
1328                 goodix_request_irq(ts);
1329                 return error;
1330         }
1331
1332         usleep_range(5000, 6000);
1333
1334         error = goodix_i2c_write_u8(ts->client, GOODIX_REG_COMMAND,
1335                                     GOODIX_CMD_SCREEN_OFF);
1336         if (error) {
1337                 dev_err(&ts->client->dev, "Screen off command failed\n");
1338                 goodix_irq_direction_input(ts);
1339                 goodix_request_irq(ts);
1340                 return -EAGAIN;
1341         }
1342
1343         /*
1344          * The datasheet specifies that the interval between sending screen-off
1345          * command and wake-up should be longer than 58 ms. To avoid waking up
1346          * sooner, delay 58ms here.
1347          */
1348         msleep(58);
1349         return 0;
1350 }
1351
1352 static int __maybe_unused goodix_resume(struct device *dev)
1353 {
1354         struct i2c_client *client = to_i2c_client(dev);
1355         struct goodix_ts_data *ts = i2c_get_clientdata(client);
1356         u8 config_ver;
1357         int error;
1358
1359         if (ts->irq_pin_access_method == IRQ_PIN_ACCESS_NONE) {
1360                 enable_irq(client->irq);
1361                 return 0;
1362         }
1363
1364         /*
1365          * Exit sleep mode by outputting HIGH level to INT pin
1366          * for 2ms~5ms.
1367          */
1368         error = goodix_irq_direction_output(ts, 1);
1369         if (error)
1370                 return error;
1371
1372         usleep_range(2000, 5000);
1373
1374         error = goodix_int_sync(ts);
1375         if (error)
1376                 return error;
1377
1378         error = goodix_i2c_read(ts->client, ts->chip->config_addr,
1379                                 &config_ver, 1);
1380         if (error)
1381                 dev_warn(dev, "Error reading config version: %d, resetting controller\n",
1382                          error);
1383         else if (config_ver != ts->config[0])
1384                 dev_info(dev, "Config version mismatch %d != %d, resetting controller\n",
1385                          config_ver, ts->config[0]);
1386
1387         if (error != 0 || config_ver != ts->config[0]) {
1388                 error = goodix_reset(ts);
1389                 if (error) {
1390                         dev_err(dev, "Controller reset failed.\n");
1391                         return error;
1392                 }
1393
1394                 error = goodix_send_cfg(ts, ts->config, ts->chip->config_len);
1395                 if (error)
1396                         return error;
1397         }
1398
1399         error = goodix_request_irq(ts);
1400         if (error)
1401                 return error;
1402
1403         return 0;
1404 }
1405
1406 static SIMPLE_DEV_PM_OPS(goodix_pm_ops, goodix_suspend, goodix_resume);
1407
1408 static const struct i2c_device_id goodix_ts_id[] = {
1409         { "GDIX1001:00", 0 },
1410         { }
1411 };
1412 MODULE_DEVICE_TABLE(i2c, goodix_ts_id);
1413
1414 #ifdef CONFIG_ACPI
1415 static const struct acpi_device_id goodix_acpi_match[] = {
1416         { "GDIX1001", 0 },
1417         { "GDIX1002", 0 },
1418         { }
1419 };
1420 MODULE_DEVICE_TABLE(acpi, goodix_acpi_match);
1421 #endif
1422
1423 #ifdef CONFIG_OF
1424 static const struct of_device_id goodix_of_match[] = {
1425         { .compatible = "goodix,gt1151" },
1426         { .compatible = "goodix,gt5663" },
1427         { .compatible = "goodix,gt5688" },
1428         { .compatible = "goodix,gt911" },
1429         { .compatible = "goodix,gt9110" },
1430         { .compatible = "goodix,gt912" },
1431         { .compatible = "goodix,gt9147" },
1432         { .compatible = "goodix,gt917s" },
1433         { .compatible = "goodix,gt927" },
1434         { .compatible = "goodix,gt9271" },
1435         { .compatible = "goodix,gt928" },
1436         { .compatible = "goodix,gt967" },
1437         { }
1438 };
1439 MODULE_DEVICE_TABLE(of, goodix_of_match);
1440 #endif
1441
1442 static struct i2c_driver goodix_ts_driver = {
1443         .probe = goodix_ts_probe,
1444         .remove = goodix_ts_remove,
1445         .id_table = goodix_ts_id,
1446         .driver = {
1447                 .name = "Goodix-TS",
1448                 .acpi_match_table = ACPI_PTR(goodix_acpi_match),
1449                 .of_match_table = of_match_ptr(goodix_of_match),
1450                 .pm = &goodix_pm_ops,
1451         },
1452 };
1453 module_i2c_driver(goodix_ts_driver);
1454
1455 MODULE_AUTHOR("Benjamin Tissoires <[email protected]>");
1456 MODULE_AUTHOR("Bastien Nocera <[email protected]>");
1457 MODULE_DESCRIPTION("Goodix touchscreen driver");
1458 MODULE_LICENSE("GPL v2");