1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Synaptics TouchPad PS/2 mouse driver 4 * 5 * 2003 Dmitry Torokhov <dtor@mail.ru> 6 * Added support for pass-through port. Special thanks to Peter Berg Larsen 7 * for explaining various Synaptics quirks. 8 * 9 * 2003 Peter Osterlund <petero2@telia.com> 10 * Ported to 2.5 input device infrastructure. 11 * 12 * Copyright (C) 2001 Stefan Gmeiner <riddlebox@freesurf.ch> 13 * start merging tpconfig and gpm code to a xfree-input module 14 * adding some changes and extensions (ex. 3rd and 4th button) 15 * 16 * Copyright (c) 1997 C. Scott Ananian <cananian@alumni.priceton.edu> 17 * Copyright (c) 1998-2000 Bruce Kalk <kall@compass.com> 18 * code for the special synaptics commands (from the tpconfig-source) 19 * 20 * Trademarks are the property of their respective owners. 21 */ 22 23 #include <linux/module.h> 24 #include <linux/delay.h> 25 #include <linux/dmi.h> 26 #include <linux/input/mt.h> 27 #include <linux/serio.h> 28 #include <linux/libps2.h> 29 #include <linux/rmi.h> 30 #include <linux/i2c.h> 31 #include <linux/slab.h> 32 #include "psmouse.h" 33 #include "synaptics.h" 34 35 /* 36 * The x/y limits are taken from the Synaptics TouchPad interfacing Guide, 37 * section 2.3.2, which says that they should be valid regardless of the 38 * actual size of the sensor. 39 * Note that newer firmware allows querying device for maximum useable 40 * coordinates. 41 */ 42 #define XMIN 0 43 #define XMAX 6143 44 #define YMIN 0 45 #define YMAX 6143 46 #define XMIN_NOMINAL 1472 47 #define XMAX_NOMINAL 5472 48 #define YMIN_NOMINAL 1408 49 #define YMAX_NOMINAL 4448 50 51 /* Size in bits of absolute position values reported by the hardware */ 52 #define ABS_POS_BITS 13 53 54 /* 55 * These values should represent the absolute maximum value that will 56 * be reported for a positive position value. Some Synaptics firmware 57 * uses this value to indicate a finger near the edge of the touchpad 58 * whose precise position cannot be determined. 59 * 60 * At least one touchpad is known to report positions in excess of this 61 * value which are actually negative values truncated to the 13-bit 62 * reporting range. These values have never been observed to be lower 63 * than 8184 (i.e. -8), so we treat all values greater than 8176 as 64 * negative and any other value as positive. 65 */ 66 #define X_MAX_POSITIVE 8176 67 #define Y_MAX_POSITIVE 8176 68 69 /* maximum ABS_MT_POSITION displacement (in mm) */ 70 #define DMAX 10 71 72 /***************************************************************************** 73 * Stuff we need even when we do not want native Synaptics support 74 ****************************************************************************/ 75 76 /* 77 * Set the synaptics touchpad mode byte by special commands 78 */ 79 static int synaptics_mode_cmd(struct psmouse *psmouse, u8 mode) 80 { 81 u8 param[1]; 82 int error; 83 84 error = ps2_sliced_command(&psmouse->ps2dev, mode); 85 if (error) 86 return error; 87 88 param[0] = SYN_PS_SET_MODE2; 89 error = ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_SETRATE); 90 if (error) 91 return error; 92 93 return 0; 94 } 95 96 int synaptics_detect(struct psmouse *psmouse, bool set_properties) 97 { 98 struct ps2dev *ps2dev = &psmouse->ps2dev; 99 u8 param[4] = { 0 }; 100 101 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES); 102 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES); 103 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES); 104 ps2_command(ps2dev, param, PSMOUSE_CMD_SETRES); 105 ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO); 106 107 if (param[1] != 0x47) 108 return -ENODEV; 109 110 if (set_properties) { 111 psmouse->vendor = "Synaptics"; 112 psmouse->name = "TouchPad"; 113 } 114 115 return 0; 116 } 117 118 void synaptics_reset(struct psmouse *psmouse) 119 { 120 /* reset touchpad back to relative mode, gestures enabled */ 121 synaptics_mode_cmd(psmouse, 0); 122 } 123 124 #if defined(CONFIG_MOUSE_PS2_SYNAPTICS) || \ 125 defined(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS) 126 127 /* This list has been kindly provided by Synaptics. */ 128 static const char * const topbuttonpad_pnp_ids[] = { 129 "LEN0017", 130 "LEN0018", 131 "LEN0019", 132 "LEN0023", 133 "LEN002A", 134 "LEN002B", 135 "LEN002C", 136 "LEN002D", 137 "LEN002E", 138 "LEN0033", /* Helix */ 139 "LEN0034", /* T431s, L440, L540, T540, W540, X1 Carbon 2nd */ 140 "LEN0035", /* X240 */ 141 "LEN0036", /* T440 */ 142 "LEN0037", /* X1 Carbon 2nd */ 143 "LEN0038", 144 "LEN0039", /* T440s */ 145 "LEN0041", 146 "LEN0042", /* Yoga */ 147 "LEN0045", 148 "LEN0047", 149 "LEN0049", 150 "LEN2000", /* S540 */ 151 "LEN2001", /* Edge E431 */ 152 "LEN2002", /* Edge E531 */ 153 "LEN2003", 154 "LEN2004", /* L440 */ 155 "LEN2005", 156 "LEN2006", /* Edge E440/E540 */ 157 "LEN2007", 158 "LEN2008", 159 "LEN2009", 160 "LEN200A", 161 "LEN200B", 162 NULL 163 }; 164 165 static const char * const smbus_pnp_ids[] = { 166 /* all of the topbuttonpad_pnp_ids are valid, we just add some extras */ 167 "LEN0048", /* X1 Carbon 3 */ 168 "LEN0046", /* X250 */ 169 "LEN004a", /* W541 */ 170 "LEN005b", /* P50 */ 171 "LEN005e", /* T560 */ 172 "LEN0071", /* T480 */ 173 "LEN0072", /* X1 Carbon Gen 5 (2017) - Elan/ALPS trackpoint */ 174 "LEN0073", /* X1 Carbon G5 (Elantech) */ 175 "LEN0092", /* X1 Carbon 6 */ 176 "LEN0093", /* T480 */ 177 "LEN0096", /* X280 */ 178 "LEN0097", /* X280 -> ALPS trackpoint */ 179 "LEN009b", /* T580 */ 180 "LEN200f", /* T450s */ 181 "LEN2054", /* E480 */ 182 "LEN2055", /* E580 */ 183 "SYN3052", /* HP EliteBook 840 G4 */ 184 "SYN3221", /* HP 15-ay000 */ 185 "SYN323d", /* HP Spectre X360 13-w013dx */ 186 NULL 187 }; 188 189 static const char * const forcepad_pnp_ids[] = { 190 "SYN300D", 191 "SYN3014", 192 NULL 193 }; 194 195 /* 196 * Send a command to the synaptics touchpad by special commands 197 */ 198 static int synaptics_send_cmd(struct psmouse *psmouse, u8 cmd, u8 *param) 199 { 200 int error; 201 202 error = ps2_sliced_command(&psmouse->ps2dev, cmd); 203 if (error) 204 return error; 205 206 error = ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO); 207 if (error) 208 return error; 209 210 return 0; 211 } 212 213 static int synaptics_query_int(struct psmouse *psmouse, u8 query_cmd, u32 *val) 214 { 215 int error; 216 union { 217 __be32 be_val; 218 char buf[4]; 219 } resp = { 0 }; 220 221 error = synaptics_send_cmd(psmouse, query_cmd, resp.buf + 1); 222 if (error) 223 return error; 224 225 *val = be32_to_cpu(resp.be_val); 226 return 0; 227 } 228 229 /* 230 * Identify Touchpad 231 * See also the SYN_ID_* macros 232 */ 233 static int synaptics_identify(struct psmouse *psmouse, 234 struct synaptics_device_info *info) 235 { 236 int error; 237 238 error = synaptics_query_int(psmouse, SYN_QUE_IDENTIFY, &info->identity); 239 if (error) 240 return error; 241 242 return SYN_ID_IS_SYNAPTICS(info->identity) ? 0 : -ENXIO; 243 } 244 245 /* 246 * Read the model-id bytes from the touchpad 247 * see also SYN_MODEL_* macros 248 */ 249 static int synaptics_model_id(struct psmouse *psmouse, 250 struct synaptics_device_info *info) 251 { 252 return synaptics_query_int(psmouse, SYN_QUE_MODEL, &info->model_id); 253 } 254 255 /* 256 * Read the firmware id from the touchpad 257 */ 258 static int synaptics_firmware_id(struct psmouse *psmouse, 259 struct synaptics_device_info *info) 260 { 261 return synaptics_query_int(psmouse, SYN_QUE_FIRMWARE_ID, 262 &info->firmware_id); 263 } 264 265 /* 266 * Read the board id and the "More Extended Queries" from the touchpad 267 * The board id is encoded in the "QUERY MODES" response 268 */ 269 static int synaptics_query_modes(struct psmouse *psmouse, 270 struct synaptics_device_info *info) 271 { 272 u8 bid[3]; 273 int error; 274 275 /* firmwares prior 7.5 have no board_id encoded */ 276 if (SYN_ID_FULL(info->identity) < 0x705) 277 return 0; 278 279 error = synaptics_send_cmd(psmouse, SYN_QUE_MODES, bid); 280 if (error) 281 return error; 282 283 info->board_id = ((bid[0] & 0xfc) << 6) | bid[1]; 284 285 if (SYN_MEXT_CAP_BIT(bid[0])) 286 return synaptics_query_int(psmouse, SYN_QUE_MEXT_CAPAB_10, 287 &info->ext_cap_10); 288 289 return 0; 290 } 291 292 /* 293 * Read the capability-bits from the touchpad 294 * see also the SYN_CAP_* macros 295 */ 296 static int synaptics_capability(struct psmouse *psmouse, 297 struct synaptics_device_info *info) 298 { 299 int error; 300 301 error = synaptics_query_int(psmouse, SYN_QUE_CAPABILITIES, 302 &info->capabilities); 303 if (error) 304 return error; 305 306 info->ext_cap = info->ext_cap_0c = 0; 307 308 /* 309 * Older firmwares had submodel ID fixed to 0x47 310 */ 311 if (SYN_ID_FULL(info->identity) < 0x705 && 312 SYN_CAP_SUBMODEL_ID(info->capabilities) != 0x47) { 313 return -ENXIO; 314 } 315 316 /* 317 * Unless capExtended is set the rest of the flags should be ignored 318 */ 319 if (!SYN_CAP_EXTENDED(info->capabilities)) 320 info->capabilities = 0; 321 322 if (SYN_EXT_CAP_REQUESTS(info->capabilities) >= 1) { 323 error = synaptics_query_int(psmouse, SYN_QUE_EXT_CAPAB, 324 &info->ext_cap); 325 if (error) { 326 psmouse_warn(psmouse, 327 "device claims to have extended capabilities, but I'm not able to read them.\n"); 328 } else { 329 /* 330 * if nExtBtn is greater than 8 it should be considered 331 * invalid and treated as 0 332 */ 333 if (SYN_CAP_MULTI_BUTTON_NO(info->ext_cap) > 8) 334 info->ext_cap &= ~SYN_CAP_MB_MASK; 335 } 336 } 337 338 if (SYN_EXT_CAP_REQUESTS(info->capabilities) >= 4) { 339 error = synaptics_query_int(psmouse, SYN_QUE_EXT_CAPAB_0C, 340 &info->ext_cap_0c); 341 if (error) 342 psmouse_warn(psmouse, 343 "device claims to have extended capability 0x0c, but I'm not able to read it.\n"); 344 } 345 346 return 0; 347 } 348 349 /* 350 * Read touchpad resolution and maximum reported coordinates 351 * Resolution is left zero if touchpad does not support the query 352 */ 353 static int synaptics_resolution(struct psmouse *psmouse, 354 struct synaptics_device_info *info) 355 { 356 u8 resp[3]; 357 int error; 358 359 if (SYN_ID_MAJOR(info->identity) < 4) 360 return 0; 361 362 error = synaptics_send_cmd(psmouse, SYN_QUE_RESOLUTION, resp); 363 if (!error) { 364 if (resp[0] != 0 && (resp[1] & 0x80) && resp[2] != 0) { 365 info->x_res = resp[0]; /* x resolution in units/mm */ 366 info->y_res = resp[2]; /* y resolution in units/mm */ 367 } 368 } 369 370 if (SYN_EXT_CAP_REQUESTS(info->capabilities) >= 5 && 371 SYN_CAP_MAX_DIMENSIONS(info->ext_cap_0c)) { 372 error = synaptics_send_cmd(psmouse, 373 SYN_QUE_EXT_MAX_COORDS, resp); 374 if (error) { 375 psmouse_warn(psmouse, 376 "device claims to have max coordinates query, but I'm not able to read it.\n"); 377 } else { 378 info->x_max = (resp[0] << 5) | ((resp[1] & 0x0f) << 1); 379 info->y_max = (resp[2] << 5) | ((resp[1] & 0xf0) >> 3); 380 psmouse_info(psmouse, 381 "queried max coordinates: x [..%d], y [..%d]\n", 382 info->x_max, info->y_max); 383 } 384 } 385 386 if (SYN_CAP_MIN_DIMENSIONS(info->ext_cap_0c) && 387 (SYN_EXT_CAP_REQUESTS(info->capabilities) >= 7 || 388 /* 389 * Firmware v8.1 does not report proper number of extended 390 * capabilities, but has been proven to report correct min 391 * coordinates. 392 */ 393 SYN_ID_FULL(info->identity) == 0x801)) { 394 error = synaptics_send_cmd(psmouse, 395 SYN_QUE_EXT_MIN_COORDS, resp); 396 if (error) { 397 psmouse_warn(psmouse, 398 "device claims to have min coordinates query, but I'm not able to read it.\n"); 399 } else { 400 info->x_min = (resp[0] << 5) | ((resp[1] & 0x0f) << 1); 401 info->y_min = (resp[2] << 5) | ((resp[1] & 0xf0) >> 3); 402 psmouse_info(psmouse, 403 "queried min coordinates: x [%d..], y [%d..]\n", 404 info->x_min, info->y_min); 405 } 406 } 407 408 return 0; 409 } 410 411 static int synaptics_query_hardware(struct psmouse *psmouse, 412 struct synaptics_device_info *info) 413 { 414 int error; 415 416 memset(info, 0, sizeof(*info)); 417 418 error = synaptics_identify(psmouse, info); 419 if (error) 420 return error; 421 422 error = synaptics_model_id(psmouse, info); 423 if (error) 424 return error; 425 426 error = synaptics_firmware_id(psmouse, info); 427 if (error) 428 return error; 429 430 error = synaptics_query_modes(psmouse, info); 431 if (error) 432 return error; 433 434 error = synaptics_capability(psmouse, info); 435 if (error) 436 return error; 437 438 error = synaptics_resolution(psmouse, info); 439 if (error) 440 return error; 441 442 return 0; 443 } 444 445 #endif /* CONFIG_MOUSE_PS2_SYNAPTICS || CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */ 446 447 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS 448 449 static bool cr48_profile_sensor; 450 451 #define ANY_BOARD_ID 0 452 struct min_max_quirk { 453 const char * const *pnp_ids; 454 struct { 455 u32 min, max; 456 } board_id; 457 u32 x_min, x_max, y_min, y_max; 458 }; 459 460 static const struct min_max_quirk min_max_pnpid_table[] = { 461 { 462 (const char * const []){"LEN0033", NULL}, 463 {ANY_BOARD_ID, ANY_BOARD_ID}, 464 1024, 5052, 2258, 4832 465 }, 466 { 467 (const char * const []){"LEN0042", NULL}, 468 {ANY_BOARD_ID, ANY_BOARD_ID}, 469 1232, 5710, 1156, 4696 470 }, 471 { 472 (const char * const []){"LEN0034", "LEN0036", "LEN0037", 473 "LEN0039", "LEN2002", "LEN2004", 474 NULL}, 475 {ANY_BOARD_ID, 2961}, 476 1024, 5112, 2024, 4832 477 }, 478 { 479 (const char * const []){"LEN2000", NULL}, 480 {ANY_BOARD_ID, ANY_BOARD_ID}, 481 1024, 5113, 2021, 4832 482 }, 483 { 484 (const char * const []){"LEN2001", NULL}, 485 {ANY_BOARD_ID, ANY_BOARD_ID}, 486 1024, 5022, 2508, 4832 487 }, 488 { 489 (const char * const []){"LEN2006", NULL}, 490 {2691, 2691}, 491 1024, 5045, 2457, 4832 492 }, 493 { 494 (const char * const []){"LEN2006", NULL}, 495 {ANY_BOARD_ID, ANY_BOARD_ID}, 496 1264, 5675, 1171, 4688 497 }, 498 { } 499 }; 500 501 /***************************************************************************** 502 * Synaptics communications functions 503 ****************************************************************************/ 504 505 /* 506 * Synaptics touchpads report the y coordinate from bottom to top, which is 507 * opposite from what userspace expects. 508 * This function is used to invert y before reporting. 509 */ 510 static int synaptics_invert_y(int y) 511 { 512 return YMAX_NOMINAL + YMIN_NOMINAL - y; 513 } 514 515 /* 516 * Apply quirk(s) if the hardware matches 517 */ 518 static void synaptics_apply_quirks(struct psmouse *psmouse, 519 struct synaptics_device_info *info) 520 { 521 int i; 522 523 for (i = 0; min_max_pnpid_table[i].pnp_ids; i++) { 524 if (!psmouse_matches_pnp_id(psmouse, 525 min_max_pnpid_table[i].pnp_ids)) 526 continue; 527 528 if (min_max_pnpid_table[i].board_id.min != ANY_BOARD_ID && 529 info->board_id < min_max_pnpid_table[i].board_id.min) 530 continue; 531 532 if (min_max_pnpid_table[i].board_id.max != ANY_BOARD_ID && 533 info->board_id > min_max_pnpid_table[i].board_id.max) 534 continue; 535 536 info->x_min = min_max_pnpid_table[i].x_min; 537 info->x_max = min_max_pnpid_table[i].x_max; 538 info->y_min = min_max_pnpid_table[i].y_min; 539 info->y_max = min_max_pnpid_table[i].y_max; 540 psmouse_info(psmouse, 541 "quirked min/max coordinates: x [%d..%d], y [%d..%d]\n", 542 info->x_min, info->x_max, 543 info->y_min, info->y_max); 544 break; 545 } 546 } 547 548 static bool synaptics_has_agm(struct synaptics_data *priv) 549 { 550 return (SYN_CAP_ADV_GESTURE(priv->info.ext_cap_0c) || 551 SYN_CAP_IMAGE_SENSOR(priv->info.ext_cap_0c)); 552 } 553 554 static int synaptics_set_advanced_gesture_mode(struct psmouse *psmouse) 555 { 556 static u8 param = 0xc8; 557 int error; 558 559 error = ps2_sliced_command(&psmouse->ps2dev, SYN_QUE_MODEL); 560 if (error) 561 return error; 562 563 error = ps2_command(&psmouse->ps2dev, ¶m, PSMOUSE_CMD_SETRATE); 564 if (error) 565 return error; 566 567 return 0; 568 } 569 570 static int synaptics_set_mode(struct psmouse *psmouse) 571 { 572 struct synaptics_data *priv = psmouse->private; 573 int error; 574 575 priv->mode = 0; 576 if (priv->absolute_mode) 577 priv->mode |= SYN_BIT_ABSOLUTE_MODE; 578 if (priv->disable_gesture) 579 priv->mode |= SYN_BIT_DISABLE_GESTURE; 580 if (psmouse->rate >= 80) 581 priv->mode |= SYN_BIT_HIGH_RATE; 582 if (SYN_CAP_EXTENDED(priv->info.capabilities)) 583 priv->mode |= SYN_BIT_W_MODE; 584 585 error = synaptics_mode_cmd(psmouse, priv->mode); 586 if (error) 587 return error; 588 589 if (priv->absolute_mode && synaptics_has_agm(priv)) { 590 error = synaptics_set_advanced_gesture_mode(psmouse); 591 if (error) { 592 psmouse_err(psmouse, 593 "Advanced gesture mode init failed: %d\n", 594 error); 595 return error; 596 } 597 } 598 599 return 0; 600 } 601 602 static void synaptics_set_rate(struct psmouse *psmouse, unsigned int rate) 603 { 604 struct synaptics_data *priv = psmouse->private; 605 606 if (rate >= 80) { 607 priv->mode |= SYN_BIT_HIGH_RATE; 608 psmouse->rate = 80; 609 } else { 610 priv->mode &= ~SYN_BIT_HIGH_RATE; 611 psmouse->rate = 40; 612 } 613 614 synaptics_mode_cmd(psmouse, priv->mode); 615 } 616 617 /***************************************************************************** 618 * Synaptics pass-through PS/2 port support 619 ****************************************************************************/ 620 static int synaptics_pt_write(struct serio *serio, u8 c) 621 { 622 struct psmouse *parent = serio_get_drvdata(serio->parent); 623 u8 rate_param = SYN_PS_CLIENT_CMD; /* indicates that we want pass-through port */ 624 int error; 625 626 error = ps2_sliced_command(&parent->ps2dev, c); 627 if (error) 628 return error; 629 630 error = ps2_command(&parent->ps2dev, &rate_param, PSMOUSE_CMD_SETRATE); 631 if (error) 632 return error; 633 634 return 0; 635 } 636 637 static int synaptics_pt_start(struct serio *serio) 638 { 639 struct psmouse *parent = serio_get_drvdata(serio->parent); 640 struct synaptics_data *priv = parent->private; 641 642 serio_pause_rx(parent->ps2dev.serio); 643 priv->pt_port = serio; 644 serio_continue_rx(parent->ps2dev.serio); 645 646 return 0; 647 } 648 649 static void synaptics_pt_stop(struct serio *serio) 650 { 651 struct psmouse *parent = serio_get_drvdata(serio->parent); 652 struct synaptics_data *priv = parent->private; 653 654 serio_pause_rx(parent->ps2dev.serio); 655 priv->pt_port = NULL; 656 serio_continue_rx(parent->ps2dev.serio); 657 } 658 659 static int synaptics_is_pt_packet(u8 *buf) 660 { 661 return (buf[0] & 0xFC) == 0x84 && (buf[3] & 0xCC) == 0xC4; 662 } 663 664 static void synaptics_pass_pt_packet(struct serio *ptport, u8 *packet) 665 { 666 struct psmouse *child = serio_get_drvdata(ptport); 667 668 if (child && child->state == PSMOUSE_ACTIVATED) { 669 serio_interrupt(ptport, packet[1], 0); 670 serio_interrupt(ptport, packet[4], 0); 671 serio_interrupt(ptport, packet[5], 0); 672 if (child->pktsize == 4) 673 serio_interrupt(ptport, packet[2], 0); 674 } else { 675 serio_interrupt(ptport, packet[1], 0); 676 } 677 } 678 679 static void synaptics_pt_activate(struct psmouse *psmouse) 680 { 681 struct synaptics_data *priv = psmouse->private; 682 struct psmouse *child = serio_get_drvdata(priv->pt_port); 683 684 /* adjust the touchpad to child's choice of protocol */ 685 if (child) { 686 if (child->pktsize == 4) 687 priv->mode |= SYN_BIT_FOUR_BYTE_CLIENT; 688 else 689 priv->mode &= ~SYN_BIT_FOUR_BYTE_CLIENT; 690 691 if (synaptics_mode_cmd(psmouse, priv->mode)) 692 psmouse_warn(psmouse, 693 "failed to switch guest protocol\n"); 694 } 695 } 696 697 static void synaptics_pt_create(struct psmouse *psmouse) 698 { 699 struct serio *serio; 700 701 serio = kzalloc(sizeof(struct serio), GFP_KERNEL); 702 if (!serio) { 703 psmouse_err(psmouse, 704 "not enough memory for pass-through port\n"); 705 return; 706 } 707 708 serio->id.type = SERIO_PS_PSTHRU; 709 strlcpy(serio->name, "Synaptics pass-through", sizeof(serio->name)); 710 strlcpy(serio->phys, "synaptics-pt/serio0", sizeof(serio->phys)); 711 serio->write = synaptics_pt_write; 712 serio->start = synaptics_pt_start; 713 serio->stop = synaptics_pt_stop; 714 serio->parent = psmouse->ps2dev.serio; 715 716 psmouse->pt_activate = synaptics_pt_activate; 717 718 psmouse_info(psmouse, "serio: %s port at %s\n", 719 serio->name, psmouse->phys); 720 serio_register_port(serio); 721 } 722 723 /***************************************************************************** 724 * Functions to interpret the absolute mode packets 725 ****************************************************************************/ 726 727 static void synaptics_parse_agm(const u8 buf[], 728 struct synaptics_data *priv, 729 struct synaptics_hw_state *hw) 730 { 731 struct synaptics_hw_state *agm = &priv->agm; 732 int agm_packet_type; 733 734 agm_packet_type = (buf[5] & 0x30) >> 4; 735 switch (agm_packet_type) { 736 case 1: 737 /* Gesture packet: (x, y, z) half resolution */ 738 agm->w = hw->w; 739 agm->x = (((buf[4] & 0x0f) << 8) | buf[1]) << 1; 740 agm->y = (((buf[4] & 0xf0) << 4) | buf[2]) << 1; 741 agm->z = ((buf[3] & 0x30) | (buf[5] & 0x0f)) << 1; 742 break; 743 744 case 2: 745 /* AGM-CONTACT packet: we are only interested in the count */ 746 priv->agm_count = buf[1]; 747 break; 748 749 default: 750 break; 751 } 752 } 753 754 static void synaptics_parse_ext_buttons(const u8 buf[], 755 struct synaptics_data *priv, 756 struct synaptics_hw_state *hw) 757 { 758 unsigned int ext_bits = 759 (SYN_CAP_MULTI_BUTTON_NO(priv->info.ext_cap) + 1) >> 1; 760 unsigned int ext_mask = GENMASK(ext_bits - 1, 0); 761 762 hw->ext_buttons = buf[4] & ext_mask; 763 hw->ext_buttons |= (buf[5] & ext_mask) << ext_bits; 764 } 765 766 static int synaptics_parse_hw_state(const u8 buf[], 767 struct synaptics_data *priv, 768 struct synaptics_hw_state *hw) 769 { 770 memset(hw, 0, sizeof(struct synaptics_hw_state)); 771 772 if (SYN_MODEL_NEWABS(priv->info.model_id)) { 773 hw->w = (((buf[0] & 0x30) >> 2) | 774 ((buf[0] & 0x04) >> 1) | 775 ((buf[3] & 0x04) >> 2)); 776 777 if (synaptics_has_agm(priv) && hw->w == 2) { 778 synaptics_parse_agm(buf, priv, hw); 779 return 1; 780 } 781 782 hw->x = (((buf[3] & 0x10) << 8) | 783 ((buf[1] & 0x0f) << 8) | 784 buf[4]); 785 hw->y = (((buf[3] & 0x20) << 7) | 786 ((buf[1] & 0xf0) << 4) | 787 buf[5]); 788 hw->z = buf[2]; 789 790 hw->left = (buf[0] & 0x01) ? 1 : 0; 791 hw->right = (buf[0] & 0x02) ? 1 : 0; 792 793 if (priv->is_forcepad) { 794 /* 795 * ForcePads, like Clickpads, use middle button 796 * bits to report primary button clicks. 797 * Unfortunately they report primary button not 798 * only when user presses on the pad above certain 799 * threshold, but also when there are more than one 800 * finger on the touchpad, which interferes with 801 * out multi-finger gestures. 802 */ 803 if (hw->z == 0) { 804 /* No contacts */ 805 priv->press = priv->report_press = false; 806 } else if (hw->w >= 4 && ((buf[0] ^ buf[3]) & 0x01)) { 807 /* 808 * Single-finger touch with pressure above 809 * the threshold. If pressure stays long 810 * enough, we'll start reporting primary 811 * button. We rely on the device continuing 812 * sending data even if finger does not 813 * move. 814 */ 815 if (!priv->press) { 816 priv->press_start = jiffies; 817 priv->press = true; 818 } else if (time_after(jiffies, 819 priv->press_start + 820 msecs_to_jiffies(50))) { 821 priv->report_press = true; 822 } 823 } else { 824 priv->press = false; 825 } 826 827 hw->left = priv->report_press; 828 829 } else if (SYN_CAP_CLICKPAD(priv->info.ext_cap_0c)) { 830 /* 831 * Clickpad's button is transmitted as middle button, 832 * however, since it is primary button, we will report 833 * it as BTN_LEFT. 834 */ 835 hw->left = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0; 836 837 } else if (SYN_CAP_MIDDLE_BUTTON(priv->info.capabilities)) { 838 hw->middle = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0; 839 if (hw->w == 2) 840 hw->scroll = (s8)buf[1]; 841 } 842 843 if (SYN_CAP_FOUR_BUTTON(priv->info.capabilities)) { 844 hw->up = ((buf[0] ^ buf[3]) & 0x01) ? 1 : 0; 845 hw->down = ((buf[0] ^ buf[3]) & 0x02) ? 1 : 0; 846 } 847 848 if (SYN_CAP_MULTI_BUTTON_NO(priv->info.ext_cap) > 0 && 849 ((buf[0] ^ buf[3]) & 0x02)) { 850 synaptics_parse_ext_buttons(buf, priv, hw); 851 } 852 } else { 853 hw->x = (((buf[1] & 0x1f) << 8) | buf[2]); 854 hw->y = (((buf[4] & 0x1f) << 8) | buf[5]); 855 856 hw->z = (((buf[0] & 0x30) << 2) | (buf[3] & 0x3F)); 857 hw->w = (((buf[1] & 0x80) >> 4) | ((buf[0] & 0x04) >> 1)); 858 859 hw->left = (buf[0] & 0x01) ? 1 : 0; 860 hw->right = (buf[0] & 0x02) ? 1 : 0; 861 } 862 863 /* 864 * Convert wrap-around values to negative. (X|Y)_MAX_POSITIVE 865 * is used by some firmware to indicate a finger at the edge of 866 * the touchpad whose precise position cannot be determined, so 867 * convert these values to the maximum axis value. 868 */ 869 if (hw->x > X_MAX_POSITIVE) 870 hw->x -= 1 << ABS_POS_BITS; 871 else if (hw->x == X_MAX_POSITIVE) 872 hw->x = XMAX; 873 874 if (hw->y > Y_MAX_POSITIVE) 875 hw->y -= 1 << ABS_POS_BITS; 876 else if (hw->y == Y_MAX_POSITIVE) 877 hw->y = YMAX; 878 879 return 0; 880 } 881 882 static void synaptics_report_semi_mt_slot(struct input_dev *dev, int slot, 883 bool active, int x, int y) 884 { 885 input_mt_slot(dev, slot); 886 input_mt_report_slot_state(dev, MT_TOOL_FINGER, active); 887 if (active) { 888 input_report_abs(dev, ABS_MT_POSITION_X, x); 889 input_report_abs(dev, ABS_MT_POSITION_Y, synaptics_invert_y(y)); 890 } 891 } 892 893 static void synaptics_report_semi_mt_data(struct input_dev *dev, 894 const struct synaptics_hw_state *a, 895 const struct synaptics_hw_state *b, 896 int num_fingers) 897 { 898 if (num_fingers >= 2) { 899 synaptics_report_semi_mt_slot(dev, 0, true, min(a->x, b->x), 900 min(a->y, b->y)); 901 synaptics_report_semi_mt_slot(dev, 1, true, max(a->x, b->x), 902 max(a->y, b->y)); 903 } else if (num_fingers == 1) { 904 synaptics_report_semi_mt_slot(dev, 0, true, a->x, a->y); 905 synaptics_report_semi_mt_slot(dev, 1, false, 0, 0); 906 } else { 907 synaptics_report_semi_mt_slot(dev, 0, false, 0, 0); 908 synaptics_report_semi_mt_slot(dev, 1, false, 0, 0); 909 } 910 } 911 912 static void synaptics_report_ext_buttons(struct psmouse *psmouse, 913 const struct synaptics_hw_state *hw) 914 { 915 struct input_dev *dev = psmouse->dev; 916 struct synaptics_data *priv = psmouse->private; 917 int ext_bits = (SYN_CAP_MULTI_BUTTON_NO(priv->info.ext_cap) + 1) >> 1; 918 int i; 919 920 if (!SYN_CAP_MULTI_BUTTON_NO(priv->info.ext_cap)) 921 return; 922 923 /* Bug in FW 8.1 & 8.2, buttons are reported only when ExtBit is 1 */ 924 if ((SYN_ID_FULL(priv->info.identity) == 0x801 || 925 SYN_ID_FULL(priv->info.identity) == 0x802) && 926 !((psmouse->packet[0] ^ psmouse->packet[3]) & 0x02)) 927 return; 928 929 if (!SYN_CAP_EXT_BUTTONS_STICK(priv->info.ext_cap_10)) { 930 for (i = 0; i < ext_bits; i++) { 931 input_report_key(dev, BTN_0 + 2 * i, 932 hw->ext_buttons & BIT(i)); 933 input_report_key(dev, BTN_1 + 2 * i, 934 hw->ext_buttons & BIT(i + ext_bits)); 935 } 936 return; 937 } 938 939 /* 940 * This generation of touchpads has the trackstick buttons 941 * physically wired to the touchpad. Re-route them through 942 * the pass-through interface. 943 */ 944 if (priv->pt_port) { 945 u8 pt_buttons; 946 947 /* The trackstick expects at most 3 buttons */ 948 pt_buttons = SYN_EXT_BUTTON_STICK_L(hw->ext_buttons) | 949 SYN_EXT_BUTTON_STICK_R(hw->ext_buttons) << 1 | 950 SYN_EXT_BUTTON_STICK_M(hw->ext_buttons) << 2; 951 952 serio_interrupt(priv->pt_port, 953 PSMOUSE_OOB_EXTRA_BTNS, SERIO_OOB_DATA); 954 serio_interrupt(priv->pt_port, pt_buttons, SERIO_OOB_DATA); 955 } 956 } 957 958 static void synaptics_report_buttons(struct psmouse *psmouse, 959 const struct synaptics_hw_state *hw) 960 { 961 struct input_dev *dev = psmouse->dev; 962 struct synaptics_data *priv = psmouse->private; 963 964 input_report_key(dev, BTN_LEFT, hw->left); 965 input_report_key(dev, BTN_RIGHT, hw->right); 966 967 if (SYN_CAP_MIDDLE_BUTTON(priv->info.capabilities)) 968 input_report_key(dev, BTN_MIDDLE, hw->middle); 969 970 if (SYN_CAP_FOUR_BUTTON(priv->info.capabilities)) { 971 input_report_key(dev, BTN_FORWARD, hw->up); 972 input_report_key(dev, BTN_BACK, hw->down); 973 } 974 975 synaptics_report_ext_buttons(psmouse, hw); 976 } 977 978 static void synaptics_report_mt_data(struct psmouse *psmouse, 979 const struct synaptics_hw_state *sgm, 980 int num_fingers) 981 { 982 struct input_dev *dev = psmouse->dev; 983 struct synaptics_data *priv = psmouse->private; 984 const struct synaptics_hw_state *hw[2] = { sgm, &priv->agm }; 985 struct input_mt_pos pos[2]; 986 int slot[2], nsemi, i; 987 988 nsemi = clamp_val(num_fingers, 0, 2); 989 990 for (i = 0; i < nsemi; i++) { 991 pos[i].x = hw[i]->x; 992 pos[i].y = synaptics_invert_y(hw[i]->y); 993 } 994 995 input_mt_assign_slots(dev, slot, pos, nsemi, DMAX * priv->info.x_res); 996 997 for (i = 0; i < nsemi; i++) { 998 input_mt_slot(dev, slot[i]); 999 input_mt_report_slot_state(dev, MT_TOOL_FINGER, true); 1000 input_report_abs(dev, ABS_MT_POSITION_X, pos[i].x); 1001 input_report_abs(dev, ABS_MT_POSITION_Y, pos[i].y); 1002 input_report_abs(dev, ABS_MT_PRESSURE, hw[i]->z); 1003 } 1004 1005 input_mt_drop_unused(dev); 1006 1007 /* Don't use active slot count to generate BTN_TOOL events. */ 1008 input_mt_report_pointer_emulation(dev, false); 1009 1010 /* Send the number of fingers reported by touchpad itself. */ 1011 input_mt_report_finger_count(dev, num_fingers); 1012 1013 synaptics_report_buttons(psmouse, sgm); 1014 1015 input_sync(dev); 1016 } 1017 1018 static void synaptics_image_sensor_process(struct psmouse *psmouse, 1019 struct synaptics_hw_state *sgm) 1020 { 1021 struct synaptics_data *priv = psmouse->private; 1022 int num_fingers; 1023 1024 /* 1025 * Update mt_state using the new finger count and current mt_state. 1026 */ 1027 if (sgm->z == 0) 1028 num_fingers = 0; 1029 else if (sgm->w >= 4) 1030 num_fingers = 1; 1031 else if (sgm->w == 0) 1032 num_fingers = 2; 1033 else if (sgm->w == 1) 1034 num_fingers = priv->agm_count ? priv->agm_count : 3; 1035 else 1036 num_fingers = 4; 1037 1038 /* Send resulting input events to user space */ 1039 synaptics_report_mt_data(psmouse, sgm, num_fingers); 1040 } 1041 1042 static bool synaptics_has_multifinger(struct synaptics_data *priv) 1043 { 1044 if (SYN_CAP_MULTIFINGER(priv->info.capabilities)) 1045 return true; 1046 1047 /* Advanced gesture mode also sends multi finger data */ 1048 return synaptics_has_agm(priv); 1049 } 1050 1051 /* 1052 * called for each full received packet from the touchpad 1053 */ 1054 static void synaptics_process_packet(struct psmouse *psmouse) 1055 { 1056 struct input_dev *dev = psmouse->dev; 1057 struct synaptics_data *priv = psmouse->private; 1058 struct synaptics_device_info *info = &priv->info; 1059 struct synaptics_hw_state hw; 1060 int num_fingers; 1061 int finger_width; 1062 1063 if (synaptics_parse_hw_state(psmouse->packet, priv, &hw)) 1064 return; 1065 1066 if (SYN_CAP_IMAGE_SENSOR(info->ext_cap_0c)) { 1067 synaptics_image_sensor_process(psmouse, &hw); 1068 return; 1069 } 1070 1071 if (hw.scroll) { 1072 priv->scroll += hw.scroll; 1073 1074 while (priv->scroll >= 4) { 1075 input_report_key(dev, BTN_BACK, !hw.down); 1076 input_sync(dev); 1077 input_report_key(dev, BTN_BACK, hw.down); 1078 input_sync(dev); 1079 priv->scroll -= 4; 1080 } 1081 while (priv->scroll <= -4) { 1082 input_report_key(dev, BTN_FORWARD, !hw.up); 1083 input_sync(dev); 1084 input_report_key(dev, BTN_FORWARD, hw.up); 1085 input_sync(dev); 1086 priv->scroll += 4; 1087 } 1088 return; 1089 } 1090 1091 if (hw.z > 0 && hw.x > 1) { 1092 num_fingers = 1; 1093 finger_width = 5; 1094 if (SYN_CAP_EXTENDED(info->capabilities)) { 1095 switch (hw.w) { 1096 case 0 ... 1: 1097 if (synaptics_has_multifinger(priv)) 1098 num_fingers = hw.w + 2; 1099 break; 1100 case 2: 1101 if (SYN_MODEL_PEN(info->model_id)) 1102 ; /* Nothing, treat a pen as a single finger */ 1103 break; 1104 case 4 ... 15: 1105 if (SYN_CAP_PALMDETECT(info->capabilities)) 1106 finger_width = hw.w; 1107 break; 1108 } 1109 } 1110 } else { 1111 num_fingers = 0; 1112 finger_width = 0; 1113 } 1114 1115 if (cr48_profile_sensor) { 1116 synaptics_report_mt_data(psmouse, &hw, num_fingers); 1117 return; 1118 } 1119 1120 if (SYN_CAP_ADV_GESTURE(info->ext_cap_0c)) 1121 synaptics_report_semi_mt_data(dev, &hw, &priv->agm, 1122 num_fingers); 1123 1124 /* Post events 1125 * BTN_TOUCH has to be first as mousedev relies on it when doing 1126 * absolute -> relative conversion 1127 */ 1128 if (hw.z > 30) input_report_key(dev, BTN_TOUCH, 1); 1129 if (hw.z < 25) input_report_key(dev, BTN_TOUCH, 0); 1130 1131 if (num_fingers > 0) { 1132 input_report_abs(dev, ABS_X, hw.x); 1133 input_report_abs(dev, ABS_Y, synaptics_invert_y(hw.y)); 1134 } 1135 input_report_abs(dev, ABS_PRESSURE, hw.z); 1136 1137 if (SYN_CAP_PALMDETECT(info->capabilities)) 1138 input_report_abs(dev, ABS_TOOL_WIDTH, finger_width); 1139 1140 input_report_key(dev, BTN_TOOL_FINGER, num_fingers == 1); 1141 if (synaptics_has_multifinger(priv)) { 1142 input_report_key(dev, BTN_TOOL_DOUBLETAP, num_fingers == 2); 1143 input_report_key(dev, BTN_TOOL_TRIPLETAP, num_fingers == 3); 1144 } 1145 1146 synaptics_report_buttons(psmouse, &hw); 1147 1148 input_sync(dev); 1149 } 1150 1151 static bool synaptics_validate_byte(struct psmouse *psmouse, 1152 int idx, enum synaptics_pkt_type pkt_type) 1153 { 1154 static const u8 newabs_mask[] = { 0xC8, 0x00, 0x00, 0xC8, 0x00 }; 1155 static const u8 newabs_rel_mask[] = { 0xC0, 0x00, 0x00, 0xC0, 0x00 }; 1156 static const u8 newabs_rslt[] = { 0x80, 0x00, 0x00, 0xC0, 0x00 }; 1157 static const u8 oldabs_mask[] = { 0xC0, 0x60, 0x00, 0xC0, 0x60 }; 1158 static const u8 oldabs_rslt[] = { 0xC0, 0x00, 0x00, 0x80, 0x00 }; 1159 const u8 *packet = psmouse->packet; 1160 1161 if (idx < 0 || idx > 4) 1162 return false; 1163 1164 switch (pkt_type) { 1165 1166 case SYN_NEWABS: 1167 case SYN_NEWABS_RELAXED: 1168 return (packet[idx] & newabs_rel_mask[idx]) == newabs_rslt[idx]; 1169 1170 case SYN_NEWABS_STRICT: 1171 return (packet[idx] & newabs_mask[idx]) == newabs_rslt[idx]; 1172 1173 case SYN_OLDABS: 1174 return (packet[idx] & oldabs_mask[idx]) == oldabs_rslt[idx]; 1175 1176 default: 1177 psmouse_err(psmouse, "unknown packet type %d\n", pkt_type); 1178 return false; 1179 } 1180 } 1181 1182 static enum synaptics_pkt_type 1183 synaptics_detect_pkt_type(struct psmouse *psmouse) 1184 { 1185 int i; 1186 1187 for (i = 0; i < 5; i++) { 1188 if (!synaptics_validate_byte(psmouse, i, SYN_NEWABS_STRICT)) { 1189 psmouse_info(psmouse, "using relaxed packet validation\n"); 1190 return SYN_NEWABS_RELAXED; 1191 } 1192 } 1193 1194 return SYN_NEWABS_STRICT; 1195 } 1196 1197 static psmouse_ret_t synaptics_process_byte(struct psmouse *psmouse) 1198 { 1199 struct synaptics_data *priv = psmouse->private; 1200 1201 if (psmouse->pktcnt >= 6) { /* Full packet received */ 1202 if (unlikely(priv->pkt_type == SYN_NEWABS)) 1203 priv->pkt_type = synaptics_detect_pkt_type(psmouse); 1204 1205 if (SYN_CAP_PASS_THROUGH(priv->info.capabilities) && 1206 synaptics_is_pt_packet(psmouse->packet)) { 1207 if (priv->pt_port) 1208 synaptics_pass_pt_packet(priv->pt_port, 1209 psmouse->packet); 1210 } else 1211 synaptics_process_packet(psmouse); 1212 1213 return PSMOUSE_FULL_PACKET; 1214 } 1215 1216 return synaptics_validate_byte(psmouse, psmouse->pktcnt - 1, priv->pkt_type) ? 1217 PSMOUSE_GOOD_DATA : PSMOUSE_BAD_DATA; 1218 } 1219 1220 /***************************************************************************** 1221 * Driver initialization/cleanup functions 1222 ****************************************************************************/ 1223 static void set_abs_position_params(struct input_dev *dev, 1224 struct synaptics_device_info *info, 1225 int x_code, int y_code) 1226 { 1227 int x_min = info->x_min ?: XMIN_NOMINAL; 1228 int x_max = info->x_max ?: XMAX_NOMINAL; 1229 int y_min = info->y_min ?: YMIN_NOMINAL; 1230 int y_max = info->y_max ?: YMAX_NOMINAL; 1231 int fuzz = SYN_CAP_REDUCED_FILTERING(info->ext_cap_0c) ? 1232 SYN_REDUCED_FILTER_FUZZ : 0; 1233 1234 input_set_abs_params(dev, x_code, x_min, x_max, fuzz, 0); 1235 input_set_abs_params(dev, y_code, y_min, y_max, fuzz, 0); 1236 input_abs_set_res(dev, x_code, info->x_res); 1237 input_abs_set_res(dev, y_code, info->y_res); 1238 } 1239 1240 static int set_input_params(struct psmouse *psmouse, 1241 struct synaptics_data *priv) 1242 { 1243 struct input_dev *dev = psmouse->dev; 1244 struct synaptics_device_info *info = &priv->info; 1245 int i; 1246 int error; 1247 1248 /* Reset default psmouse capabilities */ 1249 __clear_bit(EV_REL, dev->evbit); 1250 bitmap_zero(dev->relbit, REL_CNT); 1251 bitmap_zero(dev->keybit, KEY_CNT); 1252 1253 /* Things that apply to both modes */ 1254 __set_bit(INPUT_PROP_POINTER, dev->propbit); 1255 1256 input_set_capability(dev, EV_KEY, BTN_LEFT); 1257 1258 /* Clickpads report only left button */ 1259 if (!SYN_CAP_CLICKPAD(info->ext_cap_0c)) { 1260 input_set_capability(dev, EV_KEY, BTN_RIGHT); 1261 if (SYN_CAP_MIDDLE_BUTTON(info->capabilities)) 1262 input_set_capability(dev, EV_KEY, BTN_MIDDLE); 1263 } 1264 1265 if (!priv->absolute_mode) { 1266 /* Relative mode */ 1267 input_set_capability(dev, EV_REL, REL_X); 1268 input_set_capability(dev, EV_REL, REL_Y); 1269 return 0; 1270 } 1271 1272 /* Absolute mode */ 1273 set_abs_position_params(dev, &priv->info, ABS_X, ABS_Y); 1274 input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0); 1275 1276 if (cr48_profile_sensor) 1277 input_set_abs_params(dev, ABS_MT_PRESSURE, 0, 255, 0, 0); 1278 1279 if (SYN_CAP_IMAGE_SENSOR(info->ext_cap_0c)) { 1280 set_abs_position_params(dev, info, 1281 ABS_MT_POSITION_X, ABS_MT_POSITION_Y); 1282 /* Image sensors can report per-contact pressure */ 1283 input_set_abs_params(dev, ABS_MT_PRESSURE, 0, 255, 0, 0); 1284 1285 error = input_mt_init_slots(dev, 2, 1286 INPUT_MT_POINTER | INPUT_MT_TRACK); 1287 if (error) 1288 return error; 1289 1290 /* Image sensors can signal 4 and 5 finger clicks */ 1291 input_set_capability(dev, EV_KEY, BTN_TOOL_QUADTAP); 1292 input_set_capability(dev, EV_KEY, BTN_TOOL_QUINTTAP); 1293 } else if (SYN_CAP_ADV_GESTURE(info->ext_cap_0c)) { 1294 set_abs_position_params(dev, info, 1295 ABS_MT_POSITION_X, ABS_MT_POSITION_Y); 1296 /* 1297 * Profile sensor in CR-48 tracks contacts reasonably well, 1298 * other non-image sensors with AGM use semi-mt. 1299 */ 1300 error = input_mt_init_slots(dev, 2, 1301 INPUT_MT_POINTER | 1302 (cr48_profile_sensor ? 1303 INPUT_MT_TRACK : 1304 INPUT_MT_SEMI_MT)); 1305 if (error) 1306 return error; 1307 1308 /* 1309 * For semi-mt devices we send ABS_X/Y ourselves instead of 1310 * input_mt_report_pointer_emulation. But 1311 * input_mt_init_slots() resets the fuzz to 0, leading to a 1312 * filtered ABS_MT_POSITION_X but an unfiltered ABS_X 1313 * position. Let's re-initialize ABS_X/Y here. 1314 */ 1315 if (!cr48_profile_sensor) 1316 set_abs_position_params(dev, &priv->info, ABS_X, ABS_Y); 1317 } 1318 1319 if (SYN_CAP_PALMDETECT(info->capabilities)) 1320 input_set_abs_params(dev, ABS_TOOL_WIDTH, 0, 15, 0, 0); 1321 1322 input_set_capability(dev, EV_KEY, BTN_TOUCH); 1323 input_set_capability(dev, EV_KEY, BTN_TOOL_FINGER); 1324 1325 if (synaptics_has_multifinger(priv)) { 1326 input_set_capability(dev, EV_KEY, BTN_TOOL_DOUBLETAP); 1327 input_set_capability(dev, EV_KEY, BTN_TOOL_TRIPLETAP); 1328 } 1329 1330 if (SYN_CAP_FOUR_BUTTON(info->capabilities) || 1331 SYN_CAP_MIDDLE_BUTTON(info->capabilities)) { 1332 input_set_capability(dev, EV_KEY, BTN_FORWARD); 1333 input_set_capability(dev, EV_KEY, BTN_BACK); 1334 } 1335 1336 if (!SYN_CAP_EXT_BUTTONS_STICK(info->ext_cap_10)) 1337 for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(info->ext_cap); i++) 1338 input_set_capability(dev, EV_KEY, BTN_0 + i); 1339 1340 if (SYN_CAP_CLICKPAD(info->ext_cap_0c)) { 1341 __set_bit(INPUT_PROP_BUTTONPAD, dev->propbit); 1342 if (psmouse_matches_pnp_id(psmouse, topbuttonpad_pnp_ids) && 1343 !SYN_CAP_EXT_BUTTONS_STICK(info->ext_cap_10)) 1344 __set_bit(INPUT_PROP_TOPBUTTONPAD, dev->propbit); 1345 } 1346 1347 return 0; 1348 } 1349 1350 static ssize_t synaptics_show_disable_gesture(struct psmouse *psmouse, 1351 void *data, char *buf) 1352 { 1353 struct synaptics_data *priv = psmouse->private; 1354 1355 return sprintf(buf, "%c\n", priv->disable_gesture ? '1' : '0'); 1356 } 1357 1358 static ssize_t synaptics_set_disable_gesture(struct psmouse *psmouse, 1359 void *data, const char *buf, 1360 size_t len) 1361 { 1362 struct synaptics_data *priv = psmouse->private; 1363 unsigned int value; 1364 int err; 1365 1366 err = kstrtouint(buf, 10, &value); 1367 if (err) 1368 return err; 1369 1370 if (value > 1) 1371 return -EINVAL; 1372 1373 if (value == priv->disable_gesture) 1374 return len; 1375 1376 priv->disable_gesture = value; 1377 if (value) 1378 priv->mode |= SYN_BIT_DISABLE_GESTURE; 1379 else 1380 priv->mode &= ~SYN_BIT_DISABLE_GESTURE; 1381 1382 if (synaptics_mode_cmd(psmouse, priv->mode)) 1383 return -EIO; 1384 1385 return len; 1386 } 1387 1388 PSMOUSE_DEFINE_ATTR(disable_gesture, S_IWUSR | S_IRUGO, NULL, 1389 synaptics_show_disable_gesture, 1390 synaptics_set_disable_gesture); 1391 1392 static void synaptics_disconnect(struct psmouse *psmouse) 1393 { 1394 struct synaptics_data *priv = psmouse->private; 1395 1396 /* 1397 * We might have left a breadcrumb when trying to 1398 * set up SMbus companion. 1399 */ 1400 psmouse_smbus_cleanup(psmouse); 1401 1402 if (!priv->absolute_mode && 1403 SYN_ID_DISGEST_SUPPORTED(priv->info.identity)) 1404 device_remove_file(&psmouse->ps2dev.serio->dev, 1405 &psmouse_attr_disable_gesture.dattr); 1406 1407 synaptics_reset(psmouse); 1408 kfree(priv); 1409 psmouse->private = NULL; 1410 } 1411 1412 static int synaptics_reconnect(struct psmouse *psmouse) 1413 { 1414 struct synaptics_data *priv = psmouse->private; 1415 struct synaptics_device_info info; 1416 u8 param[2]; 1417 int retry = 0; 1418 int error; 1419 1420 do { 1421 psmouse_reset(psmouse); 1422 if (retry) { 1423 /* 1424 * On some boxes, right after resuming, the touchpad 1425 * needs some time to finish initializing (I assume 1426 * it needs time to calibrate) and start responding 1427 * to Synaptics-specific queries, so let's wait a 1428 * bit. 1429 */ 1430 ssleep(1); 1431 } 1432 ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETID); 1433 error = synaptics_detect(psmouse, 0); 1434 } while (error && ++retry < 3); 1435 1436 if (error) 1437 return error; 1438 1439 if (retry > 1) 1440 psmouse_dbg(psmouse, "reconnected after %d tries\n", retry); 1441 1442 error = synaptics_query_hardware(psmouse, &info); 1443 if (error) { 1444 psmouse_err(psmouse, "Unable to query device.\n"); 1445 return error; 1446 } 1447 1448 error = synaptics_set_mode(psmouse); 1449 if (error) { 1450 psmouse_err(psmouse, "Unable to initialize device.\n"); 1451 return error; 1452 } 1453 1454 if (info.identity != priv->info.identity || 1455 info.model_id != priv->info.model_id || 1456 info.capabilities != priv->info.capabilities || 1457 info.ext_cap != priv->info.ext_cap) { 1458 psmouse_err(psmouse, 1459 "hardware appears to be different: id(%u-%u), model(%u-%u), caps(%x-%x), ext(%x-%x).\n", 1460 priv->info.identity, info.identity, 1461 priv->info.model_id, info.model_id, 1462 priv->info.capabilities, info.capabilities, 1463 priv->info.ext_cap, info.ext_cap); 1464 return -ENXIO; 1465 } 1466 1467 return 0; 1468 } 1469 1470 static bool impaired_toshiba_kbc; 1471 1472 static const struct dmi_system_id toshiba_dmi_table[] __initconst = { 1473 #if defined(CONFIG_DMI) && defined(CONFIG_X86) 1474 { 1475 /* Toshiba Satellite */ 1476 .matches = { 1477 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 1478 DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"), 1479 }, 1480 }, 1481 { 1482 /* Toshiba Dynabook */ 1483 .matches = { 1484 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 1485 DMI_MATCH(DMI_PRODUCT_NAME, "dynabook"), 1486 }, 1487 }, 1488 { 1489 /* Toshiba Portege M300 */ 1490 .matches = { 1491 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 1492 DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE M300"), 1493 }, 1494 1495 }, 1496 { 1497 /* Toshiba Portege M300 */ 1498 .matches = { 1499 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"), 1500 DMI_MATCH(DMI_PRODUCT_NAME, "Portable PC"), 1501 DMI_MATCH(DMI_PRODUCT_VERSION, "Version 1.0"), 1502 }, 1503 1504 }, 1505 #endif 1506 { } 1507 }; 1508 1509 static bool broken_olpc_ec; 1510 1511 static const struct dmi_system_id olpc_dmi_table[] __initconst = { 1512 #if defined(CONFIG_DMI) && defined(CONFIG_OLPC) 1513 { 1514 /* OLPC XO-1 or XO-1.5 */ 1515 .matches = { 1516 DMI_MATCH(DMI_SYS_VENDOR, "OLPC"), 1517 DMI_MATCH(DMI_PRODUCT_NAME, "XO"), 1518 }, 1519 }, 1520 #endif 1521 { } 1522 }; 1523 1524 static const struct dmi_system_id __initconst cr48_dmi_table[] = { 1525 #if defined(CONFIG_DMI) && defined(CONFIG_X86) 1526 { 1527 /* Cr-48 Chromebook (Codename Mario) */ 1528 .matches = { 1529 DMI_MATCH(DMI_SYS_VENDOR, "IEC"), 1530 DMI_MATCH(DMI_PRODUCT_NAME, "Mario"), 1531 }, 1532 }, 1533 #endif 1534 { } 1535 }; 1536 1537 void __init synaptics_module_init(void) 1538 { 1539 impaired_toshiba_kbc = dmi_check_system(toshiba_dmi_table); 1540 broken_olpc_ec = dmi_check_system(olpc_dmi_table); 1541 cr48_profile_sensor = dmi_check_system(cr48_dmi_table); 1542 } 1543 1544 static int synaptics_init_ps2(struct psmouse *psmouse, 1545 struct synaptics_device_info *info, 1546 bool absolute_mode) 1547 { 1548 struct synaptics_data *priv; 1549 int err; 1550 1551 synaptics_apply_quirks(psmouse, info); 1552 1553 psmouse->private = priv = kzalloc(sizeof(struct synaptics_data), GFP_KERNEL); 1554 if (!priv) 1555 return -ENOMEM; 1556 1557 priv->info = *info; 1558 priv->absolute_mode = absolute_mode; 1559 if (SYN_ID_DISGEST_SUPPORTED(info->identity)) 1560 priv->disable_gesture = true; 1561 1562 /* 1563 * Unfortunately ForcePad capability is not exported over PS/2, 1564 * so we have to resort to checking PNP IDs. 1565 */ 1566 priv->is_forcepad = psmouse_matches_pnp_id(psmouse, forcepad_pnp_ids); 1567 1568 err = synaptics_set_mode(psmouse); 1569 if (err) { 1570 psmouse_err(psmouse, "Unable to initialize device.\n"); 1571 goto init_fail; 1572 } 1573 1574 priv->pkt_type = SYN_MODEL_NEWABS(info->model_id) ? 1575 SYN_NEWABS : SYN_OLDABS; 1576 1577 psmouse_info(psmouse, 1578 "Touchpad model: %lu, fw: %lu.%lu, id: %#x, caps: %#x/%#x/%#x/%#x, board id: %u, fw id: %u\n", 1579 SYN_ID_MODEL(info->identity), 1580 SYN_ID_MAJOR(info->identity), SYN_ID_MINOR(info->identity), 1581 info->model_id, 1582 info->capabilities, info->ext_cap, info->ext_cap_0c, 1583 info->ext_cap_10, info->board_id, info->firmware_id); 1584 1585 err = set_input_params(psmouse, priv); 1586 if (err) { 1587 psmouse_err(psmouse, 1588 "failed to set up capabilities: %d\n", err); 1589 goto init_fail; 1590 } 1591 1592 /* 1593 * Encode touchpad model so that it can be used to set 1594 * input device->id.version and be visible to userspace. 1595 * Because version is __u16 we have to drop something. 1596 * Hardware info bits seem to be good candidates as they 1597 * are documented to be for Synaptics corp. internal use. 1598 */ 1599 psmouse->model = ((info->model_id & 0x00ff0000) >> 8) | 1600 (info->model_id & 0x000000ff); 1601 1602 if (absolute_mode) { 1603 psmouse->protocol_handler = synaptics_process_byte; 1604 psmouse->pktsize = 6; 1605 } else { 1606 /* Relative mode follows standard PS/2 mouse protocol */ 1607 psmouse->protocol_handler = psmouse_process_byte; 1608 psmouse->pktsize = 3; 1609 } 1610 1611 psmouse->set_rate = synaptics_set_rate; 1612 psmouse->disconnect = synaptics_disconnect; 1613 psmouse->reconnect = synaptics_reconnect; 1614 psmouse->cleanup = synaptics_reset; 1615 /* Synaptics can usually stay in sync without extra help */ 1616 psmouse->resync_time = 0; 1617 1618 if (SYN_CAP_PASS_THROUGH(info->capabilities)) 1619 synaptics_pt_create(psmouse); 1620 1621 /* 1622 * Toshiba's KBC seems to have trouble handling data from 1623 * Synaptics at full rate. Switch to a lower rate (roughly 1624 * the same rate as a standard PS/2 mouse). 1625 */ 1626 if (psmouse->rate >= 80 && impaired_toshiba_kbc) { 1627 psmouse_info(psmouse, 1628 "Toshiba %s detected, limiting rate to 40pps.\n", 1629 dmi_get_system_info(DMI_PRODUCT_NAME)); 1630 psmouse->rate = 40; 1631 } 1632 1633 if (!priv->absolute_mode && SYN_ID_DISGEST_SUPPORTED(info->identity)) { 1634 err = device_create_file(&psmouse->ps2dev.serio->dev, 1635 &psmouse_attr_disable_gesture.dattr); 1636 if (err) { 1637 psmouse_err(psmouse, 1638 "Failed to create disable_gesture attribute (%d)", 1639 err); 1640 goto init_fail; 1641 } 1642 } 1643 1644 return 0; 1645 1646 init_fail: 1647 kfree(priv); 1648 return err; 1649 } 1650 1651 static int __synaptics_init(struct psmouse *psmouse, bool absolute_mode) 1652 { 1653 struct synaptics_device_info info; 1654 int error; 1655 1656 psmouse_reset(psmouse); 1657 1658 error = synaptics_query_hardware(psmouse, &info); 1659 if (error) { 1660 psmouse_err(psmouse, "Unable to query device: %d\n", error); 1661 return error; 1662 } 1663 1664 return synaptics_init_ps2(psmouse, &info, absolute_mode); 1665 } 1666 1667 int synaptics_init_absolute(struct psmouse *psmouse) 1668 { 1669 return __synaptics_init(psmouse, true); 1670 } 1671 1672 int synaptics_init_relative(struct psmouse *psmouse) 1673 { 1674 return __synaptics_init(psmouse, false); 1675 } 1676 1677 static int synaptics_setup_ps2(struct psmouse *psmouse, 1678 struct synaptics_device_info *info) 1679 { 1680 bool absolute_mode = true; 1681 int error; 1682 1683 /* 1684 * The OLPC XO has issues with Synaptics' absolute mode; the constant 1685 * packet spew overloads the EC such that key presses on the keyboard 1686 * are missed. Given that, don't even attempt to use Absolute mode. 1687 * Relative mode seems to work just fine. 1688 */ 1689 if (broken_olpc_ec) { 1690 psmouse_info(psmouse, 1691 "OLPC XO detected, forcing relative protocol.\n"); 1692 absolute_mode = false; 1693 } 1694 1695 error = synaptics_init_ps2(psmouse, info, absolute_mode); 1696 if (error) 1697 return error; 1698 1699 return absolute_mode ? PSMOUSE_SYNAPTICS : PSMOUSE_SYNAPTICS_RELATIVE; 1700 } 1701 1702 #else /* CONFIG_MOUSE_PS2_SYNAPTICS */ 1703 1704 void __init synaptics_module_init(void) 1705 { 1706 } 1707 1708 static int __maybe_unused 1709 synaptics_setup_ps2(struct psmouse *psmouse, 1710 struct synaptics_device_info *info) 1711 { 1712 return -ENOSYS; 1713 } 1714 1715 #endif /* CONFIG_MOUSE_PS2_SYNAPTICS */ 1716 1717 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS 1718 1719 /* 1720 * The newest Synaptics device can use a secondary bus (called InterTouch) which 1721 * provides a better bandwidth and allow a better control of the touchpads. 1722 * This is used to decide if we need to use this bus or not. 1723 */ 1724 enum { 1725 SYNAPTICS_INTERTOUCH_NOT_SET = -1, 1726 SYNAPTICS_INTERTOUCH_OFF, 1727 SYNAPTICS_INTERTOUCH_ON, 1728 }; 1729 1730 static int synaptics_intertouch = IS_ENABLED(CONFIG_RMI4_SMB) ? 1731 SYNAPTICS_INTERTOUCH_NOT_SET : SYNAPTICS_INTERTOUCH_OFF; 1732 module_param_named(synaptics_intertouch, synaptics_intertouch, int, 0644); 1733 MODULE_PARM_DESC(synaptics_intertouch, "Use a secondary bus for the Synaptics device."); 1734 1735 static int synaptics_create_intertouch(struct psmouse *psmouse, 1736 struct synaptics_device_info *info, 1737 bool leave_breadcrumbs) 1738 { 1739 bool topbuttonpad = 1740 psmouse_matches_pnp_id(psmouse, topbuttonpad_pnp_ids) && 1741 !SYN_CAP_EXT_BUTTONS_STICK(info->ext_cap_10); 1742 const struct rmi_device_platform_data pdata = { 1743 .sensor_pdata = { 1744 .sensor_type = rmi_sensor_touchpad, 1745 .axis_align.flip_y = true, 1746 .kernel_tracking = false, 1747 .topbuttonpad = topbuttonpad, 1748 }, 1749 .f30_data = { 1750 .buttonpad = SYN_CAP_CLICKPAD(info->ext_cap_0c), 1751 .trackstick_buttons = 1752 !!SYN_CAP_EXT_BUTTONS_STICK(info->ext_cap_10), 1753 }, 1754 }; 1755 const struct i2c_board_info intertouch_board = { 1756 I2C_BOARD_INFO("rmi4_smbus", 0x2c), 1757 .flags = I2C_CLIENT_HOST_NOTIFY, 1758 }; 1759 1760 return psmouse_smbus_init(psmouse, &intertouch_board, 1761 &pdata, sizeof(pdata), true, 1762 leave_breadcrumbs); 1763 } 1764 1765 /** 1766 * synaptics_setup_intertouch - called once the PS/2 devices are enumerated 1767 * and decides to instantiate a SMBus InterTouch device. 1768 */ 1769 static int synaptics_setup_intertouch(struct psmouse *psmouse, 1770 struct synaptics_device_info *info, 1771 bool leave_breadcrumbs) 1772 { 1773 int error; 1774 1775 if (synaptics_intertouch == SYNAPTICS_INTERTOUCH_OFF) 1776 return -ENXIO; 1777 1778 if (synaptics_intertouch == SYNAPTICS_INTERTOUCH_NOT_SET) { 1779 if (!psmouse_matches_pnp_id(psmouse, topbuttonpad_pnp_ids) && 1780 !psmouse_matches_pnp_id(psmouse, smbus_pnp_ids)) { 1781 1782 if (!psmouse_matches_pnp_id(psmouse, forcepad_pnp_ids)) 1783 psmouse_info(psmouse, 1784 "Your touchpad (%s) says it can support a different bus. " 1785 "If i2c-hid and hid-rmi are not used, you might want to try setting psmouse.synaptics_intertouch to 1 and report this to linux-input@vger.kernel.org.\n", 1786 psmouse->ps2dev.serio->firmware_id); 1787 1788 return -ENXIO; 1789 } 1790 } 1791 1792 psmouse_info(psmouse, "Trying to set up SMBus access\n"); 1793 1794 error = synaptics_create_intertouch(psmouse, info, leave_breadcrumbs); 1795 if (error) { 1796 if (error == -EAGAIN) 1797 psmouse_info(psmouse, "SMbus companion is not ready yet\n"); 1798 else 1799 psmouse_err(psmouse, "unable to create intertouch device\n"); 1800 1801 return error; 1802 } 1803 1804 return 0; 1805 } 1806 1807 int synaptics_init_smbus(struct psmouse *psmouse) 1808 { 1809 struct synaptics_device_info info; 1810 int error; 1811 1812 psmouse_reset(psmouse); 1813 1814 error = synaptics_query_hardware(psmouse, &info); 1815 if (error) { 1816 psmouse_err(psmouse, "Unable to query device: %d\n", error); 1817 return error; 1818 } 1819 1820 if (!SYN_CAP_INTERTOUCH(info.ext_cap_0c)) 1821 return -ENXIO; 1822 1823 return synaptics_create_intertouch(psmouse, &info, false); 1824 } 1825 1826 #else /* CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */ 1827 1828 static int __maybe_unused 1829 synaptics_setup_intertouch(struct psmouse *psmouse, 1830 struct synaptics_device_info *info, 1831 bool leave_breadcrumbs) 1832 { 1833 return -ENOSYS; 1834 } 1835 1836 int synaptics_init_smbus(struct psmouse *psmouse) 1837 { 1838 return -ENOSYS; 1839 } 1840 1841 #endif /* CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */ 1842 1843 #if defined(CONFIG_MOUSE_PS2_SYNAPTICS) || \ 1844 defined(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS) 1845 1846 int synaptics_init(struct psmouse *psmouse) 1847 { 1848 struct synaptics_device_info info; 1849 int error; 1850 int retval; 1851 1852 psmouse_reset(psmouse); 1853 1854 error = synaptics_query_hardware(psmouse, &info); 1855 if (error) { 1856 psmouse_err(psmouse, "Unable to query device: %d\n", error); 1857 return error; 1858 } 1859 1860 if (SYN_CAP_INTERTOUCH(info.ext_cap_0c)) { 1861 if ((!IS_ENABLED(CONFIG_RMI4_SMB) || 1862 !IS_ENABLED(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS)) && 1863 /* Forcepads need F21, which is not ready */ 1864 !psmouse_matches_pnp_id(psmouse, forcepad_pnp_ids)) { 1865 psmouse_warn(psmouse, 1866 "The touchpad can support a better bus than the too old PS/2 protocol. " 1867 "Make sure MOUSE_PS2_SYNAPTICS_SMBUS and RMI4_SMB are enabled to get a better touchpad experience.\n"); 1868 } 1869 1870 error = synaptics_setup_intertouch(psmouse, &info, true); 1871 if (!error) 1872 return PSMOUSE_SYNAPTICS_SMBUS; 1873 } 1874 1875 retval = synaptics_setup_ps2(psmouse, &info); 1876 if (retval < 0) { 1877 /* 1878 * Not using any flavor of Synaptics support, so clean up 1879 * SMbus breadcrumbs, if any. 1880 */ 1881 psmouse_smbus_cleanup(psmouse); 1882 } 1883 1884 return retval; 1885 } 1886 1887 #else /* CONFIG_MOUSE_PS2_SYNAPTICS || CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */ 1888 1889 int synaptics_init(struct psmouse *psmouse) 1890 { 1891 return -ENOSYS; 1892 } 1893 1894 #endif /* CONFIG_MOUSE_PS2_SYNAPTICS || CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */ 1895