drivers/input/touchscreen/elants_i2c.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Elan Microelectronics touch panels with I2C interface
   4  *
   5  * Copyright (C) 2014 Elan Microelectronics Corporation.
   6  * Scott Liu <scott.liu@emc.com.tw>
   7  *
   8  * This code is partly based on hid-multitouch.c:
   9  *
  10  *  Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr>
  11  *  Copyright (c) 2010-2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
  12  *  Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France
  13  *
  14  * This code is partly based on i2c-hid.c:
  15  *
  16  * Copyright (c) 2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
  17  * Copyright (c) 2012 Ecole Nationale de l'Aviation Civile, France
  18  * Copyright (c) 2012 Red Hat, Inc
  19  */
  20
  21
  22 #include <linux/bits.h>
  23 #include <linux/module.h>
  24 #include <linux/input.h>
  25 #include <linux/interrupt.h>
  26 #include <linux/irq.h>
  27 #include <linux/platform_device.h>
  28 #include <linux/async.h>
  29 #include <linux/i2c.h>
  30 #include <linux/delay.h>
  31 #include <linux/uaccess.h>
  32 #include <linux/buffer_head.h>
  33 #include <linux/slab.h>
  34 #include <linux/firmware.h>
  35 #include <linux/input/mt.h>
  36 #include <linux/input/touchscreen.h>
  37 #include <linux/acpi.h>
  38 #include <linux/of.h>
  39 #include <linux/gpio/consumer.h>
  40 #include <linux/regulator/consumer.h>
  41 #include <linux/uuid.h>
  42 #include <asm/unaligned.h>
  43
  44 /* Device, Driver information */
  45 #define DEVICE_NAME     "elants_i2c"
  46
  47 /* Convert from rows or columns into resolution */
  48 #define ELAN_TS_RESOLUTION(n, m)   (((n) - 1) * (m))
  49
  50 /* FW header data */
  51 #define HEADER_SIZE             4
  52 #define FW_HDR_TYPE             0
  53 #define FW_HDR_COUNT            1
  54 #define FW_HDR_LENGTH           2
  55
  56 /* Buffer mode Queue Header information */
  57 #define QUEUE_HEADER_SINGLE     0x62
  58 #define QUEUE_HEADER_NORMAL     0X63
  59 #define QUEUE_HEADER_WAIT       0x64
  60
  61 /* Command header definition */
  62 #define CMD_HEADER_WRITE        0x54
  63 #define CMD_HEADER_READ         0x53
  64 #define CMD_HEADER_6B_READ      0x5B
  65 #define CMD_HEADER_ROM_READ     0x96
  66 #define CMD_HEADER_RESP         0x52
  67 #define CMD_HEADER_6B_RESP      0x9B
  68 #define CMD_HEADER_ROM_RESP     0x95
  69 #define CMD_HEADER_HELLO        0x55
  70 #define CMD_HEADER_REK          0x66
  71
  72 /* FW position data */
  73 #define PACKET_SIZE             55
  74 #define MAX_CONTACT_NUM         10
  75 #define FW_POS_HEADER           0
  76 #define FW_POS_STATE            1
  77 #define FW_POS_TOTAL            2
  78 #define FW_POS_XY               3
  79 #define FW_POS_TOOL_TYPE        33
  80 #define FW_POS_CHECKSUM         34
  81 #define FW_POS_WIDTH            35
  82 #define FW_POS_PRESSURE         45
  83
  84 #define HEADER_REPORT_10_FINGER 0x62
  85
  86 /* Header (4 bytes) plus 3 fill 10-finger packets */
  87 #define MAX_PACKET_SIZE         169
  88
  89 #define BOOT_TIME_DELAY_MS      50
  90
  91 /* FW read command, 0x53 0x?? 0x0, 0x01 */
  92 #define E_ELAN_INFO_FW_VER      0x00
  93 #define E_ELAN_INFO_BC_VER      0x10
  94 #define E_ELAN_INFO_REK         0xD0
  95 #define E_ELAN_INFO_TEST_VER    0xE0
  96 #define E_ELAN_INFO_FW_ID       0xF0
  97 #define E_INFO_OSR              0xD6
  98 #define E_INFO_PHY_SCAN         0xD7
  99 #define E_INFO_PHY_DRIVER       0xD8
 100
 101 #define MAX_RETRIES             3
 102 #define MAX_FW_UPDATE_RETRIES   30
 103
 104 #define ELAN_FW_PAGESIZE        132
 105
 106 /* calibration timeout definition */
 107 #define ELAN_CALI_TIMEOUT_MSEC  12000
 108
 109 #define ELAN_POWERON_DELAY_USEC 500
 110 #define ELAN_RESET_DELAY_MSEC   20
 111
 112 /* FW boot code version */
 113 #define BC_VER_H_BYTE_FOR_EKTH3900x1_I2C        0x72
 114 #define BC_VER_H_BYTE_FOR_EKTH3900x2_I2C        0x82
 115 #define BC_VER_H_BYTE_FOR_EKTH3900x3_I2C        0x92
 116 #define BC_VER_H_BYTE_FOR_EKTH5312x1_I2C        0x6D
 117 #define BC_VER_H_BYTE_FOR_EKTH5312x2_I2C        0x6E
 118 #define BC_VER_H_BYTE_FOR_EKTH5312cx1_I2C       0x77
 119 #define BC_VER_H_BYTE_FOR_EKTH5312cx2_I2C       0x78
 120 #define BC_VER_H_BYTE_FOR_EKTH5312x1_I2C_USB    0x67
 121 #define BC_VER_H_BYTE_FOR_EKTH5312x2_I2C_USB    0x68
 122 #define BC_VER_H_BYTE_FOR_EKTH5312cx1_I2C_USB   0x74
 123 #define BC_VER_H_BYTE_FOR_EKTH5312cx2_I2C_USB   0x75
 124
 125 enum elants_state {
 126         ELAN_STATE_NORMAL,
 127         ELAN_WAIT_QUEUE_HEADER,
 128         ELAN_WAIT_RECALIBRATION,
 129 };
 130
 131 enum elants_iap_mode {
 132         ELAN_IAP_OPERATIONAL,
 133         ELAN_IAP_RECOVERY,
 134 };
 135
 136 /* struct elants_data - represents state of Elan touchscreen device */
 137 struct elants_data {
 138         struct i2c_client *client;
 139         struct input_dev *input;
 140
 141         struct regulator *vcc33;
 142         struct regulator *vccio;
 143         struct gpio_desc *reset_gpio;
 144
 145         u16 fw_version;
 146         u8 test_version;
 147         u8 solution_version;
 148         u8 bc_version;
 149         u8 iap_version;
 150         u16 hw_version;
 151         u8 major_res;
 152         unsigned int x_res;     /* resolution in units/mm */
 153         unsigned int y_res;
 154         unsigned int x_max;
 155         unsigned int y_max;
 156         struct touchscreen_properties prop;
 157
 158         enum elants_state state;
 159         enum elants_iap_mode iap_mode;
 160
 161         /* Guards against concurrent access to the device via sysfs */
 162         struct mutex sysfs_mutex;
 163
 164         u8 cmd_resp[HEADER_SIZE];
 165         struct completion cmd_done;
 166
 167         bool wake_irq_enabled;
 168         bool keep_power_in_suspend;
 169
 170         /* Must be last to be used for DMA operations */
 171         u8 buf[MAX_PACKET_SIZE] ____cacheline_aligned;
 172 };
 173
 174 static int elants_i2c_send(struct i2c_client *client,
 175                            const void *data, size_t size)
 176 {
 177         int ret;
 178
 179         ret = i2c_master_send(client, data, size);
 180         if (ret == size)
 181                 return 0;
 182
 183         if (ret >= 0)
 184                 ret = -EIO;
 185
 186         dev_err(&client->dev, "%s failed (%*ph): %d\n",
 187                 __func__, (int)size, data, ret);
 188
 189         return ret;
 190 }
 191
 192 static int elants_i2c_read(struct i2c_client *client, void *data, size_t size)
 193 {
 194         int ret;
 195
 196         ret = i2c_master_recv(client, data, size);
 197         if (ret == size)
 198                 return 0;
 199
 200         if (ret >= 0)
 201                 ret = -EIO;
 202
 203         dev_err(&client->dev, "%s failed: %d\n", __func__, ret);
 204
 205         return ret;
 206 }
 207
 208 static int elants_i2c_execute_command(struct i2c_client *client,
 209                                       const u8 *cmd, size_t cmd_size,
 210                                       u8 *resp, size_t resp_size,
 211                                       int retries, const char *cmd_name)
 212 {
 213         struct i2c_msg msgs[2];
 214         int ret;
 215         u8 expected_response;
 216
 217         switch (cmd[0]) {
 218         case CMD_HEADER_READ:
 219                 expected_response = CMD_HEADER_RESP;
 220                 break;
 221
 222         case CMD_HEADER_6B_READ:
 223                 expected_response = CMD_HEADER_6B_RESP;
 224                 break;
 225
 226         case CMD_HEADER_ROM_READ:
 227                 expected_response = CMD_HEADER_ROM_RESP;
 228                 break;
 229
 230         default:
 231                 dev_err(&client->dev, "(%s): invalid command: %*ph\n",
 232                         cmd_name, (int)cmd_size, cmd);
 233                 return -EINVAL;
 234         }
 235
 236         for (;;) {
 237                 msgs[0].addr = client->addr;
 238                 msgs[0].flags = client->flags & I2C_M_TEN;
 239                 msgs[0].len = cmd_size;
 240                 msgs[0].buf = (u8 *)cmd;
 241
 242                 msgs[1].addr = client->addr;
 243                 msgs[1].flags = (client->flags & I2C_M_TEN) | I2C_M_RD;
 244                 msgs[1].flags |= I2C_M_RD;
 245                 msgs[1].len = resp_size;
 246                 msgs[1].buf = resp;
 247
 248                 ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
 249                 if (ret < 0) {
 250                         if (--retries > 0) {
 251                                 dev_dbg(&client->dev,
 252                                         "(%s) I2C transfer failed: %pe (retrying)\n",
 253                                         cmd_name, ERR_PTR(ret));
 254                                 continue;
 255                         }
 256
 257                         dev_err(&client->dev,
 258                                 "(%s) I2C transfer failed: %pe\n",
 259                                 cmd_name, ERR_PTR(ret));
 260                         return ret;
 261                 }
 262
 263                 if (ret != ARRAY_SIZE(msgs) ||
 264                     resp[FW_HDR_TYPE] != expected_response) {
 265                         if (--retries > 0) {
 266                                 dev_dbg(&client->dev,
 267                                         "(%s) unexpected response: %*ph (retrying)\n",
 268                                         cmd_name, ret, resp);
 269                                 continue;
 270                         }
 271
 272                         dev_err(&client->dev,
 273                                 "(%s) unexpected response: %*ph\n",
 274                                 cmd_name, ret, resp);
 275                         return -EIO;
 276                 }
 277
 278                 return 0;
 279         }
 280 }
 281
 282 static int elants_i2c_calibrate(struct elants_data *ts)
 283 {
 284         struct i2c_client *client = ts->client;
 285         int ret, error;
 286         static const u8 w_flashkey[] = { 0x54, 0xC0, 0xE1, 0x5A };
 287         static const u8 rek[] = { 0x54, 0x29, 0x00, 0x01 };
 288         static const u8 rek_resp[] = { CMD_HEADER_REK, 0x66, 0x66, 0x66 };
 289
 290         disable_irq(client->irq);
 291
 292         ts->state = ELAN_WAIT_RECALIBRATION;
 293         reinit_completion(&ts->cmd_done);
 294
 295         elants_i2c_send(client, w_flashkey, sizeof(w_flashkey));
 296         elants_i2c_send(client, rek, sizeof(rek));
 297
 298         enable_irq(client->irq);
 299
 300         ret = wait_for_completion_interruptible_timeout(&ts->cmd_done,
 301                                 msecs_to_jiffies(ELAN_CALI_TIMEOUT_MSEC));
 302
 303         ts->state = ELAN_STATE_NORMAL;
 304
 305         if (ret <= 0) {
 306                 error = ret < 0 ? ret : -ETIMEDOUT;
 307                 dev_err(&client->dev,
 308                         "error while waiting for calibration to complete: %d\n",
 309                         error);
 310                 return error;
 311         }
 312
 313         if (memcmp(rek_resp, ts->cmd_resp, sizeof(rek_resp))) {
 314                 dev_err(&client->dev,
 315                         "unexpected calibration response: %*ph\n",
 316                         (int)sizeof(ts->cmd_resp), ts->cmd_resp);
 317                 return -EINVAL;
 318         }
 319
 320         return 0;
 321 }
 322
 323 static int elants_i2c_sw_reset(struct i2c_client *client)
 324 {
 325         const u8 soft_rst_cmd[] = { 0x77, 0x77, 0x77, 0x77 };
 326         int error;
 327
 328         error = elants_i2c_send(client, soft_rst_cmd,
 329                                 sizeof(soft_rst_cmd));
 330         if (error) {
 331                 dev_err(&client->dev, "software reset failed: %d\n", error);
 332                 return error;
 333         }
 334
 335         /*
 336          * We should wait at least 10 msec (but no more than 40) before
 337          * sending fastboot or IAP command to the device.
 338          */
 339         msleep(30);
 340
 341         return 0;
 342 }
 343
 344 static u16 elants_i2c_parse_version(u8 *buf)
 345 {
 346         return get_unaligned_be32(buf) >> 4;
 347 }
 348
 349 static int elants_i2c_query_hw_version(struct elants_data *ts)
 350 {
 351         struct i2c_client *client = ts->client;
 352         int retry_cnt = MAX_RETRIES;
 353         const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_FW_ID, 0x00, 0x01 };
 354         u8 resp[HEADER_SIZE];
 355         int error;
 356
 357         while (retry_cnt--) {
 358                 error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
 359                                                    resp, sizeof(resp), 1,
 360                                                    "read fw id");
 361                 if (error)
 362                         return error;
 363
 364                 ts->hw_version = elants_i2c_parse_version(resp);
 365                 if (ts->hw_version != 0xffff)
 366                         return 0;
 367         }
 368
 369         dev_err(&client->dev, "Invalid fw id: %#04x\n", ts->hw_version);
 370
 371         return -EINVAL;
 372 }
 373
 374 static int elants_i2c_query_fw_version(struct elants_data *ts)
 375 {
 376         struct i2c_client *client = ts->client;
 377         int retry_cnt = MAX_RETRIES;
 378         const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_FW_VER, 0x00, 0x01 };
 379         u8 resp[HEADER_SIZE];
 380         int error;
 381
 382         while (retry_cnt--) {
 383                 error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
 384                                                    resp, sizeof(resp), 1,
 385                                                    "read fw version");
 386                 if (error)
 387                         return error;
 388
 389                 ts->fw_version = elants_i2c_parse_version(resp);
 390                 if (ts->fw_version != 0x0000 && ts->fw_version != 0xffff)
 391                         return 0;
 392
 393                 dev_dbg(&client->dev, "(read fw version) resp %*phC\n",
 394                         (int)sizeof(resp), resp);
 395         }
 396
 397         dev_err(&client->dev, "Invalid fw ver: %#04x\n", ts->fw_version);
 398
 399         return -EINVAL;
 400 }
 401
 402 static int elants_i2c_query_test_version(struct elants_data *ts)
 403 {
 404         struct i2c_client *client = ts->client;
 405         int error;
 406         u16 version;
 407         const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_TEST_VER, 0x00, 0x01 };
 408         u8 resp[HEADER_SIZE];
 409
 410         error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
 411                                            resp, sizeof(resp), MAX_RETRIES,
 412                                            "read test version");
 413         if (error) {
 414                 dev_err(&client->dev, "Failed to read test version\n");
 415                 return error;
 416         }
 417
 418         version = elants_i2c_parse_version(resp);
 419         ts->test_version = version >> 8;
 420         ts->solution_version = version & 0xff;
 421
 422         return 0;
 423 }
 424
 425 static int elants_i2c_query_bc_version(struct elants_data *ts)
 426 {
 427         struct i2c_client *client = ts->client;
 428         const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_BC_VER, 0x00, 0x01 };
 429         u8 resp[HEADER_SIZE];
 430         u16 version;
 431         int error;
 432
 433         error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
 434                                            resp, sizeof(resp), 1,
 435                                            "read BC version");
 436         if (error)
 437                 return error;
 438
 439         version = elants_i2c_parse_version(resp);
 440         ts->bc_version = version >> 8;
 441         ts->iap_version = version & 0xff;
 442
 443         return 0;
 444 }
 445
 446 static int elants_i2c_query_ts_info(struct elants_data *ts)
 447 {
 448         struct i2c_client *client = ts->client;
 449         int error;
 450         u8 resp[17];
 451         u16 phy_x, phy_y, rows, cols, osr;
 452         const u8 get_resolution_cmd[] = {
 453                 CMD_HEADER_6B_READ, 0x00, 0x00, 0x00, 0x00, 0x00
 454         };
 455         const u8 get_osr_cmd[] = {
 456                 CMD_HEADER_READ, E_INFO_OSR, 0x00, 0x01
 457         };
 458         const u8 get_physical_scan_cmd[] = {
 459                 CMD_HEADER_READ, E_INFO_PHY_SCAN, 0x00, 0x01
 460         };
 461         const u8 get_physical_drive_cmd[] = {
 462                 CMD_HEADER_READ, E_INFO_PHY_DRIVER, 0x00, 0x01
 463         };
 464
 465         /* Get trace number */
 466         error = elants_i2c_execute_command(client,
 467                                            get_resolution_cmd,
 468                                            sizeof(get_resolution_cmd),
 469                                            resp, sizeof(resp), 1,
 470                                            "get resolution");
 471         if (error)
 472                 return error;
 473
 474         rows = resp[2] + resp[6] + resp[10];
 475         cols = resp[3] + resp[7] + resp[11];
 476
 477         /* Get report resolution value of ABS_MT_TOUCH_MAJOR */
 478         ts->major_res = resp[16];
 479
 480         /* Process mm_to_pixel information */
 481         error = elants_i2c_execute_command(client,
 482                                            get_osr_cmd, sizeof(get_osr_cmd),
 483                                            resp, sizeof(resp), 1, "get osr");
 484         if (error)
 485                 return error;
 486
 487         osr = resp[3];
 488
 489         error = elants_i2c_execute_command(client,
 490                                            get_physical_scan_cmd,
 491                                            sizeof(get_physical_scan_cmd),
 492                                            resp, sizeof(resp), 1,
 493                                            "get physical scan");
 494         if (error)
 495                 return error;
 496
 497         phy_x = get_unaligned_be16(&resp[2]);
 498
 499         error = elants_i2c_execute_command(client,
 500                                            get_physical_drive_cmd,
 501                                            sizeof(get_physical_drive_cmd),
 502                                            resp, sizeof(resp), 1,
 503                                            "get physical drive");
 504         if (error)
 505                 return error;
 506
 507         phy_y = get_unaligned_be16(&resp[2]);
 508
 509         dev_dbg(&client->dev, "phy_x=%d, phy_y=%d\n", phy_x, phy_y);
 510
 511         if (rows == 0 || cols == 0 || osr == 0) {
 512                 dev_warn(&client->dev,
 513                          "invalid trace number data: %d, %d, %d\n",
 514                          rows, cols, osr);
 515         } else {
 516                 /* translate trace number to TS resolution */
 517                 ts->x_max = ELAN_TS_RESOLUTION(rows, osr);
 518                 ts->x_res = DIV_ROUND_CLOSEST(ts->x_max, phy_x);
 519                 ts->y_max = ELAN_TS_RESOLUTION(cols, osr);
 520                 ts->y_res = DIV_ROUND_CLOSEST(ts->y_max, phy_y);
 521         }
 522
 523         return 0;
 524 }
 525
 526 static int elants_i2c_fastboot(struct i2c_client *client)
 527 {
 528         const u8 boot_cmd[] = { 0x4D, 0x61, 0x69, 0x6E };
 529         int error;
 530
 531         error = elants_i2c_send(client, boot_cmd, sizeof(boot_cmd));
 532         if (error) {
 533                 dev_err(&client->dev, "boot failed: %d\n", error);
 534                 return error;
 535         }
 536
 537         dev_dbg(&client->dev, "boot success -- 0x%x\n", client->addr);
 538         return 0;
 539 }
 540
 541 static int elants_i2c_initialize(struct elants_data *ts)
 542 {
 543         struct i2c_client *client = ts->client;
 544         int error, error2, retry_cnt;
 545         const u8 hello_packet[] = { 0x55, 0x55, 0x55, 0x55 };
 546         const u8 recov_packet[] = { 0x55, 0x55, 0x80, 0x80 };
 547         u8 buf[HEADER_SIZE];
 548
 549         for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
 550                 error = elants_i2c_sw_reset(client);
 551                 if (error) {
 552                         /* Continue initializing if it's the last try */
 553                         if (retry_cnt < MAX_RETRIES - 1)
 554                                 continue;
 555                 }
 556
 557                 error = elants_i2c_fastboot(client);
 558                 if (error) {
 559                         /* Continue initializing if it's the last try */
 560                         if (retry_cnt < MAX_RETRIES - 1)
 561                                 continue;
 562                 }
 563
 564                 /* Wait for Hello packet */
 565                 msleep(BOOT_TIME_DELAY_MS);
 566
 567                 error = elants_i2c_read(client, buf, sizeof(buf));
 568                 if (error) {
 569                         dev_err(&client->dev,
 570                                 "failed to read 'hello' packet: %d\n", error);
 571                 } else if (!memcmp(buf, hello_packet, sizeof(hello_packet))) {
 572                         ts->iap_mode = ELAN_IAP_OPERATIONAL;
 573                         break;
 574                 } else if (!memcmp(buf, recov_packet, sizeof(recov_packet))) {
 575                         /*
 576                          * Setting error code will mark device
 577                          * in recovery mode below.
 578                          */
 579                         error = -EIO;
 580                         break;
 581                 } else {
 582                         error = -EINVAL;
 583                         dev_err(&client->dev,
 584                                 "invalid 'hello' packet: %*ph\n",
 585                                 (int)sizeof(buf), buf);
 586                 }
 587         }
 588
 589         /* hw version is available even if device in recovery state */
 590         error2 = elants_i2c_query_hw_version(ts);
 591         if (!error2)
 592                 error2 = elants_i2c_query_bc_version(ts);
 593         if (!error)
 594                 error = error2;
 595
 596         if (!error)
 597                 error = elants_i2c_query_fw_version(ts);
 598         if (!error)
 599                 error = elants_i2c_query_test_version(ts);
 600         if (!error)
 601                 error = elants_i2c_query_ts_info(ts);
 602
 603         if (error)
 604                 ts->iap_mode = ELAN_IAP_RECOVERY;
 605
 606         return 0;
 607 }
 608
 609 /*
 610  * Firmware update interface.
 611  */
 612
 613 static int elants_i2c_fw_write_page(struct i2c_client *client,
 614                                     const void *page)
 615 {
 616         const u8 ack_ok[] = { 0xaa, 0xaa };
 617         u8 buf[2];
 618         int retry;
 619         int error;
 620
 621         for (retry = 0; retry < MAX_FW_UPDATE_RETRIES; retry++) {
 622                 error = elants_i2c_send(client, page, ELAN_FW_PAGESIZE);
 623                 if (error) {
 624                         dev_err(&client->dev,
 625                                 "IAP Write Page failed: %d\n", error);
 626                         continue;
 627                 }
 628
 629                 error = elants_i2c_read(client, buf, 2);
 630                 if (error) {
 631                         dev_err(&client->dev,
 632                                 "IAP Ack read failed: %d\n", error);
 633                         return error;
 634                 }
 635
 636                 if (!memcmp(buf, ack_ok, sizeof(ack_ok)))
 637                         return 0;
 638
 639                 error = -EIO;
 640                 dev_err(&client->dev,
 641                         "IAP Get Ack Error [%02x:%02x]\n",
 642                         buf[0], buf[1]);
 643         }
 644
 645         return error;
 646 }
 647
 648 static int elants_i2c_validate_remark_id(struct elants_data *ts,
 649                                          const struct firmware *fw)
 650 {
 651         struct i2c_client *client = ts->client;
 652         int error;
 653         const u8 cmd[] = { CMD_HEADER_ROM_READ, 0x80, 0x1F, 0x00, 0x00, 0x21 };
 654         u8 resp[6] = { 0 };
 655         u16 ts_remark_id = 0;
 656         u16 fw_remark_id = 0;
 657
 658         /* Compare TS Remark ID and FW Remark ID */
 659         error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
 660                                            resp, sizeof(resp),
 661                                            1, "read Remark ID");
 662         if (error)
 663                 return error;
 664
 665         ts_remark_id = get_unaligned_be16(&resp[3]);
 666
 667         fw_remark_id = get_unaligned_le16(&fw->data[fw->size - 4]);
 668
 669         if (fw_remark_id != ts_remark_id) {
 670                 dev_err(&client->dev,
 671                         "Remark ID Mismatched: ts_remark_id=0x%04x, fw_remark_id=0x%04x.\n",
 672                         ts_remark_id, fw_remark_id);
 673                 return -EINVAL;
 674         }
 675
 676         return 0;
 677 }
 678
 679 static bool elants_i2c_should_check_remark_id(struct elants_data *ts)
 680 {
 681         struct i2c_client *client = ts->client;
 682         const u8 bootcode_version = ts->iap_version;
 683         bool check;
 684
 685         /* I2C eKTH3900 and eKTH5312 are NOT support Remark ID */
 686         if ((bootcode_version == BC_VER_H_BYTE_FOR_EKTH3900x1_I2C) ||
 687             (bootcode_version == BC_VER_H_BYTE_FOR_EKTH3900x2_I2C) ||
 688             (bootcode_version == BC_VER_H_BYTE_FOR_EKTH3900x3_I2C) ||
 689             (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312x1_I2C) ||
 690             (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312x2_I2C) ||
 691             (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312cx1_I2C) ||
 692             (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312cx2_I2C) ||
 693             (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312x1_I2C_USB) ||
 694             (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312x2_I2C_USB) ||
 695             (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312cx1_I2C_USB) ||
 696             (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312cx2_I2C_USB)) {
 697                 dev_dbg(&client->dev,
 698                         "eKTH3900/eKTH5312(0x%02x) are not support remark id\n",
 699                         bootcode_version);
 700                 check = false;
 701         } else if (bootcode_version >= 0x60) {
 702                 check = true;
 703         } else {
 704                 check = false;
 705         }
 706
 707         return check;
 708 }
 709
 710 static int elants_i2c_do_update_firmware(struct i2c_client *client,
 711                                          const struct firmware *fw,
 712                                          bool force)
 713 {
 714         struct elants_data *ts = i2c_get_clientdata(client);
 715         const u8 enter_iap[] = { 0x45, 0x49, 0x41, 0x50 };
 716         const u8 enter_iap2[] = { 0x54, 0x00, 0x12, 0x34 };
 717         const u8 iap_ack[] = { 0x55, 0xaa, 0x33, 0xcc };
 718         const u8 close_idle[] = { 0x54, 0x2c, 0x01, 0x01 };
 719         u8 buf[HEADER_SIZE];
 720         u16 send_id;
 721         int page, n_fw_pages;
 722         int error;
 723         bool check_remark_id = elants_i2c_should_check_remark_id(ts);
 724
 725         /* Recovery mode detection! */
 726         if (force) {
 727                 dev_dbg(&client->dev, "Recovery mode procedure\n");
 728
 729                 if (check_remark_id) {
 730                         error = elants_i2c_validate_remark_id(ts, fw);
 731                         if (error)
 732                                 return error;
 733                 }
 734
 735                 error = elants_i2c_send(client, enter_iap2, sizeof(enter_iap2));
 736                 if (error) {
 737                         dev_err(&client->dev, "failed to enter IAP mode: %d\n",
 738                                 error);
 739                         return error;
 740                 }
 741         } else {
 742                 /* Start IAP Procedure */
 743                 dev_dbg(&client->dev, "Normal IAP procedure\n");
 744
 745                 /* Close idle mode */
 746                 error = elants_i2c_send(client, close_idle, sizeof(close_idle));
 747                 if (error)
 748                         dev_err(&client->dev, "Failed close idle: %d\n", error);
 749                 msleep(60);
 750
 751                 elants_i2c_sw_reset(client);
 752                 msleep(20);
 753
 754                 if (check_remark_id) {
 755                         error = elants_i2c_validate_remark_id(ts, fw);
 756                         if (error)
 757                                 return error;
 758                 }
 759
 760                 error = elants_i2c_send(client, enter_iap, sizeof(enter_iap));
 761                 if (error) {
 762                         dev_err(&client->dev, "failed to enter IAP mode: %d\n",
 763                                 error);
 764                         return error;
 765                 }
 766         }
 767
 768         msleep(20);
 769
 770         /* check IAP state */
 771         error = elants_i2c_read(client, buf, 4);
 772         if (error) {
 773                 dev_err(&client->dev,
 774                         "failed to read IAP acknowledgement: %d\n",
 775                         error);
 776                 return error;
 777         }
 778
 779         if (memcmp(buf, iap_ack, sizeof(iap_ack))) {
 780                 dev_err(&client->dev,
 781                         "failed to enter IAP: %*ph (expected %*ph)\n",
 782                         (int)sizeof(buf), buf, (int)sizeof(iap_ack), iap_ack);
 783                 return -EIO;
 784         }
 785
 786         dev_info(&client->dev, "successfully entered IAP mode");
 787
 788         send_id = client->addr;
 789         error = elants_i2c_send(client, &send_id, 1);
 790         if (error) {
 791                 dev_err(&client->dev, "sending dummy byte failed: %d\n",
 792                         error);
 793                 return error;
 794         }
 795
 796         /* Clear the last page of Master */
 797         error = elants_i2c_send(client, fw->data, ELAN_FW_PAGESIZE);
 798         if (error) {
 799                 dev_err(&client->dev, "clearing of the last page failed: %d\n",
 800                         error);
 801                 return error;
 802         }
 803
 804         error = elants_i2c_read(client, buf, 2);
 805         if (error) {
 806                 dev_err(&client->dev,
 807                         "failed to read ACK for clearing the last page: %d\n",
 808                         error);
 809                 return error;
 810         }
 811
 812         n_fw_pages = fw->size / ELAN_FW_PAGESIZE;
 813         dev_dbg(&client->dev, "IAP Pages = %d\n", n_fw_pages);
 814
 815         for (page = 0; page < n_fw_pages; page++) {
 816                 error = elants_i2c_fw_write_page(client,
 817                                         fw->data + page * ELAN_FW_PAGESIZE);
 818                 if (error) {
 819                         dev_err(&client->dev,
 820                                 "failed to write FW page %d: %d\n",
 821                                 page, error);
 822                         return error;
 823                 }
 824         }
 825
 826         /* Old iap needs to wait 200ms for WDT and rest is for hello packets */
 827         msleep(300);
 828
 829         dev_info(&client->dev, "firmware update completed\n");
 830         return 0;
 831 }
 832
 833 static int elants_i2c_fw_update(struct elants_data *ts)
 834 {
 835         struct i2c_client *client = ts->client;
 836         const struct firmware *fw;
 837         char *fw_name;
 838         int error;
 839
 840         fw_name = kasprintf(GFP_KERNEL, "/*(DEBLOBBED)*/", ts->hw_version);
 841         if (!fw_name)
 842                 return -ENOMEM;
 843
 844         dev_info(&client->dev, "requesting fw name = %s\n", fw_name);
 845         error = reject_firmware(&fw, fw_name, &client->dev);
 846         kfree(fw_name);
 847         if (error) {
 848                 dev_err(&client->dev, "failed to request firmware: %d\n",
 849                         error);
 850                 return error;
 851         }
 852
 853         if (fw->size % ELAN_FW_PAGESIZE) {
 854                 dev_err(&client->dev, "invalid firmware length: %zu\n",
 855                         fw->size);
 856                 error = -EINVAL;
 857                 goto out;
 858         }
 859
 860         disable_irq(client->irq);
 861
 862         error = elants_i2c_do_update_firmware(client, fw,
 863                                         ts->iap_mode == ELAN_IAP_RECOVERY);
 864         if (error) {
 865                 dev_err(&client->dev, "firmware update failed: %d\n", error);
 866                 ts->iap_mode = ELAN_IAP_RECOVERY;
 867                 goto out_enable_irq;
 868         }
 869
 870         error = elants_i2c_initialize(ts);
 871         if (error) {
 872                 dev_err(&client->dev,
 873                         "failed to initialize device after firmware update: %d\n",
 874                         error);
 875                 ts->iap_mode = ELAN_IAP_RECOVERY;
 876                 goto out_enable_irq;
 877         }
 878
 879         ts->iap_mode = ELAN_IAP_OPERATIONAL;
 880
 881 out_enable_irq:
 882         ts->state = ELAN_STATE_NORMAL;
 883         enable_irq(client->irq);
 884         msleep(100);
 885
 886         if (!error)
 887                 elants_i2c_calibrate(ts);
 888 out:
 889         release_firmware(fw);
 890         return error;
 891 }
 892
 893 /*
 894  * Event reporting.
 895  */
 896
 897 static void elants_i2c_mt_event(struct elants_data *ts, u8 *buf)
 898 {
 899         struct input_dev *input = ts->input;
 900         unsigned int n_fingers;
 901         unsigned int tool_type;
 902         u16 finger_state;
 903         int i;
 904
 905         n_fingers = buf[FW_POS_STATE + 1] & 0x0f;
 906         finger_state = ((buf[FW_POS_STATE + 1] & 0x30) << 4) |
 907                         buf[FW_POS_STATE];
 908
 909         dev_dbg(&ts->client->dev,
 910                 "n_fingers: %u, state: %04x\n",  n_fingers, finger_state);
 911
 912         /* Note: all fingers have the same tool type */
 913         tool_type = buf[FW_POS_TOOL_TYPE] & BIT(0) ?
 914                         MT_TOOL_FINGER : MT_TOOL_PALM;
 915
 916         for (i = 0; i < MAX_CONTACT_NUM && n_fingers; i++) {
 917                 if (finger_state & 1) {
 918                         unsigned int x, y, p, w;
 919                         u8 *pos;
 920
 921                         pos = &buf[FW_POS_XY + i * 3];
 922                         x = (((u16)pos[0] & 0xf0) << 4) | pos[1];
 923                         y = (((u16)pos[0] & 0x0f) << 8) | pos[2];
 924                         p = buf[FW_POS_PRESSURE + i];
 925                         w = buf[FW_POS_WIDTH + i];
 926
 927                         dev_dbg(&ts->client->dev, "i=%d x=%d y=%d p=%d w=%d\n",
 928                                 i, x, y, p, w);
 929
 930                         input_mt_slot(input, i);
 931                         input_mt_report_slot_state(input, tool_type, true);
 932                         touchscreen_report_pos(input, &ts->prop, x, y, true);
 933                         input_event(input, EV_ABS, ABS_MT_PRESSURE, p);
 934                         input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, w);
 935
 936                         n_fingers--;
 937                 }
 938
 939                 finger_state >>= 1;
 940         }
 941
 942         input_mt_sync_frame(input);
 943         input_sync(input);
 944 }
 945
 946 static u8 elants_i2c_calculate_checksum(u8 *buf)
 947 {
 948         u8 checksum = 0;
 949         u8 i;
 950
 951         for (i = 0; i < FW_POS_CHECKSUM; i++)
 952                 checksum += buf[i];
 953
 954         return checksum;
 955 }
 956
 957 static void elants_i2c_event(struct elants_data *ts, u8 *buf)
 958 {
 959         u8 checksum = elants_i2c_calculate_checksum(buf);
 960
 961         if (unlikely(buf[FW_POS_CHECKSUM] != checksum))
 962                 dev_warn(&ts->client->dev,
 963                          "%s: invalid checksum for packet %02x: %02x vs. %02x\n",
 964                          __func__, buf[FW_POS_HEADER],
 965                          checksum, buf[FW_POS_CHECKSUM]);
 966         else if (unlikely(buf[FW_POS_HEADER] != HEADER_REPORT_10_FINGER))
 967                 dev_warn(&ts->client->dev,
 968                          "%s: unknown packet type: %02x\n",
 969                          __func__, buf[FW_POS_HEADER]);
 970         else
 971                 elants_i2c_mt_event(ts, buf);
 972 }
 973
 974 static irqreturn_t elants_i2c_irq(int irq, void *_dev)
 975 {
 976         const u8 wait_packet[] = { 0x64, 0x64, 0x64, 0x64 };
 977         struct elants_data *ts = _dev;
 978         struct i2c_client *client = ts->client;
 979         int report_count, report_len;
 980         int i;
 981         int len;
 982
 983         len = i2c_master_recv_dmasafe(client, ts->buf, sizeof(ts->buf));
 984         if (len < 0) {
 985                 dev_err(&client->dev, "%s: failed to read data: %d\n",
 986                         __func__, len);
 987                 goto out;
 988         }
 989
 990         dev_dbg(&client->dev, "%s: packet %*ph\n",
 991                 __func__, HEADER_SIZE, ts->buf);
 992
 993         switch (ts->state) {
 994         case ELAN_WAIT_RECALIBRATION:
 995                 if (ts->buf[FW_HDR_TYPE] == CMD_HEADER_REK) {
 996                         memcpy(ts->cmd_resp, ts->buf, sizeof(ts->cmd_resp));
 997                         complete(&ts->cmd_done);
 998                         ts->state = ELAN_STATE_NORMAL;
 999                 }
1000                 break;
1001
1002         case ELAN_WAIT_QUEUE_HEADER:
1003                 if (ts->buf[FW_HDR_TYPE] != QUEUE_HEADER_NORMAL)
1004                         break;
1005
1006                 ts->state = ELAN_STATE_NORMAL;
1007                 fallthrough;
1008
1009         case ELAN_STATE_NORMAL:
1010
1011                 switch (ts->buf[FW_HDR_TYPE]) {
1012                 case CMD_HEADER_HELLO:
1013                 case CMD_HEADER_RESP:
1014                 case CMD_HEADER_REK:
1015                         break;
1016
1017                 case QUEUE_HEADER_WAIT:
1018                         if (memcmp(ts->buf, wait_packet, sizeof(wait_packet))) {
1019                                 dev_err(&client->dev,
1020                                         "invalid wait packet %*ph\n",
1021                                         HEADER_SIZE, ts->buf);
1022                         } else {
1023                                 ts->state = ELAN_WAIT_QUEUE_HEADER;
1024                                 udelay(30);
1025                         }
1026                         break;
1027
1028                 case QUEUE_HEADER_SINGLE:
1029                         elants_i2c_event(ts, &ts->buf[HEADER_SIZE]);
1030                         break;
1031
1032                 case QUEUE_HEADER_NORMAL:
1033                         report_count = ts->buf[FW_HDR_COUNT];
1034                         if (report_count == 0 || report_count > 3) {
1035                                 dev_err(&client->dev,
1036                                         "bad report count: %*ph\n",
1037                                         HEADER_SIZE, ts->buf);
1038                                 break;
1039                         }
1040
1041                         report_len = ts->buf[FW_HDR_LENGTH] / report_count;
1042                         if (report_len != PACKET_SIZE) {
1043                                 dev_err(&client->dev,
1044                                         "mismatching report length: %*ph\n",
1045                                         HEADER_SIZE, ts->buf);
1046                                 break;
1047                         }
1048
1049                         for (i = 0; i < report_count; i++) {
1050                                 u8 *buf = ts->buf + HEADER_SIZE +
1051                                                         i * PACKET_SIZE;
1052                                 elants_i2c_event(ts, buf);
1053                         }
1054                         break;
1055
1056                 default:
1057                         dev_err(&client->dev, "unknown packet %*ph\n",
1058                                 HEADER_SIZE, ts->buf);
1059                         break;
1060                 }
1061                 break;
1062         }
1063
1064 out:
1065         return IRQ_HANDLED;
1066 }
1067
1068 /*
1069  * sysfs interface
1070  */
1071 static ssize_t calibrate_store(struct device *dev,
1072                                struct device_attribute *attr,
1073                                const char *buf, size_t count)
1074 {
1075         struct i2c_client *client = to_i2c_client(dev);
1076         struct elants_data *ts = i2c_get_clientdata(client);
1077         int error;
1078
1079         error = mutex_lock_interruptible(&ts->sysfs_mutex);
1080         if (error)
1081                 return error;
1082
1083         error = elants_i2c_calibrate(ts);
1084
1085         mutex_unlock(&ts->sysfs_mutex);
1086         return error ?: count;
1087 }
1088
1089 static ssize_t write_update_fw(struct device *dev,
1090                                struct device_attribute *attr,
1091                                const char *buf, size_t count)
1092 {
1093         struct i2c_client *client = to_i2c_client(dev);
1094         struct elants_data *ts = i2c_get_clientdata(client);
1095         int error;
1096
1097         error = mutex_lock_interruptible(&ts->sysfs_mutex);
1098         if (error)
1099                 return error;
1100
1101         error = elants_i2c_fw_update(ts);
1102         dev_dbg(dev, "firmware update result: %d\n", error);
1103
1104         mutex_unlock(&ts->sysfs_mutex);
1105         return error ?: count;
1106 }
1107
1108 static ssize_t show_iap_mode(struct device *dev,
1109                              struct device_attribute *attr, char *buf)
1110 {
1111         struct i2c_client *client = to_i2c_client(dev);
1112         struct elants_data *ts = i2c_get_clientdata(client);
1113
1114         return sprintf(buf, "%s\n",
1115                        ts->iap_mode == ELAN_IAP_OPERATIONAL ?
1116                                 "Normal" : "Recovery");
1117 }
1118
1119 static ssize_t show_calibration_count(struct device *dev,
1120                                       struct device_attribute *attr, char *buf)
1121 {
1122         struct i2c_client *client = to_i2c_client(dev);
1123         const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_REK, 0x00, 0x01 };
1124         u8 resp[HEADER_SIZE];
1125         u16 rek_count;
1126         int error;
1127
1128         error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
1129                                            resp, sizeof(resp), 1,
1130                                            "read ReK status");
1131         if (error)
1132                 return sprintf(buf, "%d\n", error);
1133
1134         rek_count = get_unaligned_be16(&resp[2]);
1135         return sprintf(buf, "0x%04x\n", rek_count);
1136 }
1137
1138 static DEVICE_ATTR_WO(calibrate);
1139 static DEVICE_ATTR(iap_mode, S_IRUGO, show_iap_mode, NULL);
1140 static DEVICE_ATTR(calibration_count, S_IRUGO, show_calibration_count, NULL);
1141 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, write_update_fw);
1142
1143 struct elants_version_attribute {
1144         struct device_attribute dattr;
1145         size_t field_offset;
1146         size_t field_size;
1147 };
1148
1149 #define __ELANTS_FIELD_SIZE(_field)                                     \
1150         sizeof(((struct elants_data *)NULL)->_field)
1151 #define __ELANTS_VERIFY_SIZE(_field)                                    \
1152         (BUILD_BUG_ON_ZERO(__ELANTS_FIELD_SIZE(_field) > 2) +           \
1153          __ELANTS_FIELD_SIZE(_field))
1154 #define ELANTS_VERSION_ATTR(_field)                                     \
1155         struct elants_version_attribute elants_ver_attr_##_field = {    \
1156                 .dattr = __ATTR(_field, S_IRUGO,                        \
1157                                 elants_version_attribute_show, NULL),   \
1158                 .field_offset = offsetof(struct elants_data, _field),   \
1159                 .field_size = __ELANTS_VERIFY_SIZE(_field),             \
1160         }
1161
1162 static ssize_t elants_version_attribute_show(struct device *dev,
1163                                              struct device_attribute *dattr,
1164                                              char *buf)
1165 {
1166         struct i2c_client *client = to_i2c_client(dev);
1167         struct elants_data *ts = i2c_get_clientdata(client);
1168         struct elants_version_attribute *attr =
1169                 container_of(dattr, struct elants_version_attribute, dattr);
1170         u8 *field = (u8 *)((char *)ts + attr->field_offset);
1171         unsigned int fmt_size;
1172         unsigned int val;
1173
1174         if (attr->field_size == 1) {
1175                 val = *field;
1176                 fmt_size = 2; /* 2 HEX digits */
1177         } else {
1178                 val = *(u16 *)field;
1179                 fmt_size = 4; /* 4 HEX digits */
1180         }
1181
1182         return sprintf(buf, "%0*x\n", fmt_size, val);
1183 }
1184
1185 static ELANTS_VERSION_ATTR(fw_version);
1186 static ELANTS_VERSION_ATTR(hw_version);
1187 static ELANTS_VERSION_ATTR(test_version);
1188 static ELANTS_VERSION_ATTR(solution_version);
1189 static ELANTS_VERSION_ATTR(bc_version);
1190 static ELANTS_VERSION_ATTR(iap_version);
1191
1192 static struct attribute *elants_attributes[] = {
1193         &dev_attr_calibrate.attr,
1194         &dev_attr_update_fw.attr,
1195         &dev_attr_iap_mode.attr,
1196         &dev_attr_calibration_count.attr,
1197
1198         &elants_ver_attr_fw_version.dattr.attr,
1199         &elants_ver_attr_hw_version.dattr.attr,
1200         &elants_ver_attr_test_version.dattr.attr,
1201         &elants_ver_attr_solution_version.dattr.attr,
1202         &elants_ver_attr_bc_version.dattr.attr,
1203         &elants_ver_attr_iap_version.dattr.attr,
1204         NULL
1205 };
1206
1207 static const struct attribute_group elants_attribute_group = {
1208         .attrs = elants_attributes,
1209 };
1210
1211 static int elants_i2c_power_on(struct elants_data *ts)
1212 {
1213         int error;
1214
1215         /*
1216          * If we do not have reset gpio assume platform firmware
1217          * controls regulators and does power them on for us.
1218          */
1219         if (IS_ERR_OR_NULL(ts->reset_gpio))
1220                 return 0;
1221
1222         gpiod_set_value_cansleep(ts->reset_gpio, 1);
1223
1224         error = regulator_enable(ts->vcc33);
1225         if (error) {
1226                 dev_err(&ts->client->dev,
1227                         "failed to enable vcc33 regulator: %d\n",
1228                         error);
1229                 goto release_reset_gpio;
1230         }
1231
1232         error = regulator_enable(ts->vccio);
1233         if (error) {
1234                 dev_err(&ts->client->dev,
1235                         "failed to enable vccio regulator: %d\n",
1236                         error);
1237                 regulator_disable(ts->vcc33);
1238                 goto release_reset_gpio;
1239         }
1240
1241         /*
1242          * We need to wait a bit after powering on controller before
1243          * we are allowed to release reset GPIO.
1244          */
1245         udelay(ELAN_POWERON_DELAY_USEC);
1246
1247 release_reset_gpio:
1248         gpiod_set_value_cansleep(ts->reset_gpio, 0);
1249         if (error)
1250                 return error;
1251
1252         msleep(ELAN_RESET_DELAY_MSEC);
1253
1254         return 0;
1255 }
1256
1257 static void elants_i2c_power_off(void *_data)
1258 {
1259         struct elants_data *ts = _data;
1260
1261         if (!IS_ERR_OR_NULL(ts->reset_gpio)) {
1262                 /*
1263                  * Activate reset gpio to prevent leakage through the
1264                  * pin once we shut off power to the controller.
1265                  */
1266                 gpiod_set_value_cansleep(ts->reset_gpio, 1);
1267                 regulator_disable(ts->vccio);
1268                 regulator_disable(ts->vcc33);
1269         }
1270 }
1271
1272 #ifdef CONFIG_ACPI
1273 static const struct acpi_device_id i2c_hid_ids[] = {
1274         {"ACPI0C50", 0 },
1275         {"PNP0C50", 0 },
1276         { },
1277 };
1278
1279 static const guid_t i2c_hid_guid =
1280         GUID_INIT(0x3CDFF6F7, 0x4267, 0x4555,
1281                   0xAD, 0x05, 0xB3, 0x0A, 0x3D, 0x89, 0x38, 0xDE);
1282
1283 static bool elants_acpi_is_hid_device(struct device *dev)
1284 {
1285         acpi_handle handle = ACPI_HANDLE(dev);
1286         union acpi_object *obj;
1287
1288         if (acpi_match_device_ids(ACPI_COMPANION(dev), i2c_hid_ids))
1289                 return false;
1290
1291         obj = acpi_evaluate_dsm_typed(handle, &i2c_hid_guid, 1, 1, NULL, ACPI_TYPE_INTEGER);
1292         if (obj) {
1293                 ACPI_FREE(obj);
1294                 return true;
1295         }
1296
1297         return false;
1298 }
1299 #else
1300 static bool elants_acpi_is_hid_device(struct device *dev)
1301 {
1302         return false;
1303 }
1304 #endif
1305
1306 static int elants_i2c_probe(struct i2c_client *client,
1307                             const struct i2c_device_id *id)
1308 {
1309         union i2c_smbus_data dummy;
1310         struct elants_data *ts;
1311         unsigned long irqflags;
1312         int error;
1313
1314         /* Don't bind to i2c-hid compatible devices, these are handled by the i2c-hid drv. */
1315         if (elants_acpi_is_hid_device(&client->dev)) {
1316                 dev_warn(&client->dev, "This device appears to be an I2C-HID device, not binding\n");
1317                 return -ENODEV;
1318         }
1319
1320         if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1321                 dev_err(&client->dev, "I2C check functionality error\n");
1322                 return -ENXIO;
1323         }
1324
1325         ts = devm_kzalloc(&client->dev, sizeof(struct elants_data), GFP_KERNEL);
1326         if (!ts)
1327                 return -ENOMEM;
1328
1329         mutex_init(&ts->sysfs_mutex);
1330         init_completion(&ts->cmd_done);
1331
1332         ts->client = client;
1333         i2c_set_clientdata(client, ts);
1334
1335         ts->vcc33 = devm_regulator_get(&client->dev, "vcc33");
1336         if (IS_ERR(ts->vcc33)) {
1337                 error = PTR_ERR(ts->vcc33);
1338                 if (error != -EPROBE_DEFER)
1339                         dev_err(&client->dev,
1340                                 "Failed to get 'vcc33' regulator: %d\n",
1341                                 error);
1342                 return error;
1343         }
1344
1345         ts->vccio = devm_regulator_get(&client->dev, "vccio");
1346         if (IS_ERR(ts->vccio)) {
1347                 error = PTR_ERR(ts->vccio);
1348                 if (error != -EPROBE_DEFER)
1349                         dev_err(&client->dev,
1350                                 "Failed to get 'vccio' regulator: %d\n",
1351                                 error);
1352                 return error;
1353         }
1354
1355         ts->reset_gpio = devm_gpiod_get(&client->dev, "reset", GPIOD_OUT_LOW);
1356         if (IS_ERR(ts->reset_gpio)) {
1357                 error = PTR_ERR(ts->reset_gpio);
1358
1359                 if (error == -EPROBE_DEFER)
1360                         return error;
1361
1362                 if (error != -ENOENT && error != -ENOSYS) {
1363                         dev_err(&client->dev,
1364                                 "failed to get reset gpio: %d\n",
1365                                 error);
1366                         return error;
1367                 }
1368
1369                 ts->keep_power_in_suspend = true;
1370         }
1371
1372         error = elants_i2c_power_on(ts);
1373         if (error)
1374                 return error;
1375
1376         error = devm_add_action(&client->dev, elants_i2c_power_off, ts);
1377         if (error) {
1378                 dev_err(&client->dev,
1379                         "failed to install power off action: %d\n", error);
1380                 elants_i2c_power_off(ts);
1381                 return error;
1382         }
1383
1384         /* Make sure there is something at this address */
1385         if (i2c_smbus_xfer(client->adapter, client->addr, 0,
1386                            I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &dummy) < 0) {
1387                 dev_err(&client->dev, "nothing at this address\n");
1388                 return -ENXIO;
1389         }
1390
1391         error = elants_i2c_initialize(ts);
1392         if (error) {
1393                 dev_err(&client->dev, "failed to initialize: %d\n", error);
1394                 return error;
1395         }
1396
1397         ts->input = devm_input_allocate_device(&client->dev);
1398         if (!ts->input) {
1399                 dev_err(&client->dev, "Failed to allocate input device\n");
1400                 return -ENOMEM;
1401         }
1402
1403         ts->input->name = "Elan Touchscreen";
1404         ts->input->id.bustype = BUS_I2C;
1405
1406         /* Multitouch input params setup */
1407
1408         input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, ts->x_max, 0, 0);
1409         input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, ts->y_max, 0, 0);
1410         input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
1411         input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, 255, 0, 0);
1412         input_set_abs_params(ts->input, ABS_MT_TOOL_TYPE,
1413                              0, MT_TOOL_PALM, 0, 0);
1414         input_abs_set_res(ts->input, ABS_MT_POSITION_X, ts->x_res);
1415         input_abs_set_res(ts->input, ABS_MT_POSITION_Y, ts->y_res);
1416         if (ts->major_res > 0)
1417                 input_abs_set_res(ts->input, ABS_MT_TOUCH_MAJOR, ts->major_res);
1418
1419         touchscreen_parse_properties(ts->input, true, &ts->prop);
1420
1421         error = input_mt_init_slots(ts->input, MAX_CONTACT_NUM,
1422                                     INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
1423         if (error) {
1424                 dev_err(&client->dev,
1425                         "failed to initialize MT slots: %d\n", error);
1426                 return error;
1427         }
1428
1429         error = input_register_device(ts->input);
1430         if (error) {
1431                 dev_err(&client->dev,
1432                         "unable to register input device: %d\n", error);
1433                 return error;
1434         }
1435
1436         /*
1437          * Platform code (ACPI, DTS) should normally set up interrupt
1438          * for us, but in case it did not let's fall back to using falling
1439          * edge to be compatible with older Chromebooks.
1440          */
1441         irqflags = irq_get_trigger_type(client->irq);
1442         if (!irqflags)
1443                 irqflags = IRQF_TRIGGER_FALLING;
1444
1445         error = devm_request_threaded_irq(&client->dev, client->irq,
1446                                           NULL, elants_i2c_irq,
1447                                           irqflags | IRQF_ONESHOT,
1448                                           client->name, ts);
1449         if (error) {
1450                 dev_err(&client->dev, "Failed to register interrupt\n");
1451                 return error;
1452         }
1453
1454         /*
1455          * Systems using device tree should set up wakeup via DTS,
1456          * the rest will configure device as wakeup source by default.
1457          */
1458         if (!client->dev.of_node)
1459                 device_init_wakeup(&client->dev, true);
1460
1461         error = devm_device_add_group(&client->dev, &elants_attribute_group);
1462         if (error) {
1463                 dev_err(&client->dev, "failed to create sysfs attributes: %d\n",
1464                         error);
1465                 return error;
1466         }
1467
1468         return 0;
1469 }
1470
1471 static int __maybe_unused elants_i2c_suspend(struct device *dev)
1472 {
1473         struct i2c_client *client = to_i2c_client(dev);
1474         struct elants_data *ts = i2c_get_clientdata(client);
1475         const u8 set_sleep_cmd[] = { 0x54, 0x50, 0x00, 0x01 };
1476         int retry_cnt;
1477         int error;
1478
1479         /* Command not support in IAP recovery mode */
1480         if (ts->iap_mode != ELAN_IAP_OPERATIONAL)
1481                 return -EBUSY;
1482
1483         disable_irq(client->irq);
1484
1485         if (device_may_wakeup(dev)) {
1486                 /*
1487                  * The device will automatically enter idle mode
1488                  * that has reduced power consumption.
1489                  */
1490                 ts->wake_irq_enabled = (enable_irq_wake(client->irq) == 0);
1491         } else if (ts->keep_power_in_suspend) {
1492                 for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
1493                         error = elants_i2c_send(client, set_sleep_cmd,
1494                                                 sizeof(set_sleep_cmd));
1495                         if (!error)
1496                                 break;
1497
1498                         dev_err(&client->dev,
1499                                 "suspend command failed: %d\n", error);
1500                 }
1501         } else {
1502                 elants_i2c_power_off(ts);
1503         }
1504
1505         return 0;
1506 }
1507
1508 static int __maybe_unused elants_i2c_resume(struct device *dev)
1509 {
1510         struct i2c_client *client = to_i2c_client(dev);
1511         struct elants_data *ts = i2c_get_clientdata(client);
1512         const u8 set_active_cmd[] = { 0x54, 0x58, 0x00, 0x01 };
1513         int retry_cnt;
1514         int error;
1515
1516         if (device_may_wakeup(dev)) {
1517                 if (ts->wake_irq_enabled)
1518                         disable_irq_wake(client->irq);
1519                 elants_i2c_sw_reset(client);
1520         } else if (ts->keep_power_in_suspend) {
1521                 for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
1522                         error = elants_i2c_send(client, set_active_cmd,
1523                                                 sizeof(set_active_cmd));
1524                         if (!error)
1525                                 break;
1526
1527                         dev_err(&client->dev,
1528                                 "resume command failed: %d\n", error);
1529                 }
1530         } else {
1531                 elants_i2c_power_on(ts);
1532                 elants_i2c_initialize(ts);
1533         }
1534
1535         ts->state = ELAN_STATE_NORMAL;
1536         enable_irq(client->irq);
1537
1538         return 0;
1539 }
1540
1541 static SIMPLE_DEV_PM_OPS(elants_i2c_pm_ops,
1542                          elants_i2c_suspend, elants_i2c_resume);
1543
1544 static const struct i2c_device_id elants_i2c_id[] = {
1545         { DEVICE_NAME, 0 },
1546         { }
1547 };
1548 MODULE_DEVICE_TABLE(i2c, elants_i2c_id);
1549
1550 #ifdef CONFIG_ACPI
1551 static const struct acpi_device_id elants_acpi_id[] = {
1552         { "ELAN0001", 0 },
1553         { }
1554 };
1555 MODULE_DEVICE_TABLE(acpi, elants_acpi_id);
1556 #endif
1557
1558 #ifdef CONFIG_OF
1559 static const struct of_device_id elants_of_match[] = {
1560         { .compatible = "elan,ekth3500" },
1561         { /* sentinel */ }
1562 };
1563 MODULE_DEVICE_TABLE(of, elants_of_match);
1564 #endif
1565
1566 static struct i2c_driver elants_i2c_driver = {
1567         .probe = elants_i2c_probe,
1568         .id_table = elants_i2c_id,
1569         .driver = {
1570                 .name = DEVICE_NAME,
1571                 .pm = &elants_i2c_pm_ops,
1572                 .acpi_match_table = ACPI_PTR(elants_acpi_id),
1573                 .of_match_table = of_match_ptr(elants_of_match),
1574                 .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1575         },
1576 };
1577 module_i2c_driver(elants_i2c_driver);
1578
1579 MODULE_AUTHOR("Scott Liu <scott.liu@emc.com.tw>");
1580 MODULE_DESCRIPTION("Elan I2c Touchscreen driver");
1581 MODULE_LICENSE("GPL");