1 // SPDX-License-Identifier: GPL-2.0-only
3 * Synaptics TouchPad PS/2 mouse driver
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.
9 * 2003 Peter Osterlund <petero2@telia.com>
10 * Ported to 2.5 input device infrastructure.
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)
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)
20 * Trademarks are the property of their respective owners.
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>
33 #include "synaptics.h"
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
46 #define XMIN_NOMINAL 1472
47 #define XMAX_NOMINAL 5472
48 #define YMIN_NOMINAL 1408
49 #define YMAX_NOMINAL 4448
51 /* Size in bits of absolute position values reported by the hardware */
52 #define ABS_POS_BITS 13
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.
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.
66 #define X_MAX_POSITIVE 8176
67 #define Y_MAX_POSITIVE 8176
69 /* maximum ABS_MT_POSITION displacement (in mm) */
72 /*****************************************************************************
73 * Stuff we need even when we do not want native Synaptics support
74 ****************************************************************************/
77 * Set the synaptics touchpad mode byte by special commands
79 static int synaptics_mode_cmd(struct psmouse
*psmouse
, u8 mode
)
84 error
= ps2_sliced_command(&psmouse
->ps2dev
, mode
);
88 param
[0] = SYN_PS_SET_MODE2
;
89 error
= ps2_command(&psmouse
->ps2dev
, param
, PSMOUSE_CMD_SETRATE
);
96 int synaptics_detect(struct psmouse
*psmouse
, bool set_properties
)
98 struct ps2dev
*ps2dev
= &psmouse
->ps2dev
;
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
);
107 if (param
[1] != 0x47)
110 if (set_properties
) {
111 psmouse
->vendor
= "Synaptics";
112 psmouse
->name
= "TouchPad";
118 void synaptics_reset(struct psmouse
*psmouse
)
120 /* reset touchpad back to relative mode, gestures enabled */
121 synaptics_mode_cmd(psmouse
, 0);
124 #if defined(CONFIG_MOUSE_PS2_SYNAPTICS) || \
125 defined(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS)
127 /* This list has been kindly provided by Synaptics. */
128 static const char * const topbuttonpad_pnp_ids
[] = {
138 "LEN0033", /* Helix */
139 "LEN0034", /* T431s, L440, L540, T540, W540, X1 Carbon 2nd */
140 "LEN0035", /* X240 */
141 "LEN0036", /* T440 */
142 "LEN0037", /* X1 Carbon 2nd */
144 "LEN0039", /* T440s */
146 "LEN0042", /* Yoga */
150 "LEN2000", /* S540 */
151 "LEN2001", /* Edge E431 */
152 "LEN2002", /* Edge E531 */
154 "LEN2004", /* L440 */
156 "LEN2006", /* Edge E440/E540 */
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 */
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 "LEN0096", /* X280 */
177 "LEN0097", /* X280 -> ALPS trackpoint */
178 "LEN200f", /* T450s */
179 "LEN2054", /* E480 */
180 "LEN2055", /* E580 */
181 "SYN3052", /* HP EliteBook 840 G4 */
182 "SYN3221", /* HP 15-ay000 */
186 static const char * const forcepad_pnp_ids
[] = {
193 * Send a command to the synpatics touchpad by special commands
195 static int synaptics_send_cmd(struct psmouse
*psmouse
, u8 cmd
, u8
*param
)
199 error
= ps2_sliced_command(&psmouse
->ps2dev
, cmd
);
203 error
= ps2_command(&psmouse
->ps2dev
, param
, PSMOUSE_CMD_GETINFO
);
210 static int synaptics_query_int(struct psmouse
*psmouse
, u8 query_cmd
, u32
*val
)
218 error
= synaptics_send_cmd(psmouse
, query_cmd
, resp
.buf
+ 1);
222 *val
= be32_to_cpu(resp
.be_val
);
228 * See also the SYN_ID_* macros
230 static int synaptics_identify(struct psmouse
*psmouse
,
231 struct synaptics_device_info
*info
)
235 error
= synaptics_query_int(psmouse
, SYN_QUE_IDENTIFY
, &info
->identity
);
239 return SYN_ID_IS_SYNAPTICS(info
->identity
) ? 0 : -ENXIO
;
243 * Read the model-id bytes from the touchpad
244 * see also SYN_MODEL_* macros
246 static int synaptics_model_id(struct psmouse
*psmouse
,
247 struct synaptics_device_info
*info
)
249 return synaptics_query_int(psmouse
, SYN_QUE_MODEL
, &info
->model_id
);
253 * Read the firmware id from the touchpad
255 static int synaptics_firmware_id(struct psmouse
*psmouse
,
256 struct synaptics_device_info
*info
)
258 return synaptics_query_int(psmouse
, SYN_QUE_FIRMWARE_ID
,
263 * Read the board id and the "More Extended Queries" from the touchpad
264 * The board id is encoded in the "QUERY MODES" response
266 static int synaptics_query_modes(struct psmouse
*psmouse
,
267 struct synaptics_device_info
*info
)
272 /* firmwares prior 7.5 have no board_id encoded */
273 if (SYN_ID_FULL(info
->identity
) < 0x705)
276 error
= synaptics_send_cmd(psmouse
, SYN_QUE_MODES
, bid
);
280 info
->board_id
= ((bid
[0] & 0xfc) << 6) | bid
[1];
282 if (SYN_MEXT_CAP_BIT(bid
[0]))
283 return synaptics_query_int(psmouse
, SYN_QUE_MEXT_CAPAB_10
,
290 * Read the capability-bits from the touchpad
291 * see also the SYN_CAP_* macros
293 static int synaptics_capability(struct psmouse
*psmouse
,
294 struct synaptics_device_info
*info
)
298 error
= synaptics_query_int(psmouse
, SYN_QUE_CAPABILITIES
,
299 &info
->capabilities
);
303 info
->ext_cap
= info
->ext_cap_0c
= 0;
306 * Older firmwares had submodel ID fixed to 0x47
308 if (SYN_ID_FULL(info
->identity
) < 0x705 &&
309 SYN_CAP_SUBMODEL_ID(info
->capabilities
) != 0x47) {
314 * Unless capExtended is set the rest of the flags should be ignored
316 if (!SYN_CAP_EXTENDED(info
->capabilities
))
317 info
->capabilities
= 0;
319 if (SYN_EXT_CAP_REQUESTS(info
->capabilities
) >= 1) {
320 error
= synaptics_query_int(psmouse
, SYN_QUE_EXT_CAPAB
,
323 psmouse_warn(psmouse
,
324 "device claims to have extended capabilities, but I'm not able to read them.\n");
327 * if nExtBtn is greater than 8 it should be considered
328 * invalid and treated as 0
330 if (SYN_CAP_MULTI_BUTTON_NO(info
->ext_cap
) > 8)
331 info
->ext_cap
&= ~SYN_CAP_MB_MASK
;
335 if (SYN_EXT_CAP_REQUESTS(info
->capabilities
) >= 4) {
336 error
= synaptics_query_int(psmouse
, SYN_QUE_EXT_CAPAB_0C
,
339 psmouse_warn(psmouse
,
340 "device claims to have extended capability 0x0c, but I'm not able to read it.\n");
347 * Read touchpad resolution and maximum reported coordinates
348 * Resolution is left zero if touchpad does not support the query
350 static int synaptics_resolution(struct psmouse
*psmouse
,
351 struct synaptics_device_info
*info
)
356 if (SYN_ID_MAJOR(info
->identity
) < 4)
359 error
= synaptics_send_cmd(psmouse
, SYN_QUE_RESOLUTION
, resp
);
361 if (resp
[0] != 0 && (resp
[1] & 0x80) && resp
[2] != 0) {
362 info
->x_res
= resp
[0]; /* x resolution in units/mm */
363 info
->y_res
= resp
[2]; /* y resolution in units/mm */
367 if (SYN_EXT_CAP_REQUESTS(info
->capabilities
) >= 5 &&
368 SYN_CAP_MAX_DIMENSIONS(info
->ext_cap_0c
)) {
369 error
= synaptics_send_cmd(psmouse
,
370 SYN_QUE_EXT_MAX_COORDS
, resp
);
372 psmouse_warn(psmouse
,
373 "device claims to have max coordinates query, but I'm not able to read it.\n");
375 info
->x_max
= (resp
[0] << 5) | ((resp
[1] & 0x0f) << 1);
376 info
->y_max
= (resp
[2] << 5) | ((resp
[1] & 0xf0) >> 3);
377 psmouse_info(psmouse
,
378 "queried max coordinates: x [..%d], y [..%d]\n",
379 info
->x_max
, info
->y_max
);
383 if (SYN_CAP_MIN_DIMENSIONS(info
->ext_cap_0c
) &&
384 (SYN_EXT_CAP_REQUESTS(info
->capabilities
) >= 7 ||
386 * Firmware v8.1 does not report proper number of extended
387 * capabilities, but has been proven to report correct min
390 SYN_ID_FULL(info
->identity
) == 0x801)) {
391 error
= synaptics_send_cmd(psmouse
,
392 SYN_QUE_EXT_MIN_COORDS
, resp
);
394 psmouse_warn(psmouse
,
395 "device claims to have min coordinates query, but I'm not able to read it.\n");
397 info
->x_min
= (resp
[0] << 5) | ((resp
[1] & 0x0f) << 1);
398 info
->y_min
= (resp
[2] << 5) | ((resp
[1] & 0xf0) >> 3);
399 psmouse_info(psmouse
,
400 "queried min coordinates: x [%d..], y [%d..]\n",
401 info
->x_min
, info
->y_min
);
408 static int synaptics_query_hardware(struct psmouse
*psmouse
,
409 struct synaptics_device_info
*info
)
413 memset(info
, 0, sizeof(*info
));
415 error
= synaptics_identify(psmouse
, info
);
419 error
= synaptics_model_id(psmouse
, info
);
423 error
= synaptics_firmware_id(psmouse
, info
);
427 error
= synaptics_query_modes(psmouse
, info
);
431 error
= synaptics_capability(psmouse
, info
);
435 error
= synaptics_resolution(psmouse
, info
);
442 #endif /* CONFIG_MOUSE_PS2_SYNAPTICS || CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */
444 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS
446 static bool cr48_profile_sensor
;
448 #define ANY_BOARD_ID 0
449 struct min_max_quirk
{
450 const char * const *pnp_ids
;
454 u32 x_min
, x_max
, y_min
, y_max
;
457 static const struct min_max_quirk min_max_pnpid_table
[] = {
459 (const char * const []){"LEN0033", NULL
},
460 {ANY_BOARD_ID
, ANY_BOARD_ID
},
461 1024, 5052, 2258, 4832
464 (const char * const []){"LEN0042", NULL
},
465 {ANY_BOARD_ID
, ANY_BOARD_ID
},
466 1232, 5710, 1156, 4696
469 (const char * const []){"LEN0034", "LEN0036", "LEN0037",
470 "LEN0039", "LEN2002", "LEN2004",
472 {ANY_BOARD_ID
, 2961},
473 1024, 5112, 2024, 4832
476 (const char * const []){"LEN2000", NULL
},
477 {ANY_BOARD_ID
, ANY_BOARD_ID
},
478 1024, 5113, 2021, 4832
481 (const char * const []){"LEN2001", NULL
},
482 {ANY_BOARD_ID
, ANY_BOARD_ID
},
483 1024, 5022, 2508, 4832
486 (const char * const []){"LEN2006", NULL
},
488 1024, 5045, 2457, 4832
491 (const char * const []){"LEN2006", NULL
},
492 {ANY_BOARD_ID
, ANY_BOARD_ID
},
493 1264, 5675, 1171, 4688
498 /*****************************************************************************
499 * Synaptics communications functions
500 ****************************************************************************/
503 * Synaptics touchpads report the y coordinate from bottom to top, which is
504 * opposite from what userspace expects.
505 * This function is used to invert y before reporting.
507 static int synaptics_invert_y(int y
)
509 return YMAX_NOMINAL
+ YMIN_NOMINAL
- y
;
513 * Apply quirk(s) if the hardware matches
515 static void synaptics_apply_quirks(struct psmouse
*psmouse
,
516 struct synaptics_device_info
*info
)
520 for (i
= 0; min_max_pnpid_table
[i
].pnp_ids
; i
++) {
521 if (!psmouse_matches_pnp_id(psmouse
,
522 min_max_pnpid_table
[i
].pnp_ids
))
525 if (min_max_pnpid_table
[i
].board_id
.min
!= ANY_BOARD_ID
&&
526 info
->board_id
< min_max_pnpid_table
[i
].board_id
.min
)
529 if (min_max_pnpid_table
[i
].board_id
.max
!= ANY_BOARD_ID
&&
530 info
->board_id
> min_max_pnpid_table
[i
].board_id
.max
)
533 info
->x_min
= min_max_pnpid_table
[i
].x_min
;
534 info
->x_max
= min_max_pnpid_table
[i
].x_max
;
535 info
->y_min
= min_max_pnpid_table
[i
].y_min
;
536 info
->y_max
= min_max_pnpid_table
[i
].y_max
;
537 psmouse_info(psmouse
,
538 "quirked min/max coordinates: x [%d..%d], y [%d..%d]\n",
539 info
->x_min
, info
->x_max
,
540 info
->y_min
, info
->y_max
);
545 static bool synaptics_has_agm(struct synaptics_data
*priv
)
547 return (SYN_CAP_ADV_GESTURE(priv
->info
.ext_cap_0c
) ||
548 SYN_CAP_IMAGE_SENSOR(priv
->info
.ext_cap_0c
));
551 static int synaptics_set_advanced_gesture_mode(struct psmouse
*psmouse
)
553 static u8 param
= 0xc8;
556 error
= ps2_sliced_command(&psmouse
->ps2dev
, SYN_QUE_MODEL
);
560 error
= ps2_command(&psmouse
->ps2dev
, ¶m
, PSMOUSE_CMD_SETRATE
);
567 static int synaptics_set_mode(struct psmouse
*psmouse
)
569 struct synaptics_data
*priv
= psmouse
->private;
573 if (priv
->absolute_mode
)
574 priv
->mode
|= SYN_BIT_ABSOLUTE_MODE
;
575 if (priv
->disable_gesture
)
576 priv
->mode
|= SYN_BIT_DISABLE_GESTURE
;
577 if (psmouse
->rate
>= 80)
578 priv
->mode
|= SYN_BIT_HIGH_RATE
;
579 if (SYN_CAP_EXTENDED(priv
->info
.capabilities
))
580 priv
->mode
|= SYN_BIT_W_MODE
;
582 error
= synaptics_mode_cmd(psmouse
, priv
->mode
);
586 if (priv
->absolute_mode
&& synaptics_has_agm(priv
)) {
587 error
= synaptics_set_advanced_gesture_mode(psmouse
);
590 "Advanced gesture mode init failed: %d\n",
599 static void synaptics_set_rate(struct psmouse
*psmouse
, unsigned int rate
)
601 struct synaptics_data
*priv
= psmouse
->private;
604 priv
->mode
|= SYN_BIT_HIGH_RATE
;
607 priv
->mode
&= ~SYN_BIT_HIGH_RATE
;
611 synaptics_mode_cmd(psmouse
, priv
->mode
);
614 /*****************************************************************************
615 * Synaptics pass-through PS/2 port support
616 ****************************************************************************/
617 static int synaptics_pt_write(struct serio
*serio
, u8 c
)
619 struct psmouse
*parent
= serio_get_drvdata(serio
->parent
);
620 u8 rate_param
= SYN_PS_CLIENT_CMD
; /* indicates that we want pass-through port */
623 error
= ps2_sliced_command(&parent
->ps2dev
, c
);
627 error
= ps2_command(&parent
->ps2dev
, &rate_param
, PSMOUSE_CMD_SETRATE
);
634 static int synaptics_pt_start(struct serio
*serio
)
636 struct psmouse
*parent
= serio_get_drvdata(serio
->parent
);
637 struct synaptics_data
*priv
= parent
->private;
639 serio_pause_rx(parent
->ps2dev
.serio
);
640 priv
->pt_port
= serio
;
641 serio_continue_rx(parent
->ps2dev
.serio
);
646 static void synaptics_pt_stop(struct serio
*serio
)
648 struct psmouse
*parent
= serio_get_drvdata(serio
->parent
);
649 struct synaptics_data
*priv
= parent
->private;
651 serio_pause_rx(parent
->ps2dev
.serio
);
652 priv
->pt_port
= NULL
;
653 serio_continue_rx(parent
->ps2dev
.serio
);
656 static int synaptics_is_pt_packet(u8
*buf
)
658 return (buf
[0] & 0xFC) == 0x84 && (buf
[3] & 0xCC) == 0xC4;
661 static void synaptics_pass_pt_packet(struct serio
*ptport
, u8
*packet
)
663 struct psmouse
*child
= serio_get_drvdata(ptport
);
665 if (child
&& child
->state
== PSMOUSE_ACTIVATED
) {
666 serio_interrupt(ptport
, packet
[1], 0);
667 serio_interrupt(ptport
, packet
[4], 0);
668 serio_interrupt(ptport
, packet
[5], 0);
669 if (child
->pktsize
== 4)
670 serio_interrupt(ptport
, packet
[2], 0);
672 serio_interrupt(ptport
, packet
[1], 0);
676 static void synaptics_pt_activate(struct psmouse
*psmouse
)
678 struct synaptics_data
*priv
= psmouse
->private;
679 struct psmouse
*child
= serio_get_drvdata(priv
->pt_port
);
681 /* adjust the touchpad to child's choice of protocol */
683 if (child
->pktsize
== 4)
684 priv
->mode
|= SYN_BIT_FOUR_BYTE_CLIENT
;
686 priv
->mode
&= ~SYN_BIT_FOUR_BYTE_CLIENT
;
688 if (synaptics_mode_cmd(psmouse
, priv
->mode
))
689 psmouse_warn(psmouse
,
690 "failed to switch guest protocol\n");
694 static void synaptics_pt_create(struct psmouse
*psmouse
)
698 serio
= kzalloc(sizeof(struct serio
), GFP_KERNEL
);
701 "not enough memory for pass-through port\n");
705 serio
->id
.type
= SERIO_PS_PSTHRU
;
706 strlcpy(serio
->name
, "Synaptics pass-through", sizeof(serio
->name
));
707 strlcpy(serio
->phys
, "synaptics-pt/serio0", sizeof(serio
->name
));
708 serio
->write
= synaptics_pt_write
;
709 serio
->start
= synaptics_pt_start
;
710 serio
->stop
= synaptics_pt_stop
;
711 serio
->parent
= psmouse
->ps2dev
.serio
;
713 psmouse
->pt_activate
= synaptics_pt_activate
;
715 psmouse_info(psmouse
, "serio: %s port at %s\n",
716 serio
->name
, psmouse
->phys
);
717 serio_register_port(serio
);
720 /*****************************************************************************
721 * Functions to interpret the absolute mode packets
722 ****************************************************************************/
724 static void synaptics_parse_agm(const u8 buf
[],
725 struct synaptics_data
*priv
,
726 struct synaptics_hw_state
*hw
)
728 struct synaptics_hw_state
*agm
= &priv
->agm
;
731 agm_packet_type
= (buf
[5] & 0x30) >> 4;
732 switch (agm_packet_type
) {
734 /* Gesture packet: (x, y, z) half resolution */
736 agm
->x
= (((buf
[4] & 0x0f) << 8) | buf
[1]) << 1;
737 agm
->y
= (((buf
[4] & 0xf0) << 4) | buf
[2]) << 1;
738 agm
->z
= ((buf
[3] & 0x30) | (buf
[5] & 0x0f)) << 1;
742 /* AGM-CONTACT packet: we are only interested in the count */
743 priv
->agm_count
= buf
[1];
751 static void synaptics_parse_ext_buttons(const u8 buf
[],
752 struct synaptics_data
*priv
,
753 struct synaptics_hw_state
*hw
)
755 unsigned int ext_bits
=
756 (SYN_CAP_MULTI_BUTTON_NO(priv
->info
.ext_cap
) + 1) >> 1;
757 unsigned int ext_mask
= GENMASK(ext_bits
- 1, 0);
759 hw
->ext_buttons
= buf
[4] & ext_mask
;
760 hw
->ext_buttons
|= (buf
[5] & ext_mask
) << ext_bits
;
763 static int synaptics_parse_hw_state(const u8 buf
[],
764 struct synaptics_data
*priv
,
765 struct synaptics_hw_state
*hw
)
767 memset(hw
, 0, sizeof(struct synaptics_hw_state
));
769 if (SYN_MODEL_NEWABS(priv
->info
.model_id
)) {
770 hw
->w
= (((buf
[0] & 0x30) >> 2) |
771 ((buf
[0] & 0x04) >> 1) |
772 ((buf
[3] & 0x04) >> 2));
774 if (synaptics_has_agm(priv
) && hw
->w
== 2) {
775 synaptics_parse_agm(buf
, priv
, hw
);
779 hw
->x
= (((buf
[3] & 0x10) << 8) |
780 ((buf
[1] & 0x0f) << 8) |
782 hw
->y
= (((buf
[3] & 0x20) << 7) |
783 ((buf
[1] & 0xf0) << 4) |
787 hw
->left
= (buf
[0] & 0x01) ? 1 : 0;
788 hw
->right
= (buf
[0] & 0x02) ? 1 : 0;
790 if (priv
->is_forcepad
) {
792 * ForcePads, like Clickpads, use middle button
793 * bits to report primary button clicks.
794 * Unfortunately they report primary button not
795 * only when user presses on the pad above certain
796 * threshold, but also when there are more than one
797 * finger on the touchpad, which interferes with
798 * out multi-finger gestures.
802 priv
->press
= priv
->report_press
= false;
803 } else if (hw
->w
>= 4 && ((buf
[0] ^ buf
[3]) & 0x01)) {
805 * Single-finger touch with pressure above
806 * the threshold. If pressure stays long
807 * enough, we'll start reporting primary
808 * button. We rely on the device continuing
809 * sending data even if finger does not
813 priv
->press_start
= jiffies
;
815 } else if (time_after(jiffies
,
817 msecs_to_jiffies(50))) {
818 priv
->report_press
= true;
824 hw
->left
= priv
->report_press
;
826 } else if (SYN_CAP_CLICKPAD(priv
->info
.ext_cap_0c
)) {
828 * Clickpad's button is transmitted as middle button,
829 * however, since it is primary button, we will report
832 hw
->left
= ((buf
[0] ^ buf
[3]) & 0x01) ? 1 : 0;
834 } else if (SYN_CAP_MIDDLE_BUTTON(priv
->info
.capabilities
)) {
835 hw
->middle
= ((buf
[0] ^ buf
[3]) & 0x01) ? 1 : 0;
837 hw
->scroll
= (s8
)buf
[1];
840 if (SYN_CAP_FOUR_BUTTON(priv
->info
.capabilities
)) {
841 hw
->up
= ((buf
[0] ^ buf
[3]) & 0x01) ? 1 : 0;
842 hw
->down
= ((buf
[0] ^ buf
[3]) & 0x02) ? 1 : 0;
845 if (SYN_CAP_MULTI_BUTTON_NO(priv
->info
.ext_cap
) > 0 &&
846 ((buf
[0] ^ buf
[3]) & 0x02)) {
847 synaptics_parse_ext_buttons(buf
, priv
, hw
);
850 hw
->x
= (((buf
[1] & 0x1f) << 8) | buf
[2]);
851 hw
->y
= (((buf
[4] & 0x1f) << 8) | buf
[5]);
853 hw
->z
= (((buf
[0] & 0x30) << 2) | (buf
[3] & 0x3F));
854 hw
->w
= (((buf
[1] & 0x80) >> 4) | ((buf
[0] & 0x04) >> 1));
856 hw
->left
= (buf
[0] & 0x01) ? 1 : 0;
857 hw
->right
= (buf
[0] & 0x02) ? 1 : 0;
861 * Convert wrap-around values to negative. (X|Y)_MAX_POSITIVE
862 * is used by some firmware to indicate a finger at the edge of
863 * the touchpad whose precise position cannot be determined, so
864 * convert these values to the maximum axis value.
866 if (hw
->x
> X_MAX_POSITIVE
)
867 hw
->x
-= 1 << ABS_POS_BITS
;
868 else if (hw
->x
== X_MAX_POSITIVE
)
871 if (hw
->y
> Y_MAX_POSITIVE
)
872 hw
->y
-= 1 << ABS_POS_BITS
;
873 else if (hw
->y
== Y_MAX_POSITIVE
)
879 static void synaptics_report_semi_mt_slot(struct input_dev
*dev
, int slot
,
880 bool active
, int x
, int y
)
882 input_mt_slot(dev
, slot
);
883 input_mt_report_slot_state(dev
, MT_TOOL_FINGER
, active
);
885 input_report_abs(dev
, ABS_MT_POSITION_X
, x
);
886 input_report_abs(dev
, ABS_MT_POSITION_Y
, synaptics_invert_y(y
));
890 static void synaptics_report_semi_mt_data(struct input_dev
*dev
,
891 const struct synaptics_hw_state
*a
,
892 const struct synaptics_hw_state
*b
,
895 if (num_fingers
>= 2) {
896 synaptics_report_semi_mt_slot(dev
, 0, true, min(a
->x
, b
->x
),
898 synaptics_report_semi_mt_slot(dev
, 1, true, max(a
->x
, b
->x
),
900 } else if (num_fingers
== 1) {
901 synaptics_report_semi_mt_slot(dev
, 0, true, a
->x
, a
->y
);
902 synaptics_report_semi_mt_slot(dev
, 1, false, 0, 0);
904 synaptics_report_semi_mt_slot(dev
, 0, false, 0, 0);
905 synaptics_report_semi_mt_slot(dev
, 1, false, 0, 0);
909 static void synaptics_report_ext_buttons(struct psmouse
*psmouse
,
910 const struct synaptics_hw_state
*hw
)
912 struct input_dev
*dev
= psmouse
->dev
;
913 struct synaptics_data
*priv
= psmouse
->private;
914 int ext_bits
= (SYN_CAP_MULTI_BUTTON_NO(priv
->info
.ext_cap
) + 1) >> 1;
917 if (!SYN_CAP_MULTI_BUTTON_NO(priv
->info
.ext_cap
))
920 /* Bug in FW 8.1 & 8.2, buttons are reported only when ExtBit is 1 */
921 if ((SYN_ID_FULL(priv
->info
.identity
) == 0x801 ||
922 SYN_ID_FULL(priv
->info
.identity
) == 0x802) &&
923 !((psmouse
->packet
[0] ^ psmouse
->packet
[3]) & 0x02))
926 if (!SYN_CAP_EXT_BUTTONS_STICK(priv
->info
.ext_cap_10
)) {
927 for (i
= 0; i
< ext_bits
; i
++) {
928 input_report_key(dev
, BTN_0
+ 2 * i
,
929 hw
->ext_buttons
& BIT(i
));
930 input_report_key(dev
, BTN_1
+ 2 * i
,
931 hw
->ext_buttons
& BIT(i
+ ext_bits
));
937 * This generation of touchpads has the trackstick buttons
938 * physically wired to the touchpad. Re-route them through
939 * the pass-through interface.
944 /* The trackstick expects at most 3 buttons */
945 pt_buttons
= SYN_EXT_BUTTON_STICK_L(hw
->ext_buttons
) |
946 SYN_EXT_BUTTON_STICK_R(hw
->ext_buttons
) << 1 |
947 SYN_EXT_BUTTON_STICK_M(hw
->ext_buttons
) << 2;
949 serio_interrupt(priv
->pt_port
,
950 PSMOUSE_OOB_EXTRA_BTNS
, SERIO_OOB_DATA
);
951 serio_interrupt(priv
->pt_port
, pt_buttons
, SERIO_OOB_DATA
);
955 static void synaptics_report_buttons(struct psmouse
*psmouse
,
956 const struct synaptics_hw_state
*hw
)
958 struct input_dev
*dev
= psmouse
->dev
;
959 struct synaptics_data
*priv
= psmouse
->private;
961 input_report_key(dev
, BTN_LEFT
, hw
->left
);
962 input_report_key(dev
, BTN_RIGHT
, hw
->right
);
964 if (SYN_CAP_MIDDLE_BUTTON(priv
->info
.capabilities
))
965 input_report_key(dev
, BTN_MIDDLE
, hw
->middle
);
967 if (SYN_CAP_FOUR_BUTTON(priv
->info
.capabilities
)) {
968 input_report_key(dev
, BTN_FORWARD
, hw
->up
);
969 input_report_key(dev
, BTN_BACK
, hw
->down
);
972 synaptics_report_ext_buttons(psmouse
, hw
);
975 static void synaptics_report_mt_data(struct psmouse
*psmouse
,
976 const struct synaptics_hw_state
*sgm
,
979 struct input_dev
*dev
= psmouse
->dev
;
980 struct synaptics_data
*priv
= psmouse
->private;
981 const struct synaptics_hw_state
*hw
[2] = { sgm
, &priv
->agm
};
982 struct input_mt_pos pos
[2];
983 int slot
[2], nsemi
, i
;
985 nsemi
= clamp_val(num_fingers
, 0, 2);
987 for (i
= 0; i
< nsemi
; i
++) {
989 pos
[i
].y
= synaptics_invert_y(hw
[i
]->y
);
992 input_mt_assign_slots(dev
, slot
, pos
, nsemi
, DMAX
* priv
->info
.x_res
);
994 for (i
= 0; i
< nsemi
; i
++) {
995 input_mt_slot(dev
, slot
[i
]);
996 input_mt_report_slot_state(dev
, MT_TOOL_FINGER
, true);
997 input_report_abs(dev
, ABS_MT_POSITION_X
, pos
[i
].x
);
998 input_report_abs(dev
, ABS_MT_POSITION_Y
, pos
[i
].y
);
999 input_report_abs(dev
, ABS_MT_PRESSURE
, hw
[i
]->z
);
1002 input_mt_drop_unused(dev
);
1004 /* Don't use active slot count to generate BTN_TOOL events. */
1005 input_mt_report_pointer_emulation(dev
, false);
1007 /* Send the number of fingers reported by touchpad itself. */
1008 input_mt_report_finger_count(dev
, num_fingers
);
1010 synaptics_report_buttons(psmouse
, sgm
);
1015 static void synaptics_image_sensor_process(struct psmouse
*psmouse
,
1016 struct synaptics_hw_state
*sgm
)
1018 struct synaptics_data
*priv
= psmouse
->private;
1022 * Update mt_state using the new finger count and current mt_state.
1026 else if (sgm
->w
>= 4)
1028 else if (sgm
->w
== 0)
1030 else if (sgm
->w
== 1)
1031 num_fingers
= priv
->agm_count
? priv
->agm_count
: 3;
1035 /* Send resulting input events to user space */
1036 synaptics_report_mt_data(psmouse
, sgm
, num_fingers
);
1039 static bool synaptics_has_multifinger(struct synaptics_data
*priv
)
1041 if (SYN_CAP_MULTIFINGER(priv
->info
.capabilities
))
1044 /* Advanced gesture mode also sends multi finger data */
1045 return synaptics_has_agm(priv
);
1049 * called for each full received packet from the touchpad
1051 static void synaptics_process_packet(struct psmouse
*psmouse
)
1053 struct input_dev
*dev
= psmouse
->dev
;
1054 struct synaptics_data
*priv
= psmouse
->private;
1055 struct synaptics_device_info
*info
= &priv
->info
;
1056 struct synaptics_hw_state hw
;
1060 if (synaptics_parse_hw_state(psmouse
->packet
, priv
, &hw
))
1063 if (SYN_CAP_IMAGE_SENSOR(info
->ext_cap_0c
)) {
1064 synaptics_image_sensor_process(psmouse
, &hw
);
1069 priv
->scroll
+= hw
.scroll
;
1071 while (priv
->scroll
>= 4) {
1072 input_report_key(dev
, BTN_BACK
, !hw
.down
);
1074 input_report_key(dev
, BTN_BACK
, hw
.down
);
1078 while (priv
->scroll
<= -4) {
1079 input_report_key(dev
, BTN_FORWARD
, !hw
.up
);
1081 input_report_key(dev
, BTN_FORWARD
, hw
.up
);
1088 if (hw
.z
> 0 && hw
.x
> 1) {
1091 if (SYN_CAP_EXTENDED(info
->capabilities
)) {
1094 if (synaptics_has_multifinger(priv
))
1095 num_fingers
= hw
.w
+ 2;
1098 if (SYN_MODEL_PEN(info
->model_id
))
1099 ; /* Nothing, treat a pen as a single finger */
1102 if (SYN_CAP_PALMDETECT(info
->capabilities
))
1103 finger_width
= hw
.w
;
1112 if (cr48_profile_sensor
) {
1113 synaptics_report_mt_data(psmouse
, &hw
, num_fingers
);
1117 if (SYN_CAP_ADV_GESTURE(info
->ext_cap_0c
))
1118 synaptics_report_semi_mt_data(dev
, &hw
, &priv
->agm
,
1122 * BTN_TOUCH has to be first as mousedev relies on it when doing
1123 * absolute -> relative conversion
1125 if (hw
.z
> 30) input_report_key(dev
, BTN_TOUCH
, 1);
1126 if (hw
.z
< 25) input_report_key(dev
, BTN_TOUCH
, 0);
1128 if (num_fingers
> 0) {
1129 input_report_abs(dev
, ABS_X
, hw
.x
);
1130 input_report_abs(dev
, ABS_Y
, synaptics_invert_y(hw
.y
));
1132 input_report_abs(dev
, ABS_PRESSURE
, hw
.z
);
1134 if (SYN_CAP_PALMDETECT(info
->capabilities
))
1135 input_report_abs(dev
, ABS_TOOL_WIDTH
, finger_width
);
1137 input_report_key(dev
, BTN_TOOL_FINGER
, num_fingers
== 1);
1138 if (synaptics_has_multifinger(priv
)) {
1139 input_report_key(dev
, BTN_TOOL_DOUBLETAP
, num_fingers
== 2);
1140 input_report_key(dev
, BTN_TOOL_TRIPLETAP
, num_fingers
== 3);
1143 synaptics_report_buttons(psmouse
, &hw
);
1148 static bool synaptics_validate_byte(struct psmouse
*psmouse
,
1149 int idx
, enum synaptics_pkt_type pkt_type
)
1151 static const u8 newabs_mask
[] = { 0xC8, 0x00, 0x00, 0xC8, 0x00 };
1152 static const u8 newabs_rel_mask
[] = { 0xC0, 0x00, 0x00, 0xC0, 0x00 };
1153 static const u8 newabs_rslt
[] = { 0x80, 0x00, 0x00, 0xC0, 0x00 };
1154 static const u8 oldabs_mask
[] = { 0xC0, 0x60, 0x00, 0xC0, 0x60 };
1155 static const u8 oldabs_rslt
[] = { 0xC0, 0x00, 0x00, 0x80, 0x00 };
1156 const u8
*packet
= psmouse
->packet
;
1158 if (idx
< 0 || idx
> 4)
1164 case SYN_NEWABS_RELAXED
:
1165 return (packet
[idx
] & newabs_rel_mask
[idx
]) == newabs_rslt
[idx
];
1167 case SYN_NEWABS_STRICT
:
1168 return (packet
[idx
] & newabs_mask
[idx
]) == newabs_rslt
[idx
];
1171 return (packet
[idx
] & oldabs_mask
[idx
]) == oldabs_rslt
[idx
];
1174 psmouse_err(psmouse
, "unknown packet type %d\n", pkt_type
);
1179 static enum synaptics_pkt_type
1180 synaptics_detect_pkt_type(struct psmouse
*psmouse
)
1184 for (i
= 0; i
< 5; i
++) {
1185 if (!synaptics_validate_byte(psmouse
, i
, SYN_NEWABS_STRICT
)) {
1186 psmouse_info(psmouse
, "using relaxed packet validation\n");
1187 return SYN_NEWABS_RELAXED
;
1191 return SYN_NEWABS_STRICT
;
1194 static psmouse_ret_t
synaptics_process_byte(struct psmouse
*psmouse
)
1196 struct synaptics_data
*priv
= psmouse
->private;
1198 if (psmouse
->pktcnt
>= 6) { /* Full packet received */
1199 if (unlikely(priv
->pkt_type
== SYN_NEWABS
))
1200 priv
->pkt_type
= synaptics_detect_pkt_type(psmouse
);
1202 if (SYN_CAP_PASS_THROUGH(priv
->info
.capabilities
) &&
1203 synaptics_is_pt_packet(psmouse
->packet
)) {
1205 synaptics_pass_pt_packet(priv
->pt_port
,
1208 synaptics_process_packet(psmouse
);
1210 return PSMOUSE_FULL_PACKET
;
1213 return synaptics_validate_byte(psmouse
, psmouse
->pktcnt
- 1, priv
->pkt_type
) ?
1214 PSMOUSE_GOOD_DATA
: PSMOUSE_BAD_DATA
;
1217 /*****************************************************************************
1218 * Driver initialization/cleanup functions
1219 ****************************************************************************/
1220 static void set_abs_position_params(struct input_dev
*dev
,
1221 struct synaptics_device_info
*info
,
1222 int x_code
, int y_code
)
1224 int x_min
= info
->x_min
?: XMIN_NOMINAL
;
1225 int x_max
= info
->x_max
?: XMAX_NOMINAL
;
1226 int y_min
= info
->y_min
?: YMIN_NOMINAL
;
1227 int y_max
= info
->y_max
?: YMAX_NOMINAL
;
1228 int fuzz
= SYN_CAP_REDUCED_FILTERING(info
->ext_cap_0c
) ?
1229 SYN_REDUCED_FILTER_FUZZ
: 0;
1231 input_set_abs_params(dev
, x_code
, x_min
, x_max
, fuzz
, 0);
1232 input_set_abs_params(dev
, y_code
, y_min
, y_max
, fuzz
, 0);
1233 input_abs_set_res(dev
, x_code
, info
->x_res
);
1234 input_abs_set_res(dev
, y_code
, info
->y_res
);
1237 static int set_input_params(struct psmouse
*psmouse
,
1238 struct synaptics_data
*priv
)
1240 struct input_dev
*dev
= psmouse
->dev
;
1241 struct synaptics_device_info
*info
= &priv
->info
;
1245 /* Reset default psmouse capabilities */
1246 __clear_bit(EV_REL
, dev
->evbit
);
1247 bitmap_zero(dev
->relbit
, REL_CNT
);
1248 bitmap_zero(dev
->keybit
, KEY_CNT
);
1250 /* Things that apply to both modes */
1251 __set_bit(INPUT_PROP_POINTER
, dev
->propbit
);
1253 input_set_capability(dev
, EV_KEY
, BTN_LEFT
);
1255 /* Clickpads report only left button */
1256 if (!SYN_CAP_CLICKPAD(info
->ext_cap_0c
)) {
1257 input_set_capability(dev
, EV_KEY
, BTN_RIGHT
);
1258 if (SYN_CAP_MIDDLE_BUTTON(info
->capabilities
))
1259 input_set_capability(dev
, EV_KEY
, BTN_MIDDLE
);
1262 if (!priv
->absolute_mode
) {
1264 input_set_capability(dev
, EV_REL
, REL_X
);
1265 input_set_capability(dev
, EV_REL
, REL_Y
);
1270 set_abs_position_params(dev
, &priv
->info
, ABS_X
, ABS_Y
);
1271 input_set_abs_params(dev
, ABS_PRESSURE
, 0, 255, 0, 0);
1273 if (cr48_profile_sensor
)
1274 input_set_abs_params(dev
, ABS_MT_PRESSURE
, 0, 255, 0, 0);
1276 if (SYN_CAP_IMAGE_SENSOR(info
->ext_cap_0c
)) {
1277 set_abs_position_params(dev
, info
,
1278 ABS_MT_POSITION_X
, ABS_MT_POSITION_Y
);
1279 /* Image sensors can report per-contact pressure */
1280 input_set_abs_params(dev
, ABS_MT_PRESSURE
, 0, 255, 0, 0);
1282 error
= input_mt_init_slots(dev
, 2,
1283 INPUT_MT_POINTER
| INPUT_MT_TRACK
);
1287 /* Image sensors can signal 4 and 5 finger clicks */
1288 input_set_capability(dev
, EV_KEY
, BTN_TOOL_QUADTAP
);
1289 input_set_capability(dev
, EV_KEY
, BTN_TOOL_QUINTTAP
);
1290 } else if (SYN_CAP_ADV_GESTURE(info
->ext_cap_0c
)) {
1291 set_abs_position_params(dev
, info
,
1292 ABS_MT_POSITION_X
, ABS_MT_POSITION_Y
);
1294 * Profile sensor in CR-48 tracks contacts reasonably well,
1295 * other non-image sensors with AGM use semi-mt.
1297 error
= input_mt_init_slots(dev
, 2,
1299 (cr48_profile_sensor
?
1306 * For semi-mt devices we send ABS_X/Y ourselves instead of
1307 * input_mt_report_pointer_emulation. But
1308 * input_mt_init_slots() resets the fuzz to 0, leading to a
1309 * filtered ABS_MT_POSITION_X but an unfiltered ABS_X
1310 * position. Let's re-initialize ABS_X/Y here.
1312 if (!cr48_profile_sensor
)
1313 set_abs_position_params(dev
, &priv
->info
, ABS_X
, ABS_Y
);
1316 if (SYN_CAP_PALMDETECT(info
->capabilities
))
1317 input_set_abs_params(dev
, ABS_TOOL_WIDTH
, 0, 15, 0, 0);
1319 input_set_capability(dev
, EV_KEY
, BTN_TOUCH
);
1320 input_set_capability(dev
, EV_KEY
, BTN_TOOL_FINGER
);
1322 if (synaptics_has_multifinger(priv
)) {
1323 input_set_capability(dev
, EV_KEY
, BTN_TOOL_DOUBLETAP
);
1324 input_set_capability(dev
, EV_KEY
, BTN_TOOL_TRIPLETAP
);
1327 if (SYN_CAP_FOUR_BUTTON(info
->capabilities
) ||
1328 SYN_CAP_MIDDLE_BUTTON(info
->capabilities
)) {
1329 input_set_capability(dev
, EV_KEY
, BTN_FORWARD
);
1330 input_set_capability(dev
, EV_KEY
, BTN_BACK
);
1333 if (!SYN_CAP_EXT_BUTTONS_STICK(info
->ext_cap_10
))
1334 for (i
= 0; i
< SYN_CAP_MULTI_BUTTON_NO(info
->ext_cap
); i
++)
1335 input_set_capability(dev
, EV_KEY
, BTN_0
+ i
);
1337 if (SYN_CAP_CLICKPAD(info
->ext_cap_0c
)) {
1338 __set_bit(INPUT_PROP_BUTTONPAD
, dev
->propbit
);
1339 if (psmouse_matches_pnp_id(psmouse
, topbuttonpad_pnp_ids
) &&
1340 !SYN_CAP_EXT_BUTTONS_STICK(info
->ext_cap_10
))
1341 __set_bit(INPUT_PROP_TOPBUTTONPAD
, dev
->propbit
);
1347 static ssize_t
synaptics_show_disable_gesture(struct psmouse
*psmouse
,
1348 void *data
, char *buf
)
1350 struct synaptics_data
*priv
= psmouse
->private;
1352 return sprintf(buf
, "%c\n", priv
->disable_gesture
? '1' : '0');
1355 static ssize_t
synaptics_set_disable_gesture(struct psmouse
*psmouse
,
1356 void *data
, const char *buf
,
1359 struct synaptics_data
*priv
= psmouse
->private;
1363 err
= kstrtouint(buf
, 10, &value
);
1370 if (value
== priv
->disable_gesture
)
1373 priv
->disable_gesture
= value
;
1375 priv
->mode
|= SYN_BIT_DISABLE_GESTURE
;
1377 priv
->mode
&= ~SYN_BIT_DISABLE_GESTURE
;
1379 if (synaptics_mode_cmd(psmouse
, priv
->mode
))
1385 PSMOUSE_DEFINE_ATTR(disable_gesture
, S_IWUSR
| S_IRUGO
, NULL
,
1386 synaptics_show_disable_gesture
,
1387 synaptics_set_disable_gesture
);
1389 static void synaptics_disconnect(struct psmouse
*psmouse
)
1391 struct synaptics_data
*priv
= psmouse
->private;
1394 * We might have left a breadcrumb when trying to
1395 * set up SMbus companion.
1397 psmouse_smbus_cleanup(psmouse
);
1399 if (!priv
->absolute_mode
&&
1400 SYN_ID_DISGEST_SUPPORTED(priv
->info
.identity
))
1401 device_remove_file(&psmouse
->ps2dev
.serio
->dev
,
1402 &psmouse_attr_disable_gesture
.dattr
);
1404 synaptics_reset(psmouse
);
1406 psmouse
->private = NULL
;
1409 static int synaptics_reconnect(struct psmouse
*psmouse
)
1411 struct synaptics_data
*priv
= psmouse
->private;
1412 struct synaptics_device_info info
;
1418 psmouse_reset(psmouse
);
1421 * On some boxes, right after resuming, the touchpad
1422 * needs some time to finish initializing (I assume
1423 * it needs time to calibrate) and start responding
1424 * to Synaptics-specific queries, so let's wait a
1429 ps2_command(&psmouse
->ps2dev
, param
, PSMOUSE_CMD_GETID
);
1430 error
= synaptics_detect(psmouse
, 0);
1431 } while (error
&& ++retry
< 3);
1437 psmouse_dbg(psmouse
, "reconnected after %d tries\n", retry
);
1439 error
= synaptics_query_hardware(psmouse
, &info
);
1441 psmouse_err(psmouse
, "Unable to query device.\n");
1445 error
= synaptics_set_mode(psmouse
);
1447 psmouse_err(psmouse
, "Unable to initialize device.\n");
1451 if (info
.identity
!= priv
->info
.identity
||
1452 info
.model_id
!= priv
->info
.model_id
||
1453 info
.capabilities
!= priv
->info
.capabilities
||
1454 info
.ext_cap
!= priv
->info
.ext_cap
) {
1455 psmouse_err(psmouse
,
1456 "hardware appears to be different: id(%u-%u), model(%u-%u), caps(%x-%x), ext(%x-%x).\n",
1457 priv
->info
.identity
, info
.identity
,
1458 priv
->info
.model_id
, info
.model_id
,
1459 priv
->info
.capabilities
, info
.capabilities
,
1460 priv
->info
.ext_cap
, info
.ext_cap
);
1467 static bool impaired_toshiba_kbc
;
1469 static const struct dmi_system_id toshiba_dmi_table
[] __initconst
= {
1470 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
1472 /* Toshiba Satellite */
1474 DMI_MATCH(DMI_SYS_VENDOR
, "TOSHIBA"),
1475 DMI_MATCH(DMI_PRODUCT_NAME
, "Satellite"),
1479 /* Toshiba Dynabook */
1481 DMI_MATCH(DMI_SYS_VENDOR
, "TOSHIBA"),
1482 DMI_MATCH(DMI_PRODUCT_NAME
, "dynabook"),
1486 /* Toshiba Portege M300 */
1488 DMI_MATCH(DMI_SYS_VENDOR
, "TOSHIBA"),
1489 DMI_MATCH(DMI_PRODUCT_NAME
, "PORTEGE M300"),
1494 /* Toshiba Portege M300 */
1496 DMI_MATCH(DMI_SYS_VENDOR
, "TOSHIBA"),
1497 DMI_MATCH(DMI_PRODUCT_NAME
, "Portable PC"),
1498 DMI_MATCH(DMI_PRODUCT_VERSION
, "Version 1.0"),
1506 static bool broken_olpc_ec
;
1508 static const struct dmi_system_id olpc_dmi_table
[] __initconst
= {
1509 #if defined(CONFIG_DMI) && defined(CONFIG_OLPC)
1511 /* OLPC XO-1 or XO-1.5 */
1513 DMI_MATCH(DMI_SYS_VENDOR
, "OLPC"),
1514 DMI_MATCH(DMI_PRODUCT_NAME
, "XO"),
1521 static const struct dmi_system_id __initconst cr48_dmi_table
[] = {
1522 #if defined(CONFIG_DMI) && defined(CONFIG_X86)
1524 /* Cr-48 Chromebook (Codename Mario) */
1526 DMI_MATCH(DMI_SYS_VENDOR
, "IEC"),
1527 DMI_MATCH(DMI_PRODUCT_NAME
, "Mario"),
1534 void __init
synaptics_module_init(void)
1536 impaired_toshiba_kbc
= dmi_check_system(toshiba_dmi_table
);
1537 broken_olpc_ec
= dmi_check_system(olpc_dmi_table
);
1538 cr48_profile_sensor
= dmi_check_system(cr48_dmi_table
);
1541 static int synaptics_init_ps2(struct psmouse
*psmouse
,
1542 struct synaptics_device_info
*info
,
1545 struct synaptics_data
*priv
;
1548 synaptics_apply_quirks(psmouse
, info
);
1550 psmouse
->private = priv
= kzalloc(sizeof(struct synaptics_data
), GFP_KERNEL
);
1555 priv
->absolute_mode
= absolute_mode
;
1556 if (SYN_ID_DISGEST_SUPPORTED(info
->identity
))
1557 priv
->disable_gesture
= true;
1560 * Unfortunately ForcePad capability is not exported over PS/2,
1561 * so we have to resort to checking PNP IDs.
1563 priv
->is_forcepad
= psmouse_matches_pnp_id(psmouse
, forcepad_pnp_ids
);
1565 err
= synaptics_set_mode(psmouse
);
1567 psmouse_err(psmouse
, "Unable to initialize device.\n");
1571 priv
->pkt_type
= SYN_MODEL_NEWABS(info
->model_id
) ?
1572 SYN_NEWABS
: SYN_OLDABS
;
1574 psmouse_info(psmouse
,
1575 "Touchpad model: %lu, fw: %lu.%lu, id: %#x, caps: %#x/%#x/%#x/%#x, board id: %u, fw id: %u\n",
1576 SYN_ID_MODEL(info
->identity
),
1577 SYN_ID_MAJOR(info
->identity
), SYN_ID_MINOR(info
->identity
),
1579 info
->capabilities
, info
->ext_cap
, info
->ext_cap_0c
,
1580 info
->ext_cap_10
, info
->board_id
, info
->firmware_id
);
1582 err
= set_input_params(psmouse
, priv
);
1584 psmouse_err(psmouse
,
1585 "failed to set up capabilities: %d\n", err
);
1590 * Encode touchpad model so that it can be used to set
1591 * input device->id.version and be visible to userspace.
1592 * Because version is __u16 we have to drop something.
1593 * Hardware info bits seem to be good candidates as they
1594 * are documented to be for Synaptics corp. internal use.
1596 psmouse
->model
= ((info
->model_id
& 0x00ff0000) >> 8) |
1597 (info
->model_id
& 0x000000ff);
1599 if (absolute_mode
) {
1600 psmouse
->protocol_handler
= synaptics_process_byte
;
1601 psmouse
->pktsize
= 6;
1603 /* Relative mode follows standard PS/2 mouse protocol */
1604 psmouse
->protocol_handler
= psmouse_process_byte
;
1605 psmouse
->pktsize
= 3;
1608 psmouse
->set_rate
= synaptics_set_rate
;
1609 psmouse
->disconnect
= synaptics_disconnect
;
1610 psmouse
->reconnect
= synaptics_reconnect
;
1611 psmouse
->cleanup
= synaptics_reset
;
1612 /* Synaptics can usually stay in sync without extra help */
1613 psmouse
->resync_time
= 0;
1615 if (SYN_CAP_PASS_THROUGH(info
->capabilities
))
1616 synaptics_pt_create(psmouse
);
1619 * Toshiba's KBC seems to have trouble handling data from
1620 * Synaptics at full rate. Switch to a lower rate (roughly
1621 * the same rate as a standard PS/2 mouse).
1623 if (psmouse
->rate
>= 80 && impaired_toshiba_kbc
) {
1624 psmouse_info(psmouse
,
1625 "Toshiba %s detected, limiting rate to 40pps.\n",
1626 dmi_get_system_info(DMI_PRODUCT_NAME
));
1630 if (!priv
->absolute_mode
&& SYN_ID_DISGEST_SUPPORTED(info
->identity
)) {
1631 err
= device_create_file(&psmouse
->ps2dev
.serio
->dev
,
1632 &psmouse_attr_disable_gesture
.dattr
);
1634 psmouse_err(psmouse
,
1635 "Failed to create disable_gesture attribute (%d)",
1648 static int __synaptics_init(struct psmouse
*psmouse
, bool absolute_mode
)
1650 struct synaptics_device_info info
;
1653 psmouse_reset(psmouse
);
1655 error
= synaptics_query_hardware(psmouse
, &info
);
1657 psmouse_err(psmouse
, "Unable to query device: %d\n", error
);
1661 return synaptics_init_ps2(psmouse
, &info
, absolute_mode
);
1664 int synaptics_init_absolute(struct psmouse
*psmouse
)
1666 return __synaptics_init(psmouse
, true);
1669 int synaptics_init_relative(struct psmouse
*psmouse
)
1671 return __synaptics_init(psmouse
, false);
1674 static int synaptics_setup_ps2(struct psmouse
*psmouse
,
1675 struct synaptics_device_info
*info
)
1677 bool absolute_mode
= true;
1681 * The OLPC XO has issues with Synaptics' absolute mode; the constant
1682 * packet spew overloads the EC such that key presses on the keyboard
1683 * are missed. Given that, don't even attempt to use Absolute mode.
1684 * Relative mode seems to work just fine.
1686 if (broken_olpc_ec
) {
1687 psmouse_info(psmouse
,
1688 "OLPC XO detected, forcing relative protocol.\n");
1689 absolute_mode
= false;
1692 error
= synaptics_init_ps2(psmouse
, info
, absolute_mode
);
1696 return absolute_mode
? PSMOUSE_SYNAPTICS
: PSMOUSE_SYNAPTICS_RELATIVE
;
1699 #else /* CONFIG_MOUSE_PS2_SYNAPTICS */
1701 void __init
synaptics_module_init(void)
1705 static int __maybe_unused
1706 synaptics_setup_ps2(struct psmouse
*psmouse
,
1707 struct synaptics_device_info
*info
)
1712 #endif /* CONFIG_MOUSE_PS2_SYNAPTICS */
1714 #ifdef CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS
1717 * The newest Synaptics device can use a secondary bus (called InterTouch) which
1718 * provides a better bandwidth and allow a better control of the touchpads.
1719 * This is used to decide if we need to use this bus or not.
1722 SYNAPTICS_INTERTOUCH_NOT_SET
= -1,
1723 SYNAPTICS_INTERTOUCH_OFF
,
1724 SYNAPTICS_INTERTOUCH_ON
,
1727 static int synaptics_intertouch
= IS_ENABLED(CONFIG_RMI4_SMB
) ?
1728 SYNAPTICS_INTERTOUCH_NOT_SET
: SYNAPTICS_INTERTOUCH_OFF
;
1729 module_param_named(synaptics_intertouch
, synaptics_intertouch
, int, 0644);
1730 MODULE_PARM_DESC(synaptics_intertouch
, "Use a secondary bus for the Synaptics device.");
1732 static int synaptics_create_intertouch(struct psmouse
*psmouse
,
1733 struct synaptics_device_info
*info
,
1734 bool leave_breadcrumbs
)
1737 psmouse_matches_pnp_id(psmouse
, topbuttonpad_pnp_ids
) &&
1738 !SYN_CAP_EXT_BUTTONS_STICK(info
->ext_cap_10
);
1739 const struct rmi_device_platform_data pdata
= {
1741 .sensor_type
= rmi_sensor_touchpad
,
1742 .axis_align
.flip_y
= true,
1743 .kernel_tracking
= false,
1744 .topbuttonpad
= topbuttonpad
,
1747 .buttonpad
= SYN_CAP_CLICKPAD(info
->ext_cap_0c
),
1748 .trackstick_buttons
=
1749 !!SYN_CAP_EXT_BUTTONS_STICK(info
->ext_cap_10
),
1752 const struct i2c_board_info intertouch_board
= {
1753 I2C_BOARD_INFO("rmi4_smbus", 0x2c),
1754 .flags
= I2C_CLIENT_HOST_NOTIFY
,
1757 return psmouse_smbus_init(psmouse
, &intertouch_board
,
1758 &pdata
, sizeof(pdata
), true,
1763 * synaptics_setup_intertouch - called once the PS/2 devices are enumerated
1764 * and decides to instantiate a SMBus InterTouch device.
1766 static int synaptics_setup_intertouch(struct psmouse
*psmouse
,
1767 struct synaptics_device_info
*info
,
1768 bool leave_breadcrumbs
)
1772 if (synaptics_intertouch
== SYNAPTICS_INTERTOUCH_OFF
)
1775 if (synaptics_intertouch
== SYNAPTICS_INTERTOUCH_NOT_SET
) {
1776 if (!psmouse_matches_pnp_id(psmouse
, topbuttonpad_pnp_ids
) &&
1777 !psmouse_matches_pnp_id(psmouse
, smbus_pnp_ids
)) {
1779 if (!psmouse_matches_pnp_id(psmouse
, forcepad_pnp_ids
))
1780 psmouse_info(psmouse
,
1781 "Your touchpad (%s) says it can support a different bus. "
1782 "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",
1783 psmouse
->ps2dev
.serio
->firmware_id
);
1789 psmouse_info(psmouse
, "Trying to set up SMBus access\n");
1791 error
= synaptics_create_intertouch(psmouse
, info
, leave_breadcrumbs
);
1793 if (error
== -EAGAIN
)
1794 psmouse_info(psmouse
, "SMbus companion is not ready yet\n");
1796 psmouse_err(psmouse
, "unable to create intertouch device\n");
1804 int synaptics_init_smbus(struct psmouse
*psmouse
)
1806 struct synaptics_device_info info
;
1809 psmouse_reset(psmouse
);
1811 error
= synaptics_query_hardware(psmouse
, &info
);
1813 psmouse_err(psmouse
, "Unable to query device: %d\n", error
);
1817 if (!SYN_CAP_INTERTOUCH(info
.ext_cap_0c
))
1820 return synaptics_create_intertouch(psmouse
, &info
, false);
1823 #else /* CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */
1825 static int __maybe_unused
1826 synaptics_setup_intertouch(struct psmouse
*psmouse
,
1827 struct synaptics_device_info
*info
,
1828 bool leave_breadcrumbs
)
1833 int synaptics_init_smbus(struct psmouse
*psmouse
)
1838 #endif /* CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */
1840 #if defined(CONFIG_MOUSE_PS2_SYNAPTICS) || \
1841 defined(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS)
1843 int synaptics_init(struct psmouse
*psmouse
)
1845 struct synaptics_device_info info
;
1849 psmouse_reset(psmouse
);
1851 error
= synaptics_query_hardware(psmouse
, &info
);
1853 psmouse_err(psmouse
, "Unable to query device: %d\n", error
);
1857 if (SYN_CAP_INTERTOUCH(info
.ext_cap_0c
)) {
1858 if ((!IS_ENABLED(CONFIG_RMI4_SMB
) ||
1859 !IS_ENABLED(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS
)) &&
1860 /* Forcepads need F21, which is not ready */
1861 !psmouse_matches_pnp_id(psmouse
, forcepad_pnp_ids
)) {
1862 psmouse_warn(psmouse
,
1863 "The touchpad can support a better bus than the too old PS/2 protocol. "
1864 "Make sure MOUSE_PS2_SYNAPTICS_SMBUS and RMI4_SMB are enabled to get a better touchpad experience.\n");
1867 error
= synaptics_setup_intertouch(psmouse
, &info
, true);
1869 return PSMOUSE_SYNAPTICS_SMBUS
;
1872 retval
= synaptics_setup_ps2(psmouse
, &info
);
1875 * Not using any flavor of Synaptics support, so clean up
1876 * SMbus breadcrumbs, if any.
1878 psmouse_smbus_cleanup(psmouse
);
1884 #else /* CONFIG_MOUSE_PS2_SYNAPTICS || CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */
1886 int synaptics_init(struct psmouse
*psmouse
)
1891 #endif /* CONFIG_MOUSE_PS2_SYNAPTICS || CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS */