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