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