0001
0002
0003
0004
0005
0006
0007
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
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
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
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
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
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
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
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
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
0272
0273
0274
0275
0276
0277
0278
0279
0280
0281
0282
0283
0284
0285
0286
0287
0288
0289
0290
0291
0292
0293
0294
0295
0296
0297
0298
0299
0300
0301
0302
0303
0304
0305
0306
0307
0308
0309
0310
0311 static inline int elantech_is_buttonpad(struct elantech_device_info *info)
0312 {
0313 return info->fw_version & 0x001000;
0314 }
0315
0316
0317
0318
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
0330
0331
0332 fingers = ((packet[1] & 0x80) >> 7) +
0333 ((packet[1] & 0x30) >> 4);
0334 } else {
0335
0336
0337
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
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
0357
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
0375 input_report_key(dev, BTN_FORWARD, packet[0] & 0x40);
0376
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
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
0406
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
0417 fingers = (packet[0] & 0xc0) >> 6;
0418
0419 switch (fingers) {
0420 case 3:
0421
0422
0423
0424
0425 if (packet[3] & 0x80)
0426 fingers = 4;
0427 fallthrough;
0428 case 1:
0429
0430
0431
0432
0433 x1 = ((packet[1] & 0x0f) << 8) | packet[2];
0434
0435
0436
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
0447
0448
0449
0450
0451 x1 = (((packet[0] & 0x10) << 4) | packet[1]) << 2;
0452
0453 y1 = etd->y_max -
0454 ((((packet[0] & 0x20) << 3) | packet[2]) << 2);
0455
0456
0457
0458
0459 x2 = (((packet[3] & 0x10) << 4) | packet[4]) << 2;
0460
0461 y2 = etd->y_max -
0462 ((((packet[3] & 0x20) << 3) | packet[5]) << 2);
0463
0464
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
0494
0495
0496
0497
0498
0499
0500
0501
0502
0503
0504
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
0523
0524
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
0547 if (etd->info.debug == 1)
0548 elantech_packet_dump(psmouse);
0549
0550 break;
0551 }
0552 }
0553
0554
0555
0556
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
0568 fingers = (packet[0] & 0xc0) >> 6;
0569
0570 switch (fingers) {
0571 case 3:
0572 case 1:
0573
0574
0575
0576
0577 x1 = ((packet[1] & 0x0f) << 8) | packet[2];
0578
0579
0580
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
0589
0590
0591 etd->mt[0].x = ((packet[1] & 0x0f) << 8) | packet[2];
0592
0593
0594
0595
0596 etd->mt[0].y = etd->y_max -
0597 (((packet[4] & 0x0f) << 8) | packet[5]);
0598
0599
0600
0601 return;
0602 }
0603
0604
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
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
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
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
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
0717
0718
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
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
0772 if (etd->info.fw_version < 0x020000) {
0773
0774 p1 = (packet[0] & 0x20) >> 5;
0775 p2 = (packet[0] & 0x10) >> 4;
0776 } else {
0777
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
0793
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
0810
0811
0812
0813
0814
0815
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
0833
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
0845
0846
0847 if (!memcmp(packet, debounce_packet, sizeof(debounce_packet)))
0848 return PACKET_DEBOUNCE;
0849
0850
0851
0852
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
0885 ic_version = (etd->info.fw_version & 0x0f0000) >> 16;
0886
0887
0888
0889
0890
0891
0892
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
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
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
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
0996
0997
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
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
1031 etd->reg_10 = 0x54;
1032 etd->reg_11 = 0x88;
1033 etd->reg_21 = 0x60;
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;
1058 }
1059
1060 if (rc == 0) {
1061
1062
1063
1064
1065
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
1096
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
1133
1134 static const struct dmi_system_id elantech_dmi_has_middle_button[] = {
1135 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
1136 {
1137
1138 .matches = {
1139 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1140 DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H730"),
1141 },
1142 },
1143 {
1144
1145 .matches = {
1146 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1147 DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H760"),
1148 },
1149 },
1150 {
1151
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
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
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
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
1228
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
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
1242
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
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
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
1301 if (etd->info.hw_version == 1) {
1302 if (attr->reg == 0x10)
1303
1304 value |= ETP_R10_ABSOLUTE_MODE;
1305 else if (attr->reg == 0x11)
1306
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
1385
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
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
1419
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
1431
1432
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
1459
1460 static void elantech_disconnect(struct psmouse *psmouse)
1461 {
1462 struct elantech_data *etd = psmouse->private;
1463
1464
1465
1466
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
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
1499
1500 static const struct dmi_system_id elantech_dmi_force_crc_enabled[] = {
1501 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
1502 {
1503
1504 .matches = {
1505 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1506 DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H730"),
1507 },
1508 },
1509 {
1510
1511 .matches = {
1512 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1513 DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H760"),
1514 },
1515 },
1516 {
1517
1518 .matches = {
1519 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1520 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E544"),
1521 },
1522 },
1523 {
1524
1525 .matches = {
1526 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1527 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E546"),
1528 },
1529 },
1530 {
1531
1532 .matches = {
1533 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1534 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E547"),
1535 },
1536 },
1537 {
1538
1539 .matches = {
1540 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1541 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E554"),
1542 },
1543 },
1544 {
1545
1546 .matches = {
1547 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1548 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E556"),
1549 },
1550 },
1551 {
1552
1553 .matches = {
1554 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1555 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E557"),
1556 },
1557 },
1558 {
1559
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
1571
1572
1573 static const struct dmi_system_id no_hw_res_dmi_table[] = {
1574 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
1575 {
1576
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
1588
1589 static int elantech_change_report_id(struct psmouse *psmouse)
1590 {
1591
1592
1593
1594
1595
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
1610
1611 static int elantech_set_properties(struct elantech_device_info *info)
1612 {
1613
1614 info->ic_version = (info->fw_version & 0x0f0000) >> 16;
1615
1616
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
1637 info->pattern = 0x00;
1638 if (info->ic_version == 0x0f && (info->fw_version & 0xff) <= 0x02)
1639 info->pattern = info->fw_version & 0xff;
1640
1641
1642 info->send_cmd = info->hw_version >= 3 ? elantech_send_cmd :
1643 synaptics_send_cmd;
1644
1645
1646 info->paritycheck = 1;
1647
1648
1649
1650
1651
1652
1653 info->jumpy_cursor =
1654 (info->fw_version == 0x020022 || info->fw_version == 0x020600);
1655
1656 if (info->hw_version > 1) {
1657
1658 info->debug = 1;
1659
1660 if (info->fw_version >= 0x020800)
1661 info->reports_pressure = true;
1662 }
1663
1664
1665
1666
1667
1668 info->crc_enabled = (info->fw_version & 0x4000) == 0x4000 ||
1669 dmi_check_system(elantech_dmi_force_crc_enabled);
1670
1671
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
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
1743
1744
1745
1746 psmouse_info(psmouse,
1747 "absolute mode broken, forcing standard PS/2 protocol\n");
1748 return -ENODEV;
1749 }
1750
1751
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
1759
1760
1761
1762
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
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
1852 info->x_traces = traces;
1853
1854
1855 traces = info->capabilities[2];
1856 if ((traces >= 2) && (traces <= info->y_max))
1857 info->y_traces = traces;
1858
1859 break;
1860 }
1861
1862
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
1874
1875
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
1891
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
1948
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
1962
1963
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
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
2033
2034
2035
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
2176
2177 error = elantech_setup_ps2(psmouse, &info);
2178 if (error < 0) {
2179
2180
2181
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 }