Commit | Line | Data |
---|---|---|
eeb01a57 | 1 | /* |
b94f7d5d | 2 | * HID driver for Asus notebook built-in keyboard. |
eeb01a57 YF |
3 | * Fixes small logical maximum to match usage maximum. |
4 | * | |
b94f7d5d YF |
5 | * Currently supported devices are: |
6 | * EeeBook X205TA | |
7 | * VivoBook E200HA | |
8 | * | |
eeb01a57 YF |
9 | * Copyright (c) 2016 Yusuke Fujimaki <usk.fujimaki@gmail.com> |
10 | * | |
11 | * This module based on hid-ortek by | |
12 | * Copyright (c) 2010 Johnathon Harris <jmharris@gmail.com> | |
13 | * Copyright (c) 2011 Jiri Kosina | |
9ce12d8b BM |
14 | * |
15 | * This module has been updated to add support for Asus i2c touchpad. | |
16 | * | |
17 | * Copyright (c) 2016 Brendan McGrath <redmcg@redmandi.dyndns.org> | |
18 | * Copyright (c) 2016 Victor Vlasenko <victor.vlasenko@sysgears.com> | |
19 | * Copyright (c) 2016 Frederik Wenigwieser <frederik.wenigwieser@gmail.com> | |
eeb01a57 YF |
20 | */ |
21 | ||
22 | /* | |
23 | * This program is free software; you can redistribute it and/or modify it | |
24 | * under the terms of the GNU General Public License as published by the Free | |
25 | * Software Foundation; either version 2 of the License, or (at your option) | |
26 | * any later version. | |
27 | */ | |
28 | ||
762f948c | 29 | #include <linux/dmi.h> |
eeb01a57 YF |
30 | #include <linux/hid.h> |
31 | #include <linux/module.h> | |
9ce12d8b | 32 | #include <linux/input/mt.h> |
57573c54 | 33 | #include <linux/usb.h> /* For to_usb_interface for T100 touchpad intf check */ |
eeb01a57 YF |
34 | |
35 | #include "hid-ids.h" | |
36 | ||
9ce12d8b BM |
37 | MODULE_AUTHOR("Yusuke Fujimaki <usk.fujimaki@gmail.com>"); |
38 | MODULE_AUTHOR("Brendan McGrath <redmcg@redmandi.dyndns.org>"); | |
39 | MODULE_AUTHOR("Victor Vlasenko <victor.vlasenko@sysgears.com>"); | |
40 | MODULE_AUTHOR("Frederik Wenigwieser <frederik.wenigwieser@gmail.com>"); | |
41 | MODULE_DESCRIPTION("Asus HID Keyboard and TouchPad"); | |
42 | ||
57573c54 HG |
43 | #define T100_TPAD_INTF 2 |
44 | ||
73c75d39 | 45 | #define T100CHI_MOUSE_REPORT_ID 0x06 |
9ce12d8b BM |
46 | #define FEATURE_REPORT_ID 0x0d |
47 | #define INPUT_REPORT_ID 0x5d | |
af22a610 | 48 | #define FEATURE_KBD_REPORT_ID 0x5a |
af22a610 CC |
49 | #define FEATURE_KBD_REPORT_SIZE 16 |
50 | ||
51 | #define SUPPORT_KBD_BACKLIGHT BIT(0) | |
9ce12d8b | 52 | |
9ce12d8b BM |
53 | #define MAX_TOUCH_MAJOR 8 |
54 | #define MAX_PRESSURE 128 | |
55 | ||
9ce12d8b BM |
56 | #define BTN_LEFT_MASK 0x01 |
57 | #define CONTACT_TOOL_TYPE_MASK 0x80 | |
58 | #define CONTACT_X_MSB_MASK 0xf0 | |
59 | #define CONTACT_Y_MSB_MASK 0x0f | |
60 | #define CONTACT_TOUCH_MAJOR_MASK 0x07 | |
61 | #define CONTACT_PRESSURE_MASK 0x7f | |
62 | ||
63 | #define QUIRK_FIX_NOTEBOOK_REPORT BIT(0) | |
64 | #define QUIRK_NO_INIT_REPORTS BIT(1) | |
65 | #define QUIRK_SKIP_INPUT_MAPPING BIT(2) | |
66 | #define QUIRK_IS_MULTITOUCH BIT(3) | |
0485b1ec | 67 | #define QUIRK_NO_CONSUMER_USAGES BIT(4) |
af22a610 | 68 | #define QUIRK_USE_KBD_BACKLIGHT BIT(5) |
76dd1fbe | 69 | #define QUIRK_T100_KEYBOARD BIT(6) |
5703e52c | 70 | #define QUIRK_T100CHI BIT(7) |
832e1eee | 71 | #define QUIRK_G752_KEYBOARD BIT(8) |
9ce12d8b | 72 | |
a93913e1 | 73 | #define I2C_KEYBOARD_QUIRKS (QUIRK_FIX_NOTEBOOK_REPORT | \ |
0485b1ec MH |
74 | QUIRK_NO_INIT_REPORTS | \ |
75 | QUIRK_NO_CONSUMER_USAGES) | |
c81760b9 | 76 | #define I2C_TOUCHPAD_QUIRKS (QUIRK_NO_INIT_REPORTS | \ |
9ce12d8b BM |
77 | QUIRK_SKIP_INPUT_MAPPING | \ |
78 | QUIRK_IS_MULTITOUCH) | |
79 | ||
80 | #define TRKID_SGN ((TRKID_MAX + 1) >> 1) | |
81 | ||
af22a610 CC |
82 | struct asus_kbd_leds { |
83 | struct led_classdev cdev; | |
84 | struct hid_device *hdev; | |
85 | struct work_struct work; | |
86 | unsigned int brightness; | |
87 | bool removed; | |
88 | }; | |
89 | ||
c81760b9 HG |
90 | struct asus_touchpad_info { |
91 | int max_x; | |
92 | int max_y; | |
b61d43e6 HG |
93 | int res_x; |
94 | int res_y; | |
c81760b9 HG |
95 | int contact_size; |
96 | int max_contacts; | |
97 | }; | |
98 | ||
9ce12d8b BM |
99 | struct asus_drvdata { |
100 | unsigned long quirks; | |
101 | struct input_dev *input; | |
af22a610 | 102 | struct asus_kbd_leds *kbd_backlight; |
c81760b9 | 103 | const struct asus_touchpad_info *tp; |
af22a610 | 104 | bool enable_backlight; |
9ce12d8b BM |
105 | }; |
106 | ||
c81760b9 HG |
107 | static const struct asus_touchpad_info asus_i2c_tp = { |
108 | .max_x = 2794, | |
109 | .max_y = 1758, | |
110 | .contact_size = 5, | |
111 | .max_contacts = 5, | |
112 | }; | |
113 | ||
114 | static const struct asus_touchpad_info asus_t100ta_tp = { | |
115 | .max_x = 2240, | |
25cc2611 | 116 | .max_y = 1120, |
b61d43e6 HG |
117 | .res_x = 30, /* units/mm */ |
118 | .res_y = 27, /* units/mm */ | |
c81760b9 HG |
119 | .contact_size = 5, |
120 | .max_contacts = 5, | |
121 | }; | |
122 | ||
762f948c HG |
123 | static const struct asus_touchpad_info asus_t100ha_tp = { |
124 | .max_x = 2640, | |
125 | .max_y = 1320, | |
126 | .res_x = 30, /* units/mm */ | |
127 | .res_y = 29, /* units/mm */ | |
128 | .contact_size = 5, | |
129 | .max_contacts = 5, | |
130 | }; | |
131 | ||
dbd3ef28 HG |
132 | static const struct asus_touchpad_info asus_t200ta_tp = { |
133 | .max_x = 3120, | |
134 | .max_y = 1716, | |
135 | .res_x = 30, /* units/mm */ | |
136 | .res_y = 28, /* units/mm */ | |
137 | .contact_size = 5, | |
138 | .max_contacts = 5, | |
139 | }; | |
140 | ||
73c75d39 HG |
141 | static const struct asus_touchpad_info asus_t100chi_tp = { |
142 | .max_x = 2640, | |
143 | .max_y = 1320, | |
144 | .res_x = 31, /* units/mm */ | |
145 | .res_y = 29, /* units/mm */ | |
146 | .contact_size = 3, | |
147 | .max_contacts = 4, | |
148 | }; | |
149 | ||
c81760b9 | 150 | static void asus_report_contact_down(struct asus_drvdata *drvdat, |
9ce12d8b BM |
151 | int toolType, u8 *data) |
152 | { | |
c81760b9 HG |
153 | struct input_dev *input = drvdat->input; |
154 | int touch_major, pressure, x, y; | |
155 | ||
156 | x = (data[0] & CONTACT_X_MSB_MASK) << 4 | data[1]; | |
157 | y = drvdat->tp->max_y - ((data[0] & CONTACT_Y_MSB_MASK) << 8 | data[2]); | |
9ce12d8b | 158 | |
73c75d39 HG |
159 | input_report_abs(input, ABS_MT_POSITION_X, x); |
160 | input_report_abs(input, ABS_MT_POSITION_Y, y); | |
161 | ||
162 | if (drvdat->tp->contact_size < 5) | |
163 | return; | |
164 | ||
9ce12d8b BM |
165 | if (toolType == MT_TOOL_PALM) { |
166 | touch_major = MAX_TOUCH_MAJOR; | |
167 | pressure = MAX_PRESSURE; | |
168 | } else { | |
169 | touch_major = (data[3] >> 4) & CONTACT_TOUCH_MAJOR_MASK; | |
170 | pressure = data[4] & CONTACT_PRESSURE_MASK; | |
171 | } | |
172 | ||
9ce12d8b BM |
173 | input_report_abs(input, ABS_MT_TOUCH_MAJOR, touch_major); |
174 | input_report_abs(input, ABS_MT_PRESSURE, pressure); | |
175 | } | |
176 | ||
177 | /* Required for Synaptics Palm Detection */ | |
c81760b9 | 178 | static void asus_report_tool_width(struct asus_drvdata *drvdat) |
9ce12d8b | 179 | { |
c81760b9 | 180 | struct input_mt *mt = drvdat->input->mt; |
9ce12d8b BM |
181 | struct input_mt_slot *oldest; |
182 | int oldid, count, i; | |
183 | ||
73c75d39 HG |
184 | if (drvdat->tp->contact_size < 5) |
185 | return; | |
186 | ||
9ce12d8b BM |
187 | oldest = NULL; |
188 | oldid = mt->trkid; | |
189 | count = 0; | |
190 | ||
191 | for (i = 0; i < mt->num_slots; ++i) { | |
192 | struct input_mt_slot *ps = &mt->slots[i]; | |
193 | int id = input_mt_get_value(ps, ABS_MT_TRACKING_ID); | |
194 | ||
195 | if (id < 0) | |
196 | continue; | |
197 | if ((id - oldid) & TRKID_SGN) { | |
198 | oldest = ps; | |
199 | oldid = id; | |
200 | } | |
201 | count++; | |
202 | } | |
203 | ||
204 | if (oldest) { | |
c81760b9 | 205 | input_report_abs(drvdat->input, ABS_TOOL_WIDTH, |
9ce12d8b BM |
206 | input_mt_get_value(oldest, ABS_MT_TOUCH_MAJOR)); |
207 | } | |
208 | } | |
209 | ||
c81760b9 | 210 | static int asus_report_input(struct asus_drvdata *drvdat, u8 *data, int size) |
9ce12d8b | 211 | { |
73c75d39 | 212 | int i, toolType = MT_TOOL_FINGER; |
9ce12d8b BM |
213 | u8 *contactData = data + 2; |
214 | ||
c81760b9 HG |
215 | if (size != 3 + drvdat->tp->contact_size * drvdat->tp->max_contacts) |
216 | return 0; | |
217 | ||
218 | for (i = 0; i < drvdat->tp->max_contacts; i++) { | |
9ce12d8b | 219 | bool down = !!(data[1] & BIT(i+3)); |
73c75d39 HG |
220 | |
221 | if (drvdat->tp->contact_size >= 5) | |
222 | toolType = contactData[3] & CONTACT_TOOL_TYPE_MASK ? | |
9ce12d8b BM |
223 | MT_TOOL_PALM : MT_TOOL_FINGER; |
224 | ||
c81760b9 HG |
225 | input_mt_slot(drvdat->input, i); |
226 | input_mt_report_slot_state(drvdat->input, toolType, down); | |
9ce12d8b BM |
227 | |
228 | if (down) { | |
c81760b9 HG |
229 | asus_report_contact_down(drvdat, toolType, contactData); |
230 | contactData += drvdat->tp->contact_size; | |
9ce12d8b BM |
231 | } |
232 | } | |
233 | ||
c81760b9 HG |
234 | input_report_key(drvdat->input, BTN_LEFT, data[1] & BTN_LEFT_MASK); |
235 | asus_report_tool_width(drvdat); | |
236 | ||
237 | input_mt_sync_frame(drvdat->input); | |
238 | input_sync(drvdat->input); | |
9ce12d8b | 239 | |
c81760b9 | 240 | return 1; |
9ce12d8b BM |
241 | } |
242 | ||
243 | static int asus_raw_event(struct hid_device *hdev, | |
244 | struct hid_report *report, u8 *data, int size) | |
245 | { | |
246 | struct asus_drvdata *drvdata = hid_get_drvdata(hdev); | |
247 | ||
c81760b9 HG |
248 | if (drvdata->tp && data[0] == INPUT_REPORT_ID) |
249 | return asus_report_input(drvdata, data, size); | |
9ce12d8b BM |
250 | |
251 | return 0; | |
252 | } | |
253 | ||
af22a610 CC |
254 | static int asus_kbd_set_report(struct hid_device *hdev, u8 *buf, size_t buf_size) |
255 | { | |
256 | unsigned char *dmabuf; | |
257 | int ret; | |
258 | ||
259 | dmabuf = kmemdup(buf, buf_size, GFP_KERNEL); | |
260 | if (!dmabuf) | |
261 | return -ENOMEM; | |
262 | ||
263 | ret = hid_hw_raw_request(hdev, FEATURE_KBD_REPORT_ID, dmabuf, | |
264 | buf_size, HID_FEATURE_REPORT, | |
265 | HID_REQ_SET_REPORT); | |
266 | kfree(dmabuf); | |
267 | ||
268 | return ret; | |
269 | } | |
270 | ||
271 | static int asus_kbd_init(struct hid_device *hdev) | |
272 | { | |
273 | u8 buf[] = { FEATURE_KBD_REPORT_ID, 0x41, 0x53, 0x55, 0x53, 0x20, 0x54, | |
274 | 0x65, 0x63, 0x68, 0x2e, 0x49, 0x6e, 0x63, 0x2e, 0x00 }; | |
275 | int ret; | |
276 | ||
277 | ret = asus_kbd_set_report(hdev, buf, sizeof(buf)); | |
278 | if (ret < 0) | |
279 | hid_err(hdev, "Asus failed to send init command: %d\n", ret); | |
280 | ||
281 | return ret; | |
282 | } | |
283 | ||
284 | static int asus_kbd_get_functions(struct hid_device *hdev, | |
285 | unsigned char *kbd_func) | |
286 | { | |
287 | u8 buf[] = { FEATURE_KBD_REPORT_ID, 0x05, 0x20, 0x31, 0x00, 0x08 }; | |
288 | u8 *readbuf; | |
289 | int ret; | |
290 | ||
291 | ret = asus_kbd_set_report(hdev, buf, sizeof(buf)); | |
292 | if (ret < 0) { | |
293 | hid_err(hdev, "Asus failed to send configuration command: %d\n", ret); | |
294 | return ret; | |
295 | } | |
296 | ||
297 | readbuf = kzalloc(FEATURE_KBD_REPORT_SIZE, GFP_KERNEL); | |
298 | if (!readbuf) | |
299 | return -ENOMEM; | |
300 | ||
301 | ret = hid_hw_raw_request(hdev, FEATURE_KBD_REPORT_ID, readbuf, | |
302 | FEATURE_KBD_REPORT_SIZE, HID_FEATURE_REPORT, | |
303 | HID_REQ_GET_REPORT); | |
304 | if (ret < 0) { | |
305 | hid_err(hdev, "Asus failed to request functions: %d\n", ret); | |
306 | kfree(readbuf); | |
307 | return ret; | |
308 | } | |
309 | ||
310 | *kbd_func = readbuf[6]; | |
311 | ||
312 | kfree(readbuf); | |
313 | return ret; | |
314 | } | |
315 | ||
316 | static void asus_kbd_backlight_set(struct led_classdev *led_cdev, | |
317 | enum led_brightness brightness) | |
318 | { | |
319 | struct asus_kbd_leds *led = container_of(led_cdev, struct asus_kbd_leds, | |
320 | cdev); | |
321 | if (led->brightness == brightness) | |
322 | return; | |
323 | ||
324 | led->brightness = brightness; | |
325 | schedule_work(&led->work); | |
326 | } | |
327 | ||
328 | static enum led_brightness asus_kbd_backlight_get(struct led_classdev *led_cdev) | |
329 | { | |
330 | struct asus_kbd_leds *led = container_of(led_cdev, struct asus_kbd_leds, | |
331 | cdev); | |
332 | ||
333 | return led->brightness; | |
334 | } | |
335 | ||
336 | static void asus_kbd_backlight_work(struct work_struct *work) | |
337 | { | |
338 | struct asus_kbd_leds *led = container_of(work, struct asus_kbd_leds, work); | |
339 | u8 buf[] = { FEATURE_KBD_REPORT_ID, 0xba, 0xc5, 0xc4, 0x00 }; | |
340 | int ret; | |
341 | ||
342 | if (led->removed) | |
343 | return; | |
344 | ||
345 | buf[4] = led->brightness; | |
346 | ||
347 | ret = asus_kbd_set_report(led->hdev, buf, sizeof(buf)); | |
348 | if (ret < 0) | |
349 | hid_err(led->hdev, "Asus failed to set keyboard backlight: %d\n", ret); | |
350 | } | |
351 | ||
352 | static int asus_kbd_register_leds(struct hid_device *hdev) | |
353 | { | |
354 | struct asus_drvdata *drvdata = hid_get_drvdata(hdev); | |
355 | unsigned char kbd_func; | |
356 | int ret; | |
357 | ||
358 | /* Initialize keyboard */ | |
359 | ret = asus_kbd_init(hdev); | |
360 | if (ret < 0) | |
361 | return ret; | |
362 | ||
363 | /* Get keyboard functions */ | |
364 | ret = asus_kbd_get_functions(hdev, &kbd_func); | |
365 | if (ret < 0) | |
366 | return ret; | |
367 | ||
368 | /* Check for backlight support */ | |
369 | if (!(kbd_func & SUPPORT_KBD_BACKLIGHT)) | |
370 | return -ENODEV; | |
371 | ||
372 | drvdata->kbd_backlight = devm_kzalloc(&hdev->dev, | |
373 | sizeof(struct asus_kbd_leds), | |
374 | GFP_KERNEL); | |
375 | if (!drvdata->kbd_backlight) | |
376 | return -ENOMEM; | |
377 | ||
378 | drvdata->kbd_backlight->removed = false; | |
379 | drvdata->kbd_backlight->brightness = 0; | |
380 | drvdata->kbd_backlight->hdev = hdev; | |
381 | drvdata->kbd_backlight->cdev.name = "asus::kbd_backlight"; | |
382 | drvdata->kbd_backlight->cdev.max_brightness = 3; | |
383 | drvdata->kbd_backlight->cdev.brightness_set = asus_kbd_backlight_set; | |
384 | drvdata->kbd_backlight->cdev.brightness_get = asus_kbd_backlight_get; | |
385 | INIT_WORK(&drvdata->kbd_backlight->work, asus_kbd_backlight_work); | |
386 | ||
387 | ret = devm_led_classdev_register(&hdev->dev, &drvdata->kbd_backlight->cdev); | |
388 | if (ret < 0) { | |
389 | /* No need to have this still around */ | |
390 | devm_kfree(&hdev->dev, drvdata->kbd_backlight); | |
391 | } | |
392 | ||
393 | return ret; | |
394 | } | |
395 | ||
9ce12d8b BM |
396 | static int asus_input_configured(struct hid_device *hdev, struct hid_input *hi) |
397 | { | |
c8b1b3dd | 398 | struct input_dev *input = hi->input; |
9ce12d8b BM |
399 | struct asus_drvdata *drvdata = hid_get_drvdata(hdev); |
400 | ||
73c75d39 HG |
401 | /* T100CHI uses MULTI_INPUT, bind the touchpad to the mouse hid_input */ |
402 | if (drvdata->quirks & QUIRK_T100CHI && | |
403 | hi->report->id != T100CHI_MOUSE_REPORT_ID) | |
404 | return 0; | |
405 | ||
c81760b9 | 406 | if (drvdata->tp) { |
9ce12d8b | 407 | int ret; |
9ce12d8b | 408 | |
c81760b9 HG |
409 | input_set_abs_params(input, ABS_MT_POSITION_X, 0, |
410 | drvdata->tp->max_x, 0, 0); | |
411 | input_set_abs_params(input, ABS_MT_POSITION_Y, 0, | |
412 | drvdata->tp->max_y, 0, 0); | |
b61d43e6 HG |
413 | input_abs_set_res(input, ABS_MT_POSITION_X, drvdata->tp->res_x); |
414 | input_abs_set_res(input, ABS_MT_POSITION_Y, drvdata->tp->res_y); | |
73c75d39 HG |
415 | |
416 | if (drvdata->tp->contact_size >= 5) { | |
417 | input_set_abs_params(input, ABS_TOOL_WIDTH, 0, | |
418 | MAX_TOUCH_MAJOR, 0, 0); | |
419 | input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, | |
420 | MAX_TOUCH_MAJOR, 0, 0); | |
421 | input_set_abs_params(input, ABS_MT_PRESSURE, 0, | |
422 | MAX_PRESSURE, 0, 0); | |
423 | } | |
9ce12d8b BM |
424 | |
425 | __set_bit(BTN_LEFT, input->keybit); | |
426 | __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); | |
427 | ||
c81760b9 HG |
428 | ret = input_mt_init_slots(input, drvdata->tp->max_contacts, |
429 | INPUT_MT_POINTER); | |
9ce12d8b BM |
430 | |
431 | if (ret) { | |
432 | hid_err(hdev, "Asus input mt init slots failed: %d\n", ret); | |
433 | return ret; | |
434 | } | |
9ce12d8b BM |
435 | } |
436 | ||
c8b1b3dd BM |
437 | drvdata->input = input; |
438 | ||
af22a610 CC |
439 | if (drvdata->enable_backlight && asus_kbd_register_leds(hdev)) |
440 | hid_warn(hdev, "Failed to initialize backlight.\n"); | |
441 | ||
9ce12d8b BM |
442 | return 0; |
443 | } | |
444 | ||
a93913e1 | 445 | #define asus_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, \ |
1caccc25 | 446 | max, EV_KEY, (c)) |
9ce12d8b BM |
447 | static int asus_input_mapping(struct hid_device *hdev, |
448 | struct hid_input *hi, struct hid_field *field, | |
449 | struct hid_usage *usage, unsigned long **bit, | |
450 | int *max) | |
451 | { | |
452 | struct asus_drvdata *drvdata = hid_get_drvdata(hdev); | |
453 | ||
454 | if (drvdata->quirks & QUIRK_SKIP_INPUT_MAPPING) { | |
455 | /* Don't map anything from the HID report. | |
456 | * We do it all manually in asus_input_configured | |
457 | */ | |
458 | return -1; | |
459 | } | |
460 | ||
73c75d39 HG |
461 | /* |
462 | * Ignore a bunch of bogus collections in the T100CHI descriptor. | |
463 | * This avoids a bunch of non-functional hid_input devices getting | |
464 | * created because of the T100CHI using HID_QUIRK_MULTI_INPUT. | |
465 | */ | |
466 | if (drvdata->quirks & QUIRK_T100CHI) { | |
467 | if (field->application == (HID_UP_GENDESK | 0x0080) || | |
468 | usage->hid == (HID_UP_GENDEVCTRLS | 0x0024) || | |
469 | usage->hid == (HID_UP_GENDEVCTRLS | 0x0025) || | |
470 | usage->hid == (HID_UP_GENDEVCTRLS | 0x0026)) | |
471 | return -1; | |
472 | /* | |
473 | * We use the hid_input for the mouse report for the touchpad, | |
474 | * keep the left button, to avoid the core removing it. | |
475 | */ | |
476 | if (field->application == HID_GD_MOUSE && | |
477 | usage->hid != (HID_UP_BUTTON | 1)) | |
478 | return -1; | |
479 | } | |
480 | ||
a93913e1 | 481 | /* ASUS-specific keyboard hotkeys */ |
1caccc25 CC |
482 | if ((usage->hid & HID_USAGE_PAGE) == 0xff310000) { |
483 | set_bit(EV_REP, hi->input->evbit); | |
484 | switch (usage->hid & HID_USAGE) { | |
a93913e1 MH |
485 | case 0x10: asus_map_key_clear(KEY_BRIGHTNESSDOWN); break; |
486 | case 0x20: asus_map_key_clear(KEY_BRIGHTNESSUP); break; | |
487 | case 0x35: asus_map_key_clear(KEY_DISPLAY_OFF); break; | |
488 | case 0x6c: asus_map_key_clear(KEY_SLEEP); break; | |
489 | case 0x82: asus_map_key_clear(KEY_CAMERA); break; | |
802b24b4 | 490 | case 0x88: asus_map_key_clear(KEY_RFKILL); break; |
a93913e1 MH |
491 | case 0xb5: asus_map_key_clear(KEY_CALC); break; |
492 | case 0xc4: asus_map_key_clear(KEY_KBDILLUMUP); break; | |
493 | case 0xc5: asus_map_key_clear(KEY_KBDILLUMDOWN); break; | |
1caccc25 CC |
494 | |
495 | /* ASUS touchpad toggle */ | |
a93913e1 | 496 | case 0x6b: asus_map_key_clear(KEY_F21); break; |
1caccc25 CC |
497 | |
498 | /* ROG key */ | |
a93913e1 | 499 | case 0x38: asus_map_key_clear(KEY_PROG1); break; |
1caccc25 CC |
500 | |
501 | /* Fn+C ASUS Splendid */ | |
a93913e1 | 502 | case 0xba: asus_map_key_clear(KEY_PROG2); break; |
1caccc25 CC |
503 | |
504 | /* Fn+Space Power4Gear Hybrid */ | |
a93913e1 | 505 | case 0x5c: asus_map_key_clear(KEY_PROG3); break; |
1caccc25 CC |
506 | |
507 | default: | |
0485b1ec MH |
508 | /* ASUS lazily declares 256 usages, ignore the rest, |
509 | * as some make the keyboard appear as a pointer device. */ | |
510 | return -1; | |
1caccc25 | 511 | } |
af22a610 CC |
512 | |
513 | /* | |
514 | * Check and enable backlight only on devices with UsagePage == | |
515 | * 0xff31 to avoid initializing the keyboard firmware multiple | |
516 | * times on devices with multiple HID descriptors but same | |
517 | * PID/VID. | |
518 | */ | |
519 | if (drvdata->quirks & QUIRK_USE_KBD_BACKLIGHT) | |
520 | drvdata->enable_backlight = true; | |
521 | ||
1caccc25 CC |
522 | return 1; |
523 | } | |
524 | ||
5be91803 DD |
525 | if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) { |
526 | set_bit(EV_REP, hi->input->evbit); | |
527 | switch (usage->hid & HID_USAGE) { | |
528 | case 0xff01: asus_map_key_clear(BTN_1); break; | |
529 | case 0xff02: asus_map_key_clear(BTN_2); break; | |
530 | case 0xff03: asus_map_key_clear(BTN_3); break; | |
531 | case 0xff04: asus_map_key_clear(BTN_4); break; | |
532 | case 0xff05: asus_map_key_clear(BTN_5); break; | |
533 | case 0xff06: asus_map_key_clear(BTN_6); break; | |
534 | case 0xff07: asus_map_key_clear(BTN_7); break; | |
535 | case 0xff08: asus_map_key_clear(BTN_8); break; | |
536 | case 0xff09: asus_map_key_clear(BTN_9); break; | |
537 | case 0xff0a: asus_map_key_clear(BTN_A); break; | |
538 | case 0xff0b: asus_map_key_clear(BTN_B); break; | |
539 | case 0x00f1: asus_map_key_clear(KEY_WLAN); break; | |
540 | case 0x00f2: asus_map_key_clear(KEY_BRIGHTNESSDOWN); break; | |
541 | case 0x00f3: asus_map_key_clear(KEY_BRIGHTNESSUP); break; | |
542 | case 0x00f4: asus_map_key_clear(KEY_DISPLAY_OFF); break; | |
543 | case 0x00f7: asus_map_key_clear(KEY_CAMERA); break; | |
544 | case 0x00f8: asus_map_key_clear(KEY_PROG1); break; | |
545 | default: | |
546 | return 0; | |
547 | } | |
548 | ||
549 | return 1; | |
550 | } | |
551 | ||
0485b1ec MH |
552 | if (drvdata->quirks & QUIRK_NO_CONSUMER_USAGES && |
553 | (usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) { | |
554 | switch (usage->hid & HID_USAGE) { | |
555 | case 0xe2: /* Mute */ | |
556 | case 0xe9: /* Volume up */ | |
557 | case 0xea: /* Volume down */ | |
558 | return 0; | |
559 | default: | |
560 | /* Ignore dummy Consumer usages which make the | |
561 | * keyboard incorrectly appear as a pointer device. | |
562 | */ | |
563 | return -1; | |
564 | } | |
565 | } | |
566 | ||
9ce12d8b BM |
567 | return 0; |
568 | } | |
569 | ||
570 | static int asus_start_multitouch(struct hid_device *hdev) | |
571 | { | |
572 | int ret; | |
b9ec7009 CIK |
573 | static const unsigned char buf[] = { |
574 | FEATURE_REPORT_ID, 0x00, 0x03, 0x01, 0x00 | |
575 | }; | |
9ce12d8b BM |
576 | unsigned char *dmabuf = kmemdup(buf, sizeof(buf), GFP_KERNEL); |
577 | ||
578 | if (!dmabuf) { | |
579 | ret = -ENOMEM; | |
580 | hid_err(hdev, "Asus failed to alloc dma buf: %d\n", ret); | |
581 | return ret; | |
582 | } | |
583 | ||
584 | ret = hid_hw_raw_request(hdev, dmabuf[0], dmabuf, sizeof(buf), | |
585 | HID_FEATURE_REPORT, HID_REQ_SET_REPORT); | |
586 | ||
587 | kfree(dmabuf); | |
588 | ||
589 | if (ret != sizeof(buf)) { | |
590 | hid_err(hdev, "Asus failed to start multitouch: %d\n", ret); | |
591 | return ret; | |
592 | } | |
593 | ||
594 | return 0; | |
595 | } | |
596 | ||
597 | static int __maybe_unused asus_reset_resume(struct hid_device *hdev) | |
598 | { | |
599 | struct asus_drvdata *drvdata = hid_get_drvdata(hdev); | |
600 | ||
c81760b9 | 601 | if (drvdata->tp) |
9ce12d8b BM |
602 | return asus_start_multitouch(hdev); |
603 | ||
604 | return 0; | |
605 | } | |
606 | ||
607 | static int asus_probe(struct hid_device *hdev, const struct hid_device_id *id) | |
608 | { | |
609 | int ret; | |
610 | struct asus_drvdata *drvdata; | |
611 | ||
612 | drvdata = devm_kzalloc(&hdev->dev, sizeof(*drvdata), GFP_KERNEL); | |
613 | if (drvdata == NULL) { | |
614 | hid_err(hdev, "Can't alloc Asus descriptor\n"); | |
615 | return -ENOMEM; | |
616 | } | |
617 | ||
618 | hid_set_drvdata(hdev, drvdata); | |
619 | ||
620 | drvdata->quirks = id->driver_data; | |
621 | ||
c81760b9 HG |
622 | if (drvdata->quirks & QUIRK_IS_MULTITOUCH) |
623 | drvdata->tp = &asus_i2c_tp; | |
624 | ||
57573c54 HG |
625 | if (drvdata->quirks & QUIRK_T100_KEYBOARD) { |
626 | struct usb_interface *intf = to_usb_interface(hdev->dev.parent); | |
627 | ||
c81760b9 HG |
628 | if (intf->altsetting->desc.bInterfaceNumber == T100_TPAD_INTF) { |
629 | drvdata->quirks = QUIRK_SKIP_INPUT_MAPPING; | |
762f948c | 630 | /* |
dbd3ef28 HG |
631 | * The T100HA uses the same USB-ids as the T100TAF and |
632 | * the T200TA uses the same USB-ids as the T100TA, while | |
633 | * both have different max x/y values as the T100TA[F]. | |
762f948c HG |
634 | */ |
635 | if (dmi_match(DMI_PRODUCT_NAME, "T100HAN")) | |
636 | drvdata->tp = &asus_t100ha_tp; | |
dbd3ef28 HG |
637 | else if (dmi_match(DMI_PRODUCT_NAME, "T200TA")) |
638 | drvdata->tp = &asus_t200ta_tp; | |
762f948c HG |
639 | else |
640 | drvdata->tp = &asus_t100ta_tp; | |
c81760b9 | 641 | } |
57573c54 HG |
642 | } |
643 | ||
73c75d39 HG |
644 | if (drvdata->quirks & QUIRK_T100CHI) { |
645 | /* | |
646 | * All functionality is on a single HID interface and for | |
647 | * userspace the touchpad must be a separate input_dev. | |
648 | */ | |
39335d1c | 649 | hdev->quirks |= HID_QUIRK_MULTI_INPUT; |
73c75d39 HG |
650 | drvdata->tp = &asus_t100chi_tp; |
651 | } | |
652 | ||
9ce12d8b BM |
653 | if (drvdata->quirks & QUIRK_NO_INIT_REPORTS) |
654 | hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS; | |
655 | ||
656 | ret = hid_parse(hdev); | |
657 | if (ret) { | |
658 | hid_err(hdev, "Asus hid parse failed: %d\n", ret); | |
659 | return ret; | |
660 | } | |
661 | ||
662 | ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); | |
663 | if (ret) { | |
664 | hid_err(hdev, "Asus hw start failed: %d\n", ret); | |
665 | return ret; | |
666 | } | |
667 | ||
668 | if (!drvdata->input) { | |
669 | hid_err(hdev, "Asus input not registered\n"); | |
670 | ret = -ENOMEM; | |
671 | goto err_stop_hw; | |
672 | } | |
673 | ||
c81760b9 | 674 | if (drvdata->tp) { |
c8b1b3dd BM |
675 | drvdata->input->name = "Asus TouchPad"; |
676 | } else { | |
677 | drvdata->input->name = "Asus Keyboard"; | |
678 | } | |
9ce12d8b | 679 | |
c81760b9 | 680 | if (drvdata->tp) { |
9ce12d8b BM |
681 | ret = asus_start_multitouch(hdev); |
682 | if (ret) | |
683 | goto err_stop_hw; | |
684 | } | |
685 | ||
686 | return 0; | |
687 | err_stop_hw: | |
688 | hid_hw_stop(hdev); | |
689 | return ret; | |
690 | } | |
691 | ||
af22a610 CC |
692 | static void asus_remove(struct hid_device *hdev) |
693 | { | |
694 | struct asus_drvdata *drvdata = hid_get_drvdata(hdev); | |
695 | ||
696 | if (drvdata->kbd_backlight) { | |
697 | drvdata->kbd_backlight->removed = true; | |
698 | cancel_work_sync(&drvdata->kbd_backlight->work); | |
699 | } | |
715e944f CC |
700 | |
701 | hid_hw_stop(hdev); | |
af22a610 CC |
702 | } |
703 | ||
832e1eee MB |
704 | static const __u8 asus_g752_fixed_rdesc[] = { |
705 | 0x19, 0x00, /* Usage Minimum (0x00) */ | |
706 | 0x2A, 0xFF, 0x00, /* Usage Maximum (0xFF) */ | |
707 | }; | |
708 | ||
eeb01a57 YF |
709 | static __u8 *asus_report_fixup(struct hid_device *hdev, __u8 *rdesc, |
710 | unsigned int *rsize) | |
711 | { | |
9ce12d8b BM |
712 | struct asus_drvdata *drvdata = hid_get_drvdata(hdev); |
713 | ||
714 | if (drvdata->quirks & QUIRK_FIX_NOTEBOOK_REPORT && | |
715 | *rsize >= 56 && rdesc[54] == 0x25 && rdesc[55] == 0x65) { | |
b94f7d5d | 716 | hid_info(hdev, "Fixing up Asus notebook report descriptor\n"); |
eeb01a57 YF |
717 | rdesc[55] = 0xdd; |
718 | } | |
33edee4f | 719 | /* For the T100TA/T200TA keyboard dock */ |
76dd1fbe | 720 | if (drvdata->quirks & QUIRK_T100_KEYBOARD && |
33edee4f HG |
721 | (*rsize == 76 || *rsize == 101) && |
722 | rdesc[73] == 0x81 && rdesc[74] == 0x01) { | |
76dd1fbe HG |
723 | hid_info(hdev, "Fixing up Asus T100 keyb report descriptor\n"); |
724 | rdesc[74] &= ~HID_MAIN_ITEM_CONSTANT; | |
725 | } | |
5703e52c HG |
726 | /* For the T100CHI keyboard dock */ |
727 | if (drvdata->quirks & QUIRK_T100CHI && | |
728 | *rsize == 403 && rdesc[388] == 0x09 && rdesc[389] == 0x76) { | |
729 | /* | |
730 | * Change Usage (76h) to Usage Minimum (00h), Usage Maximum | |
731 | * (FFh) and clear the flags in the Input() byte. | |
732 | * Note the descriptor has a bogus 0 byte at the end so we | |
733 | * only need 1 extra byte. | |
734 | */ | |
735 | *rsize = 404; | |
736 | rdesc = kmemdup(rdesc, *rsize, GFP_KERNEL); | |
737 | if (!rdesc) | |
738 | return NULL; | |
739 | ||
740 | hid_info(hdev, "Fixing up T100CHI keyb report descriptor\n"); | |
741 | memmove(rdesc + 392, rdesc + 390, 12); | |
742 | rdesc[388] = 0x19; | |
743 | rdesc[389] = 0x00; | |
744 | rdesc[390] = 0x29; | |
745 | rdesc[391] = 0xff; | |
746 | rdesc[402] = 0x00; | |
747 | } | |
832e1eee MB |
748 | if (drvdata->quirks & QUIRK_G752_KEYBOARD && |
749 | *rsize == 75 && rdesc[61] == 0x15 && rdesc[62] == 0x00) { | |
750 | /* report is missing usage mninum and maximum */ | |
751 | __u8 *new_rdesc; | |
752 | size_t new_size = *rsize + sizeof(asus_g752_fixed_rdesc); | |
753 | ||
754 | new_rdesc = devm_kzalloc(&hdev->dev, new_size, GFP_KERNEL); | |
755 | if (new_rdesc == NULL) | |
756 | return rdesc; | |
757 | ||
758 | hid_info(hdev, "Fixing up Asus G752 keyb report descriptor\n"); | |
759 | /* copy the valid part */ | |
760 | memcpy(new_rdesc, rdesc, 61); | |
761 | /* insert missing part */ | |
762 | memcpy(new_rdesc + 61, asus_g752_fixed_rdesc, sizeof(asus_g752_fixed_rdesc)); | |
763 | /* copy remaining data */ | |
764 | memcpy(new_rdesc + 61 + sizeof(asus_g752_fixed_rdesc), rdesc + 61, *rsize - 61); | |
765 | ||
766 | *rsize = new_size; | |
767 | rdesc = new_rdesc; | |
768 | } | |
76dd1fbe | 769 | |
eeb01a57 YF |
770 | return rdesc; |
771 | } | |
772 | ||
773 | static const struct hid_device_id asus_devices[] = { | |
9ce12d8b | 774 | { HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, |
a93913e1 | 775 | USB_DEVICE_ID_ASUSTEK_I2C_KEYBOARD), I2C_KEYBOARD_QUIRKS}, |
9ce12d8b | 776 | { HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, |
c81760b9 | 777 | USB_DEVICE_ID_ASUSTEK_I2C_TOUCHPAD), I2C_TOUCHPAD_QUIRKS }, |
1caccc25 | 778 | { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, |
339ee3fc | 779 | USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD1), QUIRK_USE_KBD_BACKLIGHT }, |
1caccc25 | 780 | { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, |
af22a610 | 781 | USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD2), QUIRK_USE_KBD_BACKLIGHT }, |
832e1eee MB |
782 | { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, |
783 | USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD3), QUIRK_G752_KEYBOARD }, | |
76dd1fbe | 784 | { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, |
762f948c HG |
785 | USB_DEVICE_ID_ASUSTEK_T100TA_KEYBOARD), |
786 | QUIRK_T100_KEYBOARD | QUIRK_NO_CONSUMER_USAGES }, | |
787 | { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, | |
788 | USB_DEVICE_ID_ASUSTEK_T100TAF_KEYBOARD), | |
76dd1fbe | 789 | QUIRK_T100_KEYBOARD | QUIRK_NO_CONSUMER_USAGES }, |
5be91803 | 790 | { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_ASUS_AK1D) }, |
38b2d78c | 791 | { HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_ASUS_MD_5110) }, |
5be91803 | 792 | { HID_USB_DEVICE(USB_VENDOR_ID_JESS, USB_DEVICE_ID_ASUS_MD_5112) }, |
5703e52c HG |
793 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ASUSTEK, |
794 | USB_DEVICE_ID_ASUSTEK_T100CHI_KEYBOARD), QUIRK_T100CHI }, | |
795 | ||
eeb01a57 YF |
796 | { } |
797 | }; | |
798 | MODULE_DEVICE_TABLE(hid, asus_devices); | |
799 | ||
800 | static struct hid_driver asus_driver = { | |
9ce12d8b BM |
801 | .name = "asus", |
802 | .id_table = asus_devices, | |
803 | .report_fixup = asus_report_fixup, | |
804 | .probe = asus_probe, | |
af22a610 | 805 | .remove = asus_remove, |
9ce12d8b BM |
806 | .input_mapping = asus_input_mapping, |
807 | .input_configured = asus_input_configured, | |
808 | #ifdef CONFIG_PM | |
809 | .reset_resume = asus_reset_resume, | |
810 | #endif | |
811 | .raw_event = asus_raw_event | |
eeb01a57 YF |
812 | }; |
813 | module_hid_driver(asus_driver); | |
814 | ||
815 | MODULE_LICENSE("GPL"); |