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