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