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