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