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