Permalink
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Nov 21, 2011
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Sep 9, 2011
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Sep 9, 2011
Sep 9, 2011
Oct 17, 2008
Oct 11, 2011
Oct 17, 2008
Oct 17, 2008
Oct 11, 2011
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Aug 6, 2010
Oct 17, 2008
May 4, 2010
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
May 17, 2011
Oct 17, 2008
Oct 17, 2008
Sep 9, 2011
Oct 17, 2008
Aug 6, 2010
Oct 17, 2008
May 17, 2011
Oct 17, 2008
May 4, 2010
Oct 17, 2008
May 4, 2010
Oct 17, 2008
Oct 17, 2008
Sep 9, 2011
Oct 17, 2008
Oct 17, 2008
May 17, 2011
Oct 17, 2008
Aug 23, 2014
Sep 9, 2011
Sep 9, 2011
Sep 9, 2011
Sep 9, 2011
Jun 8, 2014
Sep 9, 2011
Sep 9, 2011
Jun 8, 2014
Sep 9, 2011
Oct 17, 2008
Oct 17, 2008
Sep 21, 2011
Sep 9, 2011
Sep 9, 2011
Aug 15, 2013
Aug 15, 2013
Aug 15, 2013
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Sep 21, 2011
Sep 9, 2011
Oct 17, 2008
Aug 23, 2014
Nov 8, 2014
Oct 17, 2008
Sep 9, 2011
Oct 17, 2008
Apr 19, 2009
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Sep 9, 2011
Sep 9, 2011
Sep 21, 2011
Sep 21, 2011
Sep 9, 2011
Sep 9, 2011
Nov 21, 2011
Dec 16, 2013
Dec 16, 2013
Dec 16, 2013
Aug 23, 2014
Dec 16, 2013
Nov 14, 2014
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Nov 14, 2014
Oct 17, 2008
Oct 17, 2008
Sep 9, 2011
Oct 17, 2008
Sep 9, 2011
May 17, 2011
Sep 9, 2011
Oct 17, 2008
Nov 21, 2011
Sep 9, 2011
Sep 9, 2011
Sep 9, 2011
Nov 21, 2011
Sep 9, 2011
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
May 19, 2010
Sep 8, 2014
May 19, 2010
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Sep 9, 2011
Oct 11, 2011
Feb 28, 2009
Oct 11, 2011
Oct 17, 2008
Aug 23, 2014
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Nov 8, 2014
Jun 8, 2014
May 5, 2014
Sep 9, 2011
Sep 9, 2011
Nov 9, 2011
Nov 21, 2011
Sep 9, 2011
Sep 9, 2011
Aug 15, 2013
Nov 8, 2014
May 5, 2014
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 11, 2011
Oct 17, 2008
Oct 17, 2008
Oct 11, 2011
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Oct 11, 2011
Oct 17, 2008
Aug 23, 2014
Aug 23, 2014
Oct 17, 2008
Oct 17, 2008
Aug 23, 2014
Oct 17, 2008
Oct 17, 2008
Oct 17, 2008
Newer
100644
1684 lines (1444 sloc)
45.1 KB
1
/*
3
*
5
*
6
* This program is free software; you can redistribute it and/or modify it
7
* under the terms of the GNU General Public License version 2 as published
8
* by the Free Software Foundation.
9
*
10
* Trademarks are the property of their respective owners.
11
*/
12
13
#include <linux/delay.h>
16
#include <linux/module.h>
17
#include <linux/input.h>
19
#include <linux/serio.h>
20
#include <linux/libps2.h>
22
#include "psmouse.h"
23
#include "elantech.h"
24
30
} while (0)
31
32
/*
33
* Send a Synaptics style sliced query command
34
*/
35
static 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)) {
41
return -1;
42
}
43
44
return 0;
45
}
46
47
/*
48
* V3 and later support this fast command
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
* A retrying version of ps2_command
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--;
83
msleep(ETP_PS2_COMMAND_DELAY);
84
} while (tries > 0);
85
86
if (rc)
88
89
return rc;
90
}
91
92
/*
93
* Send an Elantech style special command to read a value from a register
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
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;
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)
141
*val = param[0];
144
145
return rc;
146
}
147
148
/*
149
* Send an Elantech style special command to write a register with a value
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
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
* Dump a complete mouse movement packet to the syslog
222
*/
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
* Interpret complete data packets and report absolute mode input events for
235
* hardware version 1. (4 byte packets)
236
*/
237
static 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
249
fingers = ((packet[1] & 0x80) >> 7) +
250
((packet[1] & 0x30) >> 4);
251
} else {
256
fingers = (packet[0] & 0xc0) >> 6;
257
}
258
260
if (fingers != 1) {
261
etd->single_finger_reports = 0;
262
} else if (etd->single_finger_reports < 2) {
263
/* Discard first 2 reports of one finger, bogus */
264
etd->single_finger_reports++;
270
input_report_key(dev, BTN_TOUCH, fingers != 0);
271
272
/*
273
* byte 2: x7 x6 x5 x4 x3 x2 x1 x0
274
* byte 3: y7 y6 y5 y4 y3 y2 y1 y0
275
*/
276
if (fingers) {
277
input_report_abs(dev, ABS_X,
278
((packet[1] & 0x0c) << 6) | packet[2]);
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
291
/* rocker up */
292
input_report_key(dev, BTN_FORWARD, packet[0] & 0x40);
293
/* rocker down */
294
input_report_key(dev, BTN_BACK, packet[0] & 0x80);
295
}
296
297
input_sync(dev);
298
}
299
300
static 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
/* x1 < x2 and y1 < y2 when two fingers, x = y = 0 when not pressed */
312
static 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
* Interpret complete data packets and report absolute mode input events for
323
* hardware version 2. (6 byte packets)
324
*/
325
static void elantech_report_absolute_v2(struct psmouse *psmouse)
326
{
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
/* byte 0: n1 n0 . . . . R L */
334
fingers = (packet[0] & 0xc0) >> 6;
335
336
switch (fingers) {
337
case 3:
338
/*
339
* Same as one finger, except report of more than 3 fingers:
340
* byte 3: n4 . w1 w0 . . . .
341
*/
342
if (packet[3] & 0x80)
343
fingers = 4;
344
/* pass through... */
345
case 1:
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
* The coordinate of each finger is reported separately
364
* with a lower resolution for two finger touches:
365
* byte 0: . . ay8 ax8 . . . .
366
* byte 1: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0
367
*/
369
/* byte 2: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0 */
372
/*
373
* byte 3: . . by8 bx8 . . . .
374
* byte 4: bx7 bx6 bx5 bx4 bx3 bx2 bx1 bx0
375
*/
377
/* byte 5: by7 by8 by5 by4 by3 by2 by1 by0 */
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
}
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);
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
407
static void elantech_report_trackpoint(struct psmouse *psmouse,
408
int packet_type)
409
{
410
/*
411
* byte 0: 0 0 sx sy 0 M R L
412
* byte 1:~sx 0 0 0 0 0 0 0
413
* byte 2:~sy 0 0 0 0 0 0 0
414
* byte 3: 0 0 ~sy ~sx 0 1 1 0
415
* byte 4: x7 x6 x5 x4 x3 x2 x1 x0
416
* byte 5: y7 y6 y5 y4 y3 y2 y1 y0
417
*
418
* x and y are written in two's complement spread
419
* over 9 bits with sx/sy the relative top bit and
420
* x7..x0 and y7..y0 the lower bits.
421
* The sign of y is opposite to what the input driver
422
* expects for a relative movement
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
/* Dump unexpected packet sequences if debug=1 (default) */
454
if (etd->debug == 1)
455
elantech_packet_dump(psmouse);
456
457
break;
458
}
459
}
460
461
/*
462
* Interpret complete data packets and report absolute mode input events for
463
* hardware version 3. (12 byte packets for two fingers)
464
*/
465
static 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
/* byte 0: n1 n0 . . . . R L */
475
fingers = (packet[0] & 0xc0) >> 6;
476
477
switch (fingers) {
478
case 3:
479
case 1:
480
/*
481
* byte 1: . . . . x11 x10 x9 x8
482
* byte 2: x7 x6 x5 x4 x4 x2 x1 x0
483
*/
484
x1 = ((packet[1] & 0x0f) << 8) | packet[2];
485
/*
486
* byte 4: . . . . y11 y10 y9 y8
487
* byte 5: y7 y6 y5 y4 y3 y2 y1 y0
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
* byte 1: . . . . ax11 ax10 ax9 ax8
496
* byte 2: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0
497
*/
499
/*
500
* byte 4: . . . . ay11 ay10 ay9 ay8
501
* byte 5: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0
502
*/
504
(((packet[4] & 0x0f) << 8) | packet[5]);
505
/*
506
* wait for next packet
507
*/
508
return;
509
}
510
511
/* packet_type == PACKET_V3_TAIL */
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
/* For clickpads map both buttons to BTN_LEFT */
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
546
static void elantech_input_sync_v4(struct psmouse *psmouse)
547
{
548
struct input_dev *dev = psmouse->dev;
552
/* For clickpads map both buttons to BTN_LEFT */
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);
561
input_mt_report_pointer_emulation(dev, true);
562
input_sync(dev);
563
}
564
565
static 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
/* notify finger state change */
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
584
static 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
/* report this for backwards compatibility */
608
input_report_abs(dev, ABS_TOOL_WIDTH, traces);
609
610
elantech_input_sync_v4(psmouse);
611
}
612
613
static 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
* Motion packets give us the delta of x, y values of specific fingers,
629
* but in two's complement. Let the compiler do the conversion for us.
630
* Also _enlarge_ the numbers to int, in case of overflow.
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
654
static 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
/* impossible to get here */
673
break;
674
}
675
}
676
678
{
679
struct elantech_data *etd = psmouse->private;
680
unsigned char *packet = psmouse->packet;
681
unsigned char p1, p2, p3;
682
683
/* Parity bits are placed differently */
685
/* byte 0: D U p1 p2 1 p3 R L */
686
p1 = (packet[0] & 0x20) >> 5;
687
p2 = (packet[0] & 0x10) >> 4;
688
} else {
689
/* byte 0: n1 n0 p2 p1 1 p3 R L */
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
701
static int elantech_debounce_check_v2(struct psmouse *psmouse)
702
{
703
/*
704
* When we encounter packet that matches this exactly, it means the
705
* hardware is in debounce status. Just ignore the whole packet.
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
713
static 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
* V2 hardware has two flavors. Older ones that do not report pressure,
720
* and newer ones that reports pressure and width. With newer ones, all
721
* packets (1, 2, 3 finger touch) have the same constant bits. With
722
* older ones, 1/3 finger touch packets and 2 finger touch packets
723
* have different constant bits.
724
* With all three cases, if the constant bits are not exactly what I
725
* expected, I consider them invalid.
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
748
const u8 debounce_packet[] = { 0xc4, 0xff, 0xff, 0x02, 0xff, 0xff };
749
unsigned char *packet = psmouse->packet;
750
751
/*
752
* check debounce first, it has the same signature in byte 0
753
* and byte 3 as PACKET_V3_HEAD.
754
*/
755
if (!memcmp(packet, debounce_packet, sizeof(debounce_packet)))
756
return PACKET_DEBOUNCE;
757
758
/*
759
* If the hardware flag 'crc_enabled' is set the packets have
760
* different signatures.
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;
772
if ((packet[0] & 0x0c) == 0x0c && (packet[3] & 0xce) == 0x0c)
773
return PACKET_V3_TAIL;
791
/*
792
* Sanity check based on the constant bits of a packet.
793
* The constant bits change depending on the value of
794
* the hardware flag 'crc_enabled' but are the same for
795
* every packet, regardless of the type.
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;
820
/*
821
* Process byte stream from mouse and handle complete packets
822
*/
823
static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse)
824
{
825
struct elantech_data *etd = psmouse->private;
827
828
if (psmouse->pktcnt < psmouse->pktsize)
829
return PSMOUSE_GOOD_DATA;
830
831
if (etd->debug > 1)
833
834
switch (etd->hw_version) {
835
case 1:
837
return PSMOUSE_BAD_DATA;
838
839
elantech_report_absolute_v1(psmouse);
840
break;
841
842
case 2:
843
/* ignore debounce */
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;
859
case PACKET_DEBOUNCE:
860
/* ignore debounce */
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
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
890
}
891
892
return PSMOUSE_FULL_PACKET;
893
}
894
895
/*
896
* Put the touchpad into absolute mode
897
*/
898
static int elantech_set_absolute_mode(struct psmouse *psmouse)
899
{
900
struct elantech_data *etd = psmouse->private;
901
unsigned char val;
902
int tries = ETP_READ_BACK_TRIES;
903
int rc = 0;
904
905
switch (etd->hw_version) {
906
case 1:
907
etd->reg_10 = 0x16;
908
etd->reg_11 = 0x8f;
909
if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
910
elantech_write_reg(psmouse, 0x11, etd->reg_11)) {
911
rc = -1;
912
}
913
break;
914
915
case 2:
916
/* Windows driver values */
917
etd->reg_10 = 0x54;
918
etd->reg_11 = 0x88; /* 0x8a */
919
etd->reg_21 = 0x60; /* 0x00 */
920
if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
921
elantech_write_reg(psmouse, 0x11, etd->reg_11) ||
922
elantech_write_reg(psmouse, 0x21, etd->reg_21)) {
923
rc = -1;
924
}
937
938
case 4:
939
etd->reg_07 = 0x01;
940
if (elantech_write_reg(psmouse, 0x07, etd->reg_07))
941
rc = -1;
942
943
goto skip_readback_reg_10; /* v4 has no reg 0x10 to read */
947
/*
948
* Read back reg 0x10. For hardware version 1 we must make
949
* sure the absolute mode bit is set. For hardware version 2
952
*/
953
do {
954
rc = elantech_read_reg(psmouse, 0x10, &val);
955
if (rc == 0)
956
break;
957
tries--;
959
msleep(ETP_READ_BACK_DELAY);
960
} while (tries > 0);
971
}
972
974
if (rc)
976
977
return rc;
978
}
979
980
static int elantech_set_range(struct psmouse *psmouse,
981
unsigned int *x_min, unsigned int *y_min,
988
989
switch (etd->hw_version) {
990
case 1:
991
*x_min = ETP_XMIN_V1;
992
*y_min = ETP_YMIN_V1;
993
*x_max = ETP_XMAX_V1;
994
*y_max = ETP_YMAX_V1;
995
break;
996
997
case 2:
998
if (etd->fw_version == 0x020800 ||
999
etd->fw_version == 0x020b00 ||
1000
etd->fw_version == 0x020030) {
1001
*x_min = ETP_XMIN_V2;
1002
*y_min = ETP_YMIN_V2;
1003
*x_max = ETP_XMAX_V2;
1004
*y_max = ETP_YMAX_V2;
1005
} else {
1013
return -1;
1014
1015
fixed_dpi = param[1] & 0x10;
1016
1017
if (((etd->fw_version >> 16) == 0x14) && fixed_dpi) {
1019
return -1;
1020
1021
*x_max = (etd->capabilities[1] - i) * param[1] / 2;
1022
*y_max = (etd->capabilities[2] - i) * param[2] / 2;
1023
} else if (etd->fw_version == 0x040216) {
1024
*x_max = 819;
1025
*y_max = 405;
1026
} else if (etd->fw_version == 0x040219 || etd->fw_version == 0x040215) {
1027
*x_max = 900;
1028
*y_max = 500;
1029
} else {
1030
*x_max = (etd->capabilities[1] - i) * 64;
1031
*y_max = (etd->capabilities[2] - i) * 64;
1032
}
1038
return -1;
1039
1040
*x_max = (0x0f & param[0]) << 8 | param[1];
1041
*y_max = (0xf0 & param[0]) << 4 | param[2];
1042
break;
1046
return -1;
1047
1048
*x_max = (0x0f & param[0]) << 8 | param[1];
1049
*y_max = (0xf0 & param[0]) << 4 | param[2];
1050
traces = etd->capabilities[1];
1051
if ((traces < 2) || (traces > *x_max))
1052
return -1;
1053
1054
*width = *x_max / (traces - 1);
1055
break;
1061
/*
1062
* (value from firmware) * 10 + 790 = dpi
1063
* we also have to convert dpi to dots/mm (*10/254 to avoid floating point)
1064
*/
1065
static unsigned int elantech_convert_res(unsigned int val)
1066
{
1067
return (val * 10 + 790) * 10 / 254;
1068
}
1069
1070
static int elantech_get_resolution_v4(struct psmouse *psmouse,
1071
unsigned int *x_res,
1072
unsigned int *y_res)
1073
{
1074
unsigned char param[3];
1075
1076
if (elantech_send_cmd(psmouse, ETP_RESOLUTION_QUERY, param))
1077
return -1;
1078
1079
*x_res = elantech_convert_res(param[1] & 0x0f);
1080
*y_res = elantech_convert_res((param[1] & 0xf0) >> 4);
1081
1082
return 0;
1083
}
1084
1085
/*
1086
* Advertise INPUT_PROP_BUTTONPAD for clickpads. The testing of bit 12 in
1087
* fw_version for this is based on the following fw_version & caps table:
1088
*
1089
* Laptop-model: fw_version: caps: buttons:
1090
* Acer S3 0x461f00 10, 13, 0e clickpad
1091
* Acer S7-392 0x581f01 50, 17, 0d clickpad
1092
* Acer V5-131 0x461f02 01, 16, 0c clickpad
1093
* Acer V5-551 0x461f00 ? clickpad
1094
* Asus K53SV 0x450f01 78, 15, 0c 2 hw buttons
1095
* Asus G46VW 0x460f02 00, 18, 0c 2 hw buttons
1096
* Asus G750JX 0x360f00 00, 16, 0c 2 hw buttons
1097
* Asus UX31 0x361f00 20, 15, 0e clickpad
1098
* Asus UX32VD 0x361f02 00, 15, 0e clickpad
1099
* Avatar AVIU-145A2 0x361f00 ? clickpad
1101
* Gigabyte U2442 0x450f01 58, 17, 0c 2 hw buttons
1102
* Lenovo L430 0x350f02 b9, 15, 0c 2 hw buttons (*)
1104
* Samsung NF210 0x150b00 78, 14, 0a 2 hw buttons
1105
* Samsung NP770Z5E 0x575f01 10, 15, 0f clickpad
1106
* Samsung NP700Z5B 0x361f06 21, 15, 0f clickpad
1107
* Samsung NP900X3E-A02 0x575f03 ? clickpad
1108
* Samsung NP-QX410 0x851b00 19, 14, 0c clickpad
1109
* Samsung RC512 0x450f00 08, 15, 0c 2 hw buttons
1110
* Samsung RF710 0x450f00 ? 2 hw buttons
1111
* System76 Pangolin 0x250f01 ? 2 hw buttons
1112
* (*) + 3 trackpoint buttons
1113
* (**) + 0 trackpoint buttons
1114
* Note: Lenovo L430 and Lenovo L430 have the same fw_version/caps
1115
*/
1116
static void elantech_set_buttonpad_prop(struct psmouse *psmouse)
1117
{
1118
struct input_dev *dev = psmouse->dev;
1119
struct elantech_data *etd = psmouse->private;
1120
1121
if (etd->fw_version & 0x001000) {
1122
__set_bit(INPUT_PROP_BUTTONPAD, dev->propbit);
1123
__clear_bit(BTN_RIGHT, dev->keybit);
1124
}
1125
}
1126
1127
/*
1128
* Some hw_version 4 models do have a middle button
1129
*/
1130
static const struct dmi_system_id elantech_dmi_has_middle_button[] = {
1131
#if defined(CONFIG_DMI) && defined(CONFIG_X86)
1132
{
1133
/* Fujitsu H730 has a middle button */
1134
.matches = {
1135
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1136
DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H730"),
1137
},
1138
},
1139
#endif
1140
{ }
1141
};
1142
1143
/*
1144
* Set the appropriate event bits for the input subsystem
1145
*/
1147
{
1148
struct input_dev *dev = psmouse->dev;
1149
struct elantech_data *etd = psmouse->private;
1155
1157
__set_bit(EV_KEY, dev->evbit);
1158
__set_bit(EV_ABS, dev->evbit);
1160
1161
__set_bit(BTN_LEFT, dev->keybit);
1162
if (dmi_check_system(elantech_dmi_has_middle_button))
1163
__set_bit(BTN_MIDDLE, dev->keybit);
1164
__set_bit(BTN_RIGHT, dev->keybit);
1165
1166
__set_bit(BTN_TOUCH, dev->keybit);
1167
__set_bit(BTN_TOOL_FINGER, dev->keybit);
1168
__set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
1169
__set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
1170
1171
switch (etd->hw_version) {
1172
case 1:
1173
/* Rocker button */
1176
__set_bit(BTN_FORWARD, dev->keybit);
1177
__set_bit(BTN_BACK, dev->keybit);
1178
}
1179
input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
1180
input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
1181
break;
1182
1183
case 2:
1190
input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
1191
input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
1192
if (etd->reports_pressure) {
1193
input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2,
1194
ETP_PMAX_V2, 0, 0);
1195
input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
1196
ETP_WMAX_V2, 0, 0);
1197
}
1199
input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
1200
input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
1201
break;
1204
if (elantech_get_resolution_v4(psmouse, &x_res, &y_res)) {
1205
/*
1206
* if query failed, print a warning and leave the values
1207
* zero to resemble synaptics.c behavior.
1208
*/
1209
psmouse_warn(psmouse, "couldn't query resolution data.\n");
1210
}
1212
__set_bit(BTN_TOOL_QUADTAP, dev->keybit);
1213
/* For X to recognize me as touchpad. */
1214
input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
1215
input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
1218
/*
1219
* range of pressure and width is the same as v2,
1220
* report ABS_PRESSURE, ABS_TOOL_WIDTH for compatibility.
1221
*/
1222
input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2,
1223
ETP_PMAX_V2, 0, 0);
1224
input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
1225
ETP_WMAX_V2, 0, 0);
1226
/* Multitouch capable pad, up to 5 fingers. */
1228
input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
1229
input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
1230
input_abs_set_res(dev, ABS_MT_POSITION_X, x_res);
1231
input_abs_set_res(dev, ABS_MT_POSITION_Y, y_res);
1232
input_set_abs_params(dev, ABS_MT_PRESSURE, ETP_PMIN_V2,
1233
ETP_PMAX_V2, 0, 0);
1234
/*
1235
* The firmware reports how many trace lines the finger spans,
1236
* convert to surface unit as Protocol-B requires.
1237
*/
1238
input_set_abs_params(dev, ABS_MT_TOUCH_MAJOR, 0,
1239
ETP_WMAX_V2 * width, 0, 0);
1240
break;
1241
}
1247
}
1248
1249
struct elantech_attr_data {
1250
size_t field_offset;
1251
unsigned char reg;
1252
};
1253
1254
/*
1255
* Display a register value by reading a sysfs entry
1256
*/
1257
static ssize_t elantech_show_int_attr(struct psmouse *psmouse, void *data,
1258
char *buf)
1259
{
1260
struct elantech_data *etd = psmouse->private;
1261
struct elantech_attr_data *attr = data;
1262
unsigned char *reg = (unsigned char *) etd + attr->field_offset;
1263
int rc = 0;
1264
1265
if (attr->reg)
1266
rc = elantech_read_reg(psmouse, attr->reg, reg);
1267
1268
return sprintf(buf, "0x%02x\n", (attr->reg && rc) ? -1 : *reg);
1269
}
1270
1271
/*
1272
* Write a register value by writing a sysfs entry
1273
*/
1274
static ssize_t elantech_set_int_attr(struct psmouse *psmouse,
1275
void *data, const char *buf, size_t count)
1276
{
1277
struct elantech_data *etd = psmouse->private;
1278
struct elantech_attr_data *attr = data;
1279
unsigned char *reg = (unsigned char *) etd + attr->field_offset;
1281
int err;
1282
1284
if (err)
1285
return err;
1286
1287
/* Do we need to preserve some bits for version 2 hardware too? */
1288
if (etd->hw_version == 1) {
1289
if (attr->reg == 0x10)
1290
/* Force absolute mode always on */
1291
value |= ETP_R10_ABSOLUTE_MODE;
1292
else if (attr->reg == 0x11)
1293
/* Force 4 byte mode always on */
1294
value |= ETP_R11_4_BYTE_MODE;
1295
}
1296
1297
if (!attr->reg || elantech_write_reg(psmouse, attr->reg, value) == 0)
1298
*reg = value;
1299
1300
return count;
1301
}
1302
1303
#define ELANTECH_INT_ATTR(_name, _register) \
1304
static struct elantech_attr_data elantech_attr_##_name = { \
1305
.field_offset = offsetof(struct elantech_data, _name), \
1306
.reg = _register, \
1307
}; \
1308
PSMOUSE_DEFINE_ATTR(_name, S_IWUSR | S_IRUGO, \
1309
&elantech_attr_##_name, \
1310
elantech_show_int_attr, \
1311
elantech_set_int_attr)
1312
1314
ELANTECH_INT_ATTR(reg_10, 0x10);
1315
ELANTECH_INT_ATTR(reg_11, 0x11);
1316
ELANTECH_INT_ATTR(reg_20, 0x20);
1317
ELANTECH_INT_ATTR(reg_21, 0x21);
1318
ELANTECH_INT_ATTR(reg_22, 0x22);
1319
ELANTECH_INT_ATTR(reg_23, 0x23);
1320
ELANTECH_INT_ATTR(reg_24, 0x24);
1321
ELANTECH_INT_ATTR(reg_25, 0x25);
1322
ELANTECH_INT_ATTR(reg_26, 0x26);
1323
ELANTECH_INT_ATTR(debug, 0);
1324
ELANTECH_INT_ATTR(paritycheck, 0);
1326
1327
static struct attribute *elantech_attrs[] = {
1329
&psmouse_attr_reg_10.dattr.attr,
1330
&psmouse_attr_reg_11.dattr.attr,
1331
&psmouse_attr_reg_20.dattr.attr,
1332
&psmouse_attr_reg_21.dattr.attr,
1333
&psmouse_attr_reg_22.dattr.attr,
1334
&psmouse_attr_reg_23.dattr.attr,
1335
&psmouse_attr_reg_24.dattr.attr,
1336
&psmouse_attr_reg_25.dattr.attr,
1337
&psmouse_attr_reg_26.dattr.attr,
1338
&psmouse_attr_debug.dattr.attr,
1339
&psmouse_attr_paritycheck.dattr.attr,
1341
NULL
1342
};
1343
1344
static struct attribute_group elantech_attr_group = {
1345
.attrs = elantech_attrs,
1346
};
1347
1348
static bool elantech_is_signature_valid(const unsigned char *param)
1349
{
1350
static const unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10 };
1351
int i;
1352
1353
if (param[0] == 0)
1354
return false;
1355
1356
if (param[1] == 0)
1357
return true;
1358
1359
/*
1360
* Some models have a revision higher then 20. Meaning param[2] may
1361
* be 10 or 20, skip the rates check for these.
1362
*/
1363
if (param[0] == 0x46 && (param[1] & 0xef) == 0x0f && param[2] < 40)
1364
return true;
1365
1366
for (i = 0; i < ARRAY_SIZE(rates); i++)
1367
if (param[2] == rates[i])
1368
return false;
1369
1370
return true;
1371
}
1372
1373
/*
1374
* Use magic knock to detect Elantech touchpad
1375
*/
1377
{
1378
struct ps2dev *ps2dev = &psmouse->ps2dev;
1379
unsigned char param[3];
1380
1381
ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS);
1382
1383
if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
1384
ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
1385
ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
1386
ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) ||
1387
ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
1389
return -1;
1390
}
1391
1392
/*
1393
* Report this in case there are Elantech models that use a different
1394
* set of magic numbers
1395
*/
1396
if (param[0] != 0x3c || param[1] != 0x03 ||
1397
(param[2] != 0xc8 && param[2] != 0x00)) {
1398
psmouse_dbg(psmouse,
1399
"unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n",
1400
param[0], param[1], param[2]);
1401
return -1;
1402
}
1403
1404
/*
1405
* Query touchpad's firmware version and see if it reports known
1406
* value to avoid mis-detection. Logitech mice are known to respond
1407
* to Elantech magic knock and there might be more.
1408
*/
1409
if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
1414
psmouse_dbg(psmouse,
1415
"Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n",
1416
param[0], param[1], param[2]);
1422
}
1423
1424
if (set_properties) {
1425
psmouse->vendor = "Elantech";
1426
psmouse->name = "Touchpad";
1427
}
1428
1429
return 0;
1430
}
1431
1432
/*
1433
* Clean up sysfs entries when disconnecting
1434
*/
1435
static void elantech_disconnect(struct psmouse *psmouse)
1436
{
1437
struct elantech_data *etd = psmouse->private;
1438
1439
if (etd->tp_dev)
1440
input_unregister_device(etd->tp_dev);
1441
sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
1442
&elantech_attr_group);
1443
kfree(psmouse->private);
1444
psmouse->private = NULL;
1445
}
1446
1447
/*
1448
* Put the touchpad back into absolute mode when reconnecting
1449
*/
1450
static int elantech_reconnect(struct psmouse *psmouse)
1451
{
1454
if (elantech_detect(psmouse, 0))
1455
return -1;
1456
1457
if (elantech_set_absolute_mode(psmouse)) {
1460
return -1;
1461
}
1462
1463
return 0;
1464
}
1465
1466
/*
1467
* Some hw_version 4 models do not work with crc_disabled
1468
*/
1469
static const struct dmi_system_id elantech_dmi_force_crc_enabled[] = {
1470
#if defined(CONFIG_DMI) && defined(CONFIG_X86)
1471
{
1472
/* Fujitsu H730 does not work with crc_enabled == 0 */
1473
.matches = {
1474
DMI_MATCH(DMI_SYS_VENDOR, "FUJITSU"),
1475
DMI_MATCH(DMI_PRODUCT_NAME, "CELSIUS H730"),
1476
},
1477
},
1478
#endif
1479
{ }
1480
};
1481
1483
* Some hw_version 3 models go into error state when we try to set
1484
* bit 3 and/or bit 1 of r10.
1485
*/
1486
static const struct dmi_system_id no_hw_res_dmi_table[] = {
1487
#if defined(CONFIG_DMI) && defined(CONFIG_X86)
1488
{
1489
/* Gigabyte U2442 */
1490
.matches = {
1491
DMI_MATCH(DMI_SYS_VENDOR, "GIGABYTE"),
1492
DMI_MATCH(DMI_PRODUCT_NAME, "U2442"),
1493
},
1494
},
1495
#endif
1496
{ }
1497
};
1498
1499
/*
1500
* determine hardware version and set some properties according to it.
1501
*/
1508
if (etd->fw_version < 0x020030 || etd->fw_version == 0x020600)
1509
etd->hw_version = 1;
1510
else {
1511
switch (ver) {
1512
case 2:
1513
case 4:
1514
etd->hw_version = 2;
1515
break;
1516
case 5:
1517
etd->hw_version = 3;
1518
break;
1519
case 6:
1530
/* decide which send_cmd we're gonna use early */
1531
etd->send_cmd = etd->hw_version >= 3 ? elantech_send_cmd :
1532
synaptics_send_cmd;
1533
1534
/* Turn on packet checking by default */
1535
etd->paritycheck = 1;
1536
1537
/*
1538
* This firmware suffers from misreporting coordinates when
1539
* a touch action starts causing the mouse cursor or scrolled page
1540
* to jump. Enable a workaround.
1541
*/
1542
etd->jumpy_cursor =
1543
(etd->fw_version == 0x020022 || etd->fw_version == 0x020600);
1544
1546
/* For now show extra debug information */
1547
etd->debug = 1;
1548
1549
if (etd->fw_version >= 0x020800)
1550
etd->reports_pressure = true;
1551
}
1553
/*
1554
* The signatures of v3 and v4 packets change depending on the
1555
* value of this hardware flag.
1556
*/
1557
etd->crc_enabled = (etd->fw_version & 0x4000) == 0x4000 ||
1558
dmi_check_system(elantech_dmi_force_crc_enabled);
1560
/* Enable real hardware resolution on hw_version 3 ? */
1561
etd->set_hw_resolution = !dmi_check_system(no_hw_res_dmi_table);
1562
1566
/*
1567
* Initialize the touchpad and create sysfs entries
1568
*/
1569
int elantech_init(struct psmouse *psmouse)
1570
{
1571
struct elantech_data *etd;
1574
unsigned char param[3];
1576
1578
if (!etd)
1580
1583
etd->parity[0] = 1;
1584
for (i = 1; i < 256; i++)
1585
etd->parity[i] = etd->parity[i & (i - 1)] ^ 1;
1586
1587
/*
1589
*/
1590
if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
1592
goto init_fail;
1593
}
1600
psmouse_info(psmouse,
1601
"assuming hardware version %d (with firmware version 0x%02x%02x%02x)\n",
1602
etd->hw_version, param[0], param[1], param[2]);
1603
1607
goto init_fail;
1608
}
1609
psmouse_info(psmouse,
1610
"Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n",
1611
etd->capabilities[0], etd->capabilities[1],
1612
etd->capabilities[2]);
1613
1614
if (elantech_set_absolute_mode(psmouse)) {
1617
goto init_fail;
1618
}
1619
1624
1625
error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
1626
&elantech_attr_group);
1627
if (error) {
1628
psmouse_err(psmouse,
1629
"failed to create sysfs attributes, error: %d.\n",
1630
error);
1631
goto init_fail;
1632
}
1633
1634
/* The MSB indicates the presence of the trackpoint */
1635
if ((etd->capabilities[0] & 0x80) == 0x80) {
1636
tp_dev = input_allocate_device();
1637
1638
if (!tp_dev) {
1639
error = -ENOMEM;
1640
goto init_fail_tp_alloc;
1641
}
1642
1643
etd->tp_dev = tp_dev;
1644
snprintf(etd->tp_phys, sizeof(etd->tp_phys), "%s/input1",
1645
psmouse->ps2dev.serio->phys);
1646
tp_dev->phys = etd->tp_phys;
1647
tp_dev->name = "Elantech PS/2 TrackPoint";
1648
tp_dev->id.bustype = BUS_I8042;
1649
tp_dev->id.vendor = 0x0002;
1650
tp_dev->id.product = PSMOUSE_ELANTECH;
1651
tp_dev->id.version = 0x0000;
1652
tp_dev->dev.parent = &psmouse->ps2dev.serio->dev;
1653
tp_dev->evbit[0] = BIT_MASK(EV_KEY) | BIT_MASK(EV_REL);
1654
tp_dev->relbit[BIT_WORD(REL_X)] =
1655
BIT_MASK(REL_X) | BIT_MASK(REL_Y);
1656
tp_dev->keybit[BIT_WORD(BTN_LEFT)] =
1657
BIT_MASK(BTN_LEFT) | BIT_MASK(BTN_MIDDLE) |
1658
BIT_MASK(BTN_RIGHT);
1663
error = input_register_device(etd->tp_dev);
1664
if (error < 0)
1665
goto init_fail_tp_reg;
1666
}
1667
1668
psmouse->protocol_handler = elantech_process_byte;
1669
psmouse->disconnect = elantech_disconnect;
1670
psmouse->reconnect = elantech_reconnect;
1672
1673
return 0;
1674
init_fail_tp_reg:
1675
input_free_device(tp_dev);
1676
init_fail_tp_alloc:
1677
sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
1678
&elantech_attr_group);
1679
init_fail:
1681
kfree(etd);
1683
}