1
2
3
4
5
6
7
8
9
10
11
12
13#include <linux/delay.h>
14#include <linux/dmi.h>
15#include <linux/slab.h>
16#include <linux/module.h>
17#include <linux/input.h>
18#include <linux/input/mt.h>
19#include <linux/serio.h>
20#include <linux/libps2.h>
21#include <asm/unaligned.h>
22#include "psmouse.h"
23#include "elantech.h"
24
25#define elantech_debug(fmt, ...) \
26 do { \
27 if (etd->debug) \
28 psmouse_printk(KERN_DEBUG, psmouse, \
29 fmt, ##__VA_ARGS__); \
30 } while (0)
31
32
33
34
35static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c,
36 unsigned char *param)
37{
38 if (ps2_sliced_command(&psmouse->ps2dev, c) ||
39 ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
40 psmouse_err(psmouse, "%s query 0x%02x failed.\n", __func__, c);
41 return -1;
42 }
43
44 return 0;
45}
46
47
48
49
50static int elantech_send_cmd(struct psmouse *psmouse, unsigned char c,
51 unsigned char *param)
52{
53 struct ps2dev *ps2dev = &psmouse->ps2dev;
54
55 if (ps2_command(ps2dev, NULL, ETP_PS2_CUSTOM_COMMAND) ||
56 ps2_command(ps2dev, NULL, c) ||
57 ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
58 psmouse_err(psmouse, "%s query 0x%02x failed.\n", __func__, c);
59 return -1;
60 }
61
62 return 0;
63}
64
65
66
67
68static int elantech_ps2_command(struct psmouse *psmouse,
69 unsigned char *param, int command)
70{
71 struct ps2dev *ps2dev = &psmouse->ps2dev;
72 struct elantech_data *etd = psmouse->private;
73 int rc;
74 int tries = ETP_PS2_COMMAND_TRIES;
75
76 do {
77 rc = ps2_command(ps2dev, param, command);
78 if (rc == 0)
79 break;
80 tries--;
81 elantech_debug("retrying ps2 command 0x%02x (%d).\n",
82 command, tries);
83 msleep(ETP_PS2_COMMAND_DELAY);
84 } while (tries > 0);
85
86 if (rc)
87 psmouse_err(psmouse, "ps2 command 0x%02x failed.\n", command);
88
89 return rc;
90}
91
92
93
94
95static int elantech_read_reg(struct psmouse *psmouse, unsigned char reg,
96 unsigned char *val)
97{
98 struct elantech_data *etd = psmouse->private;
99 unsigned char param[3];
100 int rc = 0;
101
102 if (reg < 0x07 || reg > 0x26)
103 return -1;
104
105 if (reg > 0x11 && reg < 0x20)
106 return -1;
107
108 switch (etd->hw_version) {
109 case 1:
110 if (ps2_sliced_command(&psmouse->ps2dev, ETP_REGISTER_READ) ||
111 ps2_sliced_command(&psmouse->ps2dev, reg) ||
112 ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
113 rc = -1;
114 }
115 break;
116
117 case 2:
118 if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
119 elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READ) ||
120 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
121 elantech_ps2_command(psmouse, NULL, reg) ||
122 elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) {
123 rc = -1;
124 }
125 break;
126
127 case 3 ... 4:
128 if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
129 elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
130 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
131 elantech_ps2_command(psmouse, NULL, reg) ||
132 elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) {
133 rc = -1;
134 }
135 break;
136 }
137
138 if (rc)
139 psmouse_err(psmouse, "failed to read register 0x%02x.\n", reg);
140 else if (etd->hw_version != 4)
141 *val = param[0];
142 else
143 *val = param[1];
144
145 return rc;
146}
147
148
149
150
151static int elantech_write_reg(struct psmouse *psmouse, unsigned char reg,
152 unsigned char val)
153{
154 struct elantech_data *etd = psmouse->private;
155 int rc = 0;
156
157 if (reg < 0x07 || reg > 0x26)
158 return -1;
159
160 if (reg > 0x11 && reg < 0x20)
161 return -1;
162
163 switch (etd->hw_version) {
164 case 1:
165 if (ps2_sliced_command(&psmouse->ps2dev, ETP_REGISTER_WRITE) ||
166 ps2_sliced_command(&psmouse->ps2dev, reg) ||
167 ps2_sliced_command(&psmouse->ps2dev, val) ||
168 ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11)) {
169 rc = -1;
170 }
171 break;
172
173 case 2:
174 if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
175 elantech_ps2_command(psmouse, NULL, ETP_REGISTER_WRITE) ||
176 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
177 elantech_ps2_command(psmouse, NULL, reg) ||
178 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
179 elantech_ps2_command(psmouse, NULL, val) ||
180 elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
181 rc = -1;
182 }
183 break;
184
185 case 3:
186 if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
187 elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
188 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
189 elantech_ps2_command(psmouse, NULL, reg) ||
190 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
191 elantech_ps2_command(psmouse, NULL, val) ||
192 elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
193 rc = -1;
194 }
195 break;
196
197 case 4:
198 if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
199 elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
200 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
201 elantech_ps2_command(psmouse, NULL, reg) ||
202 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
203 elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
204 elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
205 elantech_ps2_command(psmouse, NULL, val) ||
206 elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
207 rc = -1;
208 }
209 break;
210 }
211
212 if (rc)
213 psmouse_err(psmouse,
214 "failed to write register 0x%02x with value 0x%02x.\n",
215 reg, val);
216
217 return rc;
218}
219
220
221
222
223static void elantech_packet_dump(struct psmouse *psmouse)
224{
225 psmouse_printk(KERN_DEBUG, psmouse, "PS/2 packet [%*ph]\n",
226 psmouse->pktsize, psmouse->packet);
227}
228
229
230
231
232
233static void elantech_report_absolute_v1(struct psmouse *psmouse)
234{
235 struct input_dev *dev = psmouse->dev;
236 struct elantech_data *etd = psmouse->private;
237 unsigned char *packet = psmouse->packet;
238 int fingers;
239
240 if (etd->fw_version < 0x020000) {
241
242
243
244
245 fingers = ((packet[1] & 0x80) >> 7) +
246 ((packet[1] & 0x30) >> 4);
247 } else {
248
249
250
251
252 fingers = (packet[0] & 0xc0) >> 6;
253 }
254
255 if (etd->jumpy_cursor) {
256 if (fingers != 1) {
257 etd->single_finger_reports = 0;
258 } else if (etd->single_finger_reports < 2) {
259
260 etd->single_finger_reports++;
261 elantech_debug("discarding packet\n");
262 return;
263 }
264 }
265
266 input_report_key(dev, BTN_TOUCH, fingers != 0);
267
268
269
270
271
272 if (fingers) {
273 input_report_abs(dev, ABS_X,
274 ((packet[1] & 0x0c) << 6) | packet[2]);
275 input_report_abs(dev, ABS_Y,
276 etd->y_max - (((packet[1] & 0x03) << 8) | packet[3]));
277 }
278
279 input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
280 input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
281 input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
282
283 psmouse_report_standard_buttons(dev, packet[0]);
284
285 if (etd->fw_version < 0x020000 &&
286 (etd->capabilities[0] & ETP_CAP_HAS_ROCKER)) {
287
288 input_report_key(dev, BTN_FORWARD, packet[0] & 0x40);
289
290 input_report_key(dev, BTN_BACK, packet[0] & 0x80);
291 }
292
293 input_sync(dev);
294}
295
296static void elantech_set_slot(struct input_dev *dev, int slot, bool active,
297 unsigned int x, unsigned int y)
298{
299 input_mt_slot(dev, slot);
300 input_mt_report_slot_state(dev, MT_TOOL_FINGER, active);
301 if (active) {
302 input_report_abs(dev, ABS_MT_POSITION_X, x);
303 input_report_abs(dev, ABS_MT_POSITION_Y, y);
304 }
305}
306
307
308static void elantech_report_semi_mt_data(struct input_dev *dev,
309 unsigned int num_fingers,
310 unsigned int x1, unsigned int y1,
311 unsigned int x2, unsigned int y2)
312{
313 elantech_set_slot(dev, 0, num_fingers != 0, x1, y1);
314 elantech_set_slot(dev, 1, num_fingers >= 2, x2, y2);
315}
316
317
318
319
320
321static void elantech_report_absolute_v2(struct psmouse *psmouse)
322{
323 struct elantech_data *etd = psmouse->private;
324 struct input_dev *dev = psmouse->dev;
325 unsigned char *packet = psmouse->packet;
326 unsigned int fingers, x1 = 0, y1 = 0, x2 = 0, y2 = 0;
327 unsigned int width = 0, pres = 0;
328
329
330 fingers = (packet[0] & 0xc0) >> 6;
331
332 switch (fingers) {
333 case 3:
334
335
336
337
338 if (packet[3] & 0x80)
339 fingers = 4;
340
341 case 1:
342
343
344
345
346 x1 = ((packet[1] & 0x0f) << 8) | packet[2];
347
348
349
350
351 y1 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
352
353 pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
354 width = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4);
355 break;
356
357 case 2:
358
359
360
361
362
363
364 x1 = (((packet[0] & 0x10) << 4) | packet[1]) << 2;
365
366 y1 = etd->y_max -
367 ((((packet[0] & 0x20) << 3) | packet[2]) << 2);
368
369
370
371
372 x2 = (((packet[3] & 0x10) << 4) | packet[4]) << 2;
373
374 y2 = etd->y_max -
375 ((((packet[3] & 0x20) << 3) | packet[5]) << 2);
376
377
378 pres = 127;
379 width = 7;
380 break;
381 }
382
383 input_report_key(dev, BTN_TOUCH, fingers != 0);
384 if (fingers != 0) {
385 input_report_abs(dev, ABS_X, x1);
386 input_report_abs(dev, ABS_Y, y1);
387 }
388 elantech_report_semi_mt_data(dev, fingers, x1, y1, x2, y2);
389 input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
390 input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
391 input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
392 input_report_key(dev, BTN_TOOL_QUADTAP, fingers == 4);
393 psmouse_report_standard_buttons(dev, packet[0]);
394 if (etd->reports_pressure) {
395 input_report_abs(dev, ABS_PRESSURE, pres);
396 input_report_abs(dev, ABS_TOOL_WIDTH, width);
397 }
398
399 input_sync(dev);
400}
401
402static void elantech_report_trackpoint(struct psmouse *psmouse,
403 int packet_type)
404{
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420 struct elantech_data *etd = psmouse->private;
421 struct input_dev *tp_dev = etd->tp_dev;
422 unsigned char *packet = psmouse->packet;
423 int x, y;
424 u32 t;
425
426 t = get_unaligned_le32(&packet[0]);
427
428 switch (t & ~7U) {
429 case 0x06000030U:
430 case 0x16008020U:
431 case 0x26800010U:
432 case 0x36808000U:
433 x = packet[4] - (int)((packet[1]^0x80) << 1);
434 y = (int)((packet[2]^0x80) << 1) - packet[5];
435
436 psmouse_report_standard_buttons(tp_dev, packet[0]);
437
438 input_report_rel(tp_dev, REL_X, x);
439 input_report_rel(tp_dev, REL_Y, y);
440
441 input_sync(tp_dev);
442
443 break;
444
445 default:
446
447 if (etd->debug == 1)
448 elantech_packet_dump(psmouse);
449
450 break;
451 }
452}
453
454
455
456
457
458static void elantech_report_absolute_v3(struct psmouse *psmouse,
459 int packet_type)
460{
461 struct input_dev *dev = psmouse->dev;
462 struct elantech_data *etd = psmouse->private;
463 unsigned char *packet = psmouse->packet;
464 unsigned int fingers = 0, x1 = 0, y1 = 0, x2 = 0, y2 = 0;
465 unsigned int width = 0, pres = 0;
466
467
468 fingers = (packet[0] & 0xc0) >> 6;
469
470 switch (fingers) {
471 case 3:
472 case 1:
473
474
475
476
477 x1 = ((packet[1] & 0x0f) << 8) | packet[2];
478
479
480
481
482 y1 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
483 break;
484
485 case 2:
486 if (packet_type == PACKET_V3_HEAD) {
487
488
489
490
491 etd->mt[0].x = ((packet[1] & 0x0f) << 8) | packet[2];
492
493
494
495
496 etd->mt[0].y = etd->y_max -
497 (((packet[4] & 0x0f) << 8) | packet[5]);
498
499
500
501 return;
502 }
503
504
505 x1 = etd->mt[0].x;
506 y1 = etd->mt[0].y;
507 x2 = ((packet[1] & 0x0f) << 8) | packet[2];
508 y2 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
509 break;
510 }
511
512 pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
513 width = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4);
514
515 input_report_key(dev, BTN_TOUCH, fingers != 0);
516 if (fingers != 0) {
517 input_report_abs(dev, ABS_X, x1);
518 input_report_abs(dev, ABS_Y, y1);
519 }
520 elantech_report_semi_mt_data(dev, fingers, x1, y1, x2, y2);
521 input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
522 input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
523 input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
524
525
526 if (etd->fw_version & 0x001000)
527 input_report_key(dev, BTN_LEFT, packet[0] & 0x03);
528 else
529 psmouse_report_standard_buttons(dev, packet[0]);
530
531 input_report_abs(dev, ABS_PRESSURE, pres);
532 input_report_abs(dev, ABS_TOOL_WIDTH, width);
533
534 input_sync(dev);
535}
536
537static void elantech_input_sync_v4(struct psmouse *psmouse)
538{
539 struct input_dev *dev = psmouse->dev;
540 struct elantech_data *etd = psmouse->private;
541 unsigned char *packet = psmouse->packet;
542
543
544 if (etd->fw_version & 0x001000)
545 input_report_key(dev, BTN_LEFT, packet[0] & 0x03);
546 else
547 psmouse_report_standard_buttons(dev, packet[0]);
548
549 input_mt_report_pointer_emulation(dev, true);
550 input_sync(dev);
551}
552
553static void process_packet_status_v4(struct psmouse *psmouse)
554{
555 struct input_dev *dev = psmouse->dev;
556 unsigned char *packet = psmouse->packet;
557 unsigned fingers;
558 int i;
559
560
561 fingers = packet[1] & 0x1f;
562 for (i = 0; i < ETP_MAX_FINGERS; i++) {
563 if ((fingers & (1 << i)) == 0) {
564 input_mt_slot(dev, i);
565 input_mt_report_slot_state(dev, MT_TOOL_FINGER, false);
566 }
567 }
568
569 elantech_input_sync_v4(psmouse);
570}
571
572static void process_packet_head_v4(struct psmouse *psmouse)
573{
574 struct input_dev *dev = psmouse->dev;
575 struct elantech_data *etd = psmouse->private;
576 unsigned char *packet = psmouse->packet;
577 int id = ((packet[3] & 0xe0) >> 5) - 1;
578 int pres, traces;
579
580 if (id < 0)
581 return;
582
583 etd->mt[id].x = ((packet[1] & 0x0f) << 8) | packet[2];
584 etd->mt[id].y = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
585 pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
586 traces = (packet[0] & 0xf0) >> 4;
587
588 input_mt_slot(dev, id);
589 input_mt_report_slot_state(dev, MT_TOOL_FINGER, true);
590
591 input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[id].x);
592 input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[id].y);
593 input_report_abs(dev, ABS_MT_PRESSURE, pres);
594 input_report_abs(dev, ABS_MT_TOUCH_MAJOR, traces * etd->width);
595
596 input_report_abs(dev, ABS_TOOL_WIDTH, traces);
597
598 elantech_input_sync_v4(psmouse);
599}
600
601static void process_packet_motion_v4(struct psmouse *psmouse)
602{
603 struct input_dev *dev = psmouse->dev;
604 struct elantech_data *etd = psmouse->private;
605 unsigned char *packet = psmouse->packet;
606 int weight, delta_x1 = 0, delta_y1 = 0, delta_x2 = 0, delta_y2 = 0;
607 int id, sid;
608
609 id = ((packet[0] & 0xe0) >> 5) - 1;
610 if (id < 0)
611 return;
612
613 sid = ((packet[3] & 0xe0) >> 5) - 1;
614 weight = (packet[0] & 0x10) ? ETP_WEIGHT_VALUE : 1;
615
616
617
618
619
620 delta_x1 = (signed char)packet[1];
621 delta_y1 = (signed char)packet[2];
622 delta_x2 = (signed char)packet[4];
623 delta_y2 = (signed char)packet[5];
624
625 etd->mt[id].x += delta_x1 * weight;
626 etd->mt[id].y -= delta_y1 * weight;
627 input_mt_slot(dev, id);
628 input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[id].x);
629 input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[id].y);
630
631 if (sid >= 0) {
632 etd->mt[sid].x += delta_x2 * weight;
633 etd->mt[sid].y -= delta_y2 * weight;
634 input_mt_slot(dev, sid);
635 input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[sid].x);
636 input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[sid].y);
637 }
638
639 elantech_input_sync_v4(psmouse);
640}
641
642static void elantech_report_absolute_v4(struct psmouse *psmouse,
643 int packet_type)
644{
645 switch (packet_type) {
646 case PACKET_V4_STATUS:
647 process_packet_status_v4(psmouse);
648 break;
649
650 case PACKET_V4_HEAD:
651 process_packet_head_v4(psmouse);
652 break;
653
654 case PACKET_V4_MOTION:
655 process_packet_motion_v4(psmouse);
656 break;
657
658 case PACKET_UNKNOWN:
659 default:
660
661 break;
662 }
663}
664
665static int elantech_packet_check_v1(struct psmouse *psmouse)
666{
667 struct elantech_data *etd = psmouse->private;
668 unsigned char *packet = psmouse->packet;
669 unsigned char p1, p2, p3;
670
671
672 if (etd->fw_version < 0x020000) {
673
674 p1 = (packet[0] & 0x20) >> 5;
675 p2 = (packet[0] & 0x10) >> 4;
676 } else {
677
678 p1 = (packet[0] & 0x10) >> 4;
679 p2 = (packet[0] & 0x20) >> 5;
680 }
681
682 p3 = (packet[0] & 0x04) >> 2;
683
684 return etd->parity[packet[1]] == p1 &&
685 etd->parity[packet[2]] == p2 &&
686 etd->parity[packet[3]] == p3;
687}
688
689static int elantech_debounce_check_v2(struct psmouse *psmouse)
690{
691
692
693
694
695 static const u8 debounce_packet[] = {
696 0x84, 0xff, 0xff, 0x02, 0xff, 0xff
697 };
698 unsigned char *packet = psmouse->packet;
699
700 return !memcmp(packet, debounce_packet, sizeof(debounce_packet));
701}
702
703static int elantech_packet_check_v2(struct psmouse *psmouse)
704{
705 struct elantech_data *etd = psmouse->private;
706 unsigned char *packet = psmouse->packet;
707
708
709
710
711
712
713
714
715
716
717 if (etd->reports_pressure)
718 return (packet[0] & 0x0c) == 0x04 &&
719 (packet[3] & 0x0f) == 0x02;
720
721 if ((packet[0] & 0xc0) == 0x80)
722 return (packet[0] & 0x0c) == 0x0c &&
723 (packet[3] & 0x0e) == 0x08;
724
725 return (packet[0] & 0x3c) == 0x3c &&
726 (packet[1] & 0xf0) == 0x00 &&
727 (packet[3] & 0x3e) == 0x38 &&
728 (packet[4] & 0xf0) == 0x00;
729}
730
731
732
733
734
735static int elantech_packet_check_v3(struct psmouse *psmouse)
736{
737 struct elantech_data *etd = psmouse->private;
738 static const u8 debounce_packet[] = {
739 0xc4, 0xff, 0xff, 0x02, 0xff, 0xff
740 };
741 unsigned char *packet = psmouse->packet;
742
743
744
745
746
747 if (!memcmp(packet, debounce_packet, sizeof(debounce_packet)))
748 return PACKET_DEBOUNCE;
749
750
751
752
753
754 if (etd->crc_enabled) {
755 if ((packet[3] & 0x09) == 0x08)
756 return PACKET_V3_HEAD;
757
758 if ((packet[3] & 0x09) == 0x09)
759 return PACKET_V3_TAIL;
760 } else {
761 if ((packet[0] & 0x0c) == 0x04 && (packet[3] & 0xcf) == 0x02)
762 return PACKET_V3_HEAD;
763
764 if ((packet[0] & 0x0c) == 0x0c && (packet[3] & 0xce) == 0x0c)
765 return PACKET_V3_TAIL;
766 if ((packet[3] & 0x0f) == 0x06)
767 return PACKET_TRACKPOINT;
768 }
769
770 return PACKET_UNKNOWN;
771}
772
773static int elantech_packet_check_v4(struct psmouse *psmouse)
774{
775 struct elantech_data *etd = psmouse->private;
776 unsigned char *packet = psmouse->packet;
777 unsigned char packet_type = packet[3] & 0x03;
778 unsigned int ic_version;
779 bool sanity_check;
780
781 if (etd->tp_dev && (packet[3] & 0x0f) == 0x06)
782 return PACKET_TRACKPOINT;
783
784
785 ic_version = (etd->fw_version & 0x0f0000) >> 16;
786
787
788
789
790
791
792
793
794 if (etd->crc_enabled)
795 sanity_check = ((packet[3] & 0x08) == 0x00);
796 else if (ic_version == 7 && etd->samples[1] == 0x2A)
797 sanity_check = ((packet[3] & 0x1c) == 0x10);
798 else
799 sanity_check = ((packet[0] & 0x0c) == 0x04 &&
800 (packet[3] & 0x1c) == 0x10);
801
802 if (!sanity_check)
803 return PACKET_UNKNOWN;
804
805 switch (packet_type) {
806 case 0:
807 return PACKET_V4_STATUS;
808
809 case 1:
810 return PACKET_V4_HEAD;
811
812 case 2:
813 return PACKET_V4_MOTION;
814 }
815
816 return PACKET_UNKNOWN;
817}
818
819
820
821
822static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse)
823{
824 struct elantech_data *etd = psmouse->private;
825 int packet_type;
826
827 if (psmouse->pktcnt < psmouse->pktsize)
828 return PSMOUSE_GOOD_DATA;
829
830 if (etd->debug > 1)
831 elantech_packet_dump(psmouse);
832
833 switch (etd->hw_version) {
834 case 1:
835 if (etd->paritycheck && !elantech_packet_check_v1(psmouse))
836 return PSMOUSE_BAD_DATA;
837
838 elantech_report_absolute_v1(psmouse);
839 break;
840
841 case 2:
842
843 if (elantech_debounce_check_v2(psmouse))
844 return PSMOUSE_FULL_PACKET;
845
846 if (etd->paritycheck && !elantech_packet_check_v2(psmouse))
847 return PSMOUSE_BAD_DATA;
848
849 elantech_report_absolute_v2(psmouse);
850 break;
851
852 case 3:
853 packet_type = elantech_packet_check_v3(psmouse);
854 switch (packet_type) {
855 case PACKET_UNKNOWN:
856 return PSMOUSE_BAD_DATA;
857
858 case PACKET_DEBOUNCE:
859
860 break;
861
862 case PACKET_TRACKPOINT:
863 elantech_report_trackpoint(psmouse, packet_type);
864 break;
865
866 default:
867 elantech_report_absolute_v3(psmouse, packet_type);
868 break;
869 }
870
871 break;
872
873 case 4:
874 packet_type = elantech_packet_check_v4(psmouse);
875 switch (packet_type) {
876 case PACKET_UNKNOWN:
877 return PSMOUSE_BAD_DATA;
878
879 case PACKET_TRACKPOINT:
880 elantech_report_trackpoint(psmouse, packet_type);
881 break;
882
883 default:
884 elantech_report_absolute_v4(psmouse, packet_type);
885 break;
886 }
887
888 break;
889 }
890
891 return PSMOUSE_FULL_PACKET;
892}
893
894
895
896
897
898
899static void elantech_set_rate_restore_reg_07(struct psmouse *psmouse,
900 unsigned int rate)
901{
902 struct elantech_data *etd = psmouse->private;
903
904 etd->original_set_rate(psmouse, rate);
905 if (elantech_write_reg(psmouse, 0x07, etd->reg_07))
906 psmouse_err(psmouse, "restoring reg_07 failed\n");
907}
908
909
910
911
912static int elantech_set_absolute_mode(struct psmouse *psmouse)
913{
914 struct elantech_data *etd = psmouse->private;
915 unsigned char val;
916 int tries = ETP_READ_BACK_TRIES;
917 int rc = 0;
918
919 switch (etd->hw_version) {
920 case 1:
921 etd->reg_10 = 0x16;
922 etd->reg_11 = 0x8f;
923 if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
924 elantech_write_reg(psmouse, 0x11, etd->reg_11)) {
925 rc = -1;
926 }
927 break;
928
929 case 2:
930
931 etd->reg_10 = 0x54;
932 etd->reg_11 = 0x88;
933 etd->reg_21 = 0x60;
934 if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
935 elantech_write_reg(psmouse, 0x11, etd->reg_11) ||
936 elantech_write_reg(psmouse, 0x21, etd->reg_21)) {
937 rc = -1;
938 }
939 break;
940
941 case 3:
942 if (etd->set_hw_resolution)
943 etd->reg_10 = 0x0b;
944 else
945 etd->reg_10 = 0x01;
946
947 if (elantech_write_reg(psmouse, 0x10, etd->reg_10))
948 rc = -1;
949
950 break;
951
952 case 4:
953 etd->reg_07 = 0x01;
954 if (elantech_write_reg(psmouse, 0x07, etd->reg_07))
955 rc = -1;
956
957 goto skip_readback_reg_10;
958 }
959
960 if (rc == 0) {
961
962
963
964
965
966
967 do {
968 rc = elantech_read_reg(psmouse, 0x10, &val);
969 if (rc == 0)
970 break;
971 tries--;
972 elantech_debug("retrying read (%d).\n", tries);
973 msleep(ETP_READ_BACK_DELAY);
974 } while (tries > 0);
975
976 if (rc) {
977 psmouse_err(psmouse,
978 "failed to read back register 0x10.\n");
979 } else if (etd->hw_version == 1 &&
980 !(val & ETP_R10_ABSOLUTE_MODE)) {
981 psmouse_err(psmouse,
982 "touchpad refuses to switch to absolute mode.\n");
983 rc = -1;
984 }
985 }
986
987 skip_readback_reg_10:
988 if (rc)
989 psmouse_err(psmouse, "failed to initialise registers.\n");
990
991 return rc;
992}
993
994static int elantech_set_range(struct psmouse *psmouse,
995 unsigned int *x_min, unsigned int *y_min,
996 unsigned int *x_max, unsigned int *y_max,
997 unsigned int *width)
998{
999 struct elantech_data *etd = psmouse->private;
1000 unsigned char param[3];
1001 unsigned char traces;
1002
1003 switch (etd->hw_version) {
1004 case 1:
1005 *x_min = ETP_XMIN_V1;
1006 *y_min = ETP_YMIN_V1;
1007 *x_max = ETP_XMAX_V1;
1008 *y_max = ETP_YMAX_V1;
1009 break;
1010
1011 case 2:
1012 if (etd->fw_version == 0x020800 ||
1013 etd->fw_version == 0x020b00 ||
1014 etd->fw_version == 0x020030) {
1015 *x_min = ETP_XMIN_V2;
1016 *y_min = ETP_YMIN_V2;
1017 *x_max = ETP_XMAX_V2;
1018 *y_max = ETP_YMAX_V2;
1019 } else {
1020 int i;
1021 int fixed_dpi;
1022
1023 i = (etd->fw_version > 0x020800 &&
1024 etd->fw_version < 0x020900) ? 1 : 2;
1025
1026 if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param))
1027 return -1;
1028
1029 fixed_dpi = param[1] & 0x10;
1030
1031 if (((etd->fw_version >> 16) == 0x14) && fixed_dpi) {
1032 if (etd->send_cmd(psmouse, ETP_SAMPLE_QUERY, param))
1033 return -1;
1034
1035 *x_max = (etd->capabilities[1] - i) * param[1] / 2;
1036 *y_max = (etd->capabilities[2] - i) * param[2] / 2;
1037 } else if (etd->fw_version == 0x040216) {
1038 *x_max = 819;
1039 *y_max = 405;
1040 } else if (etd->fw_version == 0x040219 || etd->fw_version == 0x040215) {
1041 *x_max = 900;
1042 *y_max = 500;
1043 } else {
1044 *x_max = (etd->capabilities[1] - i) * 64;
1045 *y_max = (etd->capabilities[2] - i) * 64;
1046 }
1047 }
1048 break;
1049
1050 case 3:
1051 if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param))
1052 return -1;
1053
1054 *x_max = (0x0f & param[0]) << 8 | param[1];
1055 *y_max = (0xf0 & param[0]) << 4 | param[2];
1056 break;
1057
1058 case 4:
1059 if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param))
1060 return -1;
1061
1062 *x_max = (0x0f & param[0]) << 8 | param[1];
1063 *y_max = (0xf0 & param[0]) << 4 | param[2];
1064 traces = etd->capabilities[1];
1065 if ((traces < 2) || (traces > *x_max))
1066 return -1;
1067
1068 *width = *x_max / (traces - 1);
1069 break;
1070 }
1071
1072 return 0;
1073}
1074
1075
1076
1077
1078
1079static unsigned int elantech_convert_res(unsigned int val)
1080{
1081 return (val * 10 + 790) * 10 / 254;
1082}
1083
1084static int elantech_get_resolution_v4(struct psmouse *psmouse,
1085 unsigned int *x_res,
1086 unsigned int *y_res)
1087{
1088 unsigned char param[3];
1089
1090 if (elantech_send_cmd(psmouse, ETP_RESOLUTION_QUERY, param))
1091 return -1;
1092
1093 *x_res = elantech_convert_res(param[1] & 0x0f);
1094 *y_res = elantech_convert_res((param[1] & 0xf0) >> 4);
1095
1096 return 0;
1097}
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127
1128
1129
1130
1131
1132
1133
1134
1135
1136
1137
1138static void elantech_set_buttonpad_prop(struct psmouse *psmouse)
1139{
1140 struct input_dev *dev = psmouse->dev;
1141 struct elantech_data *etd = psmouse->private;
1142
1143 if (etd->fw_version & 0x001000) {
1144 __set_bit(INPUT_PROP_BUTTONPAD, dev->propbit);
1145 __clear_bit(BTN_RIGHT, dev->keybit);
1146 }
1147}
1148
1149
1150
1151
1152static const struct dmi_system_id elantech_dmi_has_middle_button[] = {
1153#if defined(CONFIG_DMI) && defined(CONFIG_X86)
1154 {
1155
1156 .matches = {
1157 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1158 DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H730"),
1159 },
1160 },
1161 {
1162
1163 .matches = {
1164 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1165 DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H760"),
1166 },
1167 },
1168#endif
1169 { }
1170};
1171
1172
1173
1174
1175static int elantech_set_input_params(struct psmouse *psmouse)
1176{
1177 struct input_dev *dev = psmouse->dev;
1178 struct elantech_data *etd = psmouse->private;
1179 unsigned int x_min = 0, y_min = 0, x_max = 0, y_max = 0, width = 0;
1180 unsigned int x_res = 31, y_res = 31;
1181
1182 if (elantech_set_range(psmouse, &x_min, &y_min, &x_max, &y_max, &width))
1183 return -1;
1184
1185 __set_bit(INPUT_PROP_POINTER, dev->propbit);
1186 __set_bit(EV_KEY, dev->evbit);
1187 __set_bit(EV_ABS, dev->evbit);
1188 __clear_bit(EV_REL, dev->evbit);
1189
1190 __set_bit(BTN_LEFT, dev->keybit);
1191 if (dmi_check_system(elantech_dmi_has_middle_button))
1192 __set_bit(BTN_MIDDLE, dev->keybit);
1193 __set_bit(BTN_RIGHT, dev->keybit);
1194
1195 __set_bit(BTN_TOUCH, dev->keybit);
1196 __set_bit(BTN_TOOL_FINGER, dev->keybit);
1197 __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
1198 __set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
1199
1200 switch (etd->hw_version) {
1201 case 1:
1202
1203 if (etd->fw_version < 0x020000 &&
1204 (etd->capabilities[0] & ETP_CAP_HAS_ROCKER)) {
1205 __set_bit(BTN_FORWARD, dev->keybit);
1206 __set_bit(BTN_BACK, dev->keybit);
1207 }
1208 input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
1209 input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
1210 break;
1211
1212 case 2:
1213 __set_bit(BTN_TOOL_QUADTAP, dev->keybit);
1214 __set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
1215
1216 case 3:
1217 if (etd->hw_version == 3)
1218 elantech_set_buttonpad_prop(psmouse);
1219 input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
1220 input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
1221 if (etd->reports_pressure) {
1222 input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2,
1223 ETP_PMAX_V2, 0, 0);
1224 input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
1225 ETP_WMAX_V2, 0, 0);
1226 }
1227 input_mt_init_slots(dev, 2, INPUT_MT_SEMI_MT);
1228 input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
1229 input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
1230 break;
1231
1232 case 4:
1233 if (elantech_get_resolution_v4(psmouse, &x_res, &y_res)) {
1234
1235
1236
1237
1238 psmouse_warn(psmouse, "couldn't query resolution data.\n");
1239 }
1240 elantech_set_buttonpad_prop(psmouse);
1241 __set_bit(BTN_TOOL_QUADTAP, dev->keybit);
1242
1243 input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
1244 input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
1245
1246
1247
1248
1249 input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2,
1250 ETP_PMAX_V2, 0, 0);
1251 input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
1252 ETP_WMAX_V2, 0, 0);
1253
1254 input_mt_init_slots(dev, ETP_MAX_FINGERS, 0);
1255 input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
1256 input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
1257 input_set_abs_params(dev, ABS_MT_PRESSURE, ETP_PMIN_V2,
1258 ETP_PMAX_V2, 0, 0);
1259
1260
1261
1262
1263 input_set_abs_params(dev, ABS_MT_TOUCH_MAJOR, 0,
1264 ETP_WMAX_V2 * width, 0, 0);
1265 break;
1266 }
1267
1268 input_abs_set_res(dev, ABS_X, x_res);
1269 input_abs_set_res(dev, ABS_Y, y_res);
1270 if (etd->hw_version > 1) {
1271 input_abs_set_res(dev, ABS_MT_POSITION_X, x_res);
1272 input_abs_set_res(dev, ABS_MT_POSITION_Y, y_res);
1273 }
1274
1275 etd->y_max = y_max;
1276 etd->width = width;
1277
1278 return 0;
1279}
1280
1281struct elantech_attr_data {
1282 size_t field_offset;
1283 unsigned char reg;
1284};
1285
1286
1287
1288
1289static ssize_t elantech_show_int_attr(struct psmouse *psmouse, void *data,
1290 char *buf)
1291{
1292 struct elantech_data *etd = psmouse->private;
1293 struct elantech_attr_data *attr = data;
1294 unsigned char *reg = (unsigned char *) etd + attr->field_offset;
1295 int rc = 0;
1296
1297 if (attr->reg)
1298 rc = elantech_read_reg(psmouse, attr->reg, reg);
1299
1300 return sprintf(buf, "0x%02x\n", (attr->reg && rc) ? -1 : *reg);
1301}
1302
1303
1304
1305
1306static ssize_t elantech_set_int_attr(struct psmouse *psmouse,
1307 void *data, const char *buf, size_t count)
1308{
1309 struct elantech_data *etd = psmouse->private;
1310 struct elantech_attr_data *attr = data;
1311 unsigned char *reg = (unsigned char *) etd + attr->field_offset;
1312 unsigned char value;
1313 int err;
1314
1315 err = kstrtou8(buf, 16, &value);
1316 if (err)
1317 return err;
1318
1319
1320 if (etd->hw_version == 1) {
1321 if (attr->reg == 0x10)
1322
1323 value |= ETP_R10_ABSOLUTE_MODE;
1324 else if (attr->reg == 0x11)
1325
1326 value |= ETP_R11_4_BYTE_MODE;
1327 }
1328
1329 if (!attr->reg || elantech_write_reg(psmouse, attr->reg, value) == 0)
1330 *reg = value;
1331
1332 return count;
1333}
1334
1335#define ELANTECH_INT_ATTR(_name, _register) \
1336 static struct elantech_attr_data elantech_attr_##_name = { \
1337 .field_offset = offsetof(struct elantech_data, _name), \
1338 .reg = _register, \
1339 }; \
1340 PSMOUSE_DEFINE_ATTR(_name, S_IWUSR | S_IRUGO, \
1341 &elantech_attr_##_name, \
1342 elantech_show_int_attr, \
1343 elantech_set_int_attr)
1344
1345ELANTECH_INT_ATTR(reg_07, 0x07);
1346ELANTECH_INT_ATTR(reg_10, 0x10);
1347ELANTECH_INT_ATTR(reg_11, 0x11);
1348ELANTECH_INT_ATTR(reg_20, 0x20);
1349ELANTECH_INT_ATTR(reg_21, 0x21);
1350ELANTECH_INT_ATTR(reg_22, 0x22);
1351ELANTECH_INT_ATTR(reg_23, 0x23);
1352ELANTECH_INT_ATTR(reg_24, 0x24);
1353ELANTECH_INT_ATTR(reg_25, 0x25);
1354ELANTECH_INT_ATTR(reg_26, 0x26);
1355ELANTECH_INT_ATTR(debug, 0);
1356ELANTECH_INT_ATTR(paritycheck, 0);
1357ELANTECH_INT_ATTR(crc_enabled, 0);
1358
1359static struct attribute *elantech_attrs[] = {
1360 &psmouse_attr_reg_07.dattr.attr,
1361 &psmouse_attr_reg_10.dattr.attr,
1362 &psmouse_attr_reg_11.dattr.attr,
1363 &psmouse_attr_reg_20.dattr.attr,
1364 &psmouse_attr_reg_21.dattr.attr,
1365 &psmouse_attr_reg_22.dattr.attr,
1366 &psmouse_attr_reg_23.dattr.attr,
1367 &psmouse_attr_reg_24.dattr.attr,
1368 &psmouse_attr_reg_25.dattr.attr,
1369 &psmouse_attr_reg_26.dattr.attr,
1370 &psmouse_attr_debug.dattr.attr,
1371 &psmouse_attr_paritycheck.dattr.attr,
1372 &psmouse_attr_crc_enabled.dattr.attr,
1373 NULL
1374};
1375
1376static const struct attribute_group elantech_attr_group = {
1377 .attrs = elantech_attrs,
1378};
1379
1380static bool elantech_is_signature_valid(const unsigned char *param)
1381{
1382 static const unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10 };
1383 int i;
1384
1385 if (param[0] == 0)
1386 return false;
1387
1388 if (param[1] == 0)
1389 return true;
1390
1391
1392
1393
1394
1395 if ((param[0] & 0x0f) >= 0x06 && (param[1] & 0xaf) == 0x0f &&
1396 param[2] < 40)
1397 return true;
1398
1399 for (i = 0; i < ARRAY_SIZE(rates); i++)
1400 if (param[2] == rates[i])
1401 return false;
1402
1403 return true;
1404}
1405
1406
1407
1408
1409int elantech_detect(struct psmouse *psmouse, bool set_properties)
1410{
1411 struct ps2dev *ps2dev = &psmouse->ps2dev;
1412 unsigned char param[3];
1413
1414 ps2_command(ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
1415
1416 if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
1417 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
1418 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
1419 ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
1420 ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
1421 psmouse_dbg(psmouse, "sending Elantech magic knock failed.\n");
1422 return -1;
1423 }
1424
1425
1426
1427
1428
1429 if (param[0] != 0x3c || param[1] != 0x03 ||
1430 (param[2] != 0xc8 && param[2] != 0x00)) {
1431 psmouse_dbg(psmouse,
1432 "unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n",
1433 param[0], param[1], param[2]);
1434 return -1;
1435 }
1436
1437
1438
1439
1440
1441
1442 if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
1443 psmouse_dbg(psmouse, "failed to query firmware version.\n");
1444 return -1;
1445 }
1446
1447 psmouse_dbg(psmouse,
1448 "Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n",
1449 param[0], param[1], param[2]);
1450
1451 if (!elantech_is_signature_valid(param)) {
1452 psmouse_dbg(psmouse,
1453 "Probably not a real Elantech touchpad. Aborting.\n");
1454 return -1;
1455 }
1456
1457 if (set_properties) {
1458 psmouse->vendor = "Elantech";
1459 psmouse->name = "Touchpad";
1460 }
1461
1462 return 0;
1463}
1464
1465
1466
1467
1468static void elantech_disconnect(struct psmouse *psmouse)
1469{
1470 struct elantech_data *etd = psmouse->private;
1471
1472 if (etd->tp_dev)
1473 input_unregister_device(etd->tp_dev);
1474 sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
1475 &elantech_attr_group);
1476 kfree(psmouse->private);
1477 psmouse->private = NULL;
1478}
1479
1480
1481
1482
1483static int elantech_reconnect(struct psmouse *psmouse)
1484{
1485 psmouse_reset(psmouse);
1486
1487 if (elantech_detect(psmouse, 0))
1488 return -1;
1489
1490 if (elantech_set_absolute_mode(psmouse)) {
1491 psmouse_err(psmouse,
1492 "failed to put touchpad back into absolute mode.\n");
1493 return -1;
1494 }
1495
1496 return 0;
1497}
1498
1499
1500
1501
1502static const struct dmi_system_id elantech_dmi_force_crc_enabled[] = {
1503#if defined(CONFIG_DMI) && defined(CONFIG_X86)
1504 {
1505
1506 .matches = {
1507 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1508 DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H730"),
1509 },
1510 },
1511 {
1512
1513 .matches = {
1514 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1515 DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H760"),
1516 },
1517 },
1518 {
1519
1520 .matches = {
1521 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1522 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E544"),
1523 },
1524 },
1525 {
1526
1527 .matches = {
1528 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1529 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E546"),
1530 },
1531 },
1532 {
1533
1534 .matches = {
1535 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1536 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E547"),
1537 },
1538 },
1539 {
1540
1541 .matches = {
1542 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1543 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E554"),
1544 },
1545 },
1546 {
1547
1548 .matches = {
1549 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1550 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E556"),
1551 },
1552 },
1553 {
1554
1555 .matches = {
1556 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1557 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK E557"),
1558 },
1559 },
1560 {
1561
1562 .matches = {
1563 DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1564 DMI_MATCH(DMI_PRODUCT_NAME, "LIFEBOOK U745"),
1565 },
1566 },
1567#endif
1568 { }
1569};
1570
1571
1572
1573
1574
1575static const struct dmi_system_id no_hw_res_dmi_table[] = {
1576#if defined(CONFIG_DMI) && defined(CONFIG_X86)
1577 {
1578
1579 .matches = {
1580 DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
1581 DMI_MATCH(DMI_PRODUCT_NAME, "U2442"),
1582 },
1583 },
1584#endif
1585 { }
1586};
1587
1588
1589
1590
1591static int elantech_set_properties(struct elantech_data *etd)
1592{
1593
1594 int ver = (etd->fw_version & 0x0f0000) >> 16;
1595
1596
1597 if (etd->fw_version < 0x020030 || etd->fw_version == 0x020600)
1598 etd->hw_version = 1;
1599 else {
1600 switch (ver) {
1601 case 2:
1602 case 4:
1603 etd->hw_version = 2;
1604 break;
1605 case 5:
1606 etd->hw_version = 3;
1607 break;
1608 case 6 ... 15:
1609 etd->hw_version = 4;
1610 break;
1611 default:
1612 return -1;
1613 }
1614 }
1615
1616
1617 etd->send_cmd = etd->hw_version >= 3 ? elantech_send_cmd :
1618 synaptics_send_cmd;
1619
1620
1621 etd->paritycheck = 1;
1622
1623
1624
1625
1626
1627
1628 etd->jumpy_cursor =
1629 (etd->fw_version == 0x020022 || etd->fw_version == 0x020600);
1630
1631 if (etd->hw_version > 1) {
1632
1633 etd->debug = 1;
1634
1635 if (etd->fw_version >= 0x020800)
1636 etd->reports_pressure = true;
1637 }
1638
1639
1640
1641
1642
1643 etd->crc_enabled = (etd->fw_version & 0x4000) == 0x4000 ||
1644 dmi_check_system(elantech_dmi_force_crc_enabled);
1645
1646
1647 etd->set_hw_resolution = !dmi_check_system(no_hw_res_dmi_table);
1648
1649 return 0;
1650}
1651
1652
1653
1654
1655int elantech_init(struct psmouse *psmouse)
1656{
1657 struct elantech_data *etd;
1658 int i;
1659 int error = -EINVAL;
1660 unsigned char param[3];
1661 struct input_dev *tp_dev;
1662
1663 psmouse->private = etd = kzalloc(sizeof(struct elantech_data), GFP_KERNEL);
1664 if (!etd)
1665 return -ENOMEM;
1666
1667 psmouse_reset(psmouse);
1668
1669 etd->parity[0] = 1;
1670 for (i = 1; i < 256; i++)
1671 etd->parity[i] = etd->parity[i & (i - 1)] ^ 1;
1672
1673
1674
1675
1676 if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
1677 psmouse_err(psmouse, "failed to query firmware version.\n");
1678 goto init_fail;
1679 }
1680 etd->fw_version = (param[0] << 16) | (param[1] << 8) | param[2];
1681
1682 if (elantech_set_properties(etd)) {
1683 psmouse_err(psmouse, "unknown hardware version, aborting...\n");
1684 goto init_fail;
1685 }
1686 psmouse_info(psmouse,
1687 "assuming hardware version %d (with firmware version 0x%02x%02x%02x)\n",
1688 etd->hw_version, param[0], param[1], param[2]);
1689
1690 if (etd->send_cmd(psmouse, ETP_CAPABILITIES_QUERY,
1691 etd->capabilities)) {
1692 psmouse_err(psmouse, "failed to query capabilities.\n");
1693 goto init_fail;
1694 }
1695 psmouse_info(psmouse,
1696 "Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n",
1697 etd->capabilities[0], etd->capabilities[1],
1698 etd->capabilities[2]);
1699
1700 if (etd->hw_version != 1) {
1701 if (etd->send_cmd(psmouse, ETP_SAMPLE_QUERY, etd->samples)) {
1702 psmouse_err(psmouse, "failed to query sample data\n");
1703 goto init_fail;
1704 }
1705 psmouse_info(psmouse,
1706 "Elan sample query result %02x, %02x, %02x\n",
1707 etd->samples[0], etd->samples[1], etd->samples[2]);
1708 }
1709
1710 if (etd->samples[1] == 0x74 && etd->hw_version == 0x03) {
1711
1712
1713
1714
1715
1716 psmouse_info(psmouse,
1717 "absolute mode broken, forcing standard PS/2 protocol\n");
1718 goto init_fail;
1719 }
1720
1721 if (elantech_set_absolute_mode(psmouse)) {
1722 psmouse_err(psmouse,
1723 "failed to put touchpad into absolute mode.\n");
1724 goto init_fail;
1725 }
1726
1727 if (etd->fw_version == 0x381f17) {
1728 etd->original_set_rate = psmouse->set_rate;
1729 psmouse->set_rate = elantech_set_rate_restore_reg_07;
1730 }
1731
1732 if (elantech_set_input_params(psmouse)) {
1733 psmouse_err(psmouse, "failed to query touchpad range.\n");
1734 goto init_fail;
1735 }
1736
1737 error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
1738 &elantech_attr_group);
1739 if (error) {
1740 psmouse_err(psmouse,
1741 "failed to create sysfs attributes, error: %d.\n",
1742 error);
1743 goto init_fail;
1744 }
1745
1746
1747 if ((etd->capabilities[0] & 0x80) == 0x80) {
1748 tp_dev = input_allocate_device();
1749
1750 if (!tp_dev) {
1751 error = -ENOMEM;
1752 goto init_fail_tp_alloc;
1753 }
1754
1755 etd->tp_dev = tp_dev;
1756 snprintf(etd->tp_phys, sizeof(etd->tp_phys), "%s/input1",
1757 psmouse->ps2dev.serio->phys);
1758 tp_dev->phys = etd->tp_phys;
1759 tp_dev->name = "ETPS/2 Elantech TrackPoint";
1760 tp_dev->id.bustype = BUS_I8042;
1761 tp_dev->id.vendor = 0x0002;
1762 tp_dev->id.product = PSMOUSE_ELANTECH;
1763 tp_dev->id.version = 0x0000;
1764 tp_dev->dev.parent = &psmouse->ps2dev.serio->dev;
1765 tp_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
1766 tp_dev->relbit[BIT_WORD(REL_X)] =
1767 BIT_MASK(REL_X) | BIT_MASK(REL_Y);
1768 tp_dev->keybit[BIT_WORD(BTN_LEFT)] =
1769 BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_MIDDLE) |
1770 BIT_MASK(BTN_RIGHT);
1771
1772 __set_bit(INPUT_PROP_POINTER, tp_dev->propbit);
1773 __set_bit(INPUT_PROP_POINTING_STICK, tp_dev->propbit);
1774
1775 error = input_register_device(etd->tp_dev);
1776 if (error < 0)
1777 goto init_fail_tp_reg;
1778 }
1779
1780 psmouse->protocol_handler = elantech_process_byte;
1781 psmouse->disconnect = elantech_disconnect;
1782 psmouse->reconnect = elantech_reconnect;
1783 psmouse->pktsize = etd->hw_version > 1 ? 6 : 4;
1784
1785 return 0;
1786 init_fail_tp_reg:
1787 input_free_device(tp_dev);
1788 init_fail_tp_alloc:
1789 sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
1790 &elantech_attr_group);
1791 init_fail:
1792 psmouse_reset(psmouse);
1793 kfree(etd);
1794 return error;
1795}
1796