diff options
author | Linus Torvalds <torvalds@linux-foundation.org> | 2008-10-26 19:40:59 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@linux-foundation.org> | 2008-10-26 19:40:59 -0400 |
commit | 3d6eadcb5008beca1b289983ffd7771d1e947bac (patch) | |
tree | 2a765d732c67173d323e903da67db12282ad597a /drivers/input | |
parent | a483ab1dddf86a0e8924e94cf838eed602602b39 (diff) | |
parent | 2a0bd75e5e687a9c34921e942c18477ea7ec2d63 (diff) |
Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input
* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dtor/input:
Input: psmouse - add support for Elantech touchpads
Input: i8042 - add Blue FB5601 to noloop exception table
Diffstat (limited to 'drivers/input')
-rw-r--r-- | drivers/input/mouse/Kconfig | 25 | ||||
-rw-r--r-- | drivers/input/mouse/Makefile | 1 | ||||
-rw-r--r-- | drivers/input/mouse/elantech.c | 674 | ||||
-rw-r--r-- | drivers/input/mouse/elantech.h | 124 | ||||
-rw-r--r-- | drivers/input/mouse/psmouse-base.c | 23 | ||||
-rw-r--r-- | drivers/input/mouse/psmouse.h | 1 | ||||
-rw-r--r-- | drivers/input/serio/i8042-x86ia64io.h | 8 |
7 files changed, 854 insertions, 2 deletions
diff --git a/drivers/input/mouse/Kconfig b/drivers/input/mouse/Kconfig index f488b6852baf..4e9934259775 100644 --- a/drivers/input/mouse/Kconfig +++ b/drivers/input/mouse/Kconfig | |||
@@ -25,8 +25,8 @@ config MOUSE_PS2 | |||
25 | mice with wheels and extra buttons, Microsoft, Logitech or Genius | 25 | mice with wheels and extra buttons, Microsoft, Logitech or Genius |
26 | compatible. | 26 | compatible. |
27 | 27 | ||
28 | Synaptics TouchPad users might be interested in a specialized | 28 | Synaptics, ALPS or Elantech TouchPad users might be interested |
29 | XFree86 driver at: | 29 | in a specialized Xorg/XFree86 driver at: |
30 | <http://w1.894.telia.com/~u89404340/touchpad/index.html> | 30 | <http://w1.894.telia.com/~u89404340/touchpad/index.html> |
31 | and a new version of GPM at: | 31 | and a new version of GPM at: |
32 | <http://www.geocities.com/dt_or/gpm/gpm.html> | 32 | <http://www.geocities.com/dt_or/gpm/gpm.html> |
@@ -87,6 +87,27 @@ config MOUSE_PS2_TRACKPOINT | |||
87 | 87 | ||
88 | If unsure, say Y. | 88 | If unsure, say Y. |
89 | 89 | ||
90 | config MOUSE_PS2_ELANTECH | ||
91 | bool "Elantech PS/2 protocol extension" | ||
92 | depends on MOUSE_PS2 | ||
93 | help | ||
94 | Say Y here if you have an Elantech PS/2 touchpad connected | ||
95 | to your system. | ||
96 | |||
97 | Note that if you enable this driver you will need an updated | ||
98 | X.org Synaptics driver that does not require ABS_PRESSURE | ||
99 | reports from the touchpad (i.e. post 1.5.0 version). You can | ||
100 | grab a patch for the driver here: | ||
101 | |||
102 | http://userweb.kernel.org/~dtor/synaptics-no-abspressure.patch | ||
103 | |||
104 | If unsure, say N. | ||
105 | |||
106 | This driver exposes some configuration registers via sysfs | ||
107 | entries. For further information, | ||
108 | see <file:Documentation/input/elantech.txt>. | ||
109 | |||
110 | |||
90 | config MOUSE_PS2_TOUCHKIT | 111 | config MOUSE_PS2_TOUCHKIT |
91 | bool "eGalax TouchKit PS/2 protocol extension" | 112 | bool "eGalax TouchKit PS/2 protocol extension" |
92 | depends on MOUSE_PS2 | 113 | depends on MOUSE_PS2 |
diff --git a/drivers/input/mouse/Makefile b/drivers/input/mouse/Makefile index 8e6e69097801..96f1dd8037f8 100644 --- a/drivers/input/mouse/Makefile +++ b/drivers/input/mouse/Makefile | |||
@@ -21,6 +21,7 @@ obj-$(CONFIG_MOUSE_GPIO) += gpio_mouse.o | |||
21 | psmouse-objs := psmouse-base.o synaptics.o | 21 | psmouse-objs := psmouse-base.o synaptics.o |
22 | 22 | ||
23 | psmouse-$(CONFIG_MOUSE_PS2_ALPS) += alps.o | 23 | psmouse-$(CONFIG_MOUSE_PS2_ALPS) += alps.o |
24 | psmouse-$(CONFIG_MOUSE_PS2_ELANTECH) += elantech.o | ||
24 | psmouse-$(CONFIG_MOUSE_PS2_OLPC) += hgpk.o | 25 | psmouse-$(CONFIG_MOUSE_PS2_OLPC) += hgpk.o |
25 | psmouse-$(CONFIG_MOUSE_PS2_LOGIPS2PP) += logips2pp.o | 26 | psmouse-$(CONFIG_MOUSE_PS2_LOGIPS2PP) += logips2pp.o |
26 | psmouse-$(CONFIG_MOUSE_PS2_LIFEBOOK) += lifebook.o | 27 | psmouse-$(CONFIG_MOUSE_PS2_LIFEBOOK) += lifebook.o |
diff --git a/drivers/input/mouse/elantech.c b/drivers/input/mouse/elantech.c new file mode 100644 index 000000000000..b9a25d57bc5e --- /dev/null +++ b/drivers/input/mouse/elantech.c | |||
@@ -0,0 +1,674 @@ | |||
1 | /* | ||
2 | * Elantech Touchpad driver (v5) | ||
3 | * | ||
4 | * Copyright (C) 2007-2008 Arjan Opmeer <arjan@opmeer.net> | ||
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/module.h> | ||
15 | #include <linux/input.h> | ||
16 | #include <linux/serio.h> | ||
17 | #include <linux/libps2.h> | ||
18 | #include "psmouse.h" | ||
19 | #include "elantech.h" | ||
20 | |||
21 | #define elantech_debug(format, arg...) \ | ||
22 | do { \ | ||
23 | if (etd->debug) \ | ||
24 | printk(KERN_DEBUG format, ##arg); \ | ||
25 | } while (0) | ||
26 | |||
27 | /* | ||
28 | * Send a Synaptics style sliced query command | ||
29 | */ | ||
30 | static int synaptics_send_cmd(struct psmouse *psmouse, unsigned char c, | ||
31 | unsigned char *param) | ||
32 | { | ||
33 | if (psmouse_sliced_command(psmouse, c) || | ||
34 | ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) { | ||
35 | pr_err("elantech.c: synaptics_send_cmd query 0x%02x failed.\n", c); | ||
36 | return -1; | ||
37 | } | ||
38 | |||
39 | return 0; | ||
40 | } | ||
41 | |||
42 | /* | ||
43 | * A retrying version of ps2_command | ||
44 | */ | ||
45 | static int elantech_ps2_command(struct psmouse *psmouse, | ||
46 | unsigned char *param, int command) | ||
47 | { | ||
48 | struct ps2dev *ps2dev = &psmouse->ps2dev; | ||
49 | struct elantech_data *etd = psmouse->private; | ||
50 | int rc; | ||
51 | int tries = ETP_PS2_COMMAND_TRIES; | ||
52 | |||
53 | do { | ||
54 | rc = ps2_command(ps2dev, param, command); | ||
55 | if (rc == 0) | ||
56 | break; | ||
57 | tries--; | ||
58 | elantech_debug("elantech.c: retrying ps2 command 0x%02x (%d).\n", | ||
59 | command, tries); | ||
60 | msleep(ETP_PS2_COMMAND_DELAY); | ||
61 | } while (tries > 0); | ||
62 | |||
63 | if (rc) | ||
64 | pr_err("elantech.c: ps2 command 0x%02x failed.\n", command); | ||
65 | |||
66 | return rc; | ||
67 | } | ||
68 | |||
69 | /* | ||
70 | * Send an Elantech style special command to read a value from a register | ||
71 | */ | ||
72 | static int elantech_read_reg(struct psmouse *psmouse, unsigned char reg, | ||
73 | unsigned char *val) | ||
74 | { | ||
75 | struct elantech_data *etd = psmouse->private; | ||
76 | unsigned char param[3]; | ||
77 | int rc = 0; | ||
78 | |||
79 | if (reg < 0x10 || reg > 0x26) | ||
80 | return -1; | ||
81 | |||
82 | if (reg > 0x11 && reg < 0x20) | ||
83 | return -1; | ||
84 | |||
85 | switch (etd->hw_version) { | ||
86 | case 1: | ||
87 | if (psmouse_sliced_command(psmouse, ETP_REGISTER_READ) || | ||
88 | psmouse_sliced_command(psmouse, reg) || | ||
89 | ps2_command(&psmouse->ps2dev, param, PSMOUSE_CMD_GETINFO)) { | ||
90 | rc = -1; | ||
91 | } | ||
92 | break; | ||
93 | |||
94 | case 2: | ||
95 | if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || | ||
96 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_READ) || | ||
97 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || | ||
98 | elantech_ps2_command(psmouse, NULL, reg) || | ||
99 | elantech_ps2_command(psmouse, param, PSMOUSE_CMD_GETINFO)) { | ||
100 | rc = -1; | ||
101 | } | ||
102 | break; | ||
103 | } | ||
104 | |||
105 | if (rc) | ||
106 | pr_err("elantech.c: failed to read register 0x%02x.\n", reg); | ||
107 | else | ||
108 | *val = param[0]; | ||
109 | |||
110 | return rc; | ||
111 | } | ||
112 | |||
113 | /* | ||
114 | * Send an Elantech style special command to write a register with a value | ||
115 | */ | ||
116 | static int elantech_write_reg(struct psmouse *psmouse, unsigned char reg, | ||
117 | unsigned char val) | ||
118 | { | ||
119 | struct elantech_data *etd = psmouse->private; | ||
120 | int rc = 0; | ||
121 | |||
122 | if (reg < 0x10 || reg > 0x26) | ||
123 | return -1; | ||
124 | |||
125 | if (reg > 0x11 && reg < 0x20) | ||
126 | return -1; | ||
127 | |||
128 | switch (etd->hw_version) { | ||
129 | case 1: | ||
130 | if (psmouse_sliced_command(psmouse, ETP_REGISTER_WRITE) || | ||
131 | psmouse_sliced_command(psmouse, reg) || | ||
132 | psmouse_sliced_command(psmouse, val) || | ||
133 | ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_SETSCALE11)) { | ||
134 | rc = -1; | ||
135 | } | ||
136 | break; | ||
137 | |||
138 | case 2: | ||
139 | if (elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || | ||
140 | elantech_ps2_command(psmouse, NULL, ETP_REGISTER_WRITE) || | ||
141 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || | ||
142 | elantech_ps2_command(psmouse, NULL, reg) || | ||
143 | elantech_ps2_command(psmouse, NULL, ETP_PS2_CUSTOM_COMMAND) || | ||
144 | elantech_ps2_command(psmouse, NULL, val) || | ||
145 | elantech_ps2_command(psmouse, NULL, PSMOUSE_CMD_SETSCALE11)) { | ||
146 | rc = -1; | ||
147 | } | ||
148 | break; | ||
149 | } | ||
150 | |||
151 | if (rc) | ||
152 | pr_err("elantech.c: failed to write register 0x%02x with value 0x%02x.\n", | ||
153 | reg, val); | ||
154 | |||
155 | return rc; | ||
156 | } | ||
157 | |||
158 | /* | ||
159 | * Dump a complete mouse movement packet to the syslog | ||
160 | */ | ||
161 | static void elantech_packet_dump(unsigned char *packet, int size) | ||
162 | { | ||
163 | int i; | ||
164 | |||
165 | printk(KERN_DEBUG "elantech.c: PS/2 packet ["); | ||
166 | for (i = 0; i < size; i++) | ||
167 | printk("%s0x%02x ", (i) ? ", " : " ", packet[i]); | ||
168 | printk("]\n"); | ||
169 | } | ||
170 | |||
171 | /* | ||
172 | * Interpret complete data packets and report absolute mode input events for | ||
173 | * hardware version 1. (4 byte packets) | ||
174 | */ | ||
175 | static void elantech_report_absolute_v1(struct psmouse *psmouse) | ||
176 | { | ||
177 | struct input_dev *dev = psmouse->dev; | ||
178 | struct elantech_data *etd = psmouse->private; | ||
179 | unsigned char *packet = psmouse->packet; | ||
180 | int fingers; | ||
181 | |||
182 | if (etd->fw_version_maj == 0x01) { | ||
183 | /* byte 0: D U p1 p2 1 p3 R L | ||
184 | byte 1: f 0 th tw x9 x8 y9 y8 */ | ||
185 | fingers = ((packet[1] & 0x80) >> 7) + | ||
186 | ((packet[1] & 0x30) >> 4); | ||
187 | } else { | ||
188 | /* byte 0: n1 n0 p2 p1 1 p3 R L | ||
189 | byte 1: 0 0 0 0 x9 x8 y9 y8 */ | ||
190 | fingers = (packet[0] & 0xc0) >> 6; | ||
191 | } | ||
192 | |||
193 | input_report_key(dev, BTN_TOUCH, fingers != 0); | ||
194 | |||
195 | /* byte 2: x7 x6 x5 x4 x3 x2 x1 x0 | ||
196 | byte 3: y7 y6 y5 y4 y3 y2 y1 y0 */ | ||
197 | if (fingers) { | ||
198 | input_report_abs(dev, ABS_X, | ||
199 | ((packet[1] & 0x0c) << 6) | packet[2]); | ||
200 | input_report_abs(dev, ABS_Y, ETP_YMAX_V1 - | ||
201 | (((packet[1] & 0x03) << 8) | packet[3])); | ||
202 | } | ||
203 | |||
204 | input_report_key(dev, BTN_TOOL_FINGER, fingers == 1); | ||
205 | input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2); | ||
206 | input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3); | ||
207 | input_report_key(dev, BTN_LEFT, packet[0] & 0x01); | ||
208 | input_report_key(dev, BTN_RIGHT, packet[0] & 0x02); | ||
209 | |||
210 | if ((etd->fw_version_maj == 0x01) && | ||
211 | (etd->capabilities & ETP_CAP_HAS_ROCKER)) { | ||
212 | /* rocker up */ | ||
213 | input_report_key(dev, BTN_FORWARD, packet[0] & 0x40); | ||
214 | /* rocker down */ | ||
215 | input_report_key(dev, BTN_BACK, packet[0] & 0x80); | ||
216 | } | ||
217 | |||
218 | input_sync(dev); | ||
219 | } | ||
220 | |||
221 | /* | ||
222 | * Interpret complete data packets and report absolute mode input events for | ||
223 | * hardware version 2. (6 byte packets) | ||
224 | */ | ||
225 | static void elantech_report_absolute_v2(struct psmouse *psmouse) | ||
226 | { | ||
227 | struct input_dev *dev = psmouse->dev; | ||
228 | unsigned char *packet = psmouse->packet; | ||
229 | int fingers, x1, y1, x2, y2; | ||
230 | |||
231 | /* byte 0: n1 n0 . . . . R L */ | ||
232 | fingers = (packet[0] & 0xc0) >> 6; | ||
233 | input_report_key(dev, BTN_TOUCH, fingers != 0); | ||
234 | |||
235 | switch (fingers) { | ||
236 | case 1: | ||
237 | /* byte 1: x15 x14 x13 x12 x11 x10 x9 x8 | ||
238 | byte 2: x7 x6 x5 x4 x4 x2 x1 x0 */ | ||
239 | input_report_abs(dev, ABS_X, (packet[1] << 8) | packet[2]); | ||
240 | /* byte 4: y15 y14 y13 y12 y11 y10 y8 y8 | ||
241 | byte 5: y7 y6 y5 y4 y3 y2 y1 y0 */ | ||
242 | input_report_abs(dev, ABS_Y, ETP_YMAX_V2 - | ||
243 | ((packet[4] << 8) | packet[5])); | ||
244 | break; | ||
245 | |||
246 | case 2: | ||
247 | /* The coordinate of each finger is reported separately with | ||
248 | a lower resolution for two finger touches */ | ||
249 | /* byte 0: . . ay8 ax8 . . . . | ||
250 | byte 1: ax7 ax6 ax5 ax4 ax3 ax2 ax1 ax0 */ | ||
251 | x1 = ((packet[0] & 0x10) << 4) | packet[1]; | ||
252 | /* byte 2: ay7 ay6 ay5 ay4 ay3 ay2 ay1 ay0 */ | ||
253 | y1 = ETP_2FT_YMAX - (((packet[0] & 0x20) << 3) | packet[2]); | ||
254 | /* byte 3: . . by8 bx8 . . . . | ||
255 | byte 4: bx7 bx6 bx5 bx4 bx3 bx2 bx1 bx0 */ | ||
256 | x2 = ((packet[3] & 0x10) << 4) | packet[4]; | ||
257 | /* byte 5: by7 by8 by5 by4 by3 by2 by1 by0 */ | ||
258 | y2 = ETP_2FT_YMAX - (((packet[3] & 0x20) << 3) | packet[5]); | ||
259 | /* For compatibility with the X Synaptics driver scale up one | ||
260 | coordinate and report as ordinary mouse movent */ | ||
261 | input_report_abs(dev, ABS_X, x1 << 2); | ||
262 | input_report_abs(dev, ABS_Y, y1 << 2); | ||
263 | /* For compatibility with the proprietary X Elantech driver | ||
264 | report both coordinates as hat coordinates */ | ||
265 | input_report_abs(dev, ABS_HAT0X, x1); | ||
266 | input_report_abs(dev, ABS_HAT0Y, y1); | ||
267 | input_report_abs(dev, ABS_HAT1X, x2); | ||
268 | input_report_abs(dev, ABS_HAT1Y, y2); | ||
269 | break; | ||
270 | } | ||
271 | |||
272 | input_report_key(dev, BTN_TOOL_FINGER, fingers == 1); | ||
273 | input_report_key(dev, BTN_TOOL_DOUBLETAP, fingers == 2); | ||
274 | input_report_key(dev, BTN_TOOL_TRIPLETAP, fingers == 3); | ||
275 | input_report_key(dev, BTN_LEFT, packet[0] & 0x01); | ||
276 | input_report_key(dev, BTN_RIGHT, packet[0] & 0x02); | ||
277 | |||
278 | input_sync(dev); | ||
279 | } | ||
280 | |||
281 | static int elantech_check_parity_v1(struct psmouse *psmouse) | ||
282 | { | ||
283 | struct elantech_data *etd = psmouse->private; | ||
284 | unsigned char *packet = psmouse->packet; | ||
285 | unsigned char p1, p2, p3; | ||
286 | |||
287 | /* Parity bits are placed differently */ | ||
288 | if (etd->fw_version_maj == 0x01) { | ||
289 | /* byte 0: D U p1 p2 1 p3 R L */ | ||
290 | p1 = (packet[0] & 0x20) >> 5; | ||
291 | p2 = (packet[0] & 0x10) >> 4; | ||
292 | } else { | ||
293 | /* byte 0: n1 n0 p2 p1 1 p3 R L */ | ||
294 | p1 = (packet[0] & 0x10) >> 4; | ||
295 | p2 = (packet[0] & 0x20) >> 5; | ||
296 | } | ||
297 | |||
298 | p3 = (packet[0] & 0x04) >> 2; | ||
299 | |||
300 | return etd->parity[packet[1]] == p1 && | ||
301 | etd->parity[packet[2]] == p2 && | ||
302 | etd->parity[packet[3]] == p3; | ||
303 | } | ||
304 | |||
305 | /* | ||
306 | * Process byte stream from mouse and handle complete packets | ||
307 | */ | ||
308 | static psmouse_ret_t elantech_process_byte(struct psmouse *psmouse) | ||
309 | { | ||
310 | struct elantech_data *etd = psmouse->private; | ||
311 | |||
312 | if (psmouse->pktcnt < psmouse->pktsize) | ||
313 | return PSMOUSE_GOOD_DATA; | ||
314 | |||
315 | if (etd->debug > 1) | ||
316 | elantech_packet_dump(psmouse->packet, psmouse->pktsize); | ||
317 | |||
318 | switch (etd->hw_version) { | ||
319 | case 1: | ||
320 | if (etd->paritycheck && !elantech_check_parity_v1(psmouse)) | ||
321 | return PSMOUSE_BAD_DATA; | ||
322 | |||
323 | elantech_report_absolute_v1(psmouse); | ||
324 | break; | ||
325 | |||
326 | case 2: | ||
327 | /* We don't know how to check parity in protocol v2 */ | ||
328 | elantech_report_absolute_v2(psmouse); | ||
329 | break; | ||
330 | } | ||
331 | |||
332 | return PSMOUSE_FULL_PACKET; | ||
333 | } | ||
334 | |||
335 | /* | ||
336 | * Put the touchpad into absolute mode | ||
337 | */ | ||
338 | static int elantech_set_absolute_mode(struct psmouse *psmouse) | ||
339 | { | ||
340 | struct elantech_data *etd = psmouse->private; | ||
341 | unsigned char val; | ||
342 | int tries = ETP_READ_BACK_TRIES; | ||
343 | int rc = 0; | ||
344 | |||
345 | switch (etd->hw_version) { | ||
346 | case 1: | ||
347 | etd->reg_10 = 0x16; | ||
348 | etd->reg_11 = 0x8f; | ||
349 | if (elantech_write_reg(psmouse, 0x10, etd->reg_10) || | ||
350 | elantech_write_reg(psmouse, 0x11, etd->reg_11)) { | ||
351 | rc = -1; | ||
352 | } | ||
353 | break; | ||
354 | |||
355 | case 2: | ||
356 | /* Windows driver values */ | ||
357 | etd->reg_10 = 0x54; | ||
358 | etd->reg_11 = 0x88; /* 0x8a */ | ||
359 | etd->reg_21 = 0x60; /* 0x00 */ | ||
360 | if (elantech_write_reg(psmouse, 0x10, etd->reg_10) || | ||
361 | elantech_write_reg(psmouse, 0x11, etd->reg_11) || | ||
362 | elantech_write_reg(psmouse, 0x21, etd->reg_21)) { | ||
363 | rc = -1; | ||
364 | break; | ||
365 | } | ||
366 | /* | ||
367 | * Read back reg 0x10. The touchpad is probably initalising | ||
368 | * and not ready until we read back the value we just wrote. | ||
369 | */ | ||
370 | do { | ||
371 | rc = elantech_read_reg(psmouse, 0x10, &val); | ||
372 | if (rc == 0) | ||
373 | break; | ||
374 | tries--; | ||
375 | elantech_debug("elantech.c: retrying read (%d).\n", | ||
376 | tries); | ||
377 | msleep(ETP_READ_BACK_DELAY); | ||
378 | } while (tries > 0); | ||
379 | if (rc) | ||
380 | pr_err("elantech.c: failed to read back register 0x10.\n"); | ||
381 | break; | ||
382 | } | ||
383 | |||
384 | if (rc) | ||
385 | pr_err("elantech.c: failed to initialise registers.\n"); | ||
386 | |||
387 | return rc; | ||
388 | } | ||
389 | |||
390 | /* | ||
391 | * Set the appropriate event bits for the input subsystem | ||
392 | */ | ||
393 | static void elantech_set_input_params(struct psmouse *psmouse) | ||
394 | { | ||
395 | struct input_dev *dev = psmouse->dev; | ||
396 | struct elantech_data *etd = psmouse->private; | ||
397 | |||
398 | __set_bit(EV_KEY, dev->evbit); | ||
399 | __set_bit(EV_ABS, dev->evbit); | ||
400 | |||
401 | __set_bit(BTN_LEFT, dev->keybit); | ||
402 | __set_bit(BTN_RIGHT, dev->keybit); | ||
403 | |||
404 | __set_bit(BTN_TOUCH, dev->keybit); | ||
405 | __set_bit(BTN_TOOL_FINGER, dev->keybit); | ||
406 | __set_bit(BTN_TOOL_DOUBLETAP, dev->keybit); | ||
407 | __set_bit(BTN_TOOL_TRIPLETAP, dev->keybit); | ||
408 | |||
409 | switch (etd->hw_version) { | ||
410 | case 1: | ||
411 | /* Rocker button */ | ||
412 | if ((etd->fw_version_maj == 0x01) && | ||
413 | (etd->capabilities & ETP_CAP_HAS_ROCKER)) { | ||
414 | __set_bit(BTN_FORWARD, dev->keybit); | ||
415 | __set_bit(BTN_BACK, dev->keybit); | ||
416 | } | ||
417 | input_set_abs_params(dev, ABS_X, ETP_XMIN_V1, ETP_XMAX_V1, 0, 0); | ||
418 | input_set_abs_params(dev, ABS_Y, ETP_YMIN_V1, ETP_YMAX_V1, 0, 0); | ||
419 | break; | ||
420 | |||
421 | case 2: | ||
422 | input_set_abs_params(dev, ABS_X, ETP_XMIN_V2, ETP_XMAX_V2, 0, 0); | ||
423 | input_set_abs_params(dev, ABS_Y, ETP_YMIN_V2, ETP_YMAX_V2, 0, 0); | ||
424 | input_set_abs_params(dev, ABS_HAT0X, ETP_2FT_XMIN, ETP_2FT_XMAX, 0, 0); | ||
425 | input_set_abs_params(dev, ABS_HAT0Y, ETP_2FT_YMIN, ETP_2FT_YMAX, 0, 0); | ||
426 | input_set_abs_params(dev, ABS_HAT1X, ETP_2FT_XMIN, ETP_2FT_XMAX, 0, 0); | ||
427 | input_set_abs_params(dev, ABS_HAT1Y, ETP_2FT_YMIN, ETP_2FT_YMAX, 0, 0); | ||
428 | break; | ||
429 | } | ||
430 | } | ||
431 | |||
432 | struct elantech_attr_data { | ||
433 | size_t field_offset; | ||
434 | unsigned char reg; | ||
435 | }; | ||
436 | |||
437 | /* | ||
438 | * Display a register value by reading a sysfs entry | ||
439 | */ | ||
440 | static ssize_t elantech_show_int_attr(struct psmouse *psmouse, void *data, | ||
441 | char *buf) | ||
442 | { | ||
443 | struct elantech_data *etd = psmouse->private; | ||
444 | struct elantech_attr_data *attr = data; | ||
445 | unsigned char *reg = (unsigned char *) etd + attr->field_offset; | ||
446 | int rc = 0; | ||
447 | |||
448 | if (attr->reg) | ||
449 | rc = elantech_read_reg(psmouse, attr->reg, reg); | ||
450 | |||
451 | return sprintf(buf, "0x%02x\n", (attr->reg && rc) ? -1 : *reg); | ||
452 | } | ||
453 | |||
454 | /* | ||
455 | * Write a register value by writing a sysfs entry | ||
456 | */ | ||
457 | static ssize_t elantech_set_int_attr(struct psmouse *psmouse, | ||
458 | void *data, const char *buf, size_t count) | ||
459 | { | ||
460 | struct elantech_data *etd = psmouse->private; | ||
461 | struct elantech_attr_data *attr = data; | ||
462 | unsigned char *reg = (unsigned char *) etd + attr->field_offset; | ||
463 | unsigned long value; | ||
464 | int err; | ||
465 | |||
466 | err = strict_strtoul(buf, 16, &value); | ||
467 | if (err) | ||
468 | return err; | ||
469 | |||
470 | if (value > 0xff) | ||
471 | return -EINVAL; | ||
472 | |||
473 | /* Do we need to preserve some bits for version 2 hardware too? */ | ||
474 | if (etd->hw_version == 1) { | ||
475 | if (attr->reg == 0x10) | ||
476 | /* Force absolute mode always on */ | ||
477 | value |= ETP_R10_ABSOLUTE_MODE; | ||
478 | else if (attr->reg == 0x11) | ||
479 | /* Force 4 byte mode always on */ | ||
480 | value |= ETP_R11_4_BYTE_MODE; | ||
481 | } | ||
482 | |||
483 | if (!attr->reg || elantech_write_reg(psmouse, attr->reg, value) == 0) | ||
484 | *reg = value; | ||
485 | |||
486 | return count; | ||
487 | } | ||
488 | |||
489 | #define ELANTECH_INT_ATTR(_name, _register) \ | ||
490 | static struct elantech_attr_data elantech_attr_##_name = { \ | ||
491 | .field_offset = offsetof(struct elantech_data, _name), \ | ||
492 | .reg = _register, \ | ||
493 | }; \ | ||
494 | PSMOUSE_DEFINE_ATTR(_name, S_IWUSR | S_IRUGO, \ | ||
495 | &elantech_attr_##_name, \ | ||
496 | elantech_show_int_attr, \ | ||
497 | elantech_set_int_attr) | ||
498 | |||
499 | ELANTECH_INT_ATTR(reg_10, 0x10); | ||
500 | ELANTECH_INT_ATTR(reg_11, 0x11); | ||
501 | ELANTECH_INT_ATTR(reg_20, 0x20); | ||
502 | ELANTECH_INT_ATTR(reg_21, 0x21); | ||
503 | ELANTECH_INT_ATTR(reg_22, 0x22); | ||
504 | ELANTECH_INT_ATTR(reg_23, 0x23); | ||
505 | ELANTECH_INT_ATTR(reg_24, 0x24); | ||
506 | ELANTECH_INT_ATTR(reg_25, 0x25); | ||
507 | ELANTECH_INT_ATTR(reg_26, 0x26); | ||
508 | ELANTECH_INT_ATTR(debug, 0); | ||
509 | ELANTECH_INT_ATTR(paritycheck, 0); | ||
510 | |||
511 | static struct attribute *elantech_attrs[] = { | ||
512 | &psmouse_attr_reg_10.dattr.attr, | ||
513 | &psmouse_attr_reg_11.dattr.attr, | ||
514 | &psmouse_attr_reg_20.dattr.attr, | ||
515 | &psmouse_attr_reg_21.dattr.attr, | ||
516 | &psmouse_attr_reg_22.dattr.attr, | ||
517 | &psmouse_attr_reg_23.dattr.attr, | ||
518 | &psmouse_attr_reg_24.dattr.attr, | ||
519 | &psmouse_attr_reg_25.dattr.attr, | ||
520 | &psmouse_attr_reg_26.dattr.attr, | ||
521 | &psmouse_attr_debug.dattr.attr, | ||
522 | &psmouse_attr_paritycheck.dattr.attr, | ||
523 | NULL | ||
524 | }; | ||
525 | |||
526 | static struct attribute_group elantech_attr_group = { | ||
527 | .attrs = elantech_attrs, | ||
528 | }; | ||
529 | |||
530 | /* | ||
531 | * Use magic knock to detect Elantech touchpad | ||
532 | */ | ||
533 | int elantech_detect(struct psmouse *psmouse, int set_properties) | ||
534 | { | ||
535 | struct ps2dev *ps2dev = &psmouse->ps2dev; | ||
536 | unsigned char param[3]; | ||
537 | |||
538 | ps2_command(&psmouse->ps2dev, NULL, PSMOUSE_CMD_RESET_DIS); | ||
539 | |||
540 | if (ps2_command(ps2dev, NULL, PSMOUSE_CMD_DISABLE) || | ||
541 | ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) || | ||
542 | ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) || | ||
543 | ps2_command(ps2dev, NULL, PSMOUSE_CMD_SETSCALE11) || | ||
544 | ps2_command(ps2dev, param, PSMOUSE_CMD_GETINFO)) { | ||
545 | pr_err("elantech.c: sending Elantech magic knock failed.\n"); | ||
546 | return -1; | ||
547 | } | ||
548 | |||
549 | /* | ||
550 | * Report this in case there are Elantech models that use a different | ||
551 | * set of magic numbers | ||
552 | */ | ||
553 | if (param[0] != 0x3c || param[1] != 0x03 || param[2] != 0xc8) { | ||
554 | pr_info("elantech.c: unexpected magic knock result 0x%02x, 0x%02x, 0x%02x.\n", | ||
555 | param[0], param[1], param[2]); | ||
556 | return -1; | ||
557 | } | ||
558 | |||
559 | if (set_properties) { | ||
560 | psmouse->vendor = "Elantech"; | ||
561 | psmouse->name = "Touchpad"; | ||
562 | } | ||
563 | |||
564 | return 0; | ||
565 | } | ||
566 | |||
567 | /* | ||
568 | * Clean up sysfs entries when disconnecting | ||
569 | */ | ||
570 | static void elantech_disconnect(struct psmouse *psmouse) | ||
571 | { | ||
572 | sysfs_remove_group(&psmouse->ps2dev.serio->dev.kobj, | ||
573 | &elantech_attr_group); | ||
574 | kfree(psmouse->private); | ||
575 | psmouse->private = NULL; | ||
576 | } | ||
577 | |||
578 | /* | ||
579 | * Put the touchpad back into absolute mode when reconnecting | ||
580 | */ | ||
581 | static int elantech_reconnect(struct psmouse *psmouse) | ||
582 | { | ||
583 | if (elantech_detect(psmouse, 0)) | ||
584 | return -1; | ||
585 | |||
586 | if (elantech_set_absolute_mode(psmouse)) { | ||
587 | pr_err("elantech.c: failed to put touchpad back into absolute mode.\n"); | ||
588 | return -1; | ||
589 | } | ||
590 | |||
591 | return 0; | ||
592 | } | ||
593 | |||
594 | /* | ||
595 | * Initialize the touchpad and create sysfs entries | ||
596 | */ | ||
597 | int elantech_init(struct psmouse *psmouse) | ||
598 | { | ||
599 | struct elantech_data *etd; | ||
600 | int i, error; | ||
601 | unsigned char param[3]; | ||
602 | |||
603 | etd = kzalloc(sizeof(struct elantech_data), GFP_KERNEL); | ||
604 | psmouse->private = etd; | ||
605 | if (!etd) | ||
606 | return -1; | ||
607 | |||
608 | etd->parity[0] = 1; | ||
609 | for (i = 1; i < 256; i++) | ||
610 | etd->parity[i] = etd->parity[i & (i - 1)] ^ 1; | ||
611 | |||
612 | /* | ||
613 | * Find out what version hardware this is | ||
614 | */ | ||
615 | if (synaptics_send_cmd(psmouse, ETP_FW_VERSION_QUERY, param)) { | ||
616 | pr_err("elantech.c: failed to query firmware version.\n"); | ||
617 | goto init_fail; | ||
618 | } | ||
619 | pr_info("elantech.c: Elantech version query result 0x%02x, 0x%02x, 0x%02x.\n", | ||
620 | param[0], param[1], param[2]); | ||
621 | etd->fw_version_maj = param[0]; | ||
622 | etd->fw_version_min = param[2]; | ||
623 | |||
624 | /* | ||
625 | * Assume every version greater than this is new EeePC style | ||
626 | * hardware with 6 byte packets | ||
627 | */ | ||
628 | if (etd->fw_version_maj >= 0x02 && etd->fw_version_min >= 0x30) { | ||
629 | etd->hw_version = 2; | ||
630 | /* For now show extra debug information */ | ||
631 | etd->debug = 1; | ||
632 | /* Don't know how to do parity checking for version 2 */ | ||
633 | etd->paritycheck = 0; | ||
634 | } else { | ||
635 | etd->hw_version = 1; | ||
636 | etd->paritycheck = 1; | ||
637 | } | ||
638 | pr_info("elantech.c: assuming hardware version %d, firmware version %d.%d\n", | ||
639 | etd->hw_version, etd->fw_version_maj, etd->fw_version_min); | ||
640 | |||
641 | if (synaptics_send_cmd(psmouse, ETP_CAPABILITIES_QUERY, param)) { | ||
642 | pr_err("elantech.c: failed to query capabilities.\n"); | ||
643 | goto init_fail; | ||
644 | } | ||
645 | pr_info("elantech.c: Synaptics capabilities query result 0x%02x, 0x%02x, 0x%02x.\n", | ||
646 | param[0], param[1], param[2]); | ||
647 | etd->capabilities = param[0]; | ||
648 | |||
649 | if (elantech_set_absolute_mode(psmouse)) { | ||
650 | pr_err("elantech.c: failed to put touchpad into absolute mode.\n"); | ||
651 | goto init_fail; | ||
652 | } | ||
653 | |||
654 | elantech_set_input_params(psmouse); | ||
655 | |||
656 | error = sysfs_create_group(&psmouse->ps2dev.serio->dev.kobj, | ||
657 | &elantech_attr_group); | ||
658 | if (error) { | ||
659 | pr_err("elantech.c: failed to create sysfs attributes, error: %d.\n", | ||
660 | error); | ||
661 | goto init_fail; | ||
662 | } | ||
663 | |||
664 | psmouse->protocol_handler = elantech_process_byte; | ||
665 | psmouse->disconnect = elantech_disconnect; | ||
666 | psmouse->reconnect = elantech_reconnect; | ||
667 | psmouse->pktsize = etd->hw_version == 2 ? 6 : 4; | ||
668 | |||
669 | return 0; | ||
670 | |||
671 | init_fail: | ||
672 | kfree(etd); | ||
673 | return -1; | ||
674 | } | ||
diff --git a/drivers/input/mouse/elantech.h b/drivers/input/mouse/elantech.h new file mode 100644 index 000000000000..bee282b540bc --- /dev/null +++ b/drivers/input/mouse/elantech.h | |||
@@ -0,0 +1,124 @@ | |||
1 | /* | ||
2 | * Elantech Touchpad driver (v5) | ||
3 | * | ||
4 | * Copyright (C) 2007-2008 Arjan Opmeer <arjan@opmeer.net> | ||
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 | #ifndef _ELANTECH_H | ||
14 | #define _ELANTECH_H | ||
15 | |||
16 | /* | ||
17 | * Command values for Synaptics style queries | ||
18 | */ | ||
19 | #define ETP_FW_VERSION_QUERY 0x01 | ||
20 | #define ETP_CAPABILITIES_QUERY 0x02 | ||
21 | |||
22 | /* | ||
23 | * Command values for register reading or writing | ||
24 | */ | ||
25 | #define ETP_REGISTER_READ 0x10 | ||
26 | #define ETP_REGISTER_WRITE 0x11 | ||
27 | |||
28 | /* | ||
29 | * Hardware version 2 custom PS/2 command value | ||
30 | */ | ||
31 | #define ETP_PS2_CUSTOM_COMMAND 0xf8 | ||
32 | |||
33 | /* | ||
34 | * Times to retry a ps2_command and millisecond delay between tries | ||
35 | */ | ||
36 | #define ETP_PS2_COMMAND_TRIES 3 | ||
37 | #define ETP_PS2_COMMAND_DELAY 500 | ||
38 | |||
39 | /* | ||
40 | * Times to try to read back a register and millisecond delay between tries | ||
41 | */ | ||
42 | #define ETP_READ_BACK_TRIES 5 | ||
43 | #define ETP_READ_BACK_DELAY 2000 | ||
44 | |||
45 | /* | ||
46 | * Register bitmasks for hardware version 1 | ||
47 | */ | ||
48 | #define ETP_R10_ABSOLUTE_MODE 0x04 | ||
49 | #define ETP_R11_4_BYTE_MODE 0x02 | ||
50 | |||
51 | /* | ||
52 | * Capability bitmasks | ||
53 | */ | ||
54 | #define ETP_CAP_HAS_ROCKER 0x04 | ||
55 | |||
56 | /* | ||
57 | * One hard to find application note states that X axis range is 0 to 576 | ||
58 | * and Y axis range is 0 to 384 for harware version 1. | ||
59 | * Edge fuzz might be necessary because of bezel around the touchpad | ||
60 | */ | ||
61 | #define ETP_EDGE_FUZZ_V1 32 | ||
62 | |||
63 | #define ETP_XMIN_V1 ( 0 + ETP_EDGE_FUZZ_V1) | ||
64 | #define ETP_XMAX_V1 (576 - ETP_EDGE_FUZZ_V1) | ||
65 | #define ETP_YMIN_V1 ( 0 + ETP_EDGE_FUZZ_V1) | ||
66 | #define ETP_YMAX_V1 (384 - ETP_EDGE_FUZZ_V1) | ||
67 | |||
68 | /* | ||
69 | * It seems the resolution for hardware version 2 doubled. | ||
70 | * Hence the X and Y ranges are doubled too. | ||
71 | * The bezel around the pad also appears to be smaller | ||
72 | */ | ||
73 | #define ETP_EDGE_FUZZ_V2 8 | ||
74 | |||
75 | #define ETP_XMIN_V2 ( 0 + ETP_EDGE_FUZZ_V2) | ||
76 | #define ETP_XMAX_V2 (1152 - ETP_EDGE_FUZZ_V2) | ||
77 | #define ETP_YMIN_V2 ( 0 + ETP_EDGE_FUZZ_V2) | ||
78 | #define ETP_YMAX_V2 ( 768 - ETP_EDGE_FUZZ_V2) | ||
79 | |||
80 | /* | ||
81 | * For two finger touches the coordinate of each finger gets reported | ||
82 | * separately but with reduced resolution. | ||
83 | */ | ||
84 | #define ETP_2FT_FUZZ 4 | ||
85 | |||
86 | #define ETP_2FT_XMIN ( 0 + ETP_2FT_FUZZ) | ||
87 | #define ETP_2FT_XMAX (288 - ETP_2FT_FUZZ) | ||
88 | #define ETP_2FT_YMIN ( 0 + ETP_2FT_FUZZ) | ||
89 | #define ETP_2FT_YMAX (192 - ETP_2FT_FUZZ) | ||
90 | |||
91 | struct elantech_data { | ||
92 | unsigned char reg_10; | ||
93 | unsigned char reg_11; | ||
94 | unsigned char reg_20; | ||
95 | unsigned char reg_21; | ||
96 | unsigned char reg_22; | ||
97 | unsigned char reg_23; | ||
98 | unsigned char reg_24; | ||
99 | unsigned char reg_25; | ||
100 | unsigned char reg_26; | ||
101 | unsigned char debug; | ||
102 | unsigned char capabilities; | ||
103 | unsigned char fw_version_maj; | ||
104 | unsigned char fw_version_min; | ||
105 | unsigned char hw_version; | ||
106 | unsigned char paritycheck; | ||
107 | unsigned char parity[256]; | ||
108 | }; | ||
109 | |||
110 | #ifdef CONFIG_MOUSE_PS2_ELANTECH | ||
111 | int elantech_detect(struct psmouse *psmouse, int set_properties); | ||
112 | int elantech_init(struct psmouse *psmouse); | ||
113 | #else | ||
114 | static inline int elantech_detect(struct psmouse *psmouse, int set_properties) | ||
115 | { | ||
116 | return -ENOSYS; | ||
117 | } | ||
118 | static inline int elantech_init(struct psmouse *psmouse) | ||
119 | { | ||
120 | return -ENOSYS; | ||
121 | } | ||
122 | #endif /* CONFIG_MOUSE_PS2_ELANTECH */ | ||
123 | |||
124 | #endif | ||
diff --git a/drivers/input/mouse/psmouse-base.c b/drivers/input/mouse/psmouse-base.c index 126e977e199e..f8f86de694bb 100644 --- a/drivers/input/mouse/psmouse-base.c +++ b/drivers/input/mouse/psmouse-base.c | |||
@@ -29,6 +29,7 @@ | |||
29 | #include "lifebook.h" | 29 | #include "lifebook.h" |
30 | #include "trackpoint.h" | 30 | #include "trackpoint.h" |
31 | #include "touchkit_ps2.h" | 31 | #include "touchkit_ps2.h" |
32 | #include "elantech.h" | ||
32 | 33 | ||
33 | #define DRIVER_DESC "PS/2 mouse driver" | 34 | #define DRIVER_DESC "PS/2 mouse driver" |
34 | 35 | ||
@@ -650,6 +651,19 @@ static int psmouse_extensions(struct psmouse *psmouse, | |||
650 | max_proto = PSMOUSE_IMEX; | 651 | max_proto = PSMOUSE_IMEX; |
651 | } | 652 | } |
652 | 653 | ||
654 | /* | ||
655 | * Try Elantech touchpad. | ||
656 | */ | ||
657 | if (max_proto > PSMOUSE_IMEX && | ||
658 | elantech_detect(psmouse, set_properties) == 0) { | ||
659 | if (!set_properties || elantech_init(psmouse) == 0) | ||
660 | return PSMOUSE_ELANTECH; | ||
661 | /* | ||
662 | * Init failed, try basic relative protocols | ||
663 | */ | ||
664 | max_proto = PSMOUSE_IMEX; | ||
665 | } | ||
666 | |||
653 | if (max_proto > PSMOUSE_IMEX) { | 667 | if (max_proto > PSMOUSE_IMEX) { |
654 | if (genius_detect(psmouse, set_properties) == 0) | 668 | if (genius_detect(psmouse, set_properties) == 0) |
655 | return PSMOUSE_GENPS; | 669 | return PSMOUSE_GENPS; |
@@ -789,6 +803,15 @@ static const struct psmouse_protocol psmouse_protocols[] = { | |||
789 | .detect = hgpk_detect, | 803 | .detect = hgpk_detect, |
790 | }, | 804 | }, |
791 | #endif | 805 | #endif |
806 | #ifdef CONFIG_MOUSE_PS2_ELANTECH | ||
807 | { | ||
808 | .type = PSMOUSE_ELANTECH, | ||
809 | .name = "ETPS/2", | ||
810 | .alias = "elantech", | ||
811 | .detect = elantech_detect, | ||
812 | .init = elantech_init, | ||
813 | }, | ||
814 | #endif | ||
792 | { | 815 | { |
793 | .type = PSMOUSE_CORTRON, | 816 | .type = PSMOUSE_CORTRON, |
794 | .name = "CortronPS/2", | 817 | .name = "CortronPS/2", |
diff --git a/drivers/input/mouse/psmouse.h b/drivers/input/mouse/psmouse.h index 8b608a1cdd12..54ed267894bd 100644 --- a/drivers/input/mouse/psmouse.h +++ b/drivers/input/mouse/psmouse.h | |||
@@ -90,6 +90,7 @@ enum psmouse_type { | |||
90 | PSMOUSE_TOUCHKIT_PS2, | 90 | PSMOUSE_TOUCHKIT_PS2, |
91 | PSMOUSE_CORTRON, | 91 | PSMOUSE_CORTRON, |
92 | PSMOUSE_HGPK, | 92 | PSMOUSE_HGPK, |
93 | PSMOUSE_ELANTECH, | ||
93 | PSMOUSE_AUTO /* This one should always be last */ | 94 | PSMOUSE_AUTO /* This one should always be last */ |
94 | }; | 95 | }; |
95 | 96 | ||
diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h index a321aea2c7b5..eec375cd10e6 100644 --- a/drivers/input/serio/i8042-x86ia64io.h +++ b/drivers/input/serio/i8042-x86ia64io.h | |||
@@ -135,6 +135,14 @@ static struct dmi_system_id __initdata i8042_dmi_noloop_table[] = { | |||
135 | DMI_MATCH(DMI_PRODUCT_VERSION, "5a"), | 135 | DMI_MATCH(DMI_PRODUCT_VERSION, "5a"), |
136 | }, | 136 | }, |
137 | }, | 137 | }, |
138 | { | ||
139 | .ident = "Blue FB5601", | ||
140 | .matches = { | ||
141 | DMI_MATCH(DMI_SYS_VENDOR, "blue"), | ||
142 | DMI_MATCH(DMI_PRODUCT_NAME, "FB5601"), | ||
143 | DMI_MATCH(DMI_PRODUCT_VERSION, "M606"), | ||
144 | }, | ||
145 | }, | ||
138 | { } | 146 | { } |
139 | }; | 147 | }; |
140 | 148 | ||