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