1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
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
37
38
39
40
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
52#define ABS_POS_BITS 13
53
54
55
56
57
58
59
60
61
62
63
64
65
66#define X_MAX_POSITIVE 8176
67#define Y_MAX_POSITIVE 8176
68
69
70#define DMAX 10
71
72
73
74
75
76
77
78
79static 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
96int 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
118void synaptics_reset(struct psmouse *psmouse)
119{
120
121 synaptics_mode_cmd(psmouse, 0);
122}
123
124#if defined(CONFIG_MOUSE_PS2_SYNAPTICS) || \
125 defined(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS)
126
127
128static 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",
139 "LEN0034",
140 "LEN0035",
141 "LEN0036",
142 "LEN0037",
143 "LEN0038",
144 "LEN0039",
145 "LEN0041",
146 "LEN0042",
147 "LEN0045",
148 "LEN0047",
149 "LEN2000",
150 "LEN2001",
151 "LEN2002",
152 "LEN2003",
153 "LEN2004",
154 "LEN2005",
155 "LEN2006",
156 "LEN2007",
157 "LEN2008",
158 "LEN2009",
159 "LEN200A",
160 "LEN200B",
161 NULL
162};
163
164static const char * const smbus_pnp_ids[] = {
165
166 "LEN0048",
167 "LEN0046",
168 "LEN0049",
169 "LEN004a",
170 "LEN005b",
171 "LEN005e",
172 "LEN006c",
173 "LEN007a",
174 "LEN0071",
175 "LEN0072",
176 "LEN0073",
177 "LEN0091",
178 "LEN0092",
179 "LEN0093",
180 "LEN0096",
181 "LEN0097",
182 "LEN0099",
183 "LEN009b",
184 "LEN0402",
185 "LEN200f",
186 "LEN2044",
187 "LEN2054",
188 "LEN2055",
189 "LEN2068",
190 "SYN3052",
191 "SYN3221",
192 "SYN323d",
193 "SYN3257",
194 NULL
195};
196
197static const char * const forcepad_pnp_ids[] = {
198 "SYN300D",
199 "SYN3014",
200 NULL
201};
202
203
204
205
206static 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
221static 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
239
240
241static 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
255
256
257static 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
265
266static 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
275
276
277static int synaptics_query_modes(struct psmouse *psmouse,
278 struct synaptics_device_info *info)
279{
280 u8 bid[3];
281 int error;
282
283
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
302
303
304static 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
318
319 if (SYN_ID_FULL(info->identity) < 0x705 &&
320 SYN_CAP_SUBMODEL_ID(info->capabilities) != 0x47) {
321 return -ENXIO;
322 }
323
324
325
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
339
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
359
360
361static 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];
374 info->y_res = resp[2];
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
398
399
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
419static 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
454
455#ifdef CONFIG_MOUSE_PS2_SYNAPTICS
456
457static bool cr48_profile_sensor;
458
459#define ANY_BOARD_ID 0
460struct 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
468static 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
511
512
513
514
515
516
517
518static int synaptics_invert_y(int y)
519{
520 return YMAX_NOMINAL + YMIN_NOMINAL - y;
521}
522
523
524
525
526static 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
556static 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
562static 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, ¶m, PSMOUSE_CMD_SETRATE);
572 if (error)
573 return error;
574
575 return 0;
576}
577
578static 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
610static 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
627
628static 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;
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
645static 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
657static 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
667static int synaptics_is_pt_packet(u8 *buf)
668{
669 return (buf[0] & 0xFC) == 0x84 && (buf[3] & 0xCC) == 0xC4;
670}
671
672static 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
687static 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
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
705static 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
733
734
735static 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
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
754 priv->agm_count = buf[1];
755 break;
756
757 default:
758 break;
759 }
760}
761
762static 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
774static 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
804
805
806
807
808
809
810
811 if (hw->z == 0) {
812
813 priv->press = priv->report_press = false;
814 } else if (hw->w >= 4 && ((buf[0] ^ buf[3]) & 0x01)) {
815
816
817
818
819
820
821
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
840
841
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
873
874
875
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
890static 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
901static 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
920static 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
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
949
950
951
952 if (priv->pt_port) {
953 u8 pt_buttons;
954
955
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
966static 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
986static 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
1016 input_mt_report_pointer_emulation(dev, false);
1017
1018
1019 input_mt_report_finger_count(dev, num_fingers);
1020
1021 synaptics_report_buttons(psmouse, sgm);
1022
1023 input_sync(dev);
1024}
1025
1026static 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
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
1047 synaptics_report_mt_data(psmouse, sgm, num_fingers);
1048}
1049
1050static bool synaptics_has_multifinger(struct synaptics_data *priv)
1051{
1052 if (SYN_CAP_MULTIFINGER(priv->info.capabilities))
1053 return true;
1054
1055
1056 return synaptics_has_agm(priv);
1057}
1058
1059
1060
1061
1062static 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
1110
1111
1112
1113
1114 break;
1115 case 4 ... 15:
1116 if (SYN_CAP_PALMDETECT(info->capabilities))
1117 finger_width = hw.w;
1118 break;
1119 }
1120 }
1121 } else {
1122 num_fingers = 0;
1123 finger_width = 0;
1124 }
1125
1126 if (cr48_profile_sensor) {
1127 synaptics_report_mt_data(psmouse, &hw, num_fingers);
1128 return;
1129 }
1130
1131 if (SYN_CAP_ADV_GESTURE(info->ext_cap_0c))
1132 synaptics_report_semi_mt_data(dev, &hw, &priv->agm,
1133 num_fingers);
1134
1135
1136
1137
1138
1139 if (hw.z > 30) input_report_key(dev, BTN_TOUCH, 1);
1140 if (hw.z < 25) input_report_key(dev, BTN_TOUCH, 0);
1141
1142 if (num_fingers > 0) {
1143 input_report_abs(dev, ABS_X, hw.x);
1144 input_report_abs(dev, ABS_Y, synaptics_invert_y(hw.y));
1145 }
1146 input_report_abs(dev, ABS_PRESSURE, hw.z);
1147
1148 if (SYN_CAP_PALMDETECT(info->capabilities))
1149 input_report_abs(dev, ABS_TOOL_WIDTH, finger_width);
1150
1151 input_report_key(dev, BTN_TOOL_FINGER, num_fingers == 1);
1152 if (synaptics_has_multifinger(priv)) {
1153 input_report_key(dev, BTN_TOOL_DOUBLETAP, num_fingers == 2);
1154 input_report_key(dev, BTN_TOOL_TRIPLETAP, num_fingers == 3);
1155 }
1156
1157 synaptics_report_buttons(psmouse, &hw);
1158
1159 input_sync(dev);
1160}
1161
1162static bool synaptics_validate_byte(struct psmouse *psmouse,
1163 int idx, enum synaptics_pkt_type pkt_type)
1164{
1165 static const u8 newabs_mask[] = { 0xC8, 0x00, 0x00, 0xC8, 0x00 };
1166 static const u8 newabs_rel_mask[] = { 0xC0, 0x00, 0x00, 0xC0, 0x00 };
1167 static const u8 newabs_rslt[] = { 0x80, 0x00, 0x00, 0xC0, 0x00 };
1168 static const u8 oldabs_mask[] = { 0xC0, 0x60, 0x00, 0xC0, 0x60 };
1169 static const u8 oldabs_rslt[] = { 0xC0, 0x00, 0x00, 0x80, 0x00 };
1170 const u8 *packet = psmouse->packet;
1171
1172 if (idx < 0 || idx > 4)
1173 return false;
1174
1175 switch (pkt_type) {
1176
1177 case SYN_NEWABS:
1178 case SYN_NEWABS_RELAXED:
1179 return (packet[idx] & newabs_rel_mask[idx]) == newabs_rslt[idx];
1180
1181 case SYN_NEWABS_STRICT:
1182 return (packet[idx] & newabs_mask[idx]) == newabs_rslt[idx];
1183
1184 case SYN_OLDABS:
1185 return (packet[idx] & oldabs_mask[idx]) == oldabs_rslt[idx];
1186
1187 default:
1188 psmouse_err(psmouse, "unknown packet type %d\n", pkt_type);
1189 return false;
1190 }
1191}
1192
1193static enum synaptics_pkt_type
1194synaptics_detect_pkt_type(struct psmouse *psmouse)
1195{
1196 int i;
1197
1198 for (i = 0; i < 5; i++) {
1199 if (!synaptics_validate_byte(psmouse, i, SYN_NEWABS_STRICT)) {
1200 psmouse_info(psmouse, "using relaxed packet validation\n");
1201 return SYN_NEWABS_RELAXED;
1202 }
1203 }
1204
1205 return SYN_NEWABS_STRICT;
1206}
1207
1208static psmouse_ret_t synaptics_process_byte(struct psmouse *psmouse)
1209{
1210 struct synaptics_data *priv = psmouse->private;
1211
1212 if (psmouse->pktcnt >= 6) {
1213 if (unlikely(priv->pkt_type == SYN_NEWABS))
1214 priv->pkt_type = synaptics_detect_pkt_type(psmouse);
1215
1216 if (SYN_CAP_PASS_THROUGH(priv->info.capabilities) &&
1217 synaptics_is_pt_packet(psmouse->packet)) {
1218 if (priv->pt_port)
1219 synaptics_pass_pt_packet(priv->pt_port,
1220 psmouse->packet);
1221 } else
1222 synaptics_process_packet(psmouse);
1223
1224 return PSMOUSE_FULL_PACKET;
1225 }
1226
1227 return synaptics_validate_byte(psmouse, psmouse->pktcnt - 1, priv->pkt_type) ?
1228 PSMOUSE_GOOD_DATA : PSMOUSE_BAD_DATA;
1229}
1230
1231
1232
1233
1234static void set_abs_position_params(struct input_dev *dev,
1235 struct synaptics_device_info *info,
1236 int x_code, int y_code)
1237{
1238 int x_min = info->x_min ?: XMIN_NOMINAL;
1239 int x_max = info->x_max ?: XMAX_NOMINAL;
1240 int y_min = info->y_min ?: YMIN_NOMINAL;
1241 int y_max = info->y_max ?: YMAX_NOMINAL;
1242 int fuzz = SYN_CAP_REDUCED_FILTERING(info->ext_cap_0c) ?
1243 SYN_REDUCED_FILTER_FUZZ : 0;
1244
1245 input_set_abs_params(dev, x_code, x_min, x_max, fuzz, 0);
1246 input_set_abs_params(dev, y_code, y_min, y_max, fuzz, 0);
1247 input_abs_set_res(dev, x_code, info->x_res);
1248 input_abs_set_res(dev, y_code, info->y_res);
1249}
1250
1251static int set_input_params(struct psmouse *psmouse,
1252 struct synaptics_data *priv)
1253{
1254 struct input_dev *dev = psmouse->dev;
1255 struct synaptics_device_info *info = &priv->info;
1256 int i;
1257 int error;
1258
1259
1260 __clear_bit(EV_REL, dev->evbit);
1261 bitmap_zero(dev->relbit, REL_CNT);
1262 bitmap_zero(dev->keybit, KEY_CNT);
1263
1264
1265 __set_bit(INPUT_PROP_POINTER, dev->propbit);
1266
1267 input_set_capability(dev, EV_KEY, BTN_LEFT);
1268
1269
1270 if (!SYN_CAP_CLICKPAD(info->ext_cap_0c)) {
1271 input_set_capability(dev, EV_KEY, BTN_RIGHT);
1272 if (SYN_CAP_MIDDLE_BUTTON(info->capabilities))
1273 input_set_capability(dev, EV_KEY, BTN_MIDDLE);
1274 }
1275
1276 if (!priv->absolute_mode) {
1277
1278 input_set_capability(dev, EV_REL, REL_X);
1279 input_set_capability(dev, EV_REL, REL_Y);
1280 return 0;
1281 }
1282
1283
1284 set_abs_position_params(dev, &priv->info, ABS_X, ABS_Y);
1285 input_set_abs_params(dev, ABS_PRESSURE, 0, 255, 0, 0);
1286
1287 if (cr48_profile_sensor)
1288 input_set_abs_params(dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
1289
1290 if (SYN_CAP_IMAGE_SENSOR(info->ext_cap_0c)) {
1291 set_abs_position_params(dev, info,
1292 ABS_MT_POSITION_X, ABS_MT_POSITION_Y);
1293
1294 input_set_abs_params(dev, ABS_MT_PRESSURE, 0, 255, 0, 0);
1295
1296 error = input_mt_init_slots(dev, 2,
1297 INPUT_MT_POINTER | INPUT_MT_TRACK);
1298 if (error)
1299 return error;
1300
1301
1302 input_set_capability(dev, EV_KEY, BTN_TOOL_QUADTAP);
1303 input_set_capability(dev, EV_KEY, BTN_TOOL_QUINTTAP);
1304 } else if (SYN_CAP_ADV_GESTURE(info->ext_cap_0c)) {
1305 set_abs_position_params(dev, info,
1306 ABS_MT_POSITION_X, ABS_MT_POSITION_Y);
1307
1308
1309
1310
1311 error = input_mt_init_slots(dev, 2,
1312 INPUT_MT_POINTER |
1313 (cr48_profile_sensor ?
1314 INPUT_MT_TRACK :
1315 INPUT_MT_SEMI_MT));
1316 if (error)
1317 return error;
1318
1319
1320
1321
1322
1323
1324
1325
1326 if (!cr48_profile_sensor)
1327 set_abs_position_params(dev, &priv->info, ABS_X, ABS_Y);
1328 }
1329
1330 if (SYN_CAP_PALMDETECT(info->capabilities))
1331 input_set_abs_params(dev, ABS_TOOL_WIDTH, 0, 15, 0, 0);
1332
1333 input_set_capability(dev, EV_KEY, BTN_TOUCH);
1334 input_set_capability(dev, EV_KEY, BTN_TOOL_FINGER);
1335
1336 if (synaptics_has_multifinger(priv)) {
1337 input_set_capability(dev, EV_KEY, BTN_TOOL_DOUBLETAP);
1338 input_set_capability(dev, EV_KEY, BTN_TOOL_TRIPLETAP);
1339 }
1340
1341 if (SYN_CAP_FOUR_BUTTON(info->capabilities) ||
1342 SYN_CAP_MIDDLE_BUTTON(info->capabilities)) {
1343 input_set_capability(dev, EV_KEY, BTN_FORWARD);
1344 input_set_capability(dev, EV_KEY, BTN_BACK);
1345 }
1346
1347 if (!SYN_CAP_EXT_BUTTONS_STICK(info->ext_cap_10))
1348 for (i = 0; i < SYN_CAP_MULTI_BUTTON_NO(info->ext_cap); i++)
1349 input_set_capability(dev, EV_KEY, BTN_0 + i);
1350
1351 if (SYN_CAP_CLICKPAD(info->ext_cap_0c)) {
1352 __set_bit(INPUT_PROP_BUTTONPAD, dev->propbit);
1353 if (psmouse_matches_pnp_id(psmouse, topbuttonpad_pnp_ids) &&
1354 !SYN_CAP_EXT_BUTTONS_STICK(info->ext_cap_10))
1355 __set_bit(INPUT_PROP_TOPBUTTONPAD, dev->propbit);
1356 }
1357
1358 return 0;
1359}
1360
1361static ssize_t synaptics_show_disable_gesture(struct psmouse *psmouse,
1362 void *data, char *buf)
1363{
1364 struct synaptics_data *priv = psmouse->private;
1365
1366 return sprintf(buf, "%c\n", priv->disable_gesture ? '1' : '0');
1367}
1368
1369static ssize_t synaptics_set_disable_gesture(struct psmouse *psmouse,
1370 void *data, const char *buf,
1371 size_t len)
1372{
1373 struct synaptics_data *priv = psmouse->private;
1374 unsigned int value;
1375 int err;
1376
1377 err = kstrtouint(buf, 10, &value);
1378 if (err)
1379 return err;
1380
1381 if (value > 1)
1382 return -EINVAL;
1383
1384 if (value == priv->disable_gesture)
1385 return len;
1386
1387 priv->disable_gesture = value;
1388 if (value)
1389 priv->mode |= SYN_BIT_DISABLE_GESTURE;
1390 else
1391 priv->mode &= ~SYN_BIT_DISABLE_GESTURE;
1392
1393 if (synaptics_mode_cmd(psmouse, priv->mode))
1394 return -EIO;
1395
1396 return len;
1397}
1398
1399PSMOUSE_DEFINE_ATTR(disable_gesture, S_IWUSR | S_IRUGO, NULL,
1400 synaptics_show_disable_gesture,
1401 synaptics_set_disable_gesture);
1402
1403static void synaptics_disconnect(struct psmouse *psmouse)
1404{
1405 struct synaptics_data *priv = psmouse->private;
1406
1407
1408
1409
1410
1411 psmouse_smbus_cleanup(psmouse);
1412
1413 if (!priv->absolute_mode &&
1414 SYN_ID_DISGEST_SUPPORTED(priv->info.identity))
1415 device_remove_file(&psmouse->ps2dev.serio->dev,
1416 &psmouse_attr_disable_gesture.dattr);
1417
1418 synaptics_reset(psmouse);
1419 kfree(priv);
1420 psmouse->private = NULL;
1421}
1422
1423static int synaptics_reconnect(struct psmouse *psmouse)
1424{
1425 struct synaptics_data *priv = psmouse->private;
1426 struct synaptics_device_info info;
1427 u8 param[2];
1428 int retry = 0;
1429 int error;
1430
1431 do {
1432 psmouse_reset(psmouse);
1433 if (retry) {
1434
1435
1436
1437
1438
1439
1440
1441 ssleep(1);
1442 }
1443 ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETID);
1444 error = synaptics_detect(psmouse, 0);
1445 } while (error && ++retry < 3);
1446
1447 if (error)
1448 return error;
1449
1450 if (retry > 1)
1451 psmouse_dbg(psmouse, "reconnected after %d tries\n", retry);
1452
1453 error = synaptics_query_hardware(psmouse, &info);
1454 if (error) {
1455 psmouse_err(psmouse, "Unable to query device.\n");
1456 return error;
1457 }
1458
1459 error = synaptics_set_mode(psmouse);
1460 if (error) {
1461 psmouse_err(psmouse, "Unable to initialize device.\n");
1462 return error;
1463 }
1464
1465 if (info.identity != priv->info.identity ||
1466 info.model_id != priv->info.model_id ||
1467 info.capabilities != priv->info.capabilities ||
1468 info.ext_cap != priv->info.ext_cap) {
1469 psmouse_err(psmouse,
1470 "hardware appears to be different: id(%u-%u), model(%u-%u), caps(%x-%x), ext(%x-%x).\n",
1471 priv->info.identity, info.identity,
1472 priv->info.model_id, info.model_id,
1473 priv->info.capabilities, info.capabilities,
1474 priv->info.ext_cap, info.ext_cap);
1475 return -ENXIO;
1476 }
1477
1478 return 0;
1479}
1480
1481static bool impaired_toshiba_kbc;
1482
1483static const struct dmi_system_id toshiba_dmi_table[] __initconst = {
1484#if defined(CONFIG_DMI) && defined(CONFIG_X86)
1485 {
1486
1487 .matches = {
1488 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1489 DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
1490 },
1491 },
1492 {
1493
1494 .matches = {
1495 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1496 DMI_MATCH(DMI_PRODUCT_NAME, "dynabook"),
1497 },
1498 },
1499 {
1500
1501 .matches = {
1502 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1503 DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE M300"),
1504 },
1505
1506 },
1507 {
1508
1509 .matches = {
1510 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1511 DMI_MATCH(DMI_PRODUCT_NAME, "Portable PC"),
1512 DMI_MATCH(DMI_PRODUCT_VERSION, "Version 1.0"),
1513 },
1514
1515 },
1516#endif
1517 { }
1518};
1519
1520static bool broken_olpc_ec;
1521
1522static const struct dmi_system_id olpc_dmi_table[] __initconst = {
1523#if defined(CONFIG_DMI) && defined(CONFIG_OLPC)
1524 {
1525
1526 .matches = {
1527 DMI_MATCH(DMI_SYS_VENDOR, "OLPC"),
1528 DMI_MATCH(DMI_PRODUCT_NAME, "XO"),
1529 },
1530 },
1531#endif
1532 { }
1533};
1534
1535static const struct dmi_system_id __initconst cr48_dmi_table[] = {
1536#if defined(CONFIG_DMI) && defined(CONFIG_X86)
1537 {
1538
1539 .matches = {
1540 DMI_MATCH(DMI_SYS_VENDOR, "IEC"),
1541 DMI_MATCH(DMI_PRODUCT_NAME, "Mario"),
1542 },
1543 },
1544#endif
1545 { }
1546};
1547
1548void __init synaptics_module_init(void)
1549{
1550 impaired_toshiba_kbc = dmi_check_system(toshiba_dmi_table);
1551 broken_olpc_ec = dmi_check_system(olpc_dmi_table);
1552 cr48_profile_sensor = dmi_check_system(cr48_dmi_table);
1553}
1554
1555static int synaptics_init_ps2(struct psmouse *psmouse,
1556 struct synaptics_device_info *info,
1557 bool absolute_mode)
1558{
1559 struct synaptics_data *priv;
1560 int err;
1561
1562 synaptics_apply_quirks(psmouse, info);
1563
1564 psmouse->private = priv = kzalloc(sizeof(struct synaptics_data), GFP_KERNEL);
1565 if (!priv)
1566 return -ENOMEM;
1567
1568 priv->info = *info;
1569 priv->absolute_mode = absolute_mode;
1570 if (SYN_ID_DISGEST_SUPPORTED(info->identity))
1571 priv->disable_gesture = true;
1572
1573
1574
1575
1576
1577 priv->is_forcepad = psmouse_matches_pnp_id(psmouse, forcepad_pnp_ids);
1578
1579 err = synaptics_set_mode(psmouse);
1580 if (err) {
1581 psmouse_err(psmouse, "Unable to initialize device.\n");
1582 goto init_fail;
1583 }
1584
1585 priv->pkt_type = SYN_MODEL_NEWABS(info->model_id) ?
1586 SYN_NEWABS : SYN_OLDABS;
1587
1588 psmouse_info(psmouse,
1589 "Touchpad model: %lu, fw: %lu.%lu, id: %#x, caps: %#x/%#x/%#x/%#x, board id: %u, fw id: %u\n",
1590 SYN_ID_MODEL(info->identity),
1591 SYN_ID_MAJOR(info->identity), SYN_ID_MINOR(info->identity),
1592 info->model_id,
1593 info->capabilities, info->ext_cap, info->ext_cap_0c,
1594 info->ext_cap_10, info->board_id, info->firmware_id);
1595
1596 err = set_input_params(psmouse, priv);
1597 if (err) {
1598 psmouse_err(psmouse,
1599 "failed to set up capabilities: %d\n", err);
1600 goto init_fail;
1601 }
1602
1603
1604
1605
1606
1607
1608
1609
1610 psmouse->model = ((info->model_id & 0x00ff0000) >> 8) |
1611 (info->model_id & 0x000000ff);
1612
1613 if (absolute_mode) {
1614 psmouse->protocol_handler = synaptics_process_byte;
1615 psmouse->pktsize = 6;
1616 } else {
1617
1618 psmouse->protocol_handler = psmouse_process_byte;
1619 psmouse->pktsize = 3;
1620 }
1621
1622 psmouse->set_rate = synaptics_set_rate;
1623 psmouse->disconnect = synaptics_disconnect;
1624 psmouse->reconnect = synaptics_reconnect;
1625 psmouse->cleanup = synaptics_reset;
1626
1627 psmouse->resync_time = 0;
1628
1629 if (SYN_CAP_PASS_THROUGH(info->capabilities))
1630 synaptics_pt_create(psmouse);
1631
1632
1633
1634
1635
1636
1637 if (psmouse->rate >= 80 && impaired_toshiba_kbc) {
1638 psmouse_info(psmouse,
1639 "Toshiba %s detected, limiting rate to 40pps.\n",
1640 dmi_get_system_info(DMI_PRODUCT_NAME));
1641 psmouse->rate = 40;
1642 }
1643
1644 if (!priv->absolute_mode && SYN_ID_DISGEST_SUPPORTED(info->identity)) {
1645 err = device_create_file(&psmouse->ps2dev.serio->dev,
1646 &psmouse_attr_disable_gesture.dattr);
1647 if (err) {
1648 psmouse_err(psmouse,
1649 "Failed to create disable_gesture attribute (%d)",
1650 err);
1651 goto init_fail;
1652 }
1653 }
1654
1655 return 0;
1656
1657 init_fail:
1658 kfree(priv);
1659 return err;
1660}
1661
1662static int __synaptics_init(struct psmouse *psmouse, bool absolute_mode)
1663{
1664 struct synaptics_device_info info;
1665 int error;
1666
1667 psmouse_reset(psmouse);
1668
1669 error = synaptics_query_hardware(psmouse, &info);
1670 if (error) {
1671 psmouse_err(psmouse, "Unable to query device: %d\n", error);
1672 return error;
1673 }
1674
1675 return synaptics_init_ps2(psmouse, &info, absolute_mode);
1676}
1677
1678int synaptics_init_absolute(struct psmouse *psmouse)
1679{
1680 return __synaptics_init(psmouse, true);
1681}
1682
1683int synaptics_init_relative(struct psmouse *psmouse)
1684{
1685 return __synaptics_init(psmouse, false);
1686}
1687
1688static int synaptics_setup_ps2(struct psmouse *psmouse,
1689 struct synaptics_device_info *info)
1690{
1691 bool absolute_mode = true;
1692 int error;
1693
1694
1695
1696
1697
1698
1699
1700 if (broken_olpc_ec) {
1701 psmouse_info(psmouse,
1702 "OLPC XO detected, forcing relative protocol.\n");
1703 absolute_mode = false;
1704 }
1705
1706 error = synaptics_init_ps2(psmouse, info, absolute_mode);
1707 if (error)
1708 return error;
1709
1710 return absolute_mode ? PSMOUSE_SYNAPTICS : PSMOUSE_SYNAPTICS_RELATIVE;
1711}
1712
1713#else
1714
1715void __init synaptics_module_init(void)
1716{
1717}
1718
1719static int __maybe_unused
1720synaptics_setup_ps2(struct psmouse *psmouse,
1721 struct synaptics_device_info *info)
1722{
1723 return -ENOSYS;
1724}
1725
1726#endif
1727
1728#ifdef CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS
1729
1730
1731
1732
1733
1734
1735enum {
1736 SYNAPTICS_INTERTOUCH_NOT_SET = -1,
1737 SYNAPTICS_INTERTOUCH_OFF,
1738 SYNAPTICS_INTERTOUCH_ON,
1739};
1740
1741static int synaptics_intertouch = IS_ENABLED(CONFIG_RMI4_SMB) ?
1742 SYNAPTICS_INTERTOUCH_NOT_SET : SYNAPTICS_INTERTOUCH_OFF;
1743module_param_named(synaptics_intertouch, synaptics_intertouch, int, 0644);
1744MODULE_PARM_DESC(synaptics_intertouch, "Use a secondary bus for the Synaptics device.");
1745
1746static int synaptics_create_intertouch(struct psmouse *psmouse,
1747 struct synaptics_device_info *info,
1748 bool leave_breadcrumbs)
1749{
1750 bool topbuttonpad =
1751 psmouse_matches_pnp_id(psmouse, topbuttonpad_pnp_ids) &&
1752 !SYN_CAP_EXT_BUTTONS_STICK(info->ext_cap_10);
1753 const struct rmi_device_platform_data pdata = {
1754 .sensor_pdata = {
1755 .sensor_type = rmi_sensor_touchpad,
1756 .axis_align.flip_y = true,
1757 .kernel_tracking = false,
1758 .topbuttonpad = topbuttonpad,
1759 },
1760 .gpio_data = {
1761 .buttonpad = SYN_CAP_CLICKPAD(info->ext_cap_0c),
1762 .trackstick_buttons =
1763 !!SYN_CAP_EXT_BUTTONS_STICK(info->ext_cap_10),
1764 },
1765 };
1766 const struct i2c_board_info intertouch_board = {
1767 I2C_BOARD_INFO("rmi4_smbus", 0x2c),
1768 .flags = I2C_CLIENT_HOST_NOTIFY,
1769 };
1770
1771 return psmouse_smbus_init(psmouse, &intertouch_board,
1772 &pdata, sizeof(pdata), true,
1773 leave_breadcrumbs);
1774}
1775
1776
1777
1778
1779
1780static int synaptics_setup_intertouch(struct psmouse *psmouse,
1781 struct synaptics_device_info *info,
1782 bool leave_breadcrumbs)
1783{
1784 int error;
1785
1786 if (synaptics_intertouch == SYNAPTICS_INTERTOUCH_OFF)
1787 return -ENXIO;
1788
1789 if (synaptics_intertouch == SYNAPTICS_INTERTOUCH_NOT_SET) {
1790 if (!psmouse_matches_pnp_id(psmouse, topbuttonpad_pnp_ids) &&
1791 !psmouse_matches_pnp_id(psmouse, smbus_pnp_ids)) {
1792
1793 if (!psmouse_matches_pnp_id(psmouse, forcepad_pnp_ids))
1794 psmouse_info(psmouse,
1795 "Your touchpad (%s) says it can support a different bus. "
1796 "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",
1797 psmouse->ps2dev.serio->firmware_id);
1798
1799 return -ENXIO;
1800 }
1801 }
1802
1803 psmouse_info(psmouse, "Trying to set up SMBus access\n");
1804
1805 error = synaptics_create_intertouch(psmouse, info, leave_breadcrumbs);
1806 if (error) {
1807 if (error == -EAGAIN)
1808 psmouse_info(psmouse, "SMbus companion is not ready yet\n");
1809 else
1810 psmouse_err(psmouse, "unable to create intertouch device\n");
1811
1812 return error;
1813 }
1814
1815 return 0;
1816}
1817
1818int synaptics_init_smbus(struct psmouse *psmouse)
1819{
1820 struct synaptics_device_info info;
1821 int error;
1822
1823 psmouse_reset(psmouse);
1824
1825 error = synaptics_query_hardware(psmouse, &info);
1826 if (error) {
1827 psmouse_err(psmouse, "Unable to query device: %d\n", error);
1828 return error;
1829 }
1830
1831 if (!SYN_CAP_INTERTOUCH(info.ext_cap_0c))
1832 return -ENXIO;
1833
1834 return synaptics_create_intertouch(psmouse, &info, false);
1835}
1836
1837#else
1838
1839static int __maybe_unused
1840synaptics_setup_intertouch(struct psmouse *psmouse,
1841 struct synaptics_device_info *info,
1842 bool leave_breadcrumbs)
1843{
1844 return -ENOSYS;
1845}
1846
1847int synaptics_init_smbus(struct psmouse *psmouse)
1848{
1849 return -ENOSYS;
1850}
1851
1852#endif
1853
1854#if defined(CONFIG_MOUSE_PS2_SYNAPTICS) || \
1855 defined(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS)
1856
1857int synaptics_init(struct psmouse *psmouse)
1858{
1859 struct synaptics_device_info info;
1860 int error;
1861 int retval;
1862
1863 psmouse_reset(psmouse);
1864
1865 error = synaptics_query_hardware(psmouse, &info);
1866 if (error) {
1867 psmouse_err(psmouse, "Unable to query device: %d\n", error);
1868 return error;
1869 }
1870
1871 if (SYN_CAP_INTERTOUCH(info.ext_cap_0c)) {
1872 if ((!IS_ENABLED(CONFIG_RMI4_SMB) ||
1873 !IS_ENABLED(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS)) &&
1874
1875 !psmouse_matches_pnp_id(psmouse, forcepad_pnp_ids)) {
1876 psmouse_warn(psmouse,
1877 "The touchpad can support a better bus than the too old PS/2 protocol. "
1878 "Make sure MOUSE_PS2_SYNAPTICS_SMBUS and RMI4_SMB are enabled to get a better touchpad experience.\n");
1879 }
1880
1881 error = synaptics_setup_intertouch(psmouse, &info, true);
1882 if (!error)
1883 return PSMOUSE_SYNAPTICS_SMBUS;
1884 }
1885
1886 retval = synaptics_setup_ps2(psmouse, &info);
1887 if (retval < 0) {
1888
1889
1890
1891
1892 psmouse_smbus_cleanup(psmouse);
1893 }
1894
1895 return retval;
1896}
1897
1898#else
1899
1900int synaptics_init(struct psmouse *psmouse)
1901{
1902 return -ENOSYS;
1903}
1904
1905#endif
1906
