Back to home page

OSCL-LXR

 
 

    


0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Elantech Touchpad driver (v6)
0004  *
0005  * Copyright (C) 2007-2009 Arjan Opmeer <arjan@opmeer.net>
0006  *
0007  * Trademarks are the property of their respective owners.
0008  */
0009 
0010 #include <linux/delay.h>
0011 #include <linux/dmi.h>
0012 #include <linux/slab.h>
0013 #include <linux/module.h>
0014 #include <linux/i2c.h>
0015 #include <linux/input.h>
0016 #include <linux/input/mt.h>
0017 #include <linux/platform_device.h>
0018 #include <linux/serio.h>
0019 #include <linux/libps2.h>
0020 #include <asm/unaligned.h>
0021 #include "psmouse.h"
0022 #include "elantech.h"
0023 #include "elan_i2c.h"
0024 
0025 #define elantech_debug(fmt, ...)                    \
0026     do {                                \
0027         if (etd->info.debug)                    \
0028             psmouse_printk(KERN_DEBUG, psmouse,     \
0029                     fmt, ##__VA_ARGS__);        \
0030     } while (0)
0031 
0032 /*
0033  * Send a Synaptics style sliced query command
0034  */
0035 static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c,
0036                 unsigned char *param)
0037 {
0038     if (ps2_sliced_command(&psmouse->ps2dev, c) ||
0039         ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
0040         psmouse_err(psmouse, "%s query 0x%02x failed.\n", __func__, c);
0041         return -1;
0042     }
0043 
0044     return 0;
0045 }
0046 
0047 /*
0048  * V3 and later support this fast command
0049  */
0050 static int elantech_send_cmd(struct psmouse *psmouse, unsigned char c,
0051                 unsigned char *param)
0052 {
0053     struct ps2dev *ps2dev = &psmouse->ps2dev;
0054 
0055     if (ps2_command(ps2dev, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0056         ps2_command(ps2dev, NULL, c) ||
0057         ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
0058         psmouse_err(psmouse, "%s query 0x%02x failed.\n", __func__, c);
0059         return -1;
0060     }
0061 
0062     return 0;
0063 }
0064 
0065 /*
0066  * A retrying version of ps2_command
0067  */
0068 static int elantech_ps2_command(struct psmouse *psmouse,
0069                 unsigned char *param, int command)
0070 {
0071     struct ps2dev *ps2dev = &psmouse->ps2dev;
0072     struct elantech_data *etd = psmouse->private;
0073     int rc;
0074     int tries = ETP_PS2_COMMAND_TRIES;
0075 
0076     do {
0077         rc = ps2_command(ps2dev, param, command);
0078         if (rc == 0)
0079             break;
0080         tries--;
0081         elantech_debug("retrying ps2 command 0x%02x (%d).\n",
0082                 command, tries);
0083         msleep(ETP_PS2_COMMAND_DELAY);
0084     } while (tries > 0);
0085 
0086     if (rc)
0087         psmouse_err(psmouse, "ps2 command 0x%02x failed.\n", command);
0088 
0089     return rc;
0090 }
0091 
0092 /*
0093  * Send an Elantech style special command to read 3 bytes from a register
0094  */
0095 static int elantech_read_reg_params(struct psmouse *psmouse, u8 reg, u8 *param)
0096 {
0097     if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0098         elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
0099         elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0100         elantech_ps2_command(psmouse, NULL, reg) ||
0101         elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) {
0102         psmouse_err(psmouse,
0103                 "failed to read register %#02x\n", reg);
0104         return -EIO;
0105     }
0106 
0107     return 0;
0108 }
0109 
0110 /*
0111  * Send an Elantech style special command to write a register with a parameter
0112  */
0113 static int elantech_write_reg_params(struct psmouse *psmouse, u8 reg, u8 *param)
0114 {
0115     if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0116         elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
0117         elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0118         elantech_ps2_command(psmouse, NULL, reg) ||
0119         elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0120         elantech_ps2_command(psmouse, NULL, param[0]) ||
0121         elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0122         elantech_ps2_command(psmouse, NULL, param[1]) ||
0123         elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
0124         psmouse_err(psmouse,
0125                 "failed to write register %#02x with value %#02x%#02x\n",
0126                 reg, param[0], param[1]);
0127         return -EIO;
0128     }
0129 
0130     return 0;
0131 }
0132 
0133 /*
0134  * Send an Elantech style special command to read a value from a register
0135  */
0136 static int elantech_read_reg(struct psmouse *psmouse, unsigned char reg,
0137                 unsigned char *val)
0138 {
0139     struct elantech_data *etd = psmouse->private;
0140     unsigned char param[3];
0141     int rc = 0;
0142 
0143     if (reg < 0x07 || reg > 0x26)
0144         return -1;
0145 
0146     if (reg > 0x11 && reg < 0x20)
0147         return -1;
0148 
0149     switch (etd->info.hw_version) {
0150     case 1:
0151         if (ps2_sliced_command(&psmouse->ps2dev, ETP_REGISTER_READ) ||
0152             ps2_sliced_command(&psmouse->ps2dev, reg) ||
0153             ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
0154             rc = -1;
0155         }
0156         break;
0157 
0158     case 2:
0159         if (elantech_ps2_command(psmouse,  NULL, ETP_PS2_CUSTOM_COMMAND) ||
0160             elantech_ps2_command(psmouse,  NULL, ETP_REGISTER_READ) ||
0161             elantech_ps2_command(psmouse,  NULL, ETP_PS2_CUSTOM_COMMAND) ||
0162             elantech_ps2_command(psmouse,  NULL, reg) ||
0163             elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) {
0164             rc = -1;
0165         }
0166         break;
0167 
0168     case 3 ... 4:
0169         if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0170             elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
0171             elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0172             elantech_ps2_command(psmouse, NULL, reg) ||
0173             elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) {
0174             rc = -1;
0175         }
0176         break;
0177     }
0178 
0179     if (rc)
0180         psmouse_err(psmouse, "failed to read register 0x%02x.\n", reg);
0181     else if (etd->info.hw_version != 4)
0182         *val = param[0];
0183     else
0184         *val = param[1];
0185 
0186     return rc;
0187 }
0188 
0189 /*
0190  * Send an Elantech style special command to write a register with a value
0191  */
0192 static int elantech_write_reg(struct psmouse *psmouse, unsigned char reg,
0193                 unsigned char val)
0194 {
0195     struct elantech_data *etd = psmouse->private;
0196     int rc = 0;
0197 
0198     if (reg < 0x07 || reg > 0x26)
0199         return -1;
0200 
0201     if (reg > 0x11 && reg < 0x20)
0202         return -1;
0203 
0204     switch (etd->info.hw_version) {
0205     case 1:
0206         if (ps2_sliced_command(&psmouse->ps2dev, ETP_REGISTER_WRITE) ||
0207             ps2_sliced_command(&psmouse->ps2dev, reg) ||
0208             ps2_sliced_command(&psmouse->ps2dev, val) ||
0209             ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11)) {
0210             rc = -1;
0211         }
0212         break;
0213 
0214     case 2:
0215         if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0216             elantech_ps2_command(psmouse, NULL, ETP_REGISTER_WRITE) ||
0217             elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0218             elantech_ps2_command(psmouse, NULL, reg) ||
0219             elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0220             elantech_ps2_command(psmouse, NULL, val) ||
0221             elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
0222             rc = -1;
0223         }
0224         break;
0225 
0226     case 3:
0227         if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0228             elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
0229             elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0230             elantech_ps2_command(psmouse, NULL, reg) ||
0231             elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0232             elantech_ps2_command(psmouse, NULL, val) ||
0233             elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
0234             rc = -1;
0235         }
0236         break;
0237 
0238     case 4:
0239         if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0240             elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
0241             elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0242             elantech_ps2_command(psmouse, NULL, reg) ||
0243             elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0244             elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
0245             elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
0246             elantech_ps2_command(psmouse, NULL, val) ||
0247             elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
0248             rc = -1;
0249         }
0250         break;
0251     }
0252 
0253     if (rc)
0254         psmouse_err(psmouse,
0255                 "failed to write register 0x%02x with value 0x%02x.\n",
0256                 reg, val);
0257 
0258     return rc;
0259 }
0260 
0261 /*
0262  * Dump a complete mouse movement packet to the syslog
0263  */
0264 static void elantech_packet_dump(struct psmouse *psmouse)
0265 {
0266     psmouse_printk(KERN_DEBUG, psmouse, "PS/2 packet [%*ph]\n",
0267                psmouse->pktsize, psmouse->packet);
0268 }
0269 
0270 /*
0271  * Advertise INPUT_PROP_BUTTONPAD for clickpads. The testing of bit 12 in
0272  * fw_version for this is based on the following fw_version & caps table:
0273  *
0274  * Laptop-model:           fw_version:     caps:           buttons:
0275  * Acer S3                 0x461f00        10, 13, 0e      clickpad
0276  * Acer S7-392             0x581f01        50, 17, 0d      clickpad
0277  * Acer V5-131             0x461f02        01, 16, 0c      clickpad
0278  * Acer V5-551             0x461f00        ?               clickpad
0279  * Asus K53SV              0x450f01        78, 15, 0c      2 hw buttons
0280  * Asus G46VW              0x460f02        00, 18, 0c      2 hw buttons
0281  * Asus G750JX             0x360f00        00, 16, 0c      2 hw buttons
0282  * Asus TP500LN            0x381f17        10, 14, 0e      clickpad
0283  * Asus X750JN             0x381f17        10, 14, 0e      clickpad
0284  * Asus UX31               0x361f00        20, 15, 0e      clickpad
0285  * Asus UX32VD             0x361f02        00, 15, 0e      clickpad
0286  * Avatar AVIU-145A2       0x361f00        ?               clickpad
0287  * Fujitsu CELSIUS H760    0x570f02        40, 14, 0c      3 hw buttons (**)
0288  * Fujitsu CELSIUS H780    0x5d0f02        41, 16, 0d      3 hw buttons (**)
0289  * Fujitsu LIFEBOOK E544   0x470f00        d0, 12, 09      2 hw buttons
0290  * Fujitsu LIFEBOOK E546   0x470f00        50, 12, 09      2 hw buttons
0291  * Fujitsu LIFEBOOK E547   0x470f00        50, 12, 09      2 hw buttons
0292  * Fujitsu LIFEBOOK E554   0x570f01        40, 14, 0c      2 hw buttons
0293  * Fujitsu LIFEBOOK E557   0x570f01        40, 14, 0c      2 hw buttons
0294  * Fujitsu T725            0x470f01        05, 12, 09      2 hw buttons
0295  * Fujitsu H730            0x570f00        c0, 14, 0c      3 hw buttons (**)
0296  * Gigabyte U2442          0x450f01        58, 17, 0c      2 hw buttons
0297  * Lenovo L430             0x350f02        b9, 15, 0c      2 hw buttons (*)
0298  * Lenovo L530             0x350f02        b9, 15, 0c      2 hw buttons (*)
0299  * Samsung NF210           0x150b00        78, 14, 0a      2 hw buttons
0300  * Samsung NP770Z5E        0x575f01        10, 15, 0f      clickpad
0301  * Samsung NP700Z5B        0x361f06        21, 15, 0f      clickpad
0302  * Samsung NP900X3E-A02    0x575f03        ?               clickpad
0303  * Samsung NP-QX410        0x851b00        19, 14, 0c      clickpad
0304  * Samsung RC512           0x450f00        08, 15, 0c      2 hw buttons
0305  * Samsung RF710           0x450f00        ?               2 hw buttons
0306  * System76 Pangolin       0x250f01        ?               2 hw buttons
0307  * (*) + 3 trackpoint buttons
0308  * (**) + 0 trackpoint buttons
0309  * Note: Lenovo L430 and Lenovo L530 have the same fw_version/caps
0310  */
0311 static inline int elantech_is_buttonpad(struct elantech_device_info *info)
0312 {
0313     return info->fw_version & 0x001000;
0314 }
0315 
0316 /*
0317  * Interpret complete data packets and report absolute mode input events for
0318  * hardware version 1. (4 byte packets)
0319  */
0320 static void elantech_report_absolute_v1(struct psmouse *psmouse)
0321 {
0322     struct input_dev *dev = psmouse->dev;
0323     struct elantech_data *etd = psmouse->private;
0324     unsigned char *packet = psmouse->packet;
0325     int fingers;
0326 
0327     if (etd->info.fw_version < 0x020000) {
0328         /*
0329          * byte 0:  D   U  p1  p2   1  p3   R   L
0330          * byte 1:  f   0  th  tw  x9  x8  y9  y8
0331          */
0332         fingers = ((packet[1] & 0x80) >> 7) +
0333                 ((packet[1] & 0x30) >> 4);
0334     } else {
0335         /*
0336          * byte 0: n1  n0  p2  p1   1  p3   R   L
0337          * byte 1:  0   0   0   0  x9  x8  y9  y8
0338          */
0339         fingers = (packet[0] & 0xc0) >> 6;
0340     }
0341 
0342     if (etd->info.jumpy_cursor) {
0343         if (fingers != 1) {
0344             etd->single_finger_reports = 0;
0345         } else if (etd->single_finger_reports < 2) {
0346             /* Discard first 2 reports of one finger, bogus */
0347             etd->single_finger_reports++;
0348             elantech_debug("discarding packet\n");
0349             return;
0350         }
0351     }
0352 
0353     input_report_key(dev, BTN_TOUCH, fingers != 0);
0354 
0355     /*
0356      * byte 2: x7  x6  x5  x4  x3  x2  x1  x0
0357      * byte 3: y7  y6  y5  y4  y3  y2  y1  y0
0358      */
0359     if (fingers) {
0360         input_report_abs(dev, ABS_X,
0361             ((packet[1] & 0x0c) << 6) | packet[2]);
0362         input_report_abs(dev, ABS_Y,
0363             etd->y_max - (((packet[1] & 0x03) << 8) | packet[3]));
0364     }
0365 
0366     input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
0367     input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
0368     input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
0369 
0370     psmouse_report_standard_buttons(dev, packet[0]);
0371 
0372     if (etd->info.fw_version < 0x020000 &&
0373         (etd->info.capabilities[0] & ETP_CAP_HAS_ROCKER)) {
0374         /* rocker up */
0375         input_report_key(dev, BTN_FORWARD, packet[0] & 0x40);
0376         /* rocker down */
0377         input_report_key(dev, BTN_BACK, packet[0] & 0x80);
0378     }
0379 
0380     input_sync(dev);
0381 }
0382 
0383 static void elantech_set_slot(struct input_dev *dev, int slot, bool active,
0384                   unsigned int x, unsigned int y)
0385 {
0386     input_mt_slot(dev, slot);
0387     input_mt_report_slot_state(dev, MT_TOOL_FINGER, active);
0388     if (active) {
0389         input_report_abs(dev, ABS_MT_POSITION_X, x);
0390         input_report_abs(dev, ABS_MT_POSITION_Y, y);
0391     }
0392 }
0393 
0394 /* x1 < x2 and y1 < y2 when two fingers, x = y = 0 when not pressed */
0395 static void elantech_report_semi_mt_data(struct input_dev *dev,
0396                      unsigned int num_fingers,
0397                      unsigned int x1, unsigned int y1,
0398                      unsigned int x2, unsigned int y2)
0399 {
0400     elantech_set_slot(dev, 0, num_fingers != 0, x1, y1);
0401     elantech_set_slot(dev, 1, num_fingers >= 2, x2, y2);
0402 }
0403 
0404 /*
0405  * Interpret complete data packets and report absolute mode input events for
0406  * hardware version 2. (6 byte packets)
0407  */
0408 static void elantech_report_absolute_v2(struct psmouse *psmouse)
0409 {
0410     struct elantech_data *etd = psmouse->private;
0411     struct input_dev *dev = psmouse->dev;
0412     unsigned char *packet = psmouse->packet;
0413     unsigned int fingers, x1 = 0, y1 = 0, x2 = 0, y2 = 0;
0414     unsigned int width = 0, pres = 0;
0415 
0416     /* byte 0: n1  n0   .   .   .   .   R   L */
0417     fingers = (packet[0] & 0xc0) >> 6;
0418 
0419     switch (fingers) {
0420     case 3:
0421         /*
0422          * Same as one finger, except report of more than 3 fingers:
0423          * byte 3:  n4  .   w1  w0   .   .   .   .
0424          */
0425         if (packet[3] & 0x80)
0426             fingers = 4;
0427         fallthrough;
0428     case 1:
0429         /*
0430          * byte 1:  .   .   .   .  x11 x10 x9  x8
0431          * byte 2: x7  x6  x5  x4  x4  x2  x1  x0
0432          */
0433         x1 = ((packet[1] & 0x0f) << 8) | packet[2];
0434         /*
0435          * byte 4:  .   .   .   .  y11 y10 y9  y8
0436          * byte 5: y7  y6  y5  y4  y3  y2  y1  y0
0437          */
0438         y1 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
0439 
0440         pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
0441         width = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4);
0442         break;
0443 
0444     case 2:
0445         /*
0446          * The coordinate of each finger is reported separately
0447          * with a lower resolution for two finger touches:
0448          * byte 0:  .   .  ay8 ax8  .   .   .   .
0449          * byte 1: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0
0450          */
0451         x1 = (((packet[0] & 0x10) << 4) | packet[1]) << 2;
0452         /* byte 2: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0 */
0453         y1 = etd->y_max -
0454             ((((packet[0] & 0x20) << 3) | packet[2]) << 2);
0455         /*
0456          * byte 3:  .   .  by8 bx8  .   .   .   .
0457          * byte 4: bx7 bx6 bx5 bx4 bx3 bx2 bx1 bx0
0458          */
0459         x2 = (((packet[3] & 0x10) << 4) | packet[4]) << 2;
0460         /* byte 5: by7 by8 by5 by4 by3 by2 by1 by0 */
0461         y2 = etd->y_max -
0462             ((((packet[3] & 0x20) << 3) | packet[5]) << 2);
0463 
0464         /* Unknown so just report sensible values */
0465         pres = 127;
0466         width = 7;
0467         break;
0468     }
0469 
0470     input_report_key(dev, BTN_TOUCH, fingers != 0);
0471     if (fingers != 0) {
0472         input_report_abs(dev, ABS_X, x1);
0473         input_report_abs(dev, ABS_Y, y1);
0474     }
0475     elantech_report_semi_mt_data(dev, fingers, x1, y1, x2, y2);
0476     input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
0477     input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
0478     input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
0479     input_report_key(dev, BTN_TOOL_QUADTAP, fingers == 4);
0480     psmouse_report_standard_buttons(dev, packet[0]);
0481     if (etd->info.reports_pressure) {
0482         input_report_abs(dev, ABS_PRESSURE, pres);
0483         input_report_abs(dev, ABS_TOOL_WIDTH, width);
0484     }
0485 
0486     input_sync(dev);
0487 }
0488 
0489 static void elantech_report_trackpoint(struct psmouse *psmouse,
0490                        int packet_type)
0491 {
0492     /*
0493      * byte 0:  0   0  sx  sy   0   M   R   L
0494      * byte 1:~sx   0   0   0   0   0   0   0
0495      * byte 2:~sy   0   0   0   0   0   0   0
0496      * byte 3:  0   0 ~sy ~sx   0   1   1   0
0497      * byte 4: x7  x6  x5  x4  x3  x2  x1  x0
0498      * byte 5: y7  y6  y5  y4  y3  y2  y1  y0
0499      *
0500      * x and y are written in two's complement spread
0501      * over 9 bits with sx/sy the relative top bit and
0502      * x7..x0 and y7..y0 the lower bits.
0503      * The sign of y is opposite to what the input driver
0504      * expects for a relative movement
0505      */
0506 
0507     struct elantech_data *etd = psmouse->private;
0508     struct input_dev *tp_dev = etd->tp_dev;
0509     unsigned char *packet = psmouse->packet;
0510     int x, y;
0511     u32 t;
0512 
0513     t = get_unaligned_le32(&packet[0]);
0514 
0515     switch (t & ~7U) {
0516     case 0x06000030U:
0517     case 0x16008020U:
0518     case 0x26800010U:
0519     case 0x36808000U:
0520 
0521         /*
0522          * This firmware misreport coordinates for trackpoint
0523          * occasionally. Discard packets outside of [-127, 127] range
0524          * to prevent cursor jumps.
0525          */
0526         if (packet[4] == 0x80 || packet[5] == 0x80 ||
0527             packet[1] >> 7 == packet[4] >> 7 ||
0528             packet[2] >> 7 == packet[5] >> 7) {
0529             elantech_debug("discarding packet [%6ph]\n", packet);
0530             break;
0531 
0532         }
0533         x = packet[4] - (int)((packet[1]^0x80) << 1);
0534         y = (int)((packet[2]^0x80) << 1) - packet[5];
0535 
0536         psmouse_report_standard_buttons(tp_dev, packet[0]);
0537 
0538         input_report_rel(tp_dev, REL_X, x);
0539         input_report_rel(tp_dev, REL_Y, y);
0540 
0541         input_sync(tp_dev);
0542 
0543         break;
0544 
0545     default:
0546         /* Dump unexpected packet sequences if debug=1 (default) */
0547         if (etd->info.debug == 1)
0548             elantech_packet_dump(psmouse);
0549 
0550         break;
0551     }
0552 }
0553 
0554 /*
0555  * Interpret complete data packets and report absolute mode input events for
0556  * hardware version 3. (12 byte packets for two fingers)
0557  */
0558 static void elantech_report_absolute_v3(struct psmouse *psmouse,
0559                     int packet_type)
0560 {
0561     struct input_dev *dev = psmouse->dev;
0562     struct elantech_data *etd = psmouse->private;
0563     unsigned char *packet = psmouse->packet;
0564     unsigned int fingers = 0, x1 = 0, y1 = 0, x2 = 0, y2 = 0;
0565     unsigned int width = 0, pres = 0;
0566 
0567     /* byte 0: n1  n0   .   .   .   .   R   L */
0568     fingers = (packet[0] & 0xc0) >> 6;
0569 
0570     switch (fingers) {
0571     case 3:
0572     case 1:
0573         /*
0574          * byte 1:  .   .   .   .  x11 x10 x9  x8
0575          * byte 2: x7  x6  x5  x4  x4  x2  x1  x0
0576          */
0577         x1 = ((packet[1] & 0x0f) << 8) | packet[2];
0578         /*
0579          * byte 4:  .   .   .   .  y11 y10 y9  y8
0580          * byte 5: y7  y6  y5  y4  y3  y2  y1  y0
0581          */
0582         y1 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
0583         break;
0584 
0585     case 2:
0586         if (packet_type == PACKET_V3_HEAD) {
0587             /*
0588              * byte 1:   .    .    .    .  ax11 ax10 ax9  ax8
0589              * byte 2: ax7  ax6  ax5  ax4  ax3  ax2  ax1  ax0
0590              */
0591             etd->mt[0].x = ((packet[1] & 0x0f) << 8) | packet[2];
0592             /*
0593              * byte 4:   .    .    .    .  ay11 ay10 ay9  ay8
0594              * byte 5: ay7  ay6  ay5  ay4  ay3  ay2  ay1  ay0
0595              */
0596             etd->mt[0].y = etd->y_max -
0597                 (((packet[4] & 0x0f) << 8) | packet[5]);
0598             /*
0599              * wait for next packet
0600              */
0601             return;
0602         }
0603 
0604         /* packet_type == PACKET_V3_TAIL */
0605         x1 = etd->mt[0].x;
0606         y1 = etd->mt[0].y;
0607         x2 = ((packet[1] & 0x0f) << 8) | packet[2];
0608         y2 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
0609         break;
0610     }
0611 
0612     pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
0613     width = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4);
0614 
0615     input_report_key(dev, BTN_TOUCH, fingers != 0);
0616     if (fingers != 0) {
0617         input_report_abs(dev, ABS_X, x1);
0618         input_report_abs(dev, ABS_Y, y1);
0619     }
0620     elantech_report_semi_mt_data(dev, fingers, x1, y1, x2, y2);
0621     input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
0622     input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
0623     input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
0624 
0625     /* For clickpads map both buttons to BTN_LEFT */
0626     if (elantech_is_buttonpad(&etd->info))
0627         input_report_key(dev, BTN_LEFT, packet[0] & 0x03);
0628     else
0629         psmouse_report_standard_buttons(dev, packet[0]);
0630 
0631     input_report_abs(dev, ABS_PRESSURE, pres);
0632     input_report_abs(dev, ABS_TOOL_WIDTH, width);
0633 
0634     input_sync(dev);
0635 }
0636 
0637 static void elantech_input_sync_v4(struct psmouse *psmouse)
0638 {
0639     struct input_dev *dev = psmouse->dev;
0640     struct elantech_data *etd = psmouse->private;
0641     unsigned char *packet = psmouse->packet;
0642 
0643     /* For clickpads map both buttons to BTN_LEFT */
0644     if (elantech_is_buttonpad(&etd->info))
0645         input_report_key(dev, BTN_LEFT, packet[0] & 0x03);
0646     else
0647         psmouse_report_standard_buttons(dev, packet[0]);
0648 
0649     input_mt_report_pointer_emulation(dev, true);
0650     input_sync(dev);
0651 }
0652 
0653 static void process_packet_status_v4(struct psmouse *psmouse)
0654 {
0655     struct input_dev *dev = psmouse->dev;
0656     unsigned char *packet = psmouse->packet;
0657     unsigned fingers;
0658     int i;
0659 
0660     /* notify finger state change */
0661     fingers = packet[1] & 0x1f;
0662     for (i = 0; i < ETP_MAX_FINGERS; i++) {
0663         if ((fingers & (1 << i)) == 0) {
0664             input_mt_slot(dev, i);
0665             input_mt_report_slot_state(dev, MT_TOOL_FINGER, false);
0666         }
0667     }
0668 
0669     elantech_input_sync_v4(psmouse);
0670 }
0671 
0672 static void process_packet_head_v4(struct psmouse *psmouse)
0673 {
0674     struct input_dev *dev = psmouse->dev;
0675     struct elantech_data *etd = psmouse->private;
0676     unsigned char *packet = psmouse->packet;
0677     int id = ((packet[3] & 0xe0) >> 5) - 1;
0678     int pres, traces;
0679 
0680     if (id < 0)
0681         return;
0682 
0683     etd->mt[id].x = ((packet[1] & 0x0f) << 8) | packet[2];
0684     etd->mt[id].y = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
0685     pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
0686     traces = (packet[0] & 0xf0) >> 4;
0687 
0688     input_mt_slot(dev, id);
0689     input_mt_report_slot_state(dev, MT_TOOL_FINGER, true);
0690 
0691     input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[id].x);
0692     input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[id].y);
0693     input_report_abs(dev, ABS_MT_PRESSURE, pres);
0694     input_report_abs(dev, ABS_MT_TOUCH_MAJOR, traces * etd->width);
0695     /* report this for backwards compatibility */
0696     input_report_abs(dev, ABS_TOOL_WIDTH, traces);
0697 
0698     elantech_input_sync_v4(psmouse);
0699 }
0700 
0701 static void process_packet_motion_v4(struct psmouse *psmouse)
0702 {
0703     struct input_dev *dev = psmouse->dev;
0704     struct elantech_data *etd = psmouse->private;
0705     unsigned char *packet = psmouse->packet;
0706     int weight, delta_x1 = 0, delta_y1 = 0, delta_x2 = 0, delta_y2 = 0;
0707     int id, sid;
0708 
0709     id = ((packet[0] & 0xe0) >> 5) - 1;
0710     if (id < 0)
0711         return;
0712 
0713     sid = ((packet[3] & 0xe0) >> 5) - 1;
0714     weight = (packet[0] & 0x10) ? ETP_WEIGHT_VALUE : 1;
0715     /*
0716      * Motion packets give us the delta of x, y values of specific fingers,
0717      * but in two's complement. Let the compiler do the conversion for us.
0718      * Also _enlarge_ the numbers to int, in case of overflow.
0719      */
0720     delta_x1 = (signed char)packet[1];
0721     delta_y1 = (signed char)packet[2];
0722     delta_x2 = (signed char)packet[4];
0723     delta_y2 = (signed char)packet[5];
0724 
0725     etd->mt[id].x += delta_x1 * weight;
0726     etd->mt[id].y -= delta_y1 * weight;
0727     input_mt_slot(dev, id);
0728     input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[id].x);
0729     input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[id].y);
0730 
0731     if (sid >= 0) {
0732         etd->mt[sid].x += delta_x2 * weight;
0733         etd->mt[sid].y -= delta_y2 * weight;
0734         input_mt_slot(dev, sid);
0735         input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[sid].x);
0736         input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[sid].y);
0737     }
0738 
0739     elantech_input_sync_v4(psmouse);
0740 }
0741 
0742 static void elantech_report_absolute_v4(struct psmouse *psmouse,
0743                     int packet_type)
0744 {
0745     switch (packet_type) {
0746     case PACKET_V4_STATUS:
0747         process_packet_status_v4(psmouse);
0748         break;
0749 
0750     case PACKET_V4_HEAD:
0751         process_packet_head_v4(psmouse);
0752         break;
0753 
0754     case PACKET_V4_MOTION:
0755         process_packet_motion_v4(psmouse);
0756         break;
0757 
0758     case PACKET_UNKNOWN:
0759     default:
0760         /* impossible to get here */
0761         break;
0762     }
0763 }
0764 
0765 static int elantech_packet_check_v1(struct psmouse *psmouse)
0766 {
0767     struct elantech_data *etd = psmouse->private;
0768     unsigned char *packet = psmouse->packet;
0769     unsigned char p1, p2, p3;
0770 
0771     /* Parity bits are placed differently */
0772     if (etd->info.fw_version < 0x020000) {
0773         /* byte 0:  D   U  p1  p2   1  p3   R   L */
0774         p1 = (packet[0] & 0x20) >> 5;
0775         p2 = (packet[0] & 0x10) >> 4;
0776     } else {
0777         /* byte 0: n1  n0  p2  p1   1  p3   R   L */
0778         p1 = (packet[0] & 0x10) >> 4;
0779         p2 = (packet[0] & 0x20) >> 5;
0780     }
0781 
0782     p3 = (packet[0] & 0x04) >> 2;
0783 
0784     return etd->parity[packet[1]] == p1 &&
0785            etd->parity[packet[2]] == p2 &&
0786            etd->parity[packet[3]] == p3;
0787 }
0788 
0789 static int elantech_debounce_check_v2(struct psmouse *psmouse)
0790 {
0791         /*
0792          * When we encounter packet that matches this exactly, it means the
0793          * hardware is in debounce status. Just ignore the whole packet.
0794          */
0795     static const u8 debounce_packet[] = {
0796         0x84, 0xff, 0xff, 0x02, 0xff, 0xff
0797     };
0798         unsigned char *packet = psmouse->packet;
0799 
0800         return !memcmp(packet, debounce_packet, sizeof(debounce_packet));
0801 }
0802 
0803 static int elantech_packet_check_v2(struct psmouse *psmouse)
0804 {
0805     struct elantech_data *etd = psmouse->private;
0806     unsigned char *packet = psmouse->packet;
0807 
0808     /*
0809      * V2 hardware has two flavors. Older ones that do not report pressure,
0810      * and newer ones that reports pressure and width. With newer ones, all
0811      * packets (1, 2, 3 finger touch) have the same constant bits. With
0812      * older ones, 1/3 finger touch packets and 2 finger touch packets
0813      * have different constant bits.
0814      * With all three cases, if the constant bits are not exactly what I
0815      * expected, I consider them invalid.
0816      */
0817     if (etd->info.reports_pressure)
0818         return (packet[0] & 0x0c) == 0x04 &&
0819                (packet[3] & 0x0f) == 0x02;
0820 
0821     if ((packet[0] & 0xc0) == 0x80)
0822         return (packet[0] & 0x0c) == 0x0c &&
0823                (packet[3] & 0x0e) == 0x08;
0824 
0825     return (packet[0] & 0x3c) == 0x3c &&
0826            (packet[1] & 0xf0) == 0x00 &&
0827            (packet[3] & 0x3e) == 0x38 &&
0828            (packet[4] & 0xf0) == 0x00;
0829 }
0830 
0831 /*
0832  * We check the constant bits to determine what packet type we get,
0833  * so packet checking is mandatory for v3 and later hardware.
0834  */
0835 static int elantech_packet_check_v3(struct psmouse *psmouse)
0836 {
0837     struct elantech_data *etd = psmouse->private;
0838     static const u8 debounce_packet[] = {
0839         0xc4, 0xff, 0xff, 0x02, 0xff, 0xff
0840     };
0841     unsigned char *packet = psmouse->packet;
0842 
0843     /*
0844      * check debounce first, it has the same signature in byte 0
0845      * and byte 3 as PACKET_V3_HEAD.
0846      */
0847     if (!memcmp(packet, debounce_packet, sizeof(debounce_packet)))
0848         return PACKET_DEBOUNCE;
0849 
0850     /*
0851      * If the hardware flag 'crc_enabled' is set the packets have
0852      * different signatures.
0853      */
0854     if (etd->info.crc_enabled) {
0855         if ((packet[3] & 0x09) == 0x08)
0856             return PACKET_V3_HEAD;
0857 
0858         if ((packet[3] & 0x09) == 0x09)
0859             return PACKET_V3_TAIL;
0860     } else {
0861         if ((packet[0] & 0x0c) == 0x04 && (packet[3] & 0xcf) == 0x02)
0862             return PACKET_V3_HEAD;
0863 
0864         if ((packet[0] & 0x0c) == 0x0c && (packet[3] & 0xce) == 0x0c)
0865             return PACKET_V3_TAIL;
0866         if ((packet[3] & 0x0f) == 0x06)
0867             return PACKET_TRACKPOINT;
0868     }
0869 
0870     return PACKET_UNKNOWN;
0871 }
0872 
0873 static int elantech_packet_check_v4(struct psmouse *psmouse)
0874 {
0875     struct elantech_data *etd = psmouse->private;
0876     unsigned char *packet = psmouse->packet;
0877     unsigned char packet_type = packet[3] & 0x03;
0878     unsigned int ic_version;
0879     bool sanity_check;
0880 
0881     if (etd->tp_dev && (packet[3] & 0x0f) == 0x06)
0882         return PACKET_TRACKPOINT;
0883 
0884     /* This represents the version of IC body. */
0885     ic_version = (etd->info.fw_version & 0x0f0000) >> 16;
0886 
0887     /*
0888      * Sanity check based on the constant bits of a packet.
0889      * The constant bits change depending on the value of
0890      * the hardware flag 'crc_enabled' and the version of
0891      * the IC body, but are the same for every packet,
0892      * regardless of the type.
0893      */
0894     if (etd->info.crc_enabled)
0895         sanity_check = ((packet[3] & 0x08) == 0x00);
0896     else if (ic_version == 7 && etd->info.samples[1] == 0x2A)
0897         sanity_check = ((packet[3] & 0x1c) == 0x10);
0898     else
0899         sanity_check = ((packet[0] & 0x08) == 0x00 &&
0900                 (packet[3] & 0x1c) == 0x10);
0901 
0902     if (!sanity_check)
0903         return PACKET_UNKNOWN;
0904 
0905     switch (packet_type) {
0906     case 0:
0907         return PACKET_V4_STATUS;
0908 
0909     case 1:
0910         return PACKET_V4_HEAD;
0911 
0912     case 2:
0913         return PACKET_V4_MOTION;
0914     }
0915 
0916     return PACKET_UNKNOWN;
0917 }
0918 
0919 /*
0920  * Process byte stream from mouse and handle complete packets
0921  */
0922 static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse)
0923 {
0924     struct elantech_data *etd = psmouse->private;
0925     int packet_type;
0926 
0927     if (psmouse->pktcnt < psmouse->pktsize)
0928         return PSMOUSE_GOOD_DATA;
0929 
0930     if (etd->info.debug > 1)
0931         elantech_packet_dump(psmouse);
0932 
0933     switch (etd->info.hw_version) {
0934     case 1:
0935         if (etd->info.paritycheck && !elantech_packet_check_v1(psmouse))
0936             return PSMOUSE_BAD_DATA;
0937 
0938         elantech_report_absolute_v1(psmouse);
0939         break;
0940 
0941     case 2:
0942         /* ignore debounce */
0943         if (elantech_debounce_check_v2(psmouse))
0944             return PSMOUSE_FULL_PACKET;
0945 
0946         if (etd->info.paritycheck && !elantech_packet_check_v2(psmouse))
0947             return PSMOUSE_BAD_DATA;
0948 
0949         elantech_report_absolute_v2(psmouse);
0950         break;
0951 
0952     case 3:
0953         packet_type = elantech_packet_check_v3(psmouse);
0954         switch (packet_type) {
0955         case PACKET_UNKNOWN:
0956             return PSMOUSE_BAD_DATA;
0957 
0958         case PACKET_DEBOUNCE:
0959             /* ignore debounce */
0960             break;
0961 
0962         case PACKET_TRACKPOINT:
0963             elantech_report_trackpoint(psmouse, packet_type);
0964             break;
0965 
0966         default:
0967             elantech_report_absolute_v3(psmouse, packet_type);
0968             break;
0969         }
0970 
0971         break;
0972 
0973     case 4:
0974         packet_type = elantech_packet_check_v4(psmouse);
0975         switch (packet_type) {
0976         case PACKET_UNKNOWN:
0977             return PSMOUSE_BAD_DATA;
0978 
0979         case PACKET_TRACKPOINT:
0980             elantech_report_trackpoint(psmouse, packet_type);
0981             break;
0982 
0983         default:
0984             elantech_report_absolute_v4(psmouse, packet_type);
0985             break;
0986         }
0987 
0988         break;
0989     }
0990 
0991     return PSMOUSE_FULL_PACKET;
0992 }
0993 
0994 /*
0995  * This writes the reg_07 value again to the hardware at the end of every
0996  * set_rate call because the register loses its value. reg_07 allows setting
0997  * absolute mode on v4 hardware
0998  */
0999 static void elantech_set_rate_restore_reg_07(struct psmouse *psmouse,
1000         unsigned int rate)
1001 {
1002     struct elantech_data *etd = psmouse->private;
1003 
1004     etd->original_set_rate(psmouse, rate);
1005     if (elantech_write_reg(psmouse, 0x07, etd->reg_07))
1006         psmouse_err(psmouse, "restoring reg_07 failed\n");
1007 }
1008 
1009 /*
1010  * Put the touchpad into absolute mode
1011  */
1012 static int elantech_set_absolute_mode(struct psmouse *psmouse)
1013 {
1014     struct elantech_data *etd = psmouse->private;
1015     unsigned char val;
1016     int tries = ETP_READ_BACK_TRIES;
1017     int rc = 0;
1018 
1019     switch (etd->info.hw_version) {
1020     case 1:
1021         etd->reg_10 = 0x16;
1022         etd->reg_11 = 0x8f;
1023         if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
1024             elantech_write_reg(psmouse, 0x11, etd->reg_11)) {
1025             rc = -1;
1026         }
1027         break;
1028 
1029     case 2:
1030                     /* Windows driver values */
1031         etd->reg_10 = 0x54;
1032         etd->reg_11 = 0x88; /* 0x8a */
1033         etd->reg_21 = 0x60; /* 0x00 */
1034         if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
1035             elantech_write_reg(psmouse, 0x11, etd->reg_11) ||
1036             elantech_write_reg(psmouse, 0x21, etd->reg_21)) {
1037             rc = -1;
1038         }
1039         break;
1040 
1041     case 3:
1042         if (etd->info.set_hw_resolution)
1043             etd->reg_10 = 0x0b;
1044         else
1045             etd->reg_10 = 0x01;
1046 
1047         if (elantech_write_reg(psmouse, 0x10, etd->reg_10))
1048             rc = -1;
1049 
1050         break;
1051 
1052     case 4:
1053         etd->reg_07 = 0x01;
1054         if (elantech_write_reg(psmouse, 0x07, etd->reg_07))
1055             rc = -1;
1056 
1057         goto skip_readback_reg_10; /* v4 has no reg 0x10 to read */
1058     }
1059 
1060     if (rc == 0) {
1061         /*
1062          * Read back reg 0x10. For hardware version 1 we must make
1063          * sure the absolute mode bit is set. For hardware version 2
1064          * the touchpad is probably initializing and not ready until
1065          * we read back the value we just wrote.
1066          */
1067         do {
1068             rc = elantech_read_reg(psmouse, 0x10, &val);
1069             if (rc == 0)
1070                 break;
1071             tries--;
1072             elantech_debug("retrying read (%d).\n", tries);
1073             msleep(ETP_READ_BACK_DELAY);
1074         } while (tries > 0);
1075 
1076         if (rc) {
1077             psmouse_err(psmouse,
1078                     "failed to read back register 0x10.\n");
1079         } else if (etd->info.hw_version == 1 &&
1080                !(val & ETP_R10_ABSOLUTE_MODE)) {
1081             psmouse_err(psmouse,
1082                     "touchpad refuses to switch to absolute mode.\n");
1083             rc = -1;
1084         }
1085     }
1086 
1087  skip_readback_reg_10:
1088     if (rc)
1089         psmouse_err(psmouse, "failed to initialise registers.\n");
1090 
1091     return rc;
1092 }
1093 
1094 /*
1095  * (value from firmware) * 10 + 790 = dpi
1096  * we also have to convert dpi to dots/mm (*10/254 to avoid floating point)
1097  */
1098 static unsigned int elantech_convert_res(unsigned int val)
1099 {
1100     return (val * 10 + 790) * 10 / 254;
1101 }
1102 
1103 static int elantech_get_resolution_v4(struct psmouse *psmouse,
1104                       unsigned int *x_res,
1105                       unsigned int *y_res,
1106                       unsigned int *bus)
1107 {
1108     unsigned char param[3];
1109 
1110     if (elantech_send_cmd(psmouse, ETP_RESOLUTION_QUERY, param))
1111         return -1;
1112 
1113     *x_res = elantech_convert_res(param[1] & 0x0f);
1114     *y_res = elantech_convert_res((param[1] & 0xf0) >> 4);
1115     *bus = param[2];
1116 
1117     return 0;
1118 }
1119 
1120 static void elantech_set_buttonpad_prop(struct psmouse *psmouse)
1121 {
1122     struct input_dev *dev = psmouse->dev;
1123     struct elantech_data *etd = psmouse->private;
1124 
1125     if (elantech_is_buttonpad(&etd->info)) {
1126         __set_bit(INPUT_PROP_BUTTONPAD, dev->propbit);
1127         __clear_bit(BTN_RIGHT, dev->keybit);
1128     }
1129 }
1130 
1131 /*
1132  * Some hw_version 4 models do have a middle button
1133  */
1134 static const struct dmi_system_id elantech_dmi_has_middle_button[] = {
1135 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
1136     {
1137         /* Fujitsu H730 has a middle button */
1138         .matches = {
1139             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1140             DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H730"),
1141         },
1142     },
1143     {
1144         /* Fujitsu H760 also has a middle button */
1145         .matches = {
1146             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1147             DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H760"),
1148         },
1149     },
1150     {
1151         /* Fujitsu H780 also has a middle button */
1152         .matches = {
1153             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1154             DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H780"),
1155         },
1156     },
1157 #endif
1158     { }
1159 };
1160 
1161 /*
1162  * Set the appropriate event bits for the input subsystem
1163  */
1164 static int elantech_set_input_params(struct psmouse *psmouse)
1165 {
1166     struct input_dev *dev = psmouse->dev;
1167     struct elantech_data *etd = psmouse->private;
1168     struct elantech_device_info *info = &etd->info;
1169     unsigned int x_min = info->x_min, y_min = info->y_min,
1170              x_max = info->x_max, y_max = info->y_max,
1171              width = info->width;
1172 
1173     __set_bit(INPUT_PROP_POINTER, dev->propbit);
1174     __set_bit(EV_KEY, dev->evbit);
1175     __set_bit(EV_ABS, dev->evbit);
1176     __clear_bit(EV_REL, dev->evbit);
1177 
1178     __set_bit(BTN_LEFT, dev->keybit);
1179     if (info->has_middle_button)
1180         __set_bit(BTN_MIDDLE, dev->keybit);
1181     __set_bit(BTN_RIGHT, dev->keybit);
1182 
1183     __set_bit(BTN_TOUCH, dev->keybit);
1184     __set_bit(BTN_TOOL_FINGER, dev->keybit);
1185     __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
1186     __set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
1187 
1188     switch (info->hw_version) {
1189     case 1:
1190         /* Rocker button */
1191         if (info->fw_version < 0x020000 &&
1192             (info->capabilities[0] & ETP_CAP_HAS_ROCKER)) {
1193             __set_bit(BTN_FORWARD, dev->keybit);
1194             __set_bit(BTN_BACK, dev->keybit);
1195         }
1196         input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
1197         input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
1198         break;
1199 
1200     case 2:
1201         __set_bit(BTN_TOOL_QUADTAP, dev->keybit);
1202         __set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
1203         fallthrough;
1204     case 3:
1205         if (info->hw_version == 3)
1206             elantech_set_buttonpad_prop(psmouse);
1207         input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
1208         input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
1209         if (info->reports_pressure) {
1210             input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2,
1211                          ETP_PMAX_V2, 0, 0);
1212             input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
1213                          ETP_WMAX_V2, 0, 0);
1214         }
1215         input_mt_init_slots(dev, 2, INPUT_MT_SEMI_MT);
1216         input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
1217         input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
1218         break;
1219 
1220     case 4:
1221         elantech_set_buttonpad_prop(psmouse);
1222         __set_bit(BTN_TOOL_QUADTAP, dev->keybit);
1223         /* For X to recognize me as touchpad. */
1224         input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
1225         input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
1226         /*
1227          * range of pressure and width is the same as v2,
1228          * report ABS_PRESSURE, ABS_TOOL_WIDTH for compatibility.
1229          */
1230         input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2,
1231                      ETP_PMAX_V2, 0, 0);
1232         input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
1233                      ETP_WMAX_V2, 0, 0);
1234         /* Multitouch capable pad, up to 5 fingers. */
1235         input_mt_init_slots(dev, ETP_MAX_FINGERS, 0);
1236         input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
1237         input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
1238         input_set_abs_params(dev, ABS_MT_PRESSURE, ETP_PMIN_V2,
1239                      ETP_PMAX_V2, 0, 0);
1240         /*
1241          * The firmware reports how many trace lines the finger spans,
1242          * convert to surface unit as Protocol-B requires.
1243          */
1244         input_set_abs_params(dev, ABS_MT_TOUCH_MAJOR, 0,
1245                      ETP_WMAX_V2 * width, 0, 0);
1246         break;
1247     }
1248 
1249     input_abs_set_res(dev, ABS_X, info->x_res);
1250     input_abs_set_res(dev, ABS_Y, info->y_res);
1251     if (info->hw_version > 1) {
1252         input_abs_set_res(dev, ABS_MT_POSITION_X, info->x_res);
1253         input_abs_set_res(dev, ABS_MT_POSITION_Y, info->y_res);
1254     }
1255 
1256     etd->y_max = y_max;
1257     etd->width = width;
1258 
1259     return 0;
1260 }
1261 
1262 struct elantech_attr_data {
1263     size_t      field_offset;
1264     unsigned char   reg;
1265 };
1266 
1267 /*
1268  * Display a register value by reading a sysfs entry
1269  */
1270 static ssize_t elantech_show_int_attr(struct psmouse *psmouse, void *data,
1271                     char *buf)
1272 {
1273     struct elantech_data *etd = psmouse->private;
1274     struct elantech_attr_data *attr = data;
1275     unsigned char *reg = (unsigned char *) etd + attr->field_offset;
1276     int rc = 0;
1277 
1278     if (attr->reg)
1279         rc = elantech_read_reg(psmouse, attr->reg, reg);
1280 
1281     return sprintf(buf, "0x%02x\n", (attr->reg && rc) ? -1 : *reg);
1282 }
1283 
1284 /*
1285  * Write a register value by writing a sysfs entry
1286  */
1287 static ssize_t elantech_set_int_attr(struct psmouse *psmouse,
1288                      void *data, const char *buf, size_t count)
1289 {
1290     struct elantech_data *etd = psmouse->private;
1291     struct elantech_attr_data *attr = data;
1292     unsigned char *reg = (unsigned char *) etd + attr->field_offset;
1293     unsigned char value;
1294     int err;
1295 
1296     err = kstrtou8(buf, 16, &value);
1297     if (err)
1298         return err;
1299 
1300     /* Do we need to preserve some bits for version 2 hardware too? */
1301     if (etd->info.hw_version == 1) {
1302         if (attr->reg == 0x10)
1303             /* Force absolute mode always on */
1304             value |= ETP_R10_ABSOLUTE_MODE;
1305         else if (attr->reg == 0x11)
1306             /* Force 4 byte mode always on */
1307             value |= ETP_R11_4_BYTE_MODE;
1308     }
1309 
1310     if (!attr->reg || elantech_write_reg(psmouse, attr->reg, value) == 0)
1311         *reg = value;
1312 
1313     return count;
1314 }
1315 
1316 #define ELANTECH_INT_ATTR(_name, _register)             \
1317     static struct elantech_attr_data elantech_attr_##_name = {  \
1318         .field_offset = offsetof(struct elantech_data, _name),  \
1319         .reg = _register,                   \
1320     };                              \
1321     PSMOUSE_DEFINE_ATTR(_name, 0644,                \
1322                 &elantech_attr_##_name,         \
1323                 elantech_show_int_attr,         \
1324                 elantech_set_int_attr)
1325 
1326 #define ELANTECH_INFO_ATTR(_name)                          \
1327     static struct elantech_attr_data elantech_attr_##_name = {         \
1328         .field_offset = offsetof(struct elantech_data, info) +         \
1329                 offsetof(struct elantech_device_info, _name),  \
1330         .reg = 0,                              \
1331     };                                     \
1332     PSMOUSE_DEFINE_ATTR(_name, 0644,                       \
1333                 &elantech_attr_##_name,                \
1334                 elantech_show_int_attr,                \
1335                 elantech_set_int_attr)
1336 
1337 ELANTECH_INT_ATTR(reg_07, 0x07);
1338 ELANTECH_INT_ATTR(reg_10, 0x10);
1339 ELANTECH_INT_ATTR(reg_11, 0x11);
1340 ELANTECH_INT_ATTR(reg_20, 0x20);
1341 ELANTECH_INT_ATTR(reg_21, 0x21);
1342 ELANTECH_INT_ATTR(reg_22, 0x22);
1343 ELANTECH_INT_ATTR(reg_23, 0x23);
1344 ELANTECH_INT_ATTR(reg_24, 0x24);
1345 ELANTECH_INT_ATTR(reg_25, 0x25);
1346 ELANTECH_INT_ATTR(reg_26, 0x26);
1347 ELANTECH_INFO_ATTR(debug);
1348 ELANTECH_INFO_ATTR(paritycheck);
1349 ELANTECH_INFO_ATTR(crc_enabled);
1350 
1351 static struct attribute *elantech_attrs[] = {
1352     &psmouse_attr_reg_07.dattr.attr,
1353     &psmouse_attr_reg_10.dattr.attr,
1354     &psmouse_attr_reg_11.dattr.attr,
1355     &psmouse_attr_reg_20.dattr.attr,
1356     &psmouse_attr_reg_21.dattr.attr,
1357     &psmouse_attr_reg_22.dattr.attr,
1358     &psmouse_attr_reg_23.dattr.attr,
1359     &psmouse_attr_reg_24.dattr.attr,
1360     &psmouse_attr_reg_25.dattr.attr,
1361     &psmouse_attr_reg_26.dattr.attr,
1362     &psmouse_attr_debug.dattr.attr,
1363     &psmouse_attr_paritycheck.dattr.attr,
1364     &psmouse_attr_crc_enabled.dattr.attr,
1365     NULL
1366 };
1367 
1368 static const struct attribute_group elantech_attr_group = {
1369     .attrs = elantech_attrs,
1370 };
1371 
1372 static bool elantech_is_signature_valid(const unsigned char *param)
1373 {
1374     static const unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10 };
1375     int i;
1376 
1377     if (param[0] == 0)
1378         return false;
1379 
1380     if (param[1] == 0)
1381         return true;
1382 
1383     /*
1384      * Some hw_version >= 4 models have a revision higher then 20. Meaning
1385      * that param[2] may be 10 or 20, skip the rates check for these.
1386      */
1387     if ((param[0] & 0x0f) >= 0x06 && (param[1] & 0xaf) == 0x0f &&
1388         param[2] < 40)
1389         return true;
1390 
1391     for (i = 0; i < ARRAY_SIZE(rates); i++)
1392         if (param[2] == rates[i])
1393             return false;
1394 
1395     return true;
1396 }
1397 
1398 /*
1399  * Use magic knock to detect Elantech touchpad
1400  */
1401 int elantech_detect(struct psmouse *psmouse, bool set_properties)
1402 {
1403     struct ps2dev *ps2dev = &psmouse->ps2dev;
1404     unsigned char param[3];
1405 
1406     ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
1407 
1408     if (ps2_command(ps2dev,  NULL, PSMOUSE_CMD_DISABLE) ||
1409         ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11) ||
1410         ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11) ||
1411         ps2_command(ps2dev,  NULL, PSMOUSE_CMD_SETSCALE11) ||
1412         ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
1413         psmouse_dbg(psmouse, "sending Elantech magic knock failed.\n");
1414         return -1;
1415     }
1416 
1417     /*
1418      * Report this in case there are Elantech models that use a different
1419      * set of magic numbers
1420      */
1421     if (param[0] != 0x3c || param[1] != 0x03 ||
1422         (param[2] != 0xc8 && param[2] != 0x00)) {
1423         psmouse_dbg(psmouse,
1424                 "unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n",
1425                 param[0], param[1], param[2]);
1426         return -1;
1427     }
1428 
1429     /*
1430      * Query touchpad's firmware version and see if it reports known
1431      * value to avoid mis-detection. Logitech mice are known to respond
1432      * to Elantech magic knock and there might be more.
1433      */
1434     if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
1435         psmouse_dbg(psmouse, "failed to query firmware version.\n");
1436         return -1;
1437     }
1438 
1439     psmouse_dbg(psmouse,
1440             "Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n",
1441             param[0], param[1], param[2]);
1442 
1443     if (!elantech_is_signature_valid(param)) {
1444         psmouse_dbg(psmouse,
1445                 "Probably not a real Elantech touchpad. Aborting.\n");
1446         return -1;
1447     }
1448 
1449     if (set_properties) {
1450         psmouse->vendor = "Elantech";
1451         psmouse->name = "Touchpad";
1452     }
1453 
1454     return 0;
1455 }
1456 
1457 /*
1458  * Clean up sysfs entries when disconnecting
1459  */
1460 static void elantech_disconnect(struct psmouse *psmouse)
1461 {
1462     struct elantech_data *etd = psmouse->private;
1463 
1464     /*
1465      * We might have left a breadcrumb when trying to
1466      * set up SMbus companion.
1467      */
1468     psmouse_smbus_cleanup(psmouse);
1469 
1470     if (etd->tp_dev)
1471         input_unregister_device(etd->tp_dev);
1472     sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
1473                &elantech_attr_group);
1474     kfree(psmouse->private);
1475     psmouse->private = NULL;
1476 }
1477 
1478 /*
1479  * Put the touchpad back into absolute mode when reconnecting
1480  */
1481 static int elantech_reconnect(struct psmouse *psmouse)
1482 {
1483     psmouse_reset(psmouse);
1484 
1485     if (elantech_detect(psmouse, 0))
1486         return -1;
1487 
1488     if (elantech_set_absolute_mode(psmouse)) {
1489         psmouse_err(psmouse,
1490                 "failed to put touchpad back into absolute mode.\n");
1491         return -1;
1492     }
1493 
1494     return 0;
1495 }
1496 
1497 /*
1498  * Some hw_version 4 models do not work with crc_disabled
1499  */
1500 static const struct dmi_system_id elantech_dmi_force_crc_enabled[] = {
1501 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
1502     {
1503         /* Fujitsu H730 does not work with crc_enabled == 0 */
1504         .matches = {
1505             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1506             DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H730"),
1507         },
1508     },
1509     {
1510         /* Fujitsu H760 does not work with crc_enabled == 0 */
1511         .matches = {
1512             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1513             DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H760"),
1514         },
1515     },
1516     {
1517         /* Fujitsu LIFEBOOK E544  does not work with crc_enabled == 0 */
1518         .matches = {
1519             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1520             DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E544"),
1521         },
1522     },
1523     {
1524         /* Fujitsu LIFEBOOK E546  does not work with crc_enabled == 0 */
1525         .matches = {
1526             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1527             DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E546"),
1528         },
1529     },
1530     {
1531         /* Fujitsu LIFEBOOK E547 does not work with crc_enabled == 0 */
1532         .matches = {
1533             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1534             DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E547"),
1535         },
1536     },
1537     {
1538         /* Fujitsu LIFEBOOK E554  does not work with crc_enabled == 0 */
1539         .matches = {
1540             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1541             DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E554"),
1542         },
1543     },
1544     {
1545         /* Fujitsu LIFEBOOK E556 does not work with crc_enabled == 0 */
1546         .matches = {
1547             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1548             DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E556"),
1549         },
1550     },
1551     {
1552         /* Fujitsu LIFEBOOK E557 does not work with crc_enabled == 0 */
1553         .matches = {
1554             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1555             DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E557"),
1556         },
1557     },
1558     {
1559         /* Fujitsu LIFEBOOK U745 does not work with crc_enabled == 0 */
1560         .matches = {
1561             DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1562             DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK U745"),
1563         },
1564     },
1565 #endif
1566     { }
1567 };
1568 
1569 /*
1570  * Some hw_version 3 models go into error state when we try to set
1571  * bit 3 and/or bit 1 of r10.
1572  */
1573 static const struct dmi_system_id no_hw_res_dmi_table[] = {
1574 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
1575     {
1576         /* Gigabyte U2442 */
1577         .matches = {
1578             DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
1579             DMI_MATCH(DMI_PRODUCT_NAME, "U2442"),
1580         },
1581     },
1582 #endif
1583     { }
1584 };
1585 
1586 /*
1587  * Change Report id 0x5E to 0x5F.
1588  */
1589 static int elantech_change_report_id(struct psmouse *psmouse)
1590 {
1591     /*
1592      * NOTE: the code is expecting to receive param[] as an array of 3
1593      * items (see __ps2_command()), even if in this case only 2 are
1594      * actually needed. Make sure the array size is 3 to avoid potential
1595      * stack out-of-bound accesses.
1596      */
1597     unsigned char param[3] = { 0x10, 0x03 };
1598 
1599     if (elantech_write_reg_params(psmouse, 0x7, param) ||
1600         elantech_read_reg_params(psmouse, 0x7, param) ||
1601         param[0] != 0x10 || param[1] != 0x03) {
1602         psmouse_err(psmouse, "Unable to change report ID to 0x5f.\n");
1603         return -EIO;
1604     }
1605 
1606     return 0;
1607 }
1608 /*
1609  * determine hardware version and set some properties according to it.
1610  */
1611 static int elantech_set_properties(struct elantech_device_info *info)
1612 {
1613     /* This represents the version of IC body. */
1614     info->ic_version = (info->fw_version & 0x0f0000) >> 16;
1615 
1616     /* Early version of Elan touchpads doesn't obey the rule. */
1617     if (info->fw_version < 0x020030 || info->fw_version == 0x020600)
1618         info->hw_version = 1;
1619     else {
1620         switch (info->ic_version) {
1621         case 2:
1622         case 4:
1623             info->hw_version = 2;
1624             break;
1625         case 5:
1626             info->hw_version = 3;
1627             break;
1628         case 6 ... 15:
1629             info->hw_version = 4;
1630             break;
1631         default:
1632             return -1;
1633         }
1634     }
1635 
1636     /* Get information pattern for hw_version 4 */
1637     info->pattern = 0x00;
1638     if (info->ic_version == 0x0f && (info->fw_version & 0xff) <= 0x02)
1639         info->pattern = info->fw_version & 0xff;
1640 
1641     /* decide which send_cmd we're gonna use early */
1642     info->send_cmd = info->hw_version >= 3 ? elantech_send_cmd :
1643                          synaptics_send_cmd;
1644 
1645     /* Turn on packet checking by default */
1646     info->paritycheck = 1;
1647 
1648     /*
1649      * This firmware suffers from misreporting coordinates when
1650      * a touch action starts causing the mouse cursor or scrolled page
1651      * to jump. Enable a workaround.
1652      */
1653     info->jumpy_cursor =
1654         (info->fw_version == 0x020022 || info->fw_version == 0x020600);
1655 
1656     if (info->hw_version > 1) {
1657         /* For now show extra debug information */
1658         info->debug = 1;
1659 
1660         if (info->fw_version >= 0x020800)
1661             info->reports_pressure = true;
1662     }
1663 
1664     /*
1665      * The signatures of v3 and v4 packets change depending on the
1666      * value of this hardware flag.
1667      */
1668     info->crc_enabled = (info->fw_version & 0x4000) == 0x4000 ||
1669                  dmi_check_system(elantech_dmi_force_crc_enabled);
1670 
1671     /* Enable real hardware resolution on hw_version 3 ? */
1672     info->set_hw_resolution = !dmi_check_system(no_hw_res_dmi_table);
1673 
1674     return 0;
1675 }
1676 
1677 static int elantech_query_info(struct psmouse *psmouse,
1678                    struct elantech_device_info *info)
1679 {
1680     unsigned char param[3];
1681     unsigned char traces;
1682     unsigned char ic_body[3];
1683 
1684     memset(info, 0, sizeof(*info));
1685 
1686     /*
1687      * Do the version query again so we can store the result
1688      */
1689     if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
1690         psmouse_err(psmouse, "failed to query firmware version.\n");
1691         return -EINVAL;
1692     }
1693     info->fw_version = (param[0] << 16) | (param[1] << 8) | param[2];
1694 
1695     if (elantech_set_properties(info)) {
1696         psmouse_err(psmouse, "unknown hardware version, aborting...\n");
1697         return -EINVAL;
1698     }
1699     psmouse_info(psmouse,
1700              "assuming hardware version %d (with firmware version 0x%02x%02x%02x)\n",
1701              info->hw_version, param[0], param[1], param[2]);
1702 
1703     if (info->send_cmd(psmouse, ETP_CAPABILITIES_QUERY,
1704         info->capabilities)) {
1705         psmouse_err(psmouse, "failed to query capabilities.\n");
1706         return -EINVAL;
1707     }
1708     psmouse_info(psmouse,
1709              "Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n",
1710              info->capabilities[0], info->capabilities[1],
1711              info->capabilities[2]);
1712 
1713     if (info->hw_version != 1) {
1714         if (info->send_cmd(psmouse, ETP_SAMPLE_QUERY, info->samples)) {
1715             psmouse_err(psmouse, "failed to query sample data\n");
1716             return -EINVAL;
1717         }
1718         psmouse_info(psmouse,
1719                  "Elan sample query result %02x, %02x, %02x\n",
1720                  info->samples[0],
1721                  info->samples[1],
1722                  info->samples[2]);
1723     }
1724 
1725     if (info->pattern > 0x00 && info->ic_version == 0xf) {
1726         if (info->send_cmd(psmouse, ETP_ICBODY_QUERY, ic_body)) {
1727             psmouse_err(psmouse, "failed to query ic body\n");
1728             return -EINVAL;
1729         }
1730         info->ic_version = be16_to_cpup((__be16 *)ic_body);
1731         psmouse_info(psmouse,
1732                  "Elan ic body: %#04x, current fw version: %#02x\n",
1733                  info->ic_version, ic_body[2]);
1734     }
1735 
1736     info->product_id = be16_to_cpup((__be16 *)info->samples);
1737     if (info->pattern == 0x00)
1738         info->product_id &= 0xff;
1739 
1740     if (info->samples[1] == 0x74 && info->hw_version == 0x03) {
1741         /*
1742          * This module has a bug which makes absolute mode
1743          * unusable, so let's abort so we'll be using standard
1744          * PS/2 protocol.
1745          */
1746         psmouse_info(psmouse,
1747                  "absolute mode broken, forcing standard PS/2 protocol\n");
1748         return -ENODEV;
1749     }
1750 
1751     /* The MSB indicates the presence of the trackpoint */
1752     info->has_trackpoint = (info->capabilities[0] & 0x80) == 0x80;
1753 
1754     if (info->has_trackpoint && info->ic_version == 0x0011 &&
1755         (info->product_id == 0x08 || info->product_id == 0x09 ||
1756          info->product_id == 0x0d || info->product_id == 0x0e)) {
1757         /*
1758          * This module has a bug which makes trackpoint in SMBus
1759          * mode return invalid data unless trackpoint is switched
1760          * from using 0x5e reports to 0x5f. If we are not able to
1761          * make the switch, let's abort initialization so we'll be
1762          * using standard PS/2 protocol.
1763          */
1764         if (elantech_change_report_id(psmouse)) {
1765             psmouse_info(psmouse,
1766                      "Trackpoint report is broken, forcing standard PS/2 protocol\n");
1767             return -ENODEV;
1768         }
1769     }
1770 
1771     info->x_res = 31;
1772     info->y_res = 31;
1773     if (info->hw_version == 4) {
1774         if (elantech_get_resolution_v4(psmouse,
1775                            &info->x_res,
1776                            &info->y_res,
1777                            &info->bus)) {
1778             psmouse_warn(psmouse,
1779                      "failed to query resolution data.\n");
1780         }
1781     }
1782 
1783     /* query range information */
1784     switch (info->hw_version) {
1785     case 1:
1786         info->x_min = ETP_XMIN_V1;
1787         info->y_min = ETP_YMIN_V1;
1788         info->x_max = ETP_XMAX_V1;
1789         info->y_max = ETP_YMAX_V1;
1790         break;
1791 
1792     case 2:
1793         if (info->fw_version == 0x020800 ||
1794             info->fw_version == 0x020b00 ||
1795             info->fw_version == 0x020030) {
1796             info->x_min = ETP_XMIN_V2;
1797             info->y_min = ETP_YMIN_V2;
1798             info->x_max = ETP_XMAX_V2;
1799             info->y_max = ETP_YMAX_V2;
1800         } else {
1801             int i;
1802             int fixed_dpi;
1803 
1804             i = (info->fw_version > 0x020800 &&
1805                  info->fw_version < 0x020900) ? 1 : 2;
1806 
1807             if (info->send_cmd(psmouse, ETP_FW_ID_QUERY, param))
1808                 return -EINVAL;
1809 
1810             fixed_dpi = param[1] & 0x10;
1811 
1812             if (((info->fw_version >> 16) == 0x14) && fixed_dpi) {
1813                 if (info->send_cmd(psmouse, ETP_SAMPLE_QUERY, param))
1814                     return -EINVAL;
1815 
1816                 info->x_max = (info->capabilities[1] - i) * param[1] / 2;
1817                 info->y_max = (info->capabilities[2] - i) * param[2] / 2;
1818             } else if (info->fw_version == 0x040216) {
1819                 info->x_max = 819;
1820                 info->y_max = 405;
1821             } else if (info->fw_version == 0x040219 || info->fw_version == 0x040215) {
1822                 info->x_max = 900;
1823                 info->y_max = 500;
1824             } else {
1825                 info->x_max = (info->capabilities[1] - i) * 64;
1826                 info->y_max = (info->capabilities[2] - i) * 64;
1827             }
1828         }
1829         break;
1830 
1831     case 3:
1832         if (info->send_cmd(psmouse, ETP_FW_ID_QUERY, param))
1833             return -EINVAL;
1834 
1835         info->x_max = (0x0f & param[0]) << 8 | param[1];
1836         info->y_max = (0xf0 & param[0]) << 4 | param[2];
1837         break;
1838 
1839     case 4:
1840         if (info->send_cmd(psmouse, ETP_FW_ID_QUERY, param))
1841             return -EINVAL;
1842 
1843         info->x_max = (0x0f & param[0]) << 8 | param[1];
1844         info->y_max = (0xf0 & param[0]) << 4 | param[2];
1845         traces = info->capabilities[1];
1846         if ((traces < 2) || (traces > info->x_max))
1847             return -EINVAL;
1848 
1849         info->width = info->x_max / (traces - 1);
1850 
1851         /* column number of traces */
1852         info->x_traces = traces;
1853 
1854         /* row number of traces */
1855         traces = info->capabilities[2];
1856         if ((traces >= 2) && (traces <= info->y_max))
1857             info->y_traces = traces;
1858 
1859         break;
1860     }
1861 
1862     /* check for the middle button: DMI matching or new v4 firmwares */
1863     info->has_middle_button = dmi_check_system(elantech_dmi_has_middle_button) ||
1864                   (ETP_NEW_IC_SMBUS_HOST_NOTIFY(info->fw_version) &&
1865                    !elantech_is_buttonpad(info));
1866 
1867     return 0;
1868 }
1869 
1870 #if defined(CONFIG_MOUSE_PS2_ELANTECH_SMBUS)
1871 
1872 /*
1873  * The newest Elantech device can use a secondary bus (over SMBus) which
1874  * provides a better bandwidth and allow a better control of the touchpads.
1875  * This is used to decide if we need to use this bus or not.
1876  */
1877 enum {
1878     ELANTECH_SMBUS_NOT_SET = -1,
1879     ELANTECH_SMBUS_OFF,
1880     ELANTECH_SMBUS_ON,
1881 };
1882 
1883 static int elantech_smbus = IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_SMBUS) ?
1884         ELANTECH_SMBUS_NOT_SET : ELANTECH_SMBUS_OFF;
1885 module_param_named(elantech_smbus, elantech_smbus, int, 0644);
1886 MODULE_PARM_DESC(elantech_smbus, "Use a secondary bus for the Elantech device.");
1887 
1888 static const char * const i2c_blacklist_pnp_ids[] = {
1889     /*
1890      * These are known to not be working properly as bits are missing
1891      * in elan_i2c.
1892      */
1893     NULL
1894 };
1895 
1896 static int elantech_create_smbus(struct psmouse *psmouse,
1897                  struct elantech_device_info *info,
1898                  bool leave_breadcrumbs)
1899 {
1900     struct property_entry i2c_props[11] = {};
1901     struct i2c_board_info smbus_board = {
1902         I2C_BOARD_INFO("elan_i2c", 0x15),
1903         .flags = I2C_CLIENT_HOST_NOTIFY,
1904     };
1905     unsigned int idx = 0;
1906 
1907     i2c_props[idx++] = PROPERTY_ENTRY_U32("touchscreen-size-x",
1908                            info->x_max + 1);
1909     i2c_props[idx++] = PROPERTY_ENTRY_U32("touchscreen-size-y",
1910                            info->y_max + 1);
1911     i2c_props[idx++] = PROPERTY_ENTRY_U32("touchscreen-min-x",
1912                            info->x_min);
1913     i2c_props[idx++] = PROPERTY_ENTRY_U32("touchscreen-min-y",
1914                            info->y_min);
1915     if (info->x_res)
1916         i2c_props[idx++] = PROPERTY_ENTRY_U32("touchscreen-x-mm",
1917                               (info->x_max + 1) / info->x_res);
1918     if (info->y_res)
1919         i2c_props[idx++] = PROPERTY_ENTRY_U32("touchscreen-y-mm",
1920                               (info->y_max + 1) / info->y_res);
1921 
1922     if (info->has_trackpoint)
1923         i2c_props[idx++] = PROPERTY_ENTRY_BOOL("elan,trackpoint");
1924 
1925     if (info->has_middle_button)
1926         i2c_props[idx++] = PROPERTY_ENTRY_BOOL("elan,middle-button");
1927 
1928     if (info->x_traces)
1929         i2c_props[idx++] = PROPERTY_ENTRY_U32("elan,x_traces",
1930                               info->x_traces);
1931     if (info->y_traces)
1932         i2c_props[idx++] = PROPERTY_ENTRY_U32("elan,y_traces",
1933                               info->y_traces);
1934 
1935     if (elantech_is_buttonpad(info))
1936         i2c_props[idx++] = PROPERTY_ENTRY_BOOL("elan,clickpad");
1937 
1938     smbus_board.fwnode = fwnode_create_software_node(i2c_props, NULL);
1939     if (IS_ERR(smbus_board.fwnode))
1940         return PTR_ERR(smbus_board.fwnode);
1941 
1942     return psmouse_smbus_init(psmouse, &smbus_board, NULL, 0, false,
1943                   leave_breadcrumbs);
1944 }
1945 
1946 /*
1947  * elantech_setup_smbus - called once the PS/2 devices are enumerated
1948  * and decides to instantiate a SMBus InterTouch device.
1949  */
1950 static int elantech_setup_smbus(struct psmouse *psmouse,
1951                 struct elantech_device_info *info,
1952                 bool leave_breadcrumbs)
1953 {
1954     int error;
1955 
1956     if (elantech_smbus == ELANTECH_SMBUS_OFF)
1957         return -ENXIO;
1958 
1959     if (elantech_smbus == ELANTECH_SMBUS_NOT_SET) {
1960         /*
1961          * New ICs are enabled by default, unless mentioned in
1962          * i2c_blacklist_pnp_ids.
1963          * Old ICs are up to the user to decide.
1964          */
1965         if (!ETP_NEW_IC_SMBUS_HOST_NOTIFY(info->fw_version) ||
1966             psmouse_matches_pnp_id(psmouse, i2c_blacklist_pnp_ids))
1967             return -ENXIO;
1968     }
1969 
1970     psmouse_info(psmouse, "Trying to set up SMBus access\n");
1971 
1972     error = elantech_create_smbus(psmouse, info, leave_breadcrumbs);
1973     if (error) {
1974         if (error == -EAGAIN)
1975             psmouse_info(psmouse, "SMbus companion is not ready yet\n");
1976         else
1977             psmouse_err(psmouse, "unable to create intertouch device\n");
1978 
1979         return error;
1980     }
1981 
1982     return 0;
1983 }
1984 
1985 static bool elantech_use_host_notify(struct psmouse *psmouse,
1986                      struct elantech_device_info *info)
1987 {
1988     if (ETP_NEW_IC_SMBUS_HOST_NOTIFY(info->fw_version))
1989         return true;
1990 
1991     switch (info->bus) {
1992     case ETP_BUS_PS2_ONLY:
1993         /* expected case */
1994         break;
1995     case ETP_BUS_SMB_ALERT_ONLY:
1996     case ETP_BUS_PS2_SMB_ALERT:
1997         psmouse_dbg(psmouse, "Ignoring SMBus provider through alert protocol.\n");
1998         break;
1999     case ETP_BUS_SMB_HST_NTFY_ONLY:
2000     case ETP_BUS_PS2_SMB_HST_NTFY:
2001         return true;
2002     default:
2003         psmouse_dbg(psmouse,
2004                 "Ignoring SMBus bus provider %d.\n",
2005                 info->bus);
2006     }
2007 
2008     return false;
2009 }
2010 
2011 int elantech_init_smbus(struct psmouse *psmouse)
2012 {
2013     struct elantech_device_info info;
2014     int error;
2015 
2016     psmouse_reset(psmouse);
2017 
2018     error = elantech_query_info(psmouse, &info);
2019     if (error)
2020         goto init_fail;
2021 
2022     if (info.hw_version < 4) {
2023         error = -ENXIO;
2024         goto init_fail;
2025     }
2026 
2027     return elantech_create_smbus(psmouse, &info, false);
2028  init_fail:
2029     psmouse_reset(psmouse);
2030     return error;
2031 }
2032 #endif /* CONFIG_MOUSE_PS2_ELANTECH_SMBUS */
2033 
2034 /*
2035  * Initialize the touchpad and create sysfs entries
2036  */
2037 static int elantech_setup_ps2(struct psmouse *psmouse,
2038                   struct elantech_device_info *info)
2039 {
2040     struct elantech_data *etd;
2041     int i;
2042     int error = -EINVAL;
2043     struct input_dev *tp_dev;
2044 
2045     psmouse->private = etd = kzalloc(sizeof(*etd), GFP_KERNEL);
2046     if (!etd)
2047         return -ENOMEM;
2048 
2049     etd->info = *info;
2050 
2051     etd->parity[0] = 1;
2052     for (i = 1; i < 256; i++)
2053         etd->parity[i] = etd->parity[i & (i - 1)] ^ 1;
2054 
2055     if (elantech_set_absolute_mode(psmouse)) {
2056         psmouse_err(psmouse,
2057                 "failed to put touchpad into absolute mode.\n");
2058         goto init_fail;
2059     }
2060 
2061     if (info->fw_version == 0x381f17) {
2062         etd->original_set_rate = psmouse->set_rate;
2063         psmouse->set_rate = elantech_set_rate_restore_reg_07;
2064     }
2065 
2066     if (elantech_set_input_params(psmouse)) {
2067         psmouse_err(psmouse, "failed to query touchpad range.\n");
2068         goto init_fail;
2069     }
2070 
2071     error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
2072                    &elantech_attr_group);
2073     if (error) {
2074         psmouse_err(psmouse,
2075                 "failed to create sysfs attributes, error: %d.\n",
2076                 error);
2077         goto init_fail;
2078     }
2079 
2080     if (info->has_trackpoint) {
2081         tp_dev = input_allocate_device();
2082 
2083         if (!tp_dev) {
2084             error = -ENOMEM;
2085             goto init_fail_tp_alloc;
2086         }
2087 
2088         etd->tp_dev = tp_dev;
2089         snprintf(etd->tp_phys, sizeof(etd->tp_phys), "%s/input1",
2090             psmouse->ps2dev.serio->phys);
2091         tp_dev->phys = etd->tp_phys;
2092         tp_dev->name = "ETPS/2 Elantech TrackPoint";
2093         tp_dev->id.bustype = BUS_I8042;
2094         tp_dev->id.vendor  = 0x0002;
2095         tp_dev->id.product = PSMOUSE_ELANTECH;
2096         tp_dev->id.version = 0x0000;
2097         tp_dev->dev.parent = &psmouse->ps2dev.serio->dev;
2098         tp_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
2099         tp_dev->relbit[BIT_WORD(REL_X)] =
2100             BIT_MASK(REL_X) | BIT_MASK(REL_Y);
2101         tp_dev->keybit[BIT_WORD(BTN_LEFT)] =
2102             BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_MIDDLE) |
2103             BIT_MASK(BTN_RIGHT);
2104 
2105         __set_bit(INPUT_PROP_POINTER, tp_dev->propbit);
2106         __set_bit(INPUT_PROP_POINTING_STICK, tp_dev->propbit);
2107 
2108         error = input_register_device(etd->tp_dev);
2109         if (error < 0)
2110             goto init_fail_tp_reg;
2111     }
2112 
2113     psmouse->protocol_handler = elantech_process_byte;
2114     psmouse->disconnect = elantech_disconnect;
2115     psmouse->reconnect = elantech_reconnect;
2116     psmouse->pktsize = info->hw_version > 1 ? 6 : 4;
2117 
2118     return 0;
2119  init_fail_tp_reg:
2120     input_free_device(tp_dev);
2121  init_fail_tp_alloc:
2122     sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
2123                &elantech_attr_group);
2124  init_fail:
2125     kfree(etd);
2126     return error;
2127 }
2128 
2129 int elantech_init_ps2(struct psmouse *psmouse)
2130 {
2131     struct elantech_device_info info;
2132     int error;
2133 
2134     psmouse_reset(psmouse);
2135 
2136     error = elantech_query_info(psmouse, &info);
2137     if (error)
2138         goto init_fail;
2139 
2140     error = elantech_setup_ps2(psmouse, &info);
2141     if (error)
2142         goto init_fail;
2143 
2144     return 0;
2145  init_fail:
2146     psmouse_reset(psmouse);
2147     return error;
2148 }
2149 
2150 int elantech_init(struct psmouse *psmouse)
2151 {
2152     struct elantech_device_info info;
2153     int error;
2154 
2155     psmouse_reset(psmouse);
2156 
2157     error = elantech_query_info(psmouse, &info);
2158     if (error)
2159         goto init_fail;
2160 
2161 #if defined(CONFIG_MOUSE_PS2_ELANTECH_SMBUS)
2162 
2163     if (elantech_use_host_notify(psmouse, &info)) {
2164         if (!IS_ENABLED(CONFIG_MOUSE_ELAN_I2C_SMBUS) ||
2165             !IS_ENABLED(CONFIG_MOUSE_PS2_ELANTECH_SMBUS)) {
2166             psmouse_warn(psmouse,
2167                      "The touchpad can support a better bus than the too old PS/2 protocol. "
2168                      "Make sure MOUSE_PS2_ELANTECH_SMBUS and MOUSE_ELAN_I2C_SMBUS are enabled to get a better touchpad experience.\n");
2169         }
2170         error = elantech_setup_smbus(psmouse, &info, true);
2171         if (!error)
2172             return PSMOUSE_ELANTECH_SMBUS;
2173     }
2174 
2175 #endif /* CONFIG_MOUSE_PS2_ELANTECH_SMBUS */
2176 
2177     error = elantech_setup_ps2(psmouse, &info);
2178     if (error < 0) {
2179         /*
2180          * Not using any flavor of Elantech support, so clean up
2181          * SMbus breadcrumbs, if any.
2182          */
2183         psmouse_smbus_cleanup(psmouse);
2184         goto init_fail;
2185     }
2186 
2187     return PSMOUSE_ELANTECH;
2188  init_fail:
2189     psmouse_reset(psmouse);
2190     return error;
2191 }