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 if (SYN_MODEL_PEN(info->model_id))
1110 ;
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
1133
1134
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
1159static 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
1190static enum synaptics_pkt_type
1191synaptics_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
1205static psmouse_ret_t synaptics_process_byte(struct psmouse *psmouse)
1206{
1207 struct synaptics_data *priv = psmouse->private;
1208
1209 if (psmouse->pktcnt >= 6) {
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
1230
1231static 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
1248static 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
1257 __clear_bit(EV_REL, dev->evbit);
1258 bitmap_zero(dev->relbit, REL_CNT);
1259 bitmap_zero(dev->keybit, KEY_CNT);
1260
1261
1262 __set_bit(INPUT_PROP_POINTER, dev->propbit);
1263
1264 input_set_capability(dev, EV_KEY, BTN_LEFT);
1265
1266
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
1275 input_set_capability(dev, EV_REL, REL_X);
1276 input_set_capability(dev, EV_REL, REL_Y);
1277 return 0;
1278 }
1279
1280
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
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
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
1306
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
1318
1319
1320
1321
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
1358static 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
1366static 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
1396PSMOUSE_DEFINE_ATTR(disable_gesture, S_IWUSR | S_IRUGO, NULL,
1397 synaptics_show_disable_gesture,
1398 synaptics_set_disable_gesture);
1399
1400static void synaptics_disconnect(struct psmouse *psmouse)
1401{
1402 struct synaptics_data *priv = psmouse->private;
1403
1404
1405
1406
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
1420static 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
1433
1434
1435
1436
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
1478static bool impaired_toshiba_kbc;
1479
1480static const struct dmi_system_id toshiba_dmi_table[] __initconst = {
1481#if defined(CONFIG_DMI) && defined(CONFIG_X86)
1482 {
1483
1484 .matches = {
1485 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1486 DMI_MATCH(DMI_PRODUCT_NAME, "Satellite"),
1487 },
1488 },
1489 {
1490
1491 .matches = {
1492 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1493 DMI_MATCH(DMI_PRODUCT_NAME, "dynabook"),
1494 },
1495 },
1496 {
1497
1498 .matches = {
1499 DMI_MATCH(DMI_SYS_VENDOR, "TOSHIBA"),
1500 DMI_MATCH(DMI_PRODUCT_NAME, "PORTEGE M300"),
1501 },
1502
1503 },
1504 {
1505
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
1517static bool broken_olpc_ec;
1518
1519static const struct dmi_system_id olpc_dmi_table[] __initconst = {
1520#if defined(CONFIG_DMI) && defined(CONFIG_OLPC)
1521 {
1522
1523 .matches = {
1524 DMI_MATCH(DMI_SYS_VENDOR, "OLPC"),
1525 DMI_MATCH(DMI_PRODUCT_NAME, "XO"),
1526 },
1527 },
1528#endif
1529 { }
1530};
1531
1532static const struct dmi_system_id __initconst cr48_dmi_table[] = {
1533#if defined(CONFIG_DMI) && defined(CONFIG_X86)
1534 {
1535
1536 .matches = {
1537 DMI_MATCH(DMI_SYS_VENDOR, "IEC"),
1538 DMI_MATCH(DMI_PRODUCT_NAME, "Mario"),
1539 },
1540 },
1541#endif
1542 { }
1543};
1544
1545void __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
1552static 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
1572
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
1602
1603
1604
1605
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
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
1624 psmouse->resync_time = 0;
1625
1626 if (SYN_CAP_PASS_THROUGH(info->capabilities))
1627 synaptics_pt_create(psmouse);
1628
1629
1630
1631
1632
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
1659static 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
1675int synaptics_init_absolute(struct psmouse *psmouse)
1676{
1677 return __synaptics_init(psmouse, true);
1678}
1679
1680int synaptics_init_relative(struct psmouse *psmouse)
1681{
1682 return __synaptics_init(psmouse, false);
1683}
1684
1685static 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
1693
1694
1695
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
1711
1712void __init synaptics_module_init(void)
1713{
1714}
1715
1716static int __maybe_unused
1717synaptics_setup_ps2(struct psmouse *psmouse,
1718 struct synaptics_device_info *info)
1719{
1720 return -ENOSYS;
1721}
1722
1723#endif
1724
1725#ifdef CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS
1726
1727
1728
1729
1730
1731
1732enum {
1733 SYNAPTICS_INTERTOUCH_NOT_SET = -1,
1734 SYNAPTICS_INTERTOUCH_OFF,
1735 SYNAPTICS_INTERTOUCH_ON,
1736};
1737
1738static int synaptics_intertouch = IS_ENABLED(CONFIG_RMI4_SMB) ?
1739 SYNAPTICS_INTERTOUCH_NOT_SET : SYNAPTICS_INTERTOUCH_OFF;
1740module_param_named(synaptics_intertouch, synaptics_intertouch, int, 0644);
1741MODULE_PARM_DESC(synaptics_intertouch, "Use a secondary bus for the Synaptics device.");
1742
1743static 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
1775
1776
1777static 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
1815int 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
1835
1836static int __maybe_unused
1837synaptics_setup_intertouch(struct psmouse *psmouse,
1838 struct synaptics_device_info *info,
1839 bool leave_breadcrumbs)
1840{
1841 return -ENOSYS;
1842}
1843
1844int synaptics_init_smbus(struct psmouse *psmouse)
1845{
1846 return -ENOSYS;
1847}
1848
1849#endif
1850
1851#if defined(CONFIG_MOUSE_PS2_SYNAPTICS) || \
1852 defined(CONFIG_MOUSE_PS2_SYNAPTICS_SMBUS)
1853
1854int 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
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
1887
1888
1889 psmouse_smbus_cleanup(psmouse);
1890 }
1891
1892 return retval;
1893}
1894
1895#else
1896
1897int synaptics_init(struct psmouse *psmouse)
1898{
1899 return -ENOSYS;
1900}
1901
1902#endif
1903
