Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
elantech.c
Go to the documentation of this file.
1 /*
2  * Elantech Touchpad driver (v6)
3  *
4  * Copyright (C) 2007-2009 Arjan Opmeer <[email protected]>
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>
14 #include <linux/slab.h>
15 #include <linux/module.h>
16 #include <linux/input.h>
17 #include <linux/input/mt.h>
18 #include <linux/serio.h>
19 #include <linux/libps2.h>
20 #include "psmouse.h"
21 #include "elantech.h"
22 
23 #define elantech_debug(fmt, ...) \
24  do { \
25  if (etd->debug) \
26  psmouse_printk(KERN_DEBUG, psmouse, \
27  fmt, ##__VA_ARGS__); \
28  } while (0)
29 
30 /*
31  * Send a Synaptics style sliced query command
32  */
33 static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c,
34  unsigned char *param)
35 {
36  if (psmouse_sliced_command(psmouse, c) ||
37  ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
38  psmouse_err(psmouse, "%s query 0x%02x failed.\n", __func__, c);
39  return -1;
40  }
41 
42  return 0;
43 }
44 
45 /*
46  * V3 and later support this fast command
47  */
48 static int elantech_send_cmd(struct psmouse *psmouse, unsigned char c,
49  unsigned char *param)
50 {
51  struct ps2dev *ps2dev = &psmouse->ps2dev;
52 
53  if (ps2_command(ps2dev, NULL, ETP_PS2_CUSTOM_COMMAND) ||
54  ps2_command(ps2dev, NULL, c) ||
55  ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
56  psmouse_err(psmouse, "%s query 0x%02x failed.\n", __func__, c);
57  return -1;
58  }
59 
60  return 0;
61 }
62 
63 /*
64  * A retrying version of ps2_command
65  */
66 static int elantech_ps2_command(struct psmouse *psmouse,
67  unsigned char *param, int command)
68 {
69  struct ps2dev *ps2dev = &psmouse->ps2dev;
70  struct elantech_data *etd = psmouse->private;
71  int rc;
72  int tries = ETP_PS2_COMMAND_TRIES;
73 
74  do {
75  rc = ps2_command(ps2dev, param, command);
76  if (rc == 0)
77  break;
78  tries--;
79  elantech_debug("retrying ps2 command 0x%02x (%d).\n",
80  command, tries);
82  } while (tries > 0);
83 
84  if (rc)
85  psmouse_err(psmouse, "ps2 command 0x%02x failed.\n", command);
86 
87  return rc;
88 }
89 
90 /*
91  * Send an Elantech style special command to read a value from a register
92  */
93 static int elantech_read_reg(struct psmouse *psmouse, unsigned char reg,
94  unsigned char *val)
95 {
96  struct elantech_data *etd = psmouse->private;
97  unsigned char param[3];
98  int rc = 0;
99 
100  if (reg < 0x07 || reg > 0x26)
101  return -1;
102 
103  if (reg > 0x11 && reg < 0x20)
104  return -1;
105 
106  switch (etd->hw_version) {
107  case 1:
109  psmouse_sliced_command(psmouse, reg) ||
110  ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) {
111  rc = -1;
112  }
113  break;
114 
115  case 2:
116  if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
117  elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READ) ||
118  elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
119  elantech_ps2_command(psmouse, NULL, reg) ||
120  elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) {
121  rc = -1;
122  }
123  break;
124 
125  case 3 ... 4:
126  if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
127  elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
128  elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
129  elantech_ps2_command(psmouse, NULL, reg) ||
130  elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) {
131  rc = -1;
132  }
133  break;
134  }
135 
136  if (rc)
137  psmouse_err(psmouse, "failed to read register 0x%02x.\n", reg);
138  else if (etd->hw_version != 4)
139  *val = param[0];
140  else
141  *val = param[1];
142 
143  return rc;
144 }
145 
146 /*
147  * Send an Elantech style special command to write a register with a value
148  */
149 static int elantech_write_reg(struct psmouse *psmouse, unsigned char reg,
150  unsigned char val)
151 {
152  struct elantech_data *etd = psmouse->private;
153  int rc = 0;
154 
155  if (reg < 0x07 || reg > 0x26)
156  return -1;
157 
158  if (reg > 0x11 && reg < 0x20)
159  return -1;
160 
161  switch (etd->hw_version) {
162  case 1:
164  psmouse_sliced_command(psmouse, reg) ||
165  psmouse_sliced_command(psmouse, val) ||
167  rc = -1;
168  }
169  break;
170 
171  case 2:
172  if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
173  elantech_ps2_command(psmouse, NULL, ETP_REGISTER_WRITE) ||
174  elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
175  elantech_ps2_command(psmouse, NULL, reg) ||
176  elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
177  elantech_ps2_command(psmouse, NULL, val) ||
178  elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
179  rc = -1;
180  }
181  break;
182 
183  case 3:
184  if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
185  elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
186  elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
187  elantech_ps2_command(psmouse, NULL, reg) ||
188  elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
189  elantech_ps2_command(psmouse, NULL, val) ||
190  elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
191  rc = -1;
192  }
193  break;
194 
195  case 4:
196  if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
197  elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
198  elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
199  elantech_ps2_command(psmouse, NULL, reg) ||
200  elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
201  elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READWRITE) ||
202  elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) ||
203  elantech_ps2_command(psmouse, NULL, val) ||
204  elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) {
205  rc = -1;
206  }
207  break;
208  }
209 
210  if (rc)
211  psmouse_err(psmouse,
212  "failed to write register 0x%02x with value 0x%02x.\n",
213  reg, val);
214 
215  return rc;
216 }
217 
218 /*
219  * Dump a complete mouse movement packet to the syslog
220  */
221 static void elantech_packet_dump(struct psmouse *psmouse)
222 {
223  int i;
224 
225  psmouse_printk(KERN_DEBUG, psmouse, "PS/2 packet [");
226  for (i = 0; i < psmouse->pktsize; i++)
227  printk("%s0x%02x ", i ? ", " : " ", psmouse->packet[i]);
228  printk("]\n");
229 }
230 
231 /*
232  * Interpret complete data packets and report absolute mode input events for
233  * hardware version 1. (4 byte packets)
234  */
235 static void elantech_report_absolute_v1(struct psmouse *psmouse)
236 {
237  struct input_dev *dev = psmouse->dev;
238  struct elantech_data *etd = psmouse->private;
239  unsigned char *packet = psmouse->packet;
240  int fingers;
241 
242  if (etd->fw_version < 0x020000) {
243  /*
244  * byte 0: D U p1 p2 1 p3 R L
245  * byte 1: f 0 th tw x9 x8 y9 y8
246  */
247  fingers = ((packet[1] & 0x80) >> 7) +
248  ((packet[1] & 0x30) >> 4);
249  } else {
250  /*
251  * byte 0: n1 n0 p2 p1 1 p3 R L
252  * byte 1: 0 0 0 0 x9 x8 y9 y8
253  */
254  fingers = (packet[0] & 0xc0) >> 6;
255  }
256 
257  if (etd->jumpy_cursor) {
258  if (fingers != 1) {
259  etd->single_finger_reports = 0;
260  } else if (etd->single_finger_reports < 2) {
261  /* Discard first 2 reports of one finger, bogus */
262  etd->single_finger_reports++;
263  elantech_debug("discarding packet\n");
264  return;
265  }
266  }
267 
268  input_report_key(dev, BTN_TOUCH, fingers != 0);
269 
270  /*
271  * byte 2: x7 x6 x5 x4 x3 x2 x1 x0
272  * byte 3: y7 y6 y5 y4 y3 y2 y1 y0
273  */
274  if (fingers) {
275  input_report_abs(dev, ABS_X,
276  ((packet[1] & 0x0c) << 6) | packet[2]);
277  input_report_abs(dev, ABS_Y,
278  etd->y_max - (((packet[1] & 0x03) << 8) | packet[3]));
279  }
280 
281  input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
282  input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
283  input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
284  input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
285  input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
286 
287  if (etd->fw_version < 0x020000 &&
288  (etd->capabilities[0] & ETP_CAP_HAS_ROCKER)) {
289  /* rocker up */
290  input_report_key(dev, BTN_FORWARD, packet[0] & 0x40);
291  /* rocker down */
292  input_report_key(dev, BTN_BACK, packet[0] & 0x80);
293  }
294 
295  input_sync(dev);
296 }
297 
298 static void elantech_set_slot(struct input_dev *dev, int slot, bool active,
299  unsigned int x, unsigned int y)
300 {
301  input_mt_slot(dev, slot);
303  if (active) {
304  input_report_abs(dev, ABS_MT_POSITION_X, x);
305  input_report_abs(dev, ABS_MT_POSITION_Y, y);
306  }
307 }
308 
309 /* x1 < x2 and y1 < y2 when two fingers, x = y = 0 when not pressed */
310 static void elantech_report_semi_mt_data(struct input_dev *dev,
311  unsigned int num_fingers,
312  unsigned int x1, unsigned int y1,
313  unsigned int x2, unsigned int y2)
314 {
315  elantech_set_slot(dev, 0, num_fingers != 0, x1, y1);
316  elantech_set_slot(dev, 1, num_fingers == 2, x2, y2);
317 }
318 
319 /*
320  * Interpret complete data packets and report absolute mode input events for
321  * hardware version 2. (6 byte packets)
322  */
323 static void elantech_report_absolute_v2(struct psmouse *psmouse)
324 {
325  struct elantech_data *etd = psmouse->private;
326  struct input_dev *dev = psmouse->dev;
327  unsigned char *packet = psmouse->packet;
328  unsigned int fingers, x1 = 0, y1 = 0, x2 = 0, y2 = 0;
329  unsigned int width = 0, pres = 0;
330 
331  /* byte 0: n1 n0 . . . . R L */
332  fingers = (packet[0] & 0xc0) >> 6;
333 
334  switch (fingers) {
335  case 3:
336  /*
337  * Same as one finger, except report of more than 3 fingers:
338  * byte 3: n4 . w1 w0 . . . .
339  */
340  if (packet[3] & 0x80)
341  fingers = 4;
342  /* pass through... */
343  case 1:
344  /*
345  * byte 1: . . . . x11 x10 x9 x8
346  * byte 2: x7 x6 x5 x4 x4 x2 x1 x0
347  */
348  x1 = ((packet[1] & 0x0f) << 8) | packet[2];
349  /*
350  * byte 4: . . . . y11 y10 y9 y8
351  * byte 5: y7 y6 y5 y4 y3 y2 y1 y0
352  */
353  y1 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
354 
355  pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
356  width = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4);
357  break;
358 
359  case 2:
360  /*
361  * The coordinate of each finger is reported separately
362  * with a lower resolution for two finger touches:
363  * byte 0: . . ay8 ax8 . . . .
364  * byte 1: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0
365  */
366  x1 = (((packet[0] & 0x10) << 4) | packet[1]) << 2;
367  /* byte 2: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0 */
368  y1 = etd->y_max -
369  ((((packet[0] & 0x20) << 3) | packet[2]) << 2);
370  /*
371  * byte 3: . . by8 bx8 . . . .
372  * byte 4: bx7 bx6 bx5 bx4 bx3 bx2 bx1 bx0
373  */
374  x2 = (((packet[3] & 0x10) << 4) | packet[4]) << 2;
375  /* byte 5: by7 by8 by5 by4 by3 by2 by1 by0 */
376  y2 = etd->y_max -
377  ((((packet[3] & 0x20) << 3) | packet[5]) << 2);
378 
379  /* Unknown so just report sensible values */
380  pres = 127;
381  width = 7;
382  break;
383  }
384 
385  input_report_key(dev, BTN_TOUCH, fingers != 0);
386  if (fingers != 0) {
387  input_report_abs(dev, ABS_X, x1);
388  input_report_abs(dev, ABS_Y, y1);
389  }
390  elantech_report_semi_mt_data(dev, fingers, x1, y1, x2, y2);
391  input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
392  input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
393  input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
394  input_report_key(dev, BTN_TOOL_QUADTAP, fingers == 4);
395  input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
396  input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
397  if (etd->reports_pressure) {
398  input_report_abs(dev, ABS_PRESSURE, pres);
399  input_report_abs(dev, ABS_TOOL_WIDTH, width);
400  }
401 
402  input_sync(dev);
403 }
404 
405 /*
406  * Interpret complete data packets and report absolute mode input events for
407  * hardware version 3. (12 byte packets for two fingers)
408  */
409 static void elantech_report_absolute_v3(struct psmouse *psmouse,
410  int packet_type)
411 {
412  struct input_dev *dev = psmouse->dev;
413  struct elantech_data *etd = psmouse->private;
414  unsigned char *packet = psmouse->packet;
415  unsigned int fingers = 0, x1 = 0, y1 = 0, x2 = 0, y2 = 0;
416  unsigned int width = 0, pres = 0;
417 
418  /* byte 0: n1 n0 . . . . R L */
419  fingers = (packet[0] & 0xc0) >> 6;
420 
421  switch (fingers) {
422  case 3:
423  case 1:
424  /*
425  * byte 1: . . . . x11 x10 x9 x8
426  * byte 2: x7 x6 x5 x4 x4 x2 x1 x0
427  */
428  x1 = ((packet[1] & 0x0f) << 8) | packet[2];
429  /*
430  * byte 4: . . . . y11 y10 y9 y8
431  * byte 5: y7 y6 y5 y4 y3 y2 y1 y0
432  */
433  y1 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
434  break;
435 
436  case 2:
437  if (packet_type == PACKET_V3_HEAD) {
438  /*
439  * byte 1: . . . . ax11 ax10 ax9 ax8
440  * byte 2: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0
441  */
442  etd->mt[0].x = ((packet[1] & 0x0f) << 8) | packet[2];
443  /*
444  * byte 4: . . . . ay11 ay10 ay9 ay8
445  * byte 5: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0
446  */
447  etd->mt[0].y = etd->y_max -
448  (((packet[4] & 0x0f) << 8) | packet[5]);
449  /*
450  * wait for next packet
451  */
452  return;
453  }
454 
455  /* packet_type == PACKET_V3_TAIL */
456  x1 = etd->mt[0].x;
457  y1 = etd->mt[0].y;
458  x2 = ((packet[1] & 0x0f) << 8) | packet[2];
459  y2 = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
460  break;
461  }
462 
463  pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
464  width = ((packet[0] & 0x30) >> 2) | ((packet[3] & 0x30) >> 4);
465 
466  input_report_key(dev, BTN_TOUCH, fingers != 0);
467  if (fingers != 0) {
468  input_report_abs(dev, ABS_X, x1);
469  input_report_abs(dev, ABS_Y, y1);
470  }
471  elantech_report_semi_mt_data(dev, fingers, x1, y1, x2, y2);
472  input_report_key(dev, BTN_TOOL_FINGER, fingers == 1);
473  input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2);
474  input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3);
475  input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
476  input_report_key(dev, BTN_RIGHT, packet[0] & 0x02);
477  input_report_abs(dev, ABS_PRESSURE, pres);
478  input_report_abs(dev, ABS_TOOL_WIDTH, width);
479 
480  input_sync(dev);
481 }
482 
483 static void elantech_input_sync_v4(struct psmouse *psmouse)
484 {
485  struct input_dev *dev = psmouse->dev;
486  unsigned char *packet = psmouse->packet;
487 
488  input_report_key(dev, BTN_LEFT, packet[0] & 0x01);
490  input_sync(dev);
491 }
492 
493 static void process_packet_status_v4(struct psmouse *psmouse)
494 {
495  struct input_dev *dev = psmouse->dev;
496  unsigned char *packet = psmouse->packet;
497  unsigned fingers;
498  int i;
499 
500  /* notify finger state change */
501  fingers = packet[1] & 0x1f;
502  for (i = 0; i < ETP_MAX_FINGERS; i++) {
503  if ((fingers & (1 << i)) == 0) {
504  input_mt_slot(dev, i);
506  }
507  }
508 
509  elantech_input_sync_v4(psmouse);
510 }
511 
512 static void process_packet_head_v4(struct psmouse *psmouse)
513 {
514  struct input_dev *dev = psmouse->dev;
515  struct elantech_data *etd = psmouse->private;
516  unsigned char *packet = psmouse->packet;
517  int id = ((packet[3] & 0xe0) >> 5) - 1;
518  int pres, traces;
519 
520  if (id < 0)
521  return;
522 
523  etd->mt[id].x = ((packet[1] & 0x0f) << 8) | packet[2];
524  etd->mt[id].y = etd->y_max - (((packet[4] & 0x0f) << 8) | packet[5]);
525  pres = (packet[1] & 0xf0) | ((packet[4] & 0xf0) >> 4);
526  traces = (packet[0] & 0xf0) >> 4;
527 
528  input_mt_slot(dev, id);
530 
531  input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[id].x);
532  input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[id].y);
533  input_report_abs(dev, ABS_MT_PRESSURE, pres);
534  input_report_abs(dev, ABS_MT_TOUCH_MAJOR, traces * etd->width);
535  /* report this for backwards compatibility */
536  input_report_abs(dev, ABS_TOOL_WIDTH, traces);
537 
538  elantech_input_sync_v4(psmouse);
539 }
540 
541 static void process_packet_motion_v4(struct psmouse *psmouse)
542 {
543  struct input_dev *dev = psmouse->dev;
544  struct elantech_data *etd = psmouse->private;
545  unsigned char *packet = psmouse->packet;
546  int weight, delta_x1 = 0, delta_y1 = 0, delta_x2 = 0, delta_y2 = 0;
547  int id, sid;
548 
549  id = ((packet[0] & 0xe0) >> 5) - 1;
550  if (id < 0)
551  return;
552 
553  sid = ((packet[3] & 0xe0) >> 5) - 1;
554  weight = (packet[0] & 0x10) ? ETP_WEIGHT_VALUE : 1;
555  /*
556  * Motion packets give us the delta of x, y values of specific fingers,
557  * but in two's complement. Let the compiler do the conversion for us.
558  * Also _enlarge_ the numbers to int, in case of overflow.
559  */
560  delta_x1 = (signed char)packet[1];
561  delta_y1 = (signed char)packet[2];
562  delta_x2 = (signed char)packet[4];
563  delta_y2 = (signed char)packet[5];
564 
565  etd->mt[id].x += delta_x1 * weight;
566  etd->mt[id].y -= delta_y1 * weight;
567  input_mt_slot(dev, id);
568  input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[id].x);
569  input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[id].y);
570 
571  if (sid >= 0) {
572  etd->mt[sid].x += delta_x2 * weight;
573  etd->mt[sid].y -= delta_y2 * weight;
574  input_mt_slot(dev, sid);
575  input_report_abs(dev, ABS_MT_POSITION_X, etd->mt[sid].x);
576  input_report_abs(dev, ABS_MT_POSITION_Y, etd->mt[sid].y);
577  }
578 
579  elantech_input_sync_v4(psmouse);
580 }
581 
582 static void elantech_report_absolute_v4(struct psmouse *psmouse,
583  int packet_type)
584 {
585  switch (packet_type) {
586  case PACKET_V4_STATUS:
587  process_packet_status_v4(psmouse);
588  break;
589 
590  case PACKET_V4_HEAD:
591  process_packet_head_v4(psmouse);
592  break;
593 
594  case PACKET_V4_MOTION:
595  process_packet_motion_v4(psmouse);
596  break;
597 
598  case PACKET_UNKNOWN:
599  default:
600  /* impossible to get here */
601  break;
602  }
603 }
604 
605 static int elantech_packet_check_v1(struct psmouse *psmouse)
606 {
607  struct elantech_data *etd = psmouse->private;
608  unsigned char *packet = psmouse->packet;
609  unsigned char p1, p2, p3;
610 
611  /* Parity bits are placed differently */
612  if (etd->fw_version < 0x020000) {
613  /* byte 0: D U p1 p2 1 p3 R L */
614  p1 = (packet[0] & 0x20) >> 5;
615  p2 = (packet[0] & 0x10) >> 4;
616  } else {
617  /* byte 0: n1 n0 p2 p1 1 p3 R L */
618  p1 = (packet[0] & 0x10) >> 4;
619  p2 = (packet[0] & 0x20) >> 5;
620  }
621 
622  p3 = (packet[0] & 0x04) >> 2;
623 
624  return etd->parity[packet[1]] == p1 &&
625  etd->parity[packet[2]] == p2 &&
626  etd->parity[packet[3]] == p3;
627 }
628 
629 static int elantech_debounce_check_v2(struct psmouse *psmouse)
630 {
631  /*
632  * When we encounter packet that matches this exactly, it means the
633  * hardware is in debounce status. Just ignore the whole packet.
634  */
635  const u8 debounce_packet[] = { 0x84, 0xff, 0xff, 0x02, 0xff, 0xff };
636  unsigned char *packet = psmouse->packet;
637 
638  return !memcmp(packet, debounce_packet, sizeof(debounce_packet));
639 }
640 
641 static int elantech_packet_check_v2(struct psmouse *psmouse)
642 {
643  struct elantech_data *etd = psmouse->private;
644  unsigned char *packet = psmouse->packet;
645 
646  /*
647  * V2 hardware has two flavors. Older ones that do not report pressure,
648  * and newer ones that reports pressure and width. With newer ones, all
649  * packets (1, 2, 3 finger touch) have the same constant bits. With
650  * older ones, 1/3 finger touch packets and 2 finger touch packets
651  * have different constant bits.
652  * With all three cases, if the constant bits are not exactly what I
653  * expected, I consider them invalid.
654  */
655  if (etd->reports_pressure)
656  return (packet[0] & 0x0c) == 0x04 &&
657  (packet[3] & 0x0f) == 0x02;
658 
659  if ((packet[0] & 0xc0) == 0x80)
660  return (packet[0] & 0x0c) == 0x0c &&
661  (packet[3] & 0x0e) == 0x08;
662 
663  return (packet[0] & 0x3c) == 0x3c &&
664  (packet[1] & 0xf0) == 0x00 &&
665  (packet[3] & 0x3e) == 0x38 &&
666  (packet[4] & 0xf0) == 0x00;
667 }
668 
669 /*
670  * We check the constant bits to determine what packet type we get,
671  * so packet checking is mandatory for v3 and later hardware.
672  */
673 static int elantech_packet_check_v3(struct psmouse *psmouse)
674 {
675  const u8 debounce_packet[] = { 0xc4, 0xff, 0xff, 0x02, 0xff, 0xff };
676  unsigned char *packet = psmouse->packet;
677 
678  /*
679  * check debounce first, it has the same signature in byte 0
680  * and byte 3 as PACKET_V3_HEAD.
681  */
682  if (!memcmp(packet, debounce_packet, sizeof(debounce_packet)))
683  return PACKET_DEBOUNCE;
684 
685  if ((packet[0] & 0x0c) == 0x04 && (packet[3] & 0xcf) == 0x02)
686  return PACKET_V3_HEAD;
687 
688  if ((packet[0] & 0x0c) == 0x0c && (packet[3] & 0xce) == 0x0c)
689  return PACKET_V3_TAIL;
690 
691  return PACKET_UNKNOWN;
692 }
693 
694 static int elantech_packet_check_v4(struct psmouse *psmouse)
695 {
696  unsigned char *packet = psmouse->packet;
697 
698  if ((packet[0] & 0x0c) == 0x04 &&
699  (packet[3] & 0x1f) == 0x11)
700  return PACKET_V4_HEAD;
701 
702  if ((packet[0] & 0x0c) == 0x04 &&
703  (packet[3] & 0x1f) == 0x12)
704  return PACKET_V4_MOTION;
705 
706  if ((packet[0] & 0x0c) == 0x04 &&
707  (packet[3] & 0x1f) == 0x10)
708  return PACKET_V4_STATUS;
709 
710  return PACKET_UNKNOWN;
711 }
712 
713 /*
714  * Process byte stream from mouse and handle complete packets
715  */
716 static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse)
717 {
718  struct elantech_data *etd = psmouse->private;
719  int packet_type;
720 
721  if (psmouse->pktcnt < psmouse->pktsize)
722  return PSMOUSE_GOOD_DATA;
723 
724  if (etd->debug > 1)
725  elantech_packet_dump(psmouse);
726 
727  switch (etd->hw_version) {
728  case 1:
729  if (etd->paritycheck && !elantech_packet_check_v1(psmouse))
730  return PSMOUSE_BAD_DATA;
731 
732  elantech_report_absolute_v1(psmouse);
733  break;
734 
735  case 2:
736  /* ignore debounce */
737  if (elantech_debounce_check_v2(psmouse))
738  return PSMOUSE_FULL_PACKET;
739 
740  if (etd->paritycheck && !elantech_packet_check_v2(psmouse))
741  return PSMOUSE_BAD_DATA;
742 
743  elantech_report_absolute_v2(psmouse);
744  break;
745 
746  case 3:
747  packet_type = elantech_packet_check_v3(psmouse);
748  /* ignore debounce */
749  if (packet_type == PACKET_DEBOUNCE)
750  return PSMOUSE_FULL_PACKET;
751 
752  if (packet_type == PACKET_UNKNOWN)
753  return PSMOUSE_BAD_DATA;
754 
755  elantech_report_absolute_v3(psmouse, packet_type);
756  break;
757 
758  case 4:
759  packet_type = elantech_packet_check_v4(psmouse);
760  if (packet_type == PACKET_UNKNOWN)
761  return PSMOUSE_BAD_DATA;
762 
763  elantech_report_absolute_v4(psmouse, packet_type);
764  break;
765  }
766 
767  return PSMOUSE_FULL_PACKET;
768 }
769 
770 /*
771  * Put the touchpad into absolute mode
772  */
773 static int elantech_set_absolute_mode(struct psmouse *psmouse)
774 {
775  struct elantech_data *etd = psmouse->private;
776  unsigned char val;
777  int tries = ETP_READ_BACK_TRIES;
778  int rc = 0;
779 
780  switch (etd->hw_version) {
781  case 1:
782  etd->reg_10 = 0x16;
783  etd->reg_11 = 0x8f;
784  if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
785  elantech_write_reg(psmouse, 0x11, etd->reg_11)) {
786  rc = -1;
787  }
788  break;
789 
790  case 2:
791  /* Windows driver values */
792  etd->reg_10 = 0x54;
793  etd->reg_11 = 0x88; /* 0x8a */
794  etd->reg_21 = 0x60; /* 0x00 */
795  if (elantech_write_reg(psmouse, 0x10, etd->reg_10) ||
796  elantech_write_reg(psmouse, 0x11, etd->reg_11) ||
797  elantech_write_reg(psmouse, 0x21, etd->reg_21)) {
798  rc = -1;
799  }
800  break;
801 
802  case 3:
803  etd->reg_10 = 0x0b;
804  if (elantech_write_reg(psmouse, 0x10, etd->reg_10))
805  rc = -1;
806 
807  break;
808 
809  case 4:
810  etd->reg_07 = 0x01;
811  if (elantech_write_reg(psmouse, 0x07, etd->reg_07))
812  rc = -1;
813 
814  goto skip_readback_reg_10; /* v4 has no reg 0x10 to read */
815  }
816 
817  if (rc == 0) {
818  /*
819  * Read back reg 0x10. For hardware version 1 we must make
820  * sure the absolute mode bit is set. For hardware version 2
821  * the touchpad is probably initializing and not ready until
822  * we read back the value we just wrote.
823  */
824  do {
825  rc = elantech_read_reg(psmouse, 0x10, &val);
826  if (rc == 0)
827  break;
828  tries--;
829  elantech_debug("retrying read (%d).\n", tries);
831  } while (tries > 0);
832 
833  if (rc) {
834  psmouse_err(psmouse,
835  "failed to read back register 0x10.\n");
836  } else if (etd->hw_version == 1 &&
837  !(val & ETP_R10_ABSOLUTE_MODE)) {
838  psmouse_err(psmouse,
839  "touchpad refuses to switch to absolute mode.\n");
840  rc = -1;
841  }
842  }
843 
844  skip_readback_reg_10:
845  if (rc)
846  psmouse_err(psmouse, "failed to initialise registers.\n");
847 
848  return rc;
849 }
850 
851 static int elantech_set_range(struct psmouse *psmouse,
852  unsigned int *x_min, unsigned int *y_min,
853  unsigned int *x_max, unsigned int *y_max,
854  unsigned int *width)
855 {
856  struct elantech_data *etd = psmouse->private;
857  unsigned char param[3];
858  unsigned char traces;
859 
860  switch (etd->hw_version) {
861  case 1:
862  *x_min = ETP_XMIN_V1;
863  *y_min = ETP_YMIN_V1;
864  *x_max = ETP_XMAX_V1;
865  *y_max = ETP_YMAX_V1;
866  break;
867 
868  case 2:
869  if (etd->fw_version == 0x020800 ||
870  etd->fw_version == 0x020b00 ||
871  etd->fw_version == 0x020030) {
872  *x_min = ETP_XMIN_V2;
873  *y_min = ETP_YMIN_V2;
874  *x_max = ETP_XMAX_V2;
875  *y_max = ETP_YMAX_V2;
876  } else {
877  int i;
878  int fixed_dpi;
879 
880  i = (etd->fw_version > 0x020800 &&
881  etd->fw_version < 0x020900) ? 1 : 2;
882 
883  if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param))
884  return -1;
885 
886  fixed_dpi = param[1] & 0x10;
887 
888  if (((etd->fw_version >> 16) == 0x14) && fixed_dpi) {
889  if (etd->send_cmd(psmouse, ETP_SAMPLE_QUERY, param))
890  return -1;
891 
892  *x_max = (etd->capabilities[1] - i) * param[1] / 2;
893  *y_max = (etd->capabilities[2] - i) * param[2] / 2;
894  } else if (etd->fw_version == 0x040216) {
895  *x_max = 819;
896  *y_max = 405;
897  } else if (etd->fw_version == 0x040219 || etd->fw_version == 0x040215) {
898  *x_max = 900;
899  *y_max = 500;
900  } else {
901  *x_max = (etd->capabilities[1] - i) * 64;
902  *y_max = (etd->capabilities[2] - i) * 64;
903  }
904  }
905  break;
906 
907  case 3:
908  if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param))
909  return -1;
910 
911  *x_max = (0x0f & param[0]) << 8 | param[1];
912  *y_max = (0xf0 & param[0]) << 4 | param[2];
913  break;
914 
915  case 4:
916  if (etd->send_cmd(psmouse, ETP_FW_ID_QUERY, param))
917  return -1;
918 
919  *x_max = (0x0f & param[0]) << 8 | param[1];
920  *y_max = (0xf0 & param[0]) << 4 | param[2];
921  traces = etd->capabilities[1];
922  if ((traces < 2) || (traces > *x_max))
923  return -1;
924 
925  *width = *x_max / (traces - 1);
926  break;
927  }
928 
929  return 0;
930 }
931 
932 /*
933  * (value from firmware) * 10 + 790 = dpi
934  * we also have to convert dpi to dots/mm (*10/254 to avoid floating point)
935  */
936 static unsigned int elantech_convert_res(unsigned int val)
937 {
938  return (val * 10 + 790) * 10 / 254;
939 }
940 
941 static int elantech_get_resolution_v4(struct psmouse *psmouse,
942  unsigned int *x_res,
943  unsigned int *y_res)
944 {
945  unsigned char param[3];
946 
947  if (elantech_send_cmd(psmouse, ETP_RESOLUTION_QUERY, param))
948  return -1;
949 
950  *x_res = elantech_convert_res(param[1] & 0x0f);
951  *y_res = elantech_convert_res((param[1] & 0xf0) >> 4);
952 
953  return 0;
954 }
955 
956 /*
957  * Set the appropriate event bits for the input subsystem
958  */
959 static int elantech_set_input_params(struct psmouse *psmouse)
960 {
961  struct input_dev *dev = psmouse->dev;
962  struct elantech_data *etd = psmouse->private;
963  unsigned int x_min = 0, y_min = 0, x_max = 0, y_max = 0, width = 0;
964  unsigned int x_res = 0, y_res = 0;
965 
966  if (elantech_set_range(psmouse, &x_min, &y_min, &x_max, &y_max, &width))
967  return -1;
968 
969  __set_bit(INPUT_PROP_POINTER, dev->propbit);
970  __set_bit(EV_KEY, dev->evbit);
971  __set_bit(EV_ABS, dev->evbit);
972  __clear_bit(EV_REL, dev->evbit);
973 
974  __set_bit(BTN_LEFT, dev->keybit);
975  __set_bit(BTN_RIGHT, dev->keybit);
976 
977  __set_bit(BTN_TOUCH, dev->keybit);
978  __set_bit(BTN_TOOL_FINGER, dev->keybit);
979  __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit);
980  __set_bit(BTN_TOOL_TRIPLETAP, dev->keybit);
981 
982  switch (etd->hw_version) {
983  case 1:
984  /* Rocker button */
985  if (etd->fw_version < 0x020000 &&
986  (etd->capabilities[0] & ETP_CAP_HAS_ROCKER)) {
987  __set_bit(BTN_FORWARD, dev->keybit);
988  __set_bit(BTN_BACK, dev->keybit);
989  }
990  input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
991  input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
992  break;
993 
994  case 2:
995  __set_bit(BTN_TOOL_QUADTAP, dev->keybit);
996  __set_bit(INPUT_PROP_SEMI_MT, dev->propbit);
997  /* fall through */
998  case 3:
999  input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
1000  input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
1001  if (etd->reports_pressure) {
1002  input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2,
1003  ETP_PMAX_V2, 0, 0);
1004  input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
1005  ETP_WMAX_V2, 0, 0);
1006  }
1007  input_mt_init_slots(dev, 2, 0);
1008  input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
1009  input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
1010  break;
1011 
1012  case 4:
1013  if (elantech_get_resolution_v4(psmouse, &x_res, &y_res)) {
1014  /*
1015  * if query failed, print a warning and leave the values
1016  * zero to resemble synaptics.c behavior.
1017  */
1018  psmouse_warn(psmouse, "couldn't query resolution data.\n");
1019  }
1020  /* v4 is clickpad, with only one button. */
1021  __set_bit(INPUT_PROP_BUTTONPAD, dev->propbit);
1022  __clear_bit(BTN_RIGHT, dev->keybit);
1023  __set_bit(BTN_TOOL_QUADTAP, dev->keybit);
1024  /* For X to recognize me as touchpad. */
1025  input_set_abs_params(dev, ABS_X, x_min, x_max, 0, 0);
1026  input_set_abs_params(dev, ABS_Y, y_min, y_max, 0, 0);
1027  input_abs_set_res(dev, ABS_X, x_res);
1028  input_abs_set_res(dev, ABS_Y, y_res);
1029  /*
1030  * range of pressure and width is the same as v2,
1031  * report ABS_PRESSURE, ABS_TOOL_WIDTH for compatibility.
1032  */
1033  input_set_abs_params(dev, ABS_PRESSURE, ETP_PMIN_V2,
1034  ETP_PMAX_V2, 0, 0);
1035  input_set_abs_params(dev, ABS_TOOL_WIDTH, ETP_WMIN_V2,
1036  ETP_WMAX_V2, 0, 0);
1037  /* Multitouch capable pad, up to 5 fingers. */
1038  input_mt_init_slots(dev, ETP_MAX_FINGERS, 0);
1039  input_set_abs_params(dev, ABS_MT_POSITION_X, x_min, x_max, 0, 0);
1040  input_set_abs_params(dev, ABS_MT_POSITION_Y, y_min, y_max, 0, 0);
1041  input_abs_set_res(dev, ABS_MT_POSITION_X, x_res);
1042  input_abs_set_res(dev, ABS_MT_POSITION_Y, y_res);
1043  input_set_abs_params(dev, ABS_MT_PRESSURE, ETP_PMIN_V2,
1044  ETP_PMAX_V2, 0, 0);
1045  /*
1046  * The firmware reports how many trace lines the finger spans,
1047  * convert to surface unit as Protocol-B requires.
1048  */
1049  input_set_abs_params(dev, ABS_MT_TOUCH_MAJOR, 0,
1050  ETP_WMAX_V2 * width, 0, 0);
1051  break;
1052  }
1053 
1054  etd->y_max = y_max;
1055  etd->width = width;
1056 
1057  return 0;
1058 }
1059 
1062  unsigned char reg;
1063 };
1064 
1065 /*
1066  * Display a register value by reading a sysfs entry
1067  */
1068 static ssize_t elantech_show_int_attr(struct psmouse *psmouse, void *data,
1069  char *buf)
1070 {
1071  struct elantech_data *etd = psmouse->private;
1072  struct elantech_attr_data *attr = data;
1073  unsigned char *reg = (unsigned char *) etd + attr->field_offset;
1074  int rc = 0;
1075 
1076  if (attr->reg)
1077  rc = elantech_read_reg(psmouse, attr->reg, reg);
1078 
1079  return sprintf(buf, "0x%02x\n", (attr->reg && rc) ? -1 : *reg);
1080 }
1081 
1082 /*
1083  * Write a register value by writing a sysfs entry
1084  */
1085 static ssize_t elantech_set_int_attr(struct psmouse *psmouse,
1086  void *data, const char *buf, size_t count)
1087 {
1088  struct elantech_data *etd = psmouse->private;
1089  struct elantech_attr_data *attr = data;
1090  unsigned char *reg = (unsigned char *) etd + attr->field_offset;
1091  unsigned char value;
1092  int err;
1093 
1094  err = kstrtou8(buf, 16, &value);
1095  if (err)
1096  return err;
1097 
1098  /* Do we need to preserve some bits for version 2 hardware too? */
1099  if (etd->hw_version == 1) {
1100  if (attr->reg == 0x10)
1101  /* Force absolute mode always on */
1103  else if (attr->reg == 0x11)
1104  /* Force 4 byte mode always on */
1106  }
1107 
1108  if (!attr->reg || elantech_write_reg(psmouse, attr->reg, value) == 0)
1109  *reg = value;
1110 
1111  return count;
1112 }
1113 
1114 #define ELANTECH_INT_ATTR(_name, _register) \
1115  static struct elantech_attr_data elantech_attr_##_name = { \
1116  .field_offset = offsetof(struct elantech_data, _name), \
1117  .reg = _register, \
1118  }; \
1119  PSMOUSE_DEFINE_ATTR(_name, S_IWUSR | S_IRUGO, \
1120  &elantech_attr_##_name, \
1121  elantech_show_int_attr, \
1122  elantech_set_int_attr)
1123 
1124 ELANTECH_INT_ATTR(reg_07, 0x07);
1125 ELANTECH_INT_ATTR(reg_10, 0x10);
1126 ELANTECH_INT_ATTR(reg_11, 0x11);
1127 ELANTECH_INT_ATTR(reg_20, 0x20);
1128 ELANTECH_INT_ATTR(reg_21, 0x21);
1129 ELANTECH_INT_ATTR(reg_22, 0x22);
1130 ELANTECH_INT_ATTR(reg_23, 0x23);
1131 ELANTECH_INT_ATTR(reg_24, 0x24);
1132 ELANTECH_INT_ATTR(reg_25, 0x25);
1133 ELANTECH_INT_ATTR(reg_26, 0x26);
1135 ELANTECH_INT_ATTR(paritycheck, 0);
1136 
1137 static struct attribute *elantech_attrs[] = {
1138  &psmouse_attr_reg_07.dattr.attr,
1139  &psmouse_attr_reg_10.dattr.attr,
1140  &psmouse_attr_reg_11.dattr.attr,
1141  &psmouse_attr_reg_20.dattr.attr,
1142  &psmouse_attr_reg_21.dattr.attr,
1143  &psmouse_attr_reg_22.dattr.attr,
1144  &psmouse_attr_reg_23.dattr.attr,
1145  &psmouse_attr_reg_24.dattr.attr,
1146  &psmouse_attr_reg_25.dattr.attr,
1147  &psmouse_attr_reg_26.dattr.attr,
1148  &psmouse_attr_debug.dattr.attr,
1149  &psmouse_attr_paritycheck.dattr.attr,
1150  NULL
1151 };
1152 
1153 static struct attribute_group elantech_attr_group = {
1154  .attrs = elantech_attrs,
1155 };
1156 
1157 static bool elantech_is_signature_valid(const unsigned char *param)
1158 {
1159  static const unsigned char rates[] = { 200, 100, 80, 60, 40, 20, 10 };
1160  int i;
1161 
1162  if (param[0] == 0)
1163  return false;
1164 
1165  if (param[1] == 0)
1166  return true;
1167 
1168  for (i = 0; i < ARRAY_SIZE(rates); i++)
1169  if (param[2] == rates[i])
1170  return false;
1171 
1172  return true;
1173 }
1174 
1175 /*
1176  * Use magic knock to detect Elantech touchpad
1177  */
1178 int elantech_detect(struct psmouse *psmouse, bool set_properties)
1179 {
1180  struct ps2dev *ps2dev = &psmouse->ps2dev;
1181  unsigned char param[3];
1182 
1184 
1185  if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) ||
1189  ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) {
1190  psmouse_dbg(psmouse, "sending Elantech magic knock failed.\n");
1191  return -1;
1192  }
1193 
1194  /*
1195  * Report this in case there are Elantech models that use a different
1196  * set of magic numbers
1197  */
1198  if (param[0] != 0x3c || param[1] != 0x03 ||
1199  (param[2] != 0xc8 && param[2] != 0x00)) {
1200  psmouse_dbg(psmouse,
1201  "unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n",
1202  param[0], param[1], param[2]);
1203  return -1;
1204  }
1205 
1206  /*
1207  * Query touchpad's firmware version and see if it reports known
1208  * value to avoid mis-detection. Logitech mice are known to respond
1209  * to Elantech magic knock and there might be more.
1210  */
1211  if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
1212  psmouse_dbg(psmouse, "failed to query firmware version.\n");
1213  return -1;
1214  }
1215 
1216  psmouse_dbg(psmouse,
1217  "Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n",
1218  param[0], param[1], param[2]);
1219 
1220  if (!elantech_is_signature_valid(param)) {
1221  psmouse_dbg(psmouse,
1222  "Probably not a real Elantech touchpad. Aborting.\n");
1223  return -1;
1224  }
1225 
1226  if (set_properties) {
1227  psmouse->vendor = "Elantech";
1228  psmouse->name = "Touchpad";
1229  }
1230 
1231  return 0;
1232 }
1233 
1234 /*
1235  * Clean up sysfs entries when disconnecting
1236  */
1237 static void elantech_disconnect(struct psmouse *psmouse)
1238 {
1239  sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj,
1240  &elantech_attr_group);
1241  kfree(psmouse->private);
1242  psmouse->private = NULL;
1243 }
1244 
1245 /*
1246  * Put the touchpad back into absolute mode when reconnecting
1247  */
1248 static int elantech_reconnect(struct psmouse *psmouse)
1249 {
1250  psmouse_reset(psmouse);
1251 
1252  if (elantech_detect(psmouse, 0))
1253  return -1;
1254 
1255  if (elantech_set_absolute_mode(psmouse)) {
1256  psmouse_err(psmouse,
1257  "failed to put touchpad back into absolute mode.\n");
1258  return -1;
1259  }
1260 
1261  return 0;
1262 }
1263 
1264 /*
1265  * determine hardware version and set some properties according to it.
1266  */
1267 static int elantech_set_properties(struct elantech_data *etd)
1268 {
1269  /* This represents the version of IC body. */
1270  int ver = (etd->fw_version & 0x0f0000) >> 16;
1271 
1272  /* Early version of Elan touchpads doesn't obey the rule. */
1273  if (etd->fw_version < 0x020030 || etd->fw_version == 0x020600)
1274  etd->hw_version = 1;
1275  else {
1276  switch (ver) {
1277  case 2:
1278  case 4:
1279  etd->hw_version = 2;
1280  break;
1281  case 5:
1282  etd->hw_version = 3;
1283  break;
1284  case 6:
1285  etd->hw_version = 4;
1286  break;
1287  default:
1288  return -1;
1289  }
1290  }
1291 
1292  /* decide which send_cmd we're gonna use early */
1293  etd->send_cmd = etd->hw_version >= 3 ? elantech_send_cmd :
1294  synaptics_send_cmd;
1295 
1296  /* Turn on packet checking by default */
1297  etd->paritycheck = 1;
1298 
1299  /*
1300  * This firmware suffers from misreporting coordinates when
1301  * a touch action starts causing the mouse cursor or scrolled page
1302  * to jump. Enable a workaround.
1303  */
1304  etd->jumpy_cursor =
1305  (etd->fw_version == 0x020022 || etd->fw_version == 0x020600);
1306 
1307  if (etd->hw_version > 1) {
1308  /* For now show extra debug information */
1309  etd->debug = 1;
1310 
1311  if (etd->fw_version >= 0x020800)
1312  etd->reports_pressure = true;
1313  }
1314 
1315  return 0;
1316 }
1317 
1318 /*
1319  * Initialize the touchpad and create sysfs entries
1320  */
1321 int elantech_init(struct psmouse *psmouse)
1322 {
1323  struct elantech_data *etd;
1324  int i, error;
1325  unsigned char param[3];
1326 
1327  psmouse->private = etd = kzalloc(sizeof(struct elantech_data), GFP_KERNEL);
1328  if (!etd)
1329  return -ENOMEM;
1330 
1331  psmouse_reset(psmouse);
1332 
1333  etd->parity[0] = 1;
1334  for (i = 1; i < 256; i++)
1335  etd->parity[i] = etd->parity[i & (i - 1)] ^ 1;
1336 
1337  /*
1338  * Do the version query again so we can store the result
1339  */
1340  if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) {
1341  psmouse_err(psmouse, "failed to query firmware version.\n");
1342  goto init_fail;
1343  }
1344  etd->fw_version = (param[0] << 16) | (param[1] << 8) | param[2];
1345 
1346  if (elantech_set_properties(etd)) {
1347  psmouse_err(psmouse, "unknown hardware version, aborting...\n");
1348  goto init_fail;
1349  }
1350  psmouse_info(psmouse,
1351  "assuming hardware version %d (with firmware version 0x%02x%02x%02x)\n",
1352  etd->hw_version, param[0], param[1], param[2]);
1353 
1354  if (etd->send_cmd(psmouse, ETP_CAPABILITIES_QUERY,
1355  etd->capabilities)) {
1356  psmouse_err(psmouse, "failed to query capabilities.\n");
1357  goto init_fail;
1358  }
1359  psmouse_info(psmouse,
1360  "Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n",
1361  etd->capabilities[0], etd->capabilities[1],
1362  etd->capabilities[2]);
1363 
1364  if (elantech_set_absolute_mode(psmouse)) {
1365  psmouse_err(psmouse,
1366  "failed to put touchpad into absolute mode.\n");
1367  goto init_fail;
1368  }
1369 
1370  if (elantech_set_input_params(psmouse)) {
1371  psmouse_err(psmouse, "failed to query touchpad range.\n");
1372  goto init_fail;
1373  }
1374 
1375  error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj,
1376  &elantech_attr_group);
1377  if (error) {
1378  psmouse_err(psmouse,
1379  "failed to create sysfs attributes, error: %d.\n",
1380  error);
1381  goto init_fail;
1382  }
1383 
1384  psmouse->protocol_handler = elantech_process_byte;
1385  psmouse->disconnect = elantech_disconnect;
1386  psmouse->reconnect = elantech_reconnect;
1387  psmouse->pktsize = etd->hw_version > 1 ? 6 : 4;
1388 
1389  return 0;
1390 
1391  init_fail:
1392  kfree(etd);
1393  return -1;
1394 }