Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Elan Microelectronics touch panels with I2C interface
0004  *
0005  * Copyright (C) 2014 Elan Microelectronics Corporation.
0006  * Scott Liu <scott.liu@emc.com.tw>
0007  *
0008  * This code is partly based on hid-multitouch.c:
0009  *
0010  *  Copyright (c) 2010-2012 Stephane Chatty <chatty@enac.fr>
0011  *  Copyright (c) 2010-2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
0012  *  Copyright (c) 2010-2012 Ecole Nationale de l'Aviation Civile, France
0013  *
0014  * This code is partly based on i2c-hid.c:
0015  *
0016  * Copyright (c) 2012 Benjamin Tissoires <benjamin.tissoires@gmail.com>
0017  * Copyright (c) 2012 Ecole Nationale de l'Aviation Civile, France
0018  * Copyright (c) 2012 Red Hat, Inc
0019  */
0020 
0021 
0022 #include <linux/bits.h>
0023 #include <linux/module.h>
0024 #include <linux/input.h>
0025 #include <linux/interrupt.h>
0026 #include <linux/irq.h>
0027 #include <linux/platform_device.h>
0028 #include <linux/async.h>
0029 #include <linux/i2c.h>
0030 #include <linux/delay.h>
0031 #include <linux/uaccess.h>
0032 #include <linux/buffer_head.h>
0033 #include <linux/slab.h>
0034 #include <linux/firmware.h>
0035 #include <linux/input/mt.h>
0036 #include <linux/input/touchscreen.h>
0037 #include <linux/acpi.h>
0038 #include <linux/of.h>
0039 #include <linux/gpio/consumer.h>
0040 #include <linux/regulator/consumer.h>
0041 #include <linux/uuid.h>
0042 #include <asm/unaligned.h>
0043 
0044 /* Device, Driver information */
0045 #define DEVICE_NAME "elants_i2c"
0046 
0047 /* Convert from rows or columns into resolution */
0048 #define ELAN_TS_RESOLUTION(n, m)   (((n) - 1) * (m))
0049 
0050 /* FW header data */
0051 #define HEADER_SIZE     4
0052 #define FW_HDR_TYPE     0
0053 #define FW_HDR_COUNT        1
0054 #define FW_HDR_LENGTH       2
0055 
0056 /* Buffer mode Queue Header information */
0057 #define QUEUE_HEADER_SINGLE 0x62
0058 #define QUEUE_HEADER_NORMAL 0X63
0059 #define QUEUE_HEADER_WAIT   0x64
0060 #define QUEUE_HEADER_NORMAL2    0x66
0061 
0062 /* Command header definition */
0063 #define CMD_HEADER_WRITE    0x54
0064 #define CMD_HEADER_READ     0x53
0065 #define CMD_HEADER_6B_READ  0x5B
0066 #define CMD_HEADER_ROM_READ 0x96
0067 #define CMD_HEADER_RESP     0x52
0068 #define CMD_HEADER_6B_RESP  0x9B
0069 #define CMD_HEADER_ROM_RESP 0x95
0070 #define CMD_HEADER_HELLO    0x55
0071 #define CMD_HEADER_REK      0x66
0072 
0073 /* FW position data */
0074 #define PACKET_SIZE_OLD     40
0075 #define PACKET_SIZE     55
0076 #define MAX_CONTACT_NUM     10
0077 #define FW_POS_HEADER       0
0078 #define FW_POS_STATE        1
0079 #define FW_POS_TOTAL        2
0080 #define FW_POS_XY       3
0081 #define FW_POS_TOOL_TYPE    33
0082 #define FW_POS_CHECKSUM     34
0083 #define FW_POS_WIDTH        35
0084 #define FW_POS_PRESSURE     45
0085 
0086 #define HEADER_REPORT_10_FINGER 0x62
0087 
0088 /* Header (4 bytes) plus 3 full 10-finger packets */
0089 #define MAX_PACKET_SIZE     169
0090 
0091 #define BOOT_TIME_DELAY_MS  50
0092 
0093 /* FW read command, 0x53 0x?? 0x0, 0x01 */
0094 #define E_ELAN_INFO_FW_VER  0x00
0095 #define E_ELAN_INFO_BC_VER  0x10
0096 #define E_ELAN_INFO_X_RES   0x60
0097 #define E_ELAN_INFO_Y_RES   0x63
0098 #define E_ELAN_INFO_REK     0xD0
0099 #define E_ELAN_INFO_TEST_VER    0xE0
0100 #define E_ELAN_INFO_FW_ID   0xF0
0101 #define E_INFO_OSR      0xD6
0102 #define E_INFO_PHY_SCAN     0xD7
0103 #define E_INFO_PHY_DRIVER   0xD8
0104 
0105 /* FW write command, 0x54 0x?? 0x0, 0x01 */
0106 #define E_POWER_STATE_SLEEP 0x50
0107 #define E_POWER_STATE_RESUME    0x58
0108 
0109 #define MAX_RETRIES     3
0110 #define MAX_FW_UPDATE_RETRIES   30
0111 
0112 #define ELAN_FW_PAGESIZE    132
0113 
0114 /* calibration timeout definition */
0115 #define ELAN_CALI_TIMEOUT_MSEC  12000
0116 
0117 #define ELAN_POWERON_DELAY_USEC 500
0118 #define ELAN_RESET_DELAY_MSEC   20
0119 
0120 /* FW boot code version */
0121 #define BC_VER_H_BYTE_FOR_EKTH3900x1_I2C        0x72
0122 #define BC_VER_H_BYTE_FOR_EKTH3900x2_I2C        0x82
0123 #define BC_VER_H_BYTE_FOR_EKTH3900x3_I2C        0x92
0124 #define BC_VER_H_BYTE_FOR_EKTH5312x1_I2C        0x6D
0125 #define BC_VER_H_BYTE_FOR_EKTH5312x2_I2C        0x6E
0126 #define BC_VER_H_BYTE_FOR_EKTH5312cx1_I2C       0x77
0127 #define BC_VER_H_BYTE_FOR_EKTH5312cx2_I2C       0x78
0128 #define BC_VER_H_BYTE_FOR_EKTH5312x1_I2C_USB    0x67
0129 #define BC_VER_H_BYTE_FOR_EKTH5312x2_I2C_USB    0x68
0130 #define BC_VER_H_BYTE_FOR_EKTH5312cx1_I2C_USB   0x74
0131 #define BC_VER_H_BYTE_FOR_EKTH5312cx2_I2C_USB   0x75
0132 
0133 enum elants_chip_id {
0134     EKTH3500,
0135     EKTF3624,
0136 };
0137 
0138 enum elants_state {
0139     ELAN_STATE_NORMAL,
0140     ELAN_WAIT_QUEUE_HEADER,
0141     ELAN_WAIT_RECALIBRATION,
0142 };
0143 
0144 enum elants_iap_mode {
0145     ELAN_IAP_OPERATIONAL,
0146     ELAN_IAP_RECOVERY,
0147 };
0148 
0149 /* struct elants_data - represents state of Elan touchscreen device */
0150 struct elants_data {
0151     struct i2c_client *client;
0152     struct input_dev *input;
0153 
0154     struct regulator *vcc33;
0155     struct regulator *vccio;
0156     struct gpio_desc *reset_gpio;
0157 
0158     u16 fw_version;
0159     u8 test_version;
0160     u8 solution_version;
0161     u8 bc_version;
0162     u8 iap_version;
0163     u16 hw_version;
0164     u8 major_res;
0165     unsigned int x_res; /* resolution in units/mm */
0166     unsigned int y_res;
0167     unsigned int x_max;
0168     unsigned int y_max;
0169     unsigned int phy_x;
0170     unsigned int phy_y;
0171     struct touchscreen_properties prop;
0172 
0173     enum elants_state state;
0174     enum elants_chip_id chip_id;
0175     enum elants_iap_mode iap_mode;
0176 
0177     /* Guards against concurrent access to the device via sysfs */
0178     struct mutex sysfs_mutex;
0179 
0180     u8 cmd_resp[HEADER_SIZE];
0181     struct completion cmd_done;
0182 
0183     bool wake_irq_enabled;
0184     bool keep_power_in_suspend;
0185 
0186     /* Must be last to be used for DMA operations */
0187     u8 buf[MAX_PACKET_SIZE] ____cacheline_aligned;
0188 };
0189 
0190 static int elants_i2c_send(struct i2c_client *client,
0191                const void *data, size_t size)
0192 {
0193     int ret;
0194 
0195     ret = i2c_master_send(client, data, size);
0196     if (ret == size)
0197         return 0;
0198 
0199     if (ret >= 0)
0200         ret = -EIO;
0201 
0202     dev_err(&client->dev, "%s failed (%*ph): %d\n",
0203         __func__, (int)size, data, ret);
0204 
0205     return ret;
0206 }
0207 
0208 static int elants_i2c_read(struct i2c_client *client, void *data, size_t size)
0209 {
0210     int ret;
0211 
0212     ret = i2c_master_recv(client, data, size);
0213     if (ret == size)
0214         return 0;
0215 
0216     if (ret >= 0)
0217         ret = -EIO;
0218 
0219     dev_err(&client->dev, "%s failed: %d\n", __func__, ret);
0220 
0221     return ret;
0222 }
0223 
0224 static int elants_i2c_execute_command(struct i2c_client *client,
0225                       const u8 *cmd, size_t cmd_size,
0226                       u8 *resp, size_t resp_size,
0227                       int retries, const char *cmd_name)
0228 {
0229     struct i2c_msg msgs[2];
0230     int ret;
0231     u8 expected_response;
0232 
0233     switch (cmd[0]) {
0234     case CMD_HEADER_READ:
0235         expected_response = CMD_HEADER_RESP;
0236         break;
0237 
0238     case CMD_HEADER_6B_READ:
0239         expected_response = CMD_HEADER_6B_RESP;
0240         break;
0241 
0242     case CMD_HEADER_ROM_READ:
0243         expected_response = CMD_HEADER_ROM_RESP;
0244         break;
0245 
0246     default:
0247         dev_err(&client->dev, "(%s): invalid command: %*ph\n",
0248             cmd_name, (int)cmd_size, cmd);
0249         return -EINVAL;
0250     }
0251 
0252     for (;;) {
0253         msgs[0].addr = client->addr;
0254         msgs[0].flags = client->flags & I2C_M_TEN;
0255         msgs[0].len = cmd_size;
0256         msgs[0].buf = (u8 *)cmd;
0257 
0258         msgs[1].addr = client->addr;
0259         msgs[1].flags = (client->flags & I2C_M_TEN) | I2C_M_RD;
0260         msgs[1].flags |= I2C_M_RD;
0261         msgs[1].len = resp_size;
0262         msgs[1].buf = resp;
0263 
0264         ret = i2c_transfer(client->adapter, msgs, ARRAY_SIZE(msgs));
0265         if (ret < 0) {
0266             if (--retries > 0) {
0267                 dev_dbg(&client->dev,
0268                     "(%s) I2C transfer failed: %pe (retrying)\n",
0269                     cmd_name, ERR_PTR(ret));
0270                 continue;
0271             }
0272 
0273             dev_err(&client->dev,
0274                 "(%s) I2C transfer failed: %pe\n",
0275                 cmd_name, ERR_PTR(ret));
0276             return ret;
0277         }
0278 
0279         if (ret != ARRAY_SIZE(msgs) ||
0280             resp[FW_HDR_TYPE] != expected_response) {
0281             if (--retries > 0) {
0282                 dev_dbg(&client->dev,
0283                     "(%s) unexpected response: %*ph (retrying)\n",
0284                     cmd_name, ret, resp);
0285                 continue;
0286             }
0287 
0288             dev_err(&client->dev,
0289                 "(%s) unexpected response: %*ph\n",
0290                 cmd_name, ret, resp);
0291             return -EIO;
0292         }
0293 
0294         return 0;
0295     }
0296 }
0297 
0298 static int elants_i2c_calibrate(struct elants_data *ts)
0299 {
0300     struct i2c_client *client = ts->client;
0301     int ret, error;
0302     static const u8 w_flashkey[] = { CMD_HEADER_WRITE, 0xC0, 0xE1, 0x5A };
0303     static const u8 rek[] = { CMD_HEADER_WRITE, 0x29, 0x00, 0x01 };
0304     static const u8 rek_resp[] = { CMD_HEADER_REK, 0x66, 0x66, 0x66 };
0305 
0306     disable_irq(client->irq);
0307 
0308     ts->state = ELAN_WAIT_RECALIBRATION;
0309     reinit_completion(&ts->cmd_done);
0310 
0311     elants_i2c_send(client, w_flashkey, sizeof(w_flashkey));
0312     elants_i2c_send(client, rek, sizeof(rek));
0313 
0314     enable_irq(client->irq);
0315 
0316     ret = wait_for_completion_interruptible_timeout(&ts->cmd_done,
0317                 msecs_to_jiffies(ELAN_CALI_TIMEOUT_MSEC));
0318 
0319     ts->state = ELAN_STATE_NORMAL;
0320 
0321     if (ret <= 0) {
0322         error = ret < 0 ? ret : -ETIMEDOUT;
0323         dev_err(&client->dev,
0324             "error while waiting for calibration to complete: %d\n",
0325             error);
0326         return error;
0327     }
0328 
0329     if (memcmp(rek_resp, ts->cmd_resp, sizeof(rek_resp))) {
0330         dev_err(&client->dev,
0331             "unexpected calibration response: %*ph\n",
0332             (int)sizeof(ts->cmd_resp), ts->cmd_resp);
0333         return -EINVAL;
0334     }
0335 
0336     return 0;
0337 }
0338 
0339 static int elants_i2c_sw_reset(struct i2c_client *client)
0340 {
0341     const u8 soft_rst_cmd[] = { 0x77, 0x77, 0x77, 0x77 };
0342     int error;
0343 
0344     error = elants_i2c_send(client, soft_rst_cmd,
0345                 sizeof(soft_rst_cmd));
0346     if (error) {
0347         dev_err(&client->dev, "software reset failed: %d\n", error);
0348         return error;
0349     }
0350 
0351     /*
0352      * We should wait at least 10 msec (but no more than 40) before
0353      * sending fastboot or IAP command to the device.
0354      */
0355     msleep(30);
0356 
0357     return 0;
0358 }
0359 
0360 static u16 elants_i2c_parse_version(u8 *buf)
0361 {
0362     return get_unaligned_be32(buf) >> 4;
0363 }
0364 
0365 static int elants_i2c_query_hw_version(struct elants_data *ts)
0366 {
0367     struct i2c_client *client = ts->client;
0368     int retry_cnt = MAX_RETRIES;
0369     const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_FW_ID, 0x00, 0x01 };
0370     u8 resp[HEADER_SIZE];
0371     int error;
0372 
0373     while (retry_cnt--) {
0374         error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
0375                            resp, sizeof(resp), 1,
0376                            "read fw id");
0377         if (error)
0378             return error;
0379 
0380         ts->hw_version = elants_i2c_parse_version(resp);
0381         if (ts->hw_version != 0xffff)
0382             return 0;
0383     }
0384 
0385     dev_err(&client->dev, "Invalid fw id: %#04x\n", ts->hw_version);
0386 
0387     return -EINVAL;
0388 }
0389 
0390 static int elants_i2c_query_fw_version(struct elants_data *ts)
0391 {
0392     struct i2c_client *client = ts->client;
0393     int retry_cnt = MAX_RETRIES;
0394     const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_FW_VER, 0x00, 0x01 };
0395     u8 resp[HEADER_SIZE];
0396     int error;
0397 
0398     while (retry_cnt--) {
0399         error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
0400                            resp, sizeof(resp), 1,
0401                            "read fw version");
0402         if (error)
0403             return error;
0404 
0405         ts->fw_version = elants_i2c_parse_version(resp);
0406         if (ts->fw_version != 0x0000 && ts->fw_version != 0xffff)
0407             return 0;
0408 
0409         dev_dbg(&client->dev, "(read fw version) resp %*phC\n",
0410             (int)sizeof(resp), resp);
0411     }
0412 
0413     dev_err(&client->dev, "Invalid fw ver: %#04x\n", ts->fw_version);
0414 
0415     return -EINVAL;
0416 }
0417 
0418 static int elants_i2c_query_test_version(struct elants_data *ts)
0419 {
0420     struct i2c_client *client = ts->client;
0421     int error;
0422     u16 version;
0423     const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_TEST_VER, 0x00, 0x01 };
0424     u8 resp[HEADER_SIZE];
0425 
0426     error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
0427                        resp, sizeof(resp), MAX_RETRIES,
0428                        "read test version");
0429     if (error) {
0430         dev_err(&client->dev, "Failed to read test version\n");
0431         return error;
0432     }
0433 
0434     version = elants_i2c_parse_version(resp);
0435     ts->test_version = version >> 8;
0436     ts->solution_version = version & 0xff;
0437 
0438     return 0;
0439 }
0440 
0441 static int elants_i2c_query_bc_version(struct elants_data *ts)
0442 {
0443     struct i2c_client *client = ts->client;
0444     const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_BC_VER, 0x00, 0x01 };
0445     u8 resp[HEADER_SIZE];
0446     u16 version;
0447     int error;
0448 
0449     error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
0450                        resp, sizeof(resp), 1,
0451                        "read BC version");
0452     if (error)
0453         return error;
0454 
0455     version = elants_i2c_parse_version(resp);
0456     ts->bc_version = version >> 8;
0457     ts->iap_version = version & 0xff;
0458 
0459     return 0;
0460 }
0461 
0462 static int elants_i2c_query_ts_info_ektf(struct elants_data *ts)
0463 {
0464     struct i2c_client *client = ts->client;
0465     int error;
0466     u8 resp[4];
0467     u16 phy_x, phy_y;
0468     const u8 get_xres_cmd[] = {
0469         CMD_HEADER_READ, E_ELAN_INFO_X_RES, 0x00, 0x00
0470     };
0471     const u8 get_yres_cmd[] = {
0472         CMD_HEADER_READ, E_ELAN_INFO_Y_RES, 0x00, 0x00
0473     };
0474 
0475     /* Get X/Y size in mm */
0476     error = elants_i2c_execute_command(client, get_xres_cmd,
0477                        sizeof(get_xres_cmd),
0478                        resp, sizeof(resp), 1,
0479                        "get X size");
0480     if (error)
0481         return error;
0482 
0483     phy_x = resp[2] | ((resp[3] & 0xF0) << 4);
0484 
0485     error = elants_i2c_execute_command(client, get_yres_cmd,
0486                        sizeof(get_yres_cmd),
0487                        resp, sizeof(resp), 1,
0488                        "get Y size");
0489     if (error)
0490         return error;
0491 
0492     phy_y = resp[2] | ((resp[3] & 0xF0) << 4);
0493 
0494     dev_dbg(&client->dev, "phy_x=%d, phy_y=%d\n", phy_x, phy_y);
0495 
0496     ts->phy_x = phy_x;
0497     ts->phy_y = phy_y;
0498 
0499     /* eKTF doesn't report max size, set it to default values */
0500     ts->x_max = 2240 - 1;
0501     ts->y_max = 1408 - 1;
0502 
0503     return 0;
0504 }
0505 
0506 static int elants_i2c_query_ts_info_ekth(struct elants_data *ts)
0507 {
0508     struct i2c_client *client = ts->client;
0509     int error;
0510     u8 resp[17];
0511     u16 phy_x, phy_y, rows, cols, osr;
0512     const u8 get_resolution_cmd[] = {
0513         CMD_HEADER_6B_READ, 0x00, 0x00, 0x00, 0x00, 0x00
0514     };
0515     const u8 get_osr_cmd[] = {
0516         CMD_HEADER_READ, E_INFO_OSR, 0x00, 0x01
0517     };
0518     const u8 get_physical_scan_cmd[] = {
0519         CMD_HEADER_READ, E_INFO_PHY_SCAN, 0x00, 0x01
0520     };
0521     const u8 get_physical_drive_cmd[] = {
0522         CMD_HEADER_READ, E_INFO_PHY_DRIVER, 0x00, 0x01
0523     };
0524 
0525     /* Get trace number */
0526     error = elants_i2c_execute_command(client,
0527                        get_resolution_cmd,
0528                        sizeof(get_resolution_cmd),
0529                        resp, sizeof(resp), 1,
0530                        "get resolution");
0531     if (error)
0532         return error;
0533 
0534     rows = resp[2] + resp[6] + resp[10];
0535     cols = resp[3] + resp[7] + resp[11];
0536 
0537     /* Get report resolution value of ABS_MT_TOUCH_MAJOR */
0538     ts->major_res = resp[16];
0539 
0540     /* Process mm_to_pixel information */
0541     error = elants_i2c_execute_command(client,
0542                        get_osr_cmd, sizeof(get_osr_cmd),
0543                        resp, sizeof(resp), 1, "get osr");
0544     if (error)
0545         return error;
0546 
0547     osr = resp[3];
0548 
0549     error = elants_i2c_execute_command(client,
0550                        get_physical_scan_cmd,
0551                        sizeof(get_physical_scan_cmd),
0552                        resp, sizeof(resp), 1,
0553                        "get physical scan");
0554     if (error)
0555         return error;
0556 
0557     phy_x = get_unaligned_be16(&resp[2]);
0558 
0559     error = elants_i2c_execute_command(client,
0560                        get_physical_drive_cmd,
0561                        sizeof(get_physical_drive_cmd),
0562                        resp, sizeof(resp), 1,
0563                        "get physical drive");
0564     if (error)
0565         return error;
0566 
0567     phy_y = get_unaligned_be16(&resp[2]);
0568 
0569     dev_dbg(&client->dev, "phy_x=%d, phy_y=%d\n", phy_x, phy_y);
0570 
0571     if (rows == 0 || cols == 0 || osr == 0) {
0572         dev_warn(&client->dev,
0573              "invalid trace number data: %d, %d, %d\n",
0574              rows, cols, osr);
0575     } else {
0576         /* translate trace number to TS resolution */
0577         ts->x_max = ELAN_TS_RESOLUTION(rows, osr);
0578         ts->x_res = DIV_ROUND_CLOSEST(ts->x_max, phy_x);
0579         ts->y_max = ELAN_TS_RESOLUTION(cols, osr);
0580         ts->y_res = DIV_ROUND_CLOSEST(ts->y_max, phy_y);
0581         ts->phy_x = phy_x;
0582         ts->phy_y = phy_y;
0583     }
0584 
0585     return 0;
0586 }
0587 
0588 static int elants_i2c_fastboot(struct i2c_client *client)
0589 {
0590     const u8 boot_cmd[] = { 0x4D, 0x61, 0x69, 0x6E };
0591     int error;
0592 
0593     error = elants_i2c_send(client, boot_cmd, sizeof(boot_cmd));
0594     if (error) {
0595         dev_err(&client->dev, "boot failed: %d\n", error);
0596         return error;
0597     }
0598 
0599     dev_dbg(&client->dev, "boot success -- 0x%x\n", client->addr);
0600     return 0;
0601 }
0602 
0603 static int elants_i2c_initialize(struct elants_data *ts)
0604 {
0605     struct i2c_client *client = ts->client;
0606     int error, error2, retry_cnt;
0607     const u8 hello_packet[] = { 0x55, 0x55, 0x55, 0x55 };
0608     const u8 recov_packet[] = { 0x55, 0x55, 0x80, 0x80 };
0609     u8 buf[HEADER_SIZE];
0610 
0611     for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
0612         error = elants_i2c_sw_reset(client);
0613         if (error) {
0614             /* Continue initializing if it's the last try */
0615             if (retry_cnt < MAX_RETRIES - 1)
0616                 continue;
0617         }
0618 
0619         error = elants_i2c_fastboot(client);
0620         if (error) {
0621             /* Continue initializing if it's the last try */
0622             if (retry_cnt < MAX_RETRIES - 1)
0623                 continue;
0624         }
0625 
0626         /* Wait for Hello packet */
0627         msleep(BOOT_TIME_DELAY_MS);
0628 
0629         error = elants_i2c_read(client, buf, sizeof(buf));
0630         if (error) {
0631             dev_err(&client->dev,
0632                 "failed to read 'hello' packet: %d\n", error);
0633         } else if (!memcmp(buf, hello_packet, sizeof(hello_packet))) {
0634             ts->iap_mode = ELAN_IAP_OPERATIONAL;
0635             break;
0636         } else if (!memcmp(buf, recov_packet, sizeof(recov_packet))) {
0637             /*
0638              * Setting error code will mark device
0639              * in recovery mode below.
0640              */
0641             error = -EIO;
0642             break;
0643         } else {
0644             error = -EINVAL;
0645             dev_err(&client->dev,
0646                 "invalid 'hello' packet: %*ph\n",
0647                 (int)sizeof(buf), buf);
0648         }
0649     }
0650 
0651     /* hw version is available even if device in recovery state */
0652     error2 = elants_i2c_query_hw_version(ts);
0653     if (!error2)
0654         error2 = elants_i2c_query_bc_version(ts);
0655     if (!error)
0656         error = error2;
0657 
0658     if (!error)
0659         error = elants_i2c_query_fw_version(ts);
0660     if (!error)
0661         error = elants_i2c_query_test_version(ts);
0662 
0663     switch (ts->chip_id) {
0664     case EKTH3500:
0665         if (!error)
0666             error = elants_i2c_query_ts_info_ekth(ts);
0667         break;
0668     case EKTF3624:
0669         if (!error)
0670             error = elants_i2c_query_ts_info_ektf(ts);
0671         break;
0672     default:
0673         BUG();
0674     }
0675 
0676     if (error)
0677         ts->iap_mode = ELAN_IAP_RECOVERY;
0678 
0679     return 0;
0680 }
0681 
0682 /*
0683  * Firmware update interface.
0684  */
0685 
0686 static int elants_i2c_fw_write_page(struct i2c_client *client,
0687                     const void *page)
0688 {
0689     const u8 ack_ok[] = { 0xaa, 0xaa };
0690     u8 buf[2];
0691     int retry;
0692     int error;
0693 
0694     for (retry = 0; retry < MAX_FW_UPDATE_RETRIES; retry++) {
0695         error = elants_i2c_send(client, page, ELAN_FW_PAGESIZE);
0696         if (error) {
0697             dev_err(&client->dev,
0698                 "IAP Write Page failed: %d\n", error);
0699             continue;
0700         }
0701 
0702         error = elants_i2c_read(client, buf, 2);
0703         if (error) {
0704             dev_err(&client->dev,
0705                 "IAP Ack read failed: %d\n", error);
0706             return error;
0707         }
0708 
0709         if (!memcmp(buf, ack_ok, sizeof(ack_ok)))
0710             return 0;
0711 
0712         error = -EIO;
0713         dev_err(&client->dev,
0714             "IAP Get Ack Error [%02x:%02x]\n",
0715             buf[0], buf[1]);
0716     }
0717 
0718     return error;
0719 }
0720 
0721 static int elants_i2c_validate_remark_id(struct elants_data *ts,
0722                      const struct firmware *fw)
0723 {
0724     struct i2c_client *client = ts->client;
0725     int error;
0726     const u8 cmd[] = { CMD_HEADER_ROM_READ, 0x80, 0x1F, 0x00, 0x00, 0x21 };
0727     u8 resp[6] = { 0 };
0728     u16 ts_remark_id = 0;
0729     u16 fw_remark_id = 0;
0730 
0731     /* Compare TS Remark ID and FW Remark ID */
0732     error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
0733                        resp, sizeof(resp),
0734                        1, "read Remark ID");
0735     if (error)
0736         return error;
0737 
0738     ts_remark_id = get_unaligned_be16(&resp[3]);
0739 
0740     fw_remark_id = get_unaligned_le16(&fw->data[fw->size - 4]);
0741 
0742     if (fw_remark_id != ts_remark_id) {
0743         dev_err(&client->dev,
0744             "Remark ID Mismatched: ts_remark_id=0x%04x, fw_remark_id=0x%04x.\n",
0745             ts_remark_id, fw_remark_id);
0746         return -EINVAL;
0747     }
0748 
0749     return 0;
0750 }
0751 
0752 static bool elants_i2c_should_check_remark_id(struct elants_data *ts)
0753 {
0754     struct i2c_client *client = ts->client;
0755     const u8 bootcode_version = ts->iap_version;
0756     bool check;
0757 
0758     /* I2C eKTH3900 and eKTH5312 are NOT support Remark ID */
0759     if ((bootcode_version == BC_VER_H_BYTE_FOR_EKTH3900x1_I2C) ||
0760         (bootcode_version == BC_VER_H_BYTE_FOR_EKTH3900x2_I2C) ||
0761         (bootcode_version == BC_VER_H_BYTE_FOR_EKTH3900x3_I2C) ||
0762         (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312x1_I2C) ||
0763         (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312x2_I2C) ||
0764         (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312cx1_I2C) ||
0765         (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312cx2_I2C) ||
0766         (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312x1_I2C_USB) ||
0767         (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312x2_I2C_USB) ||
0768         (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312cx1_I2C_USB) ||
0769         (bootcode_version == BC_VER_H_BYTE_FOR_EKTH5312cx2_I2C_USB)) {
0770         dev_dbg(&client->dev,
0771             "eKTH3900/eKTH5312(0x%02x) are not support remark id\n",
0772             bootcode_version);
0773         check = false;
0774     } else if (bootcode_version >= 0x60) {
0775         check = true;
0776     } else {
0777         check = false;
0778     }
0779 
0780     return check;
0781 }
0782 
0783 static int elants_i2c_do_update_firmware(struct i2c_client *client,
0784                      const struct firmware *fw,
0785                      bool force)
0786 {
0787     struct elants_data *ts = i2c_get_clientdata(client);
0788     const u8 enter_iap[] = { 0x45, 0x49, 0x41, 0x50 };
0789     const u8 enter_iap2[] = { 0x54, 0x00, 0x12, 0x34 };
0790     const u8 iap_ack[] = { 0x55, 0xaa, 0x33, 0xcc };
0791     const u8 close_idle[] = { 0x54, 0x2c, 0x01, 0x01 };
0792     u8 buf[HEADER_SIZE];
0793     u16 send_id;
0794     int page, n_fw_pages;
0795     int error;
0796     bool check_remark_id = elants_i2c_should_check_remark_id(ts);
0797 
0798     /* Recovery mode detection! */
0799     if (force) {
0800         dev_dbg(&client->dev, "Recovery mode procedure\n");
0801 
0802         if (check_remark_id) {
0803             error = elants_i2c_validate_remark_id(ts, fw);
0804             if (error)
0805                 return error;
0806         }
0807 
0808         error = elants_i2c_send(client, enter_iap2, sizeof(enter_iap2));
0809         if (error) {
0810             dev_err(&client->dev, "failed to enter IAP mode: %d\n",
0811                 error);
0812             return error;
0813         }
0814     } else {
0815         /* Start IAP Procedure */
0816         dev_dbg(&client->dev, "Normal IAP procedure\n");
0817 
0818         /* Close idle mode */
0819         error = elants_i2c_send(client, close_idle, sizeof(close_idle));
0820         if (error)
0821             dev_err(&client->dev, "Failed close idle: %d\n", error);
0822         msleep(60);
0823 
0824         elants_i2c_sw_reset(client);
0825         msleep(20);
0826 
0827         if (check_remark_id) {
0828             error = elants_i2c_validate_remark_id(ts, fw);
0829             if (error)
0830                 return error;
0831         }
0832 
0833         error = elants_i2c_send(client, enter_iap, sizeof(enter_iap));
0834         if (error) {
0835             dev_err(&client->dev, "failed to enter IAP mode: %d\n",
0836                 error);
0837             return error;
0838         }
0839     }
0840 
0841     msleep(20);
0842 
0843     /* check IAP state */
0844     error = elants_i2c_read(client, buf, 4);
0845     if (error) {
0846         dev_err(&client->dev,
0847             "failed to read IAP acknowledgement: %d\n",
0848             error);
0849         return error;
0850     }
0851 
0852     if (memcmp(buf, iap_ack, sizeof(iap_ack))) {
0853         dev_err(&client->dev,
0854             "failed to enter IAP: %*ph (expected %*ph)\n",
0855             (int)sizeof(buf), buf, (int)sizeof(iap_ack), iap_ack);
0856         return -EIO;
0857     }
0858 
0859     dev_info(&client->dev, "successfully entered IAP mode");
0860 
0861     send_id = client->addr;
0862     error = elants_i2c_send(client, &send_id, 1);
0863     if (error) {
0864         dev_err(&client->dev, "sending dummy byte failed: %d\n",
0865             error);
0866         return error;
0867     }
0868 
0869     /* Clear the last page of Master */
0870     error = elants_i2c_send(client, fw->data, ELAN_FW_PAGESIZE);
0871     if (error) {
0872         dev_err(&client->dev, "clearing of the last page failed: %d\n",
0873             error);
0874         return error;
0875     }
0876 
0877     error = elants_i2c_read(client, buf, 2);
0878     if (error) {
0879         dev_err(&client->dev,
0880             "failed to read ACK for clearing the last page: %d\n",
0881             error);
0882         return error;
0883     }
0884 
0885     n_fw_pages = fw->size / ELAN_FW_PAGESIZE;
0886     dev_dbg(&client->dev, "IAP Pages = %d\n", n_fw_pages);
0887 
0888     for (page = 0; page < n_fw_pages; page++) {
0889         error = elants_i2c_fw_write_page(client,
0890                     fw->data + page * ELAN_FW_PAGESIZE);
0891         if (error) {
0892             dev_err(&client->dev,
0893                 "failed to write FW page %d: %d\n",
0894                 page, error);
0895             return error;
0896         }
0897     }
0898 
0899     /* Old iap needs to wait 200ms for WDT and rest is for hello packets */
0900     msleep(300);
0901 
0902     dev_info(&client->dev, "firmware update completed\n");
0903     return 0;
0904 }
0905 
0906 static int elants_i2c_fw_update(struct elants_data *ts)
0907 {
0908     struct i2c_client *client = ts->client;
0909     const struct firmware *fw;
0910     char *fw_name;
0911     int error;
0912 
0913     fw_name = kasprintf(GFP_KERNEL, "elants_i2c_%04x.bin", ts->hw_version);
0914     if (!fw_name)
0915         return -ENOMEM;
0916 
0917     dev_info(&client->dev, "requesting fw name = %s\n", fw_name);
0918     error = request_firmware(&fw, fw_name, &client->dev);
0919     kfree(fw_name);
0920     if (error) {
0921         dev_err(&client->dev, "failed to request firmware: %d\n",
0922             error);
0923         return error;
0924     }
0925 
0926     if (fw->size % ELAN_FW_PAGESIZE) {
0927         dev_err(&client->dev, "invalid firmware length: %zu\n",
0928             fw->size);
0929         error = -EINVAL;
0930         goto out;
0931     }
0932 
0933     disable_irq(client->irq);
0934 
0935     error = elants_i2c_do_update_firmware(client, fw,
0936                     ts->iap_mode == ELAN_IAP_RECOVERY);
0937     if (error) {
0938         dev_err(&client->dev, "firmware update failed: %d\n", error);
0939         ts->iap_mode = ELAN_IAP_RECOVERY;
0940         goto out_enable_irq;
0941     }
0942 
0943     error = elants_i2c_initialize(ts);
0944     if (error) {
0945         dev_err(&client->dev,
0946             "failed to initialize device after firmware update: %d\n",
0947             error);
0948         ts->iap_mode = ELAN_IAP_RECOVERY;
0949         goto out_enable_irq;
0950     }
0951 
0952     ts->iap_mode = ELAN_IAP_OPERATIONAL;
0953 
0954 out_enable_irq:
0955     ts->state = ELAN_STATE_NORMAL;
0956     enable_irq(client->irq);
0957     msleep(100);
0958 
0959     if (!error)
0960         elants_i2c_calibrate(ts);
0961 out:
0962     release_firmware(fw);
0963     return error;
0964 }
0965 
0966 /*
0967  * Event reporting.
0968  */
0969 
0970 static void elants_i2c_mt_event(struct elants_data *ts, u8 *buf,
0971                 size_t packet_size)
0972 {
0973     struct input_dev *input = ts->input;
0974     unsigned int n_fingers;
0975     unsigned int tool_type;
0976     u16 finger_state;
0977     int i;
0978 
0979     n_fingers = buf[FW_POS_STATE + 1] & 0x0f;
0980     finger_state = ((buf[FW_POS_STATE + 1] & 0x30) << 4) |
0981             buf[FW_POS_STATE];
0982 
0983     dev_dbg(&ts->client->dev,
0984         "n_fingers: %u, state: %04x\n",  n_fingers, finger_state);
0985 
0986     /* Note: all fingers have the same tool type */
0987     tool_type = buf[FW_POS_TOOL_TYPE] & BIT(0) ?
0988             MT_TOOL_FINGER : MT_TOOL_PALM;
0989 
0990     for (i = 0; i < MAX_CONTACT_NUM && n_fingers; i++) {
0991         if (finger_state & 1) {
0992             unsigned int x, y, p, w;
0993             u8 *pos;
0994 
0995             pos = &buf[FW_POS_XY + i * 3];
0996             x = (((u16)pos[0] & 0xf0) << 4) | pos[1];
0997             y = (((u16)pos[0] & 0x0f) << 8) | pos[2];
0998 
0999             /*
1000              * eKTF3624 may have use "old" touch-report format,
1001              * depending on a device and TS firmware version.
1002              * For example, ASUS Transformer devices use the "old"
1003              * format, while ASUS Nexus 7 uses the "new" formant.
1004              */
1005             if (packet_size == PACKET_SIZE_OLD &&
1006                 ts->chip_id == EKTF3624) {
1007                 w = buf[FW_POS_WIDTH + i / 2];
1008                 w >>= 4 * (~i & 1);
1009                 w |= w << 4;
1010                 w |= !w;
1011                 p = w;
1012             } else {
1013                 p = buf[FW_POS_PRESSURE + i];
1014                 w = buf[FW_POS_WIDTH + i];
1015             }
1016 
1017             dev_dbg(&ts->client->dev, "i=%d x=%d y=%d p=%d w=%d\n",
1018                 i, x, y, p, w);
1019 
1020             input_mt_slot(input, i);
1021             input_mt_report_slot_state(input, tool_type, true);
1022             touchscreen_report_pos(input, &ts->prop, x, y, true);
1023             input_event(input, EV_ABS, ABS_MT_PRESSURE, p);
1024             input_event(input, EV_ABS, ABS_MT_TOUCH_MAJOR, w);
1025 
1026             n_fingers--;
1027         }
1028 
1029         finger_state >>= 1;
1030     }
1031 
1032     input_mt_sync_frame(input);
1033     input_sync(input);
1034 }
1035 
1036 static u8 elants_i2c_calculate_checksum(u8 *buf)
1037 {
1038     u8 checksum = 0;
1039     u8 i;
1040 
1041     for (i = 0; i < FW_POS_CHECKSUM; i++)
1042         checksum += buf[i];
1043 
1044     return checksum;
1045 }
1046 
1047 static void elants_i2c_event(struct elants_data *ts, u8 *buf,
1048                  size_t packet_size)
1049 {
1050     u8 checksum = elants_i2c_calculate_checksum(buf);
1051 
1052     if (unlikely(buf[FW_POS_CHECKSUM] != checksum))
1053         dev_warn(&ts->client->dev,
1054              "%s: invalid checksum for packet %02x: %02x vs. %02x\n",
1055              __func__, buf[FW_POS_HEADER],
1056              checksum, buf[FW_POS_CHECKSUM]);
1057     else if (unlikely(buf[FW_POS_HEADER] != HEADER_REPORT_10_FINGER))
1058         dev_warn(&ts->client->dev,
1059              "%s: unknown packet type: %02x\n",
1060              __func__, buf[FW_POS_HEADER]);
1061     else
1062         elants_i2c_mt_event(ts, buf, packet_size);
1063 }
1064 
1065 static irqreturn_t elants_i2c_irq(int irq, void *_dev)
1066 {
1067     const u8 wait_packet[] = { 0x64, 0x64, 0x64, 0x64 };
1068     struct elants_data *ts = _dev;
1069     struct i2c_client *client = ts->client;
1070     int report_count, report_len;
1071     int i;
1072     int len;
1073 
1074     len = i2c_master_recv_dmasafe(client, ts->buf, sizeof(ts->buf));
1075     if (len < 0) {
1076         dev_err(&client->dev, "%s: failed to read data: %d\n",
1077             __func__, len);
1078         goto out;
1079     }
1080 
1081     dev_dbg(&client->dev, "%s: packet %*ph\n",
1082         __func__, HEADER_SIZE, ts->buf);
1083 
1084     switch (ts->state) {
1085     case ELAN_WAIT_RECALIBRATION:
1086         if (ts->buf[FW_HDR_TYPE] == CMD_HEADER_REK) {
1087             memcpy(ts->cmd_resp, ts->buf, sizeof(ts->cmd_resp));
1088             complete(&ts->cmd_done);
1089             ts->state = ELAN_STATE_NORMAL;
1090         }
1091         break;
1092 
1093     case ELAN_WAIT_QUEUE_HEADER:
1094         if (ts->buf[FW_HDR_TYPE] != QUEUE_HEADER_NORMAL)
1095             break;
1096 
1097         ts->state = ELAN_STATE_NORMAL;
1098         fallthrough;
1099 
1100     case ELAN_STATE_NORMAL:
1101 
1102         switch (ts->buf[FW_HDR_TYPE]) {
1103         case CMD_HEADER_HELLO:
1104         case CMD_HEADER_RESP:
1105             break;
1106 
1107         case QUEUE_HEADER_WAIT:
1108             if (memcmp(ts->buf, wait_packet, sizeof(wait_packet))) {
1109                 dev_err(&client->dev,
1110                     "invalid wait packet %*ph\n",
1111                     HEADER_SIZE, ts->buf);
1112             } else {
1113                 ts->state = ELAN_WAIT_QUEUE_HEADER;
1114                 udelay(30);
1115             }
1116             break;
1117 
1118         case QUEUE_HEADER_SINGLE:
1119             elants_i2c_event(ts, &ts->buf[HEADER_SIZE],
1120                      ts->buf[FW_HDR_LENGTH]);
1121             break;
1122 
1123         case QUEUE_HEADER_NORMAL2: /* CMD_HEADER_REK */
1124             /*
1125              * Depending on firmware version, eKTF3624 touchscreens
1126              * may utilize one of these opcodes for the touch events:
1127              * 0x63 (NORMAL) and 0x66 (NORMAL2).  The 0x63 is used by
1128              * older firmware version and differs from 0x66 such that
1129              * touch pressure value needs to be adjusted.  The 0x66
1130              * opcode of newer firmware is equal to 0x63 of eKTH3500.
1131              */
1132             if (ts->chip_id != EKTF3624)
1133                 break;
1134 
1135             fallthrough;
1136 
1137         case QUEUE_HEADER_NORMAL:
1138             report_count = ts->buf[FW_HDR_COUNT];
1139             if (report_count == 0 || report_count > 3) {
1140                 dev_err(&client->dev,
1141                     "bad report count: %*ph\n",
1142                     HEADER_SIZE, ts->buf);
1143                 break;
1144             }
1145 
1146             report_len = ts->buf[FW_HDR_LENGTH] / report_count;
1147 
1148             if (report_len == PACKET_SIZE_OLD &&
1149                 ts->chip_id == EKTF3624) {
1150                 dev_dbg_once(&client->dev,
1151                          "using old report format\n");
1152             } else if (report_len != PACKET_SIZE) {
1153                 dev_err(&client->dev,
1154                     "mismatching report length: %*ph\n",
1155                     HEADER_SIZE, ts->buf);
1156                 break;
1157             }
1158 
1159             for (i = 0; i < report_count; i++) {
1160                 u8 *buf = ts->buf + HEADER_SIZE +
1161                             i * report_len;
1162                 elants_i2c_event(ts, buf, report_len);
1163             }
1164             break;
1165 
1166         default:
1167             dev_err(&client->dev, "unknown packet %*ph\n",
1168                 HEADER_SIZE, ts->buf);
1169             break;
1170         }
1171         break;
1172     }
1173 
1174 out:
1175     return IRQ_HANDLED;
1176 }
1177 
1178 /*
1179  * sysfs interface
1180  */
1181 static ssize_t calibrate_store(struct device *dev,
1182                    struct device_attribute *attr,
1183                    const char *buf, size_t count)
1184 {
1185     struct i2c_client *client = to_i2c_client(dev);
1186     struct elants_data *ts = i2c_get_clientdata(client);
1187     int error;
1188 
1189     error = mutex_lock_interruptible(&ts->sysfs_mutex);
1190     if (error)
1191         return error;
1192 
1193     error = elants_i2c_calibrate(ts);
1194 
1195     mutex_unlock(&ts->sysfs_mutex);
1196     return error ?: count;
1197 }
1198 
1199 static ssize_t write_update_fw(struct device *dev,
1200                    struct device_attribute *attr,
1201                    const char *buf, size_t count)
1202 {
1203     struct i2c_client *client = to_i2c_client(dev);
1204     struct elants_data *ts = i2c_get_clientdata(client);
1205     int error;
1206 
1207     error = mutex_lock_interruptible(&ts->sysfs_mutex);
1208     if (error)
1209         return error;
1210 
1211     error = elants_i2c_fw_update(ts);
1212     dev_dbg(dev, "firmware update result: %d\n", error);
1213 
1214     mutex_unlock(&ts->sysfs_mutex);
1215     return error ?: count;
1216 }
1217 
1218 static ssize_t show_iap_mode(struct device *dev,
1219                  struct device_attribute *attr, char *buf)
1220 {
1221     struct i2c_client *client = to_i2c_client(dev);
1222     struct elants_data *ts = i2c_get_clientdata(client);
1223 
1224     return sprintf(buf, "%s\n",
1225                ts->iap_mode == ELAN_IAP_OPERATIONAL ?
1226                 "Normal" : "Recovery");
1227 }
1228 
1229 static ssize_t show_calibration_count(struct device *dev,
1230                       struct device_attribute *attr, char *buf)
1231 {
1232     struct i2c_client *client = to_i2c_client(dev);
1233     const u8 cmd[] = { CMD_HEADER_READ, E_ELAN_INFO_REK, 0x00, 0x01 };
1234     u8 resp[HEADER_SIZE];
1235     u16 rek_count;
1236     int error;
1237 
1238     error = elants_i2c_execute_command(client, cmd, sizeof(cmd),
1239                        resp, sizeof(resp), 1,
1240                        "read ReK status");
1241     if (error)
1242         return sprintf(buf, "%d\n", error);
1243 
1244     rek_count = get_unaligned_be16(&resp[2]);
1245     return sprintf(buf, "0x%04x\n", rek_count);
1246 }
1247 
1248 static DEVICE_ATTR_WO(calibrate);
1249 static DEVICE_ATTR(iap_mode, S_IRUGO, show_iap_mode, NULL);
1250 static DEVICE_ATTR(calibration_count, S_IRUGO, show_calibration_count, NULL);
1251 static DEVICE_ATTR(update_fw, S_IWUSR, NULL, write_update_fw);
1252 
1253 struct elants_version_attribute {
1254     struct device_attribute dattr;
1255     size_t field_offset;
1256     size_t field_size;
1257 };
1258 
1259 #define __ELANTS_FIELD_SIZE(_field)                 \
1260     sizeof(((struct elants_data *)NULL)->_field)
1261 #define __ELANTS_VERIFY_SIZE(_field)                    \
1262     (BUILD_BUG_ON_ZERO(__ELANTS_FIELD_SIZE(_field) > 2) +       \
1263      __ELANTS_FIELD_SIZE(_field))
1264 #define ELANTS_VERSION_ATTR(_field)                 \
1265     struct elants_version_attribute elants_ver_attr_##_field = {    \
1266         .dattr = __ATTR(_field, S_IRUGO,            \
1267                 elants_version_attribute_show, NULL),   \
1268         .field_offset = offsetof(struct elants_data, _field),   \
1269         .field_size = __ELANTS_VERIFY_SIZE(_field),     \
1270     }
1271 
1272 static ssize_t elants_version_attribute_show(struct device *dev,
1273                          struct device_attribute *dattr,
1274                          char *buf)
1275 {
1276     struct i2c_client *client = to_i2c_client(dev);
1277     struct elants_data *ts = i2c_get_clientdata(client);
1278     struct elants_version_attribute *attr =
1279         container_of(dattr, struct elants_version_attribute, dattr);
1280     u8 *field = (u8 *)((char *)ts + attr->field_offset);
1281     unsigned int fmt_size;
1282     unsigned int val;
1283 
1284     if (attr->field_size == 1) {
1285         val = *field;
1286         fmt_size = 2; /* 2 HEX digits */
1287     } else {
1288         val = *(u16 *)field;
1289         fmt_size = 4; /* 4 HEX digits */
1290     }
1291 
1292     return sprintf(buf, "%0*x\n", fmt_size, val);
1293 }
1294 
1295 static ELANTS_VERSION_ATTR(fw_version);
1296 static ELANTS_VERSION_ATTR(hw_version);
1297 static ELANTS_VERSION_ATTR(test_version);
1298 static ELANTS_VERSION_ATTR(solution_version);
1299 static ELANTS_VERSION_ATTR(bc_version);
1300 static ELANTS_VERSION_ATTR(iap_version);
1301 
1302 static struct attribute *elants_attributes[] = {
1303     &dev_attr_calibrate.attr,
1304     &dev_attr_update_fw.attr,
1305     &dev_attr_iap_mode.attr,
1306     &dev_attr_calibration_count.attr,
1307 
1308     &elants_ver_attr_fw_version.dattr.attr,
1309     &elants_ver_attr_hw_version.dattr.attr,
1310     &elants_ver_attr_test_version.dattr.attr,
1311     &elants_ver_attr_solution_version.dattr.attr,
1312     &elants_ver_attr_bc_version.dattr.attr,
1313     &elants_ver_attr_iap_version.dattr.attr,
1314     NULL
1315 };
1316 
1317 static const struct attribute_group elants_attribute_group = {
1318     .attrs = elants_attributes,
1319 };
1320 
1321 static int elants_i2c_power_on(struct elants_data *ts)
1322 {
1323     int error;
1324 
1325     /*
1326      * If we do not have reset gpio assume platform firmware
1327      * controls regulators and does power them on for us.
1328      */
1329     if (IS_ERR_OR_NULL(ts->reset_gpio))
1330         return 0;
1331 
1332     gpiod_set_value_cansleep(ts->reset_gpio, 1);
1333 
1334     error = regulator_enable(ts->vcc33);
1335     if (error) {
1336         dev_err(&ts->client->dev,
1337             "failed to enable vcc33 regulator: %d\n",
1338             error);
1339         goto release_reset_gpio;
1340     }
1341 
1342     error = regulator_enable(ts->vccio);
1343     if (error) {
1344         dev_err(&ts->client->dev,
1345             "failed to enable vccio regulator: %d\n",
1346             error);
1347         regulator_disable(ts->vcc33);
1348         goto release_reset_gpio;
1349     }
1350 
1351     /*
1352      * We need to wait a bit after powering on controller before
1353      * we are allowed to release reset GPIO.
1354      */
1355     udelay(ELAN_POWERON_DELAY_USEC);
1356 
1357 release_reset_gpio:
1358     gpiod_set_value_cansleep(ts->reset_gpio, 0);
1359     if (error)
1360         return error;
1361 
1362     msleep(ELAN_RESET_DELAY_MSEC);
1363 
1364     return 0;
1365 }
1366 
1367 static void elants_i2c_power_off(void *_data)
1368 {
1369     struct elants_data *ts = _data;
1370 
1371     if (!IS_ERR_OR_NULL(ts->reset_gpio)) {
1372         /*
1373          * Activate reset gpio to prevent leakage through the
1374          * pin once we shut off power to the controller.
1375          */
1376         gpiod_set_value_cansleep(ts->reset_gpio, 1);
1377         regulator_disable(ts->vccio);
1378         regulator_disable(ts->vcc33);
1379     }
1380 }
1381 
1382 #ifdef CONFIG_ACPI
1383 static const struct acpi_device_id i2c_hid_ids[] = {
1384     {"ACPI0C50", 0 },
1385     {"PNP0C50", 0 },
1386     { },
1387 };
1388 
1389 static const guid_t i2c_hid_guid =
1390     GUID_INIT(0x3CDFF6F7, 0x4267, 0x4555,
1391           0xAD, 0x05, 0xB3, 0x0A, 0x3D, 0x89, 0x38, 0xDE);
1392 
1393 static bool elants_acpi_is_hid_device(struct device *dev)
1394 {
1395     acpi_handle handle = ACPI_HANDLE(dev);
1396     union acpi_object *obj;
1397 
1398     if (acpi_match_device_ids(ACPI_COMPANION(dev), i2c_hid_ids))
1399         return false;
1400 
1401     obj = acpi_evaluate_dsm_typed(handle, &i2c_hid_guid, 1, 1, NULL, ACPI_TYPE_INTEGER);
1402     if (obj) {
1403         ACPI_FREE(obj);
1404         return true;
1405     }
1406 
1407     return false;
1408 }
1409 #else
1410 static bool elants_acpi_is_hid_device(struct device *dev)
1411 {
1412     return false;
1413 }
1414 #endif
1415 
1416 static int elants_i2c_probe(struct i2c_client *client)
1417 {
1418     union i2c_smbus_data dummy;
1419     struct elants_data *ts;
1420     unsigned long irqflags;
1421     int error;
1422 
1423     /* Don't bind to i2c-hid compatible devices, these are handled by the i2c-hid drv. */
1424     if (elants_acpi_is_hid_device(&client->dev)) {
1425         dev_warn(&client->dev, "This device appears to be an I2C-HID device, not binding\n");
1426         return -ENODEV;
1427     }
1428 
1429     if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
1430         dev_err(&client->dev, "I2C check functionality error\n");
1431         return -ENXIO;
1432     }
1433 
1434     ts = devm_kzalloc(&client->dev, sizeof(struct elants_data), GFP_KERNEL);
1435     if (!ts)
1436         return -ENOMEM;
1437 
1438     mutex_init(&ts->sysfs_mutex);
1439     init_completion(&ts->cmd_done);
1440 
1441     ts->client = client;
1442     ts->chip_id = (enum elants_chip_id)(uintptr_t)device_get_match_data(&client->dev);
1443     i2c_set_clientdata(client, ts);
1444 
1445     ts->vcc33 = devm_regulator_get(&client->dev, "vcc33");
1446     if (IS_ERR(ts->vcc33)) {
1447         error = PTR_ERR(ts->vcc33);
1448         if (error != -EPROBE_DEFER)
1449             dev_err(&client->dev,
1450                 "Failed to get 'vcc33' regulator: %d\n",
1451                 error);
1452         return error;
1453     }
1454 
1455     ts->vccio = devm_regulator_get(&client->dev, "vccio");
1456     if (IS_ERR(ts->vccio)) {
1457         error = PTR_ERR(ts->vccio);
1458         if (error != -EPROBE_DEFER)
1459             dev_err(&client->dev,
1460                 "Failed to get 'vccio' regulator: %d\n",
1461                 error);
1462         return error;
1463     }
1464 
1465     ts->reset_gpio = devm_gpiod_get(&client->dev, "reset", GPIOD_OUT_LOW);
1466     if (IS_ERR(ts->reset_gpio)) {
1467         error = PTR_ERR(ts->reset_gpio);
1468 
1469         if (error == -EPROBE_DEFER)
1470             return error;
1471 
1472         if (error != -ENOENT && error != -ENOSYS) {
1473             dev_err(&client->dev,
1474                 "failed to get reset gpio: %d\n",
1475                 error);
1476             return error;
1477         }
1478 
1479         ts->keep_power_in_suspend = true;
1480     }
1481 
1482     error = elants_i2c_power_on(ts);
1483     if (error)
1484         return error;
1485 
1486     error = devm_add_action_or_reset(&client->dev,
1487                      elants_i2c_power_off, ts);
1488     if (error) {
1489         dev_err(&client->dev,
1490             "failed to install power off action: %d\n", error);
1491         return error;
1492     }
1493 
1494     /* Make sure there is something at this address */
1495     if (i2c_smbus_xfer(client->adapter, client->addr, 0,
1496                I2C_SMBUS_READ, 0, I2C_SMBUS_BYTE, &dummy) < 0) {
1497         dev_err(&client->dev, "nothing at this address\n");
1498         return -ENXIO;
1499     }
1500 
1501     error = elants_i2c_initialize(ts);
1502     if (error) {
1503         dev_err(&client->dev, "failed to initialize: %d\n", error);
1504         return error;
1505     }
1506 
1507     ts->input = devm_input_allocate_device(&client->dev);
1508     if (!ts->input) {
1509         dev_err(&client->dev, "Failed to allocate input device\n");
1510         return -ENOMEM;
1511     }
1512 
1513     ts->input->name = "Elan Touchscreen";
1514     ts->input->id.bustype = BUS_I2C;
1515 
1516     /* Multitouch input params setup */
1517 
1518     input_set_abs_params(ts->input, ABS_MT_POSITION_X, 0, ts->x_max, 0, 0);
1519     input_set_abs_params(ts->input, ABS_MT_POSITION_Y, 0, ts->y_max, 0, 0);
1520     input_set_abs_params(ts->input, ABS_MT_TOUCH_MAJOR, 0, 255, 0, 0);
1521     input_set_abs_params(ts->input, ABS_MT_PRESSURE, 0, 255, 0, 0);
1522     input_set_abs_params(ts->input, ABS_MT_TOOL_TYPE,
1523                  0, MT_TOOL_PALM, 0, 0);
1524 
1525     touchscreen_parse_properties(ts->input, true, &ts->prop);
1526 
1527     if (ts->chip_id == EKTF3624 && ts->phy_x && ts->phy_y) {
1528         /* calculate resolution from size */
1529         ts->x_res = DIV_ROUND_CLOSEST(ts->prop.max_x, ts->phy_x);
1530         ts->y_res = DIV_ROUND_CLOSEST(ts->prop.max_y, ts->phy_y);
1531     }
1532 
1533     input_abs_set_res(ts->input, ABS_MT_POSITION_X, ts->x_res);
1534     input_abs_set_res(ts->input, ABS_MT_POSITION_Y, ts->y_res);
1535     input_abs_set_res(ts->input, ABS_MT_TOUCH_MAJOR, ts->major_res);
1536 
1537     error = input_mt_init_slots(ts->input, MAX_CONTACT_NUM,
1538                     INPUT_MT_DIRECT | INPUT_MT_DROP_UNUSED);
1539     if (error) {
1540         dev_err(&client->dev,
1541             "failed to initialize MT slots: %d\n", error);
1542         return error;
1543     }
1544 
1545     error = input_register_device(ts->input);
1546     if (error) {
1547         dev_err(&client->dev,
1548             "unable to register input device: %d\n", error);
1549         return error;
1550     }
1551 
1552     /*
1553      * Platform code (ACPI, DTS) should normally set up interrupt
1554      * for us, but in case it did not let's fall back to using falling
1555      * edge to be compatible with older Chromebooks.
1556      */
1557     irqflags = irq_get_trigger_type(client->irq);
1558     if (!irqflags)
1559         irqflags = IRQF_TRIGGER_FALLING;
1560 
1561     error = devm_request_threaded_irq(&client->dev, client->irq,
1562                       NULL, elants_i2c_irq,
1563                       irqflags | IRQF_ONESHOT,
1564                       client->name, ts);
1565     if (error) {
1566         dev_err(&client->dev, "Failed to register interrupt\n");
1567         return error;
1568     }
1569 
1570     /*
1571      * Systems using device tree should set up wakeup via DTS,
1572      * the rest will configure device as wakeup source by default.
1573      */
1574     if (!client->dev.of_node)
1575         device_init_wakeup(&client->dev, true);
1576 
1577     error = devm_device_add_group(&client->dev, &elants_attribute_group);
1578     if (error) {
1579         dev_err(&client->dev, "failed to create sysfs attributes: %d\n",
1580             error);
1581         return error;
1582     }
1583 
1584     return 0;
1585 }
1586 
1587 static int __maybe_unused elants_i2c_suspend(struct device *dev)
1588 {
1589     struct i2c_client *client = to_i2c_client(dev);
1590     struct elants_data *ts = i2c_get_clientdata(client);
1591     const u8 set_sleep_cmd[] = {
1592         CMD_HEADER_WRITE, E_POWER_STATE_SLEEP, 0x00, 0x01
1593     };
1594     int retry_cnt;
1595     int error;
1596 
1597     /* Command not support in IAP recovery mode */
1598     if (ts->iap_mode != ELAN_IAP_OPERATIONAL)
1599         return -EBUSY;
1600 
1601     disable_irq(client->irq);
1602 
1603     if (device_may_wakeup(dev)) {
1604         /*
1605          * The device will automatically enter idle mode
1606          * that has reduced power consumption.
1607          */
1608         ts->wake_irq_enabled = (enable_irq_wake(client->irq) == 0);
1609     } else if (ts->keep_power_in_suspend) {
1610         for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
1611             error = elants_i2c_send(client, set_sleep_cmd,
1612                         sizeof(set_sleep_cmd));
1613             if (!error)
1614                 break;
1615 
1616             dev_err(&client->dev,
1617                 "suspend command failed: %d\n", error);
1618         }
1619     } else {
1620         elants_i2c_power_off(ts);
1621     }
1622 
1623     return 0;
1624 }
1625 
1626 static int __maybe_unused elants_i2c_resume(struct device *dev)
1627 {
1628     struct i2c_client *client = to_i2c_client(dev);
1629     struct elants_data *ts = i2c_get_clientdata(client);
1630     const u8 set_active_cmd[] = {
1631         CMD_HEADER_WRITE, E_POWER_STATE_RESUME, 0x00, 0x01
1632     };
1633     int retry_cnt;
1634     int error;
1635 
1636     if (device_may_wakeup(dev)) {
1637         if (ts->wake_irq_enabled)
1638             disable_irq_wake(client->irq);
1639         elants_i2c_sw_reset(client);
1640     } else if (ts->keep_power_in_suspend) {
1641         for (retry_cnt = 0; retry_cnt < MAX_RETRIES; retry_cnt++) {
1642             error = elants_i2c_send(client, set_active_cmd,
1643                         sizeof(set_active_cmd));
1644             if (!error)
1645                 break;
1646 
1647             dev_err(&client->dev,
1648                 "resume command failed: %d\n", error);
1649         }
1650     } else {
1651         elants_i2c_power_on(ts);
1652         elants_i2c_initialize(ts);
1653     }
1654 
1655     ts->state = ELAN_STATE_NORMAL;
1656     enable_irq(client->irq);
1657 
1658     return 0;
1659 }
1660 
1661 static SIMPLE_DEV_PM_OPS(elants_i2c_pm_ops,
1662              elants_i2c_suspend, elants_i2c_resume);
1663 
1664 static const struct i2c_device_id elants_i2c_id[] = {
1665     { DEVICE_NAME, EKTH3500 },
1666     { "ekth3500", EKTH3500 },
1667     { "ektf3624", EKTF3624 },
1668     { }
1669 };
1670 MODULE_DEVICE_TABLE(i2c, elants_i2c_id);
1671 
1672 #ifdef CONFIG_ACPI
1673 static const struct acpi_device_id elants_acpi_id[] = {
1674     { "ELAN0001", EKTH3500 },
1675     { }
1676 };
1677 MODULE_DEVICE_TABLE(acpi, elants_acpi_id);
1678 #endif
1679 
1680 #ifdef CONFIG_OF
1681 static const struct of_device_id elants_of_match[] = {
1682     { .compatible = "elan,ekth3500", .data = (void *)EKTH3500 },
1683     { .compatible = "elan,ektf3624", .data = (void *)EKTF3624 },
1684     { /* sentinel */ }
1685 };
1686 MODULE_DEVICE_TABLE(of, elants_of_match);
1687 #endif
1688 
1689 static struct i2c_driver elants_i2c_driver = {
1690     .probe_new = elants_i2c_probe,
1691     .id_table = elants_i2c_id,
1692     .driver = {
1693         .name = DEVICE_NAME,
1694         .pm = &elants_i2c_pm_ops,
1695         .acpi_match_table = ACPI_PTR(elants_acpi_id),
1696         .of_match_table = of_match_ptr(elants_of_match),
1697         .probe_type = PROBE_PREFER_ASYNCHRONOUS,
1698     },
1699 };
1700 module_i2c_driver(elants_i2c_driver);
1701 
1702 MODULE_AUTHOR("Scott Liu <scott.liu@emc.com.tw>");
1703 MODULE_DESCRIPTION("Elan I2c Touchscreen driver");
1704 MODULE_LICENSE("GPL");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!