1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * HID driver for Lenovo: |
4 | * - ThinkPad USB Keyboard with TrackPoint (tpkbd) |
5 | * - ThinkPad Compact Bluetooth Keyboard with TrackPoint (cptkbd) |
6 | * - ThinkPad Compact USB Keyboard with TrackPoint (cptkbd) |
7 | * - ThinkPad TrackPoint Keyboard II USB/Bluetooth (cptkbd/tpIIkbd) |
8 | * |
9 | * Copyright (c) 2012 Bernhard Seibold |
10 | * Copyright (c) 2014 Jamie Lentin <jm@lentin.co.uk> |
11 | * |
12 | * Linux IBM/Lenovo Scrollpoint mouse driver: |
13 | * - IBM Scrollpoint III |
14 | * - IBM Scrollpoint Pro |
15 | * - IBM Scrollpoint Optical |
16 | * - IBM Scrollpoint Optical 800dpi |
17 | * - IBM Scrollpoint Optical 800dpi Pro |
18 | * - Lenovo Scrollpoint Optical |
19 | * |
20 | * Copyright (c) 2012 Peter De Wachter <pdewacht@gmail.com> |
21 | * Copyright (c) 2018 Peter Ganzhorn <peter.ganzhorn@gmail.com> |
22 | */ |
23 | |
24 | /* |
25 | */ |
26 | |
27 | #include <linux/module.h> |
28 | #include <linux/sysfs.h> |
29 | #include <linux/device.h> |
30 | #include <linux/hid.h> |
31 | #include <linux/input.h> |
32 | #include <linux/leds.h> |
33 | #include <linux/workqueue.h> |
34 | |
35 | #include "hid-ids.h" |
36 | |
37 | /* Userspace expects F20 for mic-mute KEY_MICMUTE does not work */ |
38 | #define LENOVO_KEY_MICMUTE KEY_F20 |
39 | |
40 | struct lenovo_drvdata { |
41 | u8 led_report[3]; /* Must be first for proper alignment */ |
42 | int led_state; |
43 | struct mutex led_report_mutex; |
44 | struct led_classdev led_mute; |
45 | struct led_classdev led_micmute; |
46 | struct work_struct fn_lock_sync_work; |
47 | struct hid_device *hdev; |
48 | int press_to_select; |
49 | int dragging; |
50 | int release_to_select; |
51 | int select_right; |
52 | int sensitivity; |
53 | int press_speed; |
54 | /* 0: Up |
55 | * 1: Down (undecided) |
56 | * 2: Scrolling |
57 | * 3: Patched firmware, disable workaround |
58 | */ |
59 | u8 middlebutton_state; |
60 | bool fn_lock; |
61 | }; |
62 | |
63 | #define map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, EV_KEY, (c)) |
64 | |
65 | #define TP10UBKBD_LED_OUTPUT_REPORT 9 |
66 | |
67 | #define TP10UBKBD_FN_LOCK_LED 0x54 |
68 | #define TP10UBKBD_MUTE_LED 0x64 |
69 | #define TP10UBKBD_MICMUTE_LED 0x74 |
70 | |
71 | #define TP10UBKBD_LED_OFF 1 |
72 | #define TP10UBKBD_LED_ON 2 |
73 | |
74 | static int lenovo_led_set_tp10ubkbd(struct hid_device *hdev, u8 led_code, |
75 | enum led_brightness value) |
76 | { |
77 | struct lenovo_drvdata *data = hid_get_drvdata(hdev); |
78 | int ret; |
79 | |
80 | mutex_lock(&data->led_report_mutex); |
81 | |
82 | data->led_report[0] = TP10UBKBD_LED_OUTPUT_REPORT; |
83 | data->led_report[1] = led_code; |
84 | data->led_report[2] = value ? TP10UBKBD_LED_ON : TP10UBKBD_LED_OFF; |
85 | ret = hid_hw_raw_request(hdev, reportnum: data->led_report[0], buf: data->led_report, len: 3, |
86 | rtype: HID_OUTPUT_REPORT, reqtype: HID_REQ_SET_REPORT); |
87 | if (ret != 3) { |
88 | if (ret != -ENODEV) |
89 | hid_err(hdev, "Set LED output report error: %d\n" , ret); |
90 | |
91 | ret = ret < 0 ? ret : -EIO; |
92 | } else { |
93 | ret = 0; |
94 | } |
95 | |
96 | mutex_unlock(lock: &data->led_report_mutex); |
97 | |
98 | return ret; |
99 | } |
100 | |
101 | static void lenovo_tp10ubkbd_sync_fn_lock(struct work_struct *work) |
102 | { |
103 | struct lenovo_drvdata *data = |
104 | container_of(work, struct lenovo_drvdata, fn_lock_sync_work); |
105 | |
106 | lenovo_led_set_tp10ubkbd(hdev: data->hdev, TP10UBKBD_FN_LOCK_LED, |
107 | value: data->fn_lock); |
108 | } |
109 | |
110 | static const __u8 lenovo_pro_dock_need_fixup_collection[] = { |
111 | 0x05, 0x88, /* Usage Page (Vendor Usage Page 0x88) */ |
112 | 0x09, 0x01, /* Usage (Vendor Usage 0x01) */ |
113 | 0xa1, 0x01, /* Collection (Application) */ |
114 | 0x85, 0x04, /* Report ID (4) */ |
115 | 0x19, 0x00, /* Usage Minimum (0) */ |
116 | 0x2a, 0xff, 0xff, /* Usage Maximum (65535) */ |
117 | }; |
118 | |
119 | /* Broken ThinkPad TrackPoint II collection (Bluetooth mode) */ |
120 | static const __u8 lenovo_tpIIbtkbd_need_fixup_collection[] = { |
121 | 0x06, 0x00, 0xFF, /* Usage Page (Vendor Defined 0xFF00) */ |
122 | 0x09, 0x01, /* Usage (0x01) */ |
123 | 0xA1, 0x01, /* Collection (Application) */ |
124 | 0x85, 0x05, /* Report ID (5) */ |
125 | 0x1A, 0xF1, 0x00, /* Usage Minimum (0xF1) */ |
126 | 0x2A, 0xFC, 0x00, /* Usage Maximum (0xFC) */ |
127 | 0x15, 0x00, /* Logical Minimum (0) */ |
128 | 0x25, 0x01, /* Logical Maximum (1) */ |
129 | 0x75, 0x01, /* Report Size (1) */ |
130 | 0x95, 0x0D, /* Report Count (13) */ |
131 | 0x81, 0x02, /* Input (Data,Var,Abs,No Wrap,Linear,Preferred State,No Null Position) */ |
132 | 0x95, 0x03, /* Report Count (3) */ |
133 | 0x81, 0x01, /* Input (Const,Array,Abs,No Wrap,Linear,Preferred State,No Null Position) */ |
134 | }; |
135 | |
136 | static __u8 *lenovo_report_fixup(struct hid_device *hdev, __u8 *rdesc, |
137 | unsigned int *rsize) |
138 | { |
139 | switch (hdev->product) { |
140 | case USB_DEVICE_ID_LENOVO_TPPRODOCK: |
141 | /* the fixups that need to be done: |
142 | * - get a reasonable usage max for the vendor collection |
143 | * 0x8801 from the report ID 4 |
144 | */ |
145 | if (*rsize >= 153 && |
146 | memcmp(p: &rdesc[140], q: lenovo_pro_dock_need_fixup_collection, |
147 | size: sizeof(lenovo_pro_dock_need_fixup_collection)) == 0) { |
148 | rdesc[151] = 0x01; |
149 | rdesc[152] = 0x00; |
150 | } |
151 | break; |
152 | case USB_DEVICE_ID_LENOVO_TPIIBTKBD: |
153 | if (*rsize >= 263 && |
154 | memcmp(p: &rdesc[234], q: lenovo_tpIIbtkbd_need_fixup_collection, |
155 | size: sizeof(lenovo_tpIIbtkbd_need_fixup_collection)) == 0) { |
156 | rdesc[244] = 0x00; /* usage minimum = 0x00 */ |
157 | rdesc[247] = 0xff; /* usage maximum = 0xff */ |
158 | rdesc[252] = 0xff; /* logical maximum = 0xff */ |
159 | rdesc[254] = 0x08; /* report size = 0x08 */ |
160 | rdesc[256] = 0x01; /* report count = 0x01 */ |
161 | rdesc[258] = 0x00; /* input = 0x00 */ |
162 | rdesc[260] = 0x01; /* report count (2) = 0x01 */ |
163 | } |
164 | break; |
165 | } |
166 | return rdesc; |
167 | } |
168 | |
169 | static int lenovo_input_mapping_tpkbd(struct hid_device *hdev, |
170 | struct hid_input *hi, struct hid_field *field, |
171 | struct hid_usage *usage, unsigned long **bit, int *max) |
172 | { |
173 | if (usage->hid == (HID_UP_BUTTON | 0x0010)) { |
174 | /* This sub-device contains trackpoint, mark it */ |
175 | hid_set_drvdata(hdev, data: (void *)1); |
176 | map_key_clear(LENOVO_KEY_MICMUTE); |
177 | return 1; |
178 | } |
179 | return 0; |
180 | } |
181 | |
182 | static int lenovo_input_mapping_cptkbd(struct hid_device *hdev, |
183 | struct hid_input *hi, struct hid_field *field, |
184 | struct hid_usage *usage, unsigned long **bit, int *max) |
185 | { |
186 | /* HID_UP_LNVENDOR = USB, HID_UP_MSVENDOR = BT */ |
187 | if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR || |
188 | (usage->hid & HID_USAGE_PAGE) == HID_UP_LNVENDOR) { |
189 | switch (usage->hid & HID_USAGE) { |
190 | case 0x00f1: /* Fn-F4: Mic mute */ |
191 | map_key_clear(LENOVO_KEY_MICMUTE); |
192 | return 1; |
193 | case 0x00f2: /* Fn-F5: Brightness down */ |
194 | map_key_clear(KEY_BRIGHTNESSDOWN); |
195 | return 1; |
196 | case 0x00f3: /* Fn-F6: Brightness up */ |
197 | map_key_clear(KEY_BRIGHTNESSUP); |
198 | return 1; |
199 | case 0x00f4: /* Fn-F7: External display (projector) */ |
200 | map_key_clear(KEY_SWITCHVIDEOMODE); |
201 | return 1; |
202 | case 0x00f5: /* Fn-F8: Wireless */ |
203 | map_key_clear(KEY_WLAN); |
204 | return 1; |
205 | case 0x00f6: /* Fn-F9: Control panel */ |
206 | map_key_clear(KEY_CONFIG); |
207 | return 1; |
208 | case 0x00f8: /* Fn-F11: View open applications (3 boxes) */ |
209 | map_key_clear(KEY_SCALE); |
210 | return 1; |
211 | case 0x00f9: /* Fn-F12: Open My computer (6 boxes) USB-only */ |
212 | /* NB: This mapping is invented in raw_event below */ |
213 | map_key_clear(KEY_FILE); |
214 | return 1; |
215 | case 0x00fa: /* Fn-Esc: Fn-lock toggle */ |
216 | map_key_clear(KEY_FN_ESC); |
217 | return 1; |
218 | case 0x00fb: /* Middle mouse button (in native mode) */ |
219 | map_key_clear(BTN_MIDDLE); |
220 | return 1; |
221 | } |
222 | } |
223 | |
224 | /* Compatibility middle/wheel mappings should be ignored */ |
225 | if (usage->hid == HID_GD_WHEEL) |
226 | return -1; |
227 | if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON && |
228 | (usage->hid & HID_USAGE) == 0x003) |
229 | return -1; |
230 | if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER && |
231 | (usage->hid & HID_USAGE) == 0x238) |
232 | return -1; |
233 | |
234 | /* Map wheel emulation reports: 0xffa1 = USB, 0xff10 = BT */ |
235 | if ((usage->hid & HID_USAGE_PAGE) == 0xff100000 || |
236 | (usage->hid & HID_USAGE_PAGE) == 0xffa10000) { |
237 | field->flags |= HID_MAIN_ITEM_RELATIVE | HID_MAIN_ITEM_VARIABLE; |
238 | field->logical_minimum = -127; |
239 | field->logical_maximum = 127; |
240 | |
241 | switch (usage->hid & HID_USAGE) { |
242 | case 0x0000: |
243 | hid_map_usage(hidinput: hi, usage, bit, max, EV_REL, REL_HWHEEL); |
244 | return 1; |
245 | case 0x0001: |
246 | hid_map_usage(hidinput: hi, usage, bit, max, EV_REL, REL_WHEEL); |
247 | return 1; |
248 | default: |
249 | return -1; |
250 | } |
251 | } |
252 | |
253 | return 0; |
254 | } |
255 | |
256 | static int lenovo_input_mapping_tpIIkbd(struct hid_device *hdev, |
257 | struct hid_input *hi, struct hid_field *field, |
258 | struct hid_usage *usage, unsigned long **bit, int *max) |
259 | { |
260 | /* |
261 | * 0xff0a0000 = USB, HID_UP_MSVENDOR = BT. |
262 | * |
263 | * In BT mode, there are two HID_UP_MSVENDOR pages. |
264 | * Use only the page that contains report ID == 5. |
265 | */ |
266 | if (((usage->hid & HID_USAGE_PAGE) == 0xff0a0000 || |
267 | (usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) && |
268 | field->report->id == 5) { |
269 | switch (usage->hid & HID_USAGE) { |
270 | case 0x00bb: /* Fn-F4: Mic mute */ |
271 | map_key_clear(LENOVO_KEY_MICMUTE); |
272 | return 1; |
273 | case 0x00c3: /* Fn-F5: Brightness down */ |
274 | map_key_clear(KEY_BRIGHTNESSDOWN); |
275 | return 1; |
276 | case 0x00c4: /* Fn-F6: Brightness up */ |
277 | map_key_clear(KEY_BRIGHTNESSUP); |
278 | return 1; |
279 | case 0x00c1: /* Fn-F8: Notification center */ |
280 | map_key_clear(KEY_NOTIFICATION_CENTER); |
281 | return 1; |
282 | case 0x00bc: /* Fn-F9: Control panel */ |
283 | map_key_clear(KEY_CONFIG); |
284 | return 1; |
285 | case 0x00b6: /* Fn-F10: Bluetooth */ |
286 | map_key_clear(KEY_BLUETOOTH); |
287 | return 1; |
288 | case 0x00b7: /* Fn-F11: Keyboard config */ |
289 | map_key_clear(KEY_KEYBOARD); |
290 | return 1; |
291 | case 0x00b8: /* Fn-F12: User function */ |
292 | map_key_clear(KEY_PROG1); |
293 | return 1; |
294 | case 0x00b9: /* Fn-PrtSc: Snipping tool */ |
295 | map_key_clear(KEY_SELECTIVE_SCREENSHOT); |
296 | return 1; |
297 | case 0x00b5: /* Fn-Esc: Fn-lock toggle */ |
298 | map_key_clear(KEY_FN_ESC); |
299 | return 1; |
300 | } |
301 | } |
302 | |
303 | if ((usage->hid & HID_USAGE_PAGE) == 0xffa00000) { |
304 | switch (usage->hid & HID_USAGE) { |
305 | case 0x00fb: /* Middle mouse (in native USB mode) */ |
306 | map_key_clear(BTN_MIDDLE); |
307 | return 1; |
308 | } |
309 | } |
310 | |
311 | if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR && |
312 | field->report->id == 21) { |
313 | switch (usage->hid & HID_USAGE) { |
314 | case 0x0004: /* Middle mouse (in native Bluetooth mode) */ |
315 | map_key_clear(BTN_MIDDLE); |
316 | return 1; |
317 | } |
318 | } |
319 | |
320 | /* Compatibility middle/wheel mappings should be ignored */ |
321 | if (usage->hid == HID_GD_WHEEL) |
322 | return -1; |
323 | if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON && |
324 | (usage->hid & HID_USAGE) == 0x003) |
325 | return -1; |
326 | if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER && |
327 | (usage->hid & HID_USAGE) == 0x238) |
328 | return -1; |
329 | |
330 | /* Map wheel emulation reports: 0xff10 */ |
331 | if ((usage->hid & HID_USAGE_PAGE) == 0xff100000) { |
332 | field->flags |= HID_MAIN_ITEM_RELATIVE | HID_MAIN_ITEM_VARIABLE; |
333 | field->logical_minimum = -127; |
334 | field->logical_maximum = 127; |
335 | |
336 | switch (usage->hid & HID_USAGE) { |
337 | case 0x0000: |
338 | hid_map_usage(hidinput: hi, usage, bit, max, EV_REL, REL_HWHEEL); |
339 | return 1; |
340 | case 0x0001: |
341 | hid_map_usage(hidinput: hi, usage, bit, max, EV_REL, REL_WHEEL); |
342 | return 1; |
343 | default: |
344 | return -1; |
345 | } |
346 | } |
347 | |
348 | return 0; |
349 | } |
350 | |
351 | static int lenovo_input_mapping_scrollpoint(struct hid_device *hdev, |
352 | struct hid_input *hi, struct hid_field *field, |
353 | struct hid_usage *usage, unsigned long **bit, int *max) |
354 | { |
355 | if (usage->hid == HID_GD_Z) { |
356 | hid_map_usage(hidinput: hi, usage, bit, max, EV_REL, REL_HWHEEL); |
357 | return 1; |
358 | } |
359 | return 0; |
360 | } |
361 | |
362 | static int lenovo_input_mapping_tp10_ultrabook_kbd(struct hid_device *hdev, |
363 | struct hid_input *hi, struct hid_field *field, |
364 | struct hid_usage *usage, unsigned long **bit, int *max) |
365 | { |
366 | /* |
367 | * The ThinkPad 10 Ultrabook Keyboard uses 0x000c0001 usage for |
368 | * a bunch of keys which have no standard consumer page code. |
369 | */ |
370 | if (usage->hid == 0x000c0001) { |
371 | switch (usage->usage_index) { |
372 | case 8: /* Fn-Esc: Fn-lock toggle */ |
373 | map_key_clear(KEY_FN_ESC); |
374 | return 1; |
375 | case 9: /* Fn-F4: Mic mute */ |
376 | map_key_clear(LENOVO_KEY_MICMUTE); |
377 | return 1; |
378 | case 10: /* Fn-F7: Control panel */ |
379 | map_key_clear(KEY_CONFIG); |
380 | return 1; |
381 | case 11: /* Fn-F8: Search (magnifier glass) */ |
382 | map_key_clear(KEY_SEARCH); |
383 | return 1; |
384 | case 12: /* Fn-F10: Open My computer (6 boxes) */ |
385 | map_key_clear(KEY_FILE); |
386 | return 1; |
387 | } |
388 | } |
389 | |
390 | /* |
391 | * The Ultrabook Keyboard sends a spurious F23 key-press when resuming |
392 | * from suspend and it does not actually have a F23 key, ignore it. |
393 | */ |
394 | if (usage->hid == 0x00070072) |
395 | return -1; |
396 | |
397 | return 0; |
398 | } |
399 | |
400 | static int lenovo_input_mapping_x1_tab_kbd(struct hid_device *hdev, |
401 | struct hid_input *hi, struct hid_field *field, |
402 | struct hid_usage *usage, unsigned long **bit, int *max) |
403 | { |
404 | /* |
405 | * The ThinkPad X1 Tablet Thin Keyboard uses 0x000c0001 usage for |
406 | * a bunch of keys which have no standard consumer page code. |
407 | */ |
408 | if (usage->hid == 0x000c0001) { |
409 | switch (usage->usage_index) { |
410 | case 0: /* Fn-F10: Enable/disable bluetooth */ |
411 | map_key_clear(KEY_BLUETOOTH); |
412 | return 1; |
413 | case 1: /* Fn-F11: Keyboard settings */ |
414 | map_key_clear(KEY_KEYBOARD); |
415 | return 1; |
416 | case 2: /* Fn-F12: User function / Cortana */ |
417 | map_key_clear(KEY_MACRO1); |
418 | return 1; |
419 | case 3: /* Fn-PrtSc: Snipping tool */ |
420 | map_key_clear(KEY_SELECTIVE_SCREENSHOT); |
421 | return 1; |
422 | case 8: /* Fn-Esc: Fn-lock toggle */ |
423 | map_key_clear(KEY_FN_ESC); |
424 | return 1; |
425 | case 9: /* Fn-F4: Mute/unmute microphone */ |
426 | map_key_clear(KEY_MICMUTE); |
427 | return 1; |
428 | case 10: /* Fn-F9: Settings */ |
429 | map_key_clear(KEY_CONFIG); |
430 | return 1; |
431 | case 13: /* Fn-F7: Manage external displays */ |
432 | map_key_clear(KEY_SWITCHVIDEOMODE); |
433 | return 1; |
434 | case 14: /* Fn-F8: Enable/disable wifi */ |
435 | map_key_clear(KEY_WLAN); |
436 | return 1; |
437 | } |
438 | } |
439 | |
440 | if (usage->hid == (HID_UP_KEYBOARD | 0x009a)) { |
441 | map_key_clear(KEY_SYSRQ); |
442 | return 1; |
443 | } |
444 | |
445 | return 0; |
446 | } |
447 | |
448 | static int lenovo_input_mapping(struct hid_device *hdev, |
449 | struct hid_input *hi, struct hid_field *field, |
450 | struct hid_usage *usage, unsigned long **bit, int *max) |
451 | { |
452 | switch (hdev->product) { |
453 | case USB_DEVICE_ID_LENOVO_TPKBD: |
454 | return lenovo_input_mapping_tpkbd(hdev, hi, field, |
455 | usage, bit, max); |
456 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
457 | case USB_DEVICE_ID_LENOVO_CBTKBD: |
458 | return lenovo_input_mapping_cptkbd(hdev, hi, field, |
459 | usage, bit, max); |
460 | case USB_DEVICE_ID_LENOVO_TPIIUSBKBD: |
461 | case USB_DEVICE_ID_LENOVO_TPIIBTKBD: |
462 | return lenovo_input_mapping_tpIIkbd(hdev, hi, field, |
463 | usage, bit, max); |
464 | case USB_DEVICE_ID_IBM_SCROLLPOINT_III: |
465 | case USB_DEVICE_ID_IBM_SCROLLPOINT_PRO: |
466 | case USB_DEVICE_ID_IBM_SCROLLPOINT_OPTICAL: |
467 | case USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL: |
468 | case USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL_PRO: |
469 | case USB_DEVICE_ID_LENOVO_SCROLLPOINT_OPTICAL: |
470 | return lenovo_input_mapping_scrollpoint(hdev, hi, field, |
471 | usage, bit, max); |
472 | case USB_DEVICE_ID_LENOVO_TP10UBKBD: |
473 | return lenovo_input_mapping_tp10_ultrabook_kbd(hdev, hi, field, |
474 | usage, bit, max); |
475 | case USB_DEVICE_ID_LENOVO_X1_TAB: |
476 | return lenovo_input_mapping_x1_tab_kbd(hdev, hi, field, usage, bit, max); |
477 | default: |
478 | return 0; |
479 | } |
480 | } |
481 | |
482 | #undef map_key_clear |
483 | |
484 | /* Send a config command to the keyboard */ |
485 | static int lenovo_send_cmd_cptkbd(struct hid_device *hdev, |
486 | unsigned char byte2, unsigned char byte3) |
487 | { |
488 | int ret; |
489 | unsigned char *buf; |
490 | |
491 | buf = kzalloc(size: 3, GFP_KERNEL); |
492 | if (!buf) |
493 | return -ENOMEM; |
494 | |
495 | /* |
496 | * Feature report 0x13 is used for USB, |
497 | * output report 0x18 is used for Bluetooth. |
498 | * buf[0] is ignored by hid_hw_raw_request. |
499 | */ |
500 | buf[0] = 0x18; |
501 | buf[1] = byte2; |
502 | buf[2] = byte3; |
503 | |
504 | switch (hdev->product) { |
505 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
506 | case USB_DEVICE_ID_LENOVO_TPIIUSBKBD: |
507 | ret = hid_hw_raw_request(hdev, reportnum: 0x13, buf, len: 3, |
508 | rtype: HID_FEATURE_REPORT, reqtype: HID_REQ_SET_REPORT); |
509 | break; |
510 | case USB_DEVICE_ID_LENOVO_CBTKBD: |
511 | case USB_DEVICE_ID_LENOVO_TPIIBTKBD: |
512 | ret = hid_hw_output_report(hdev, buf, len: 3); |
513 | break; |
514 | default: |
515 | ret = -EINVAL; |
516 | break; |
517 | } |
518 | |
519 | kfree(objp: buf); |
520 | |
521 | return ret < 0 ? ret : 0; /* BT returns 0, USB returns sizeof(buf) */ |
522 | } |
523 | |
524 | static void lenovo_features_set_cptkbd(struct hid_device *hdev) |
525 | { |
526 | int ret; |
527 | struct lenovo_drvdata *cptkbd_data = hid_get_drvdata(hdev); |
528 | |
529 | /* |
530 | * Tell the keyboard a driver understands it, and turn F7, F9, F11 into |
531 | * regular keys |
532 | */ |
533 | ret = lenovo_send_cmd_cptkbd(hdev, byte2: 0x01, byte3: 0x03); |
534 | if (ret) |
535 | hid_warn(hdev, "Failed to switch F7/9/11 mode: %d\n" , ret); |
536 | |
537 | /* Switch middle button to native mode */ |
538 | ret = lenovo_send_cmd_cptkbd(hdev, byte2: 0x09, byte3: 0x01); |
539 | if (ret) |
540 | hid_warn(hdev, "Failed to switch middle button: %d\n" , ret); |
541 | |
542 | ret = lenovo_send_cmd_cptkbd(hdev, byte2: 0x05, byte3: cptkbd_data->fn_lock); |
543 | if (ret) |
544 | hid_err(hdev, "Fn-lock setting failed: %d\n" , ret); |
545 | |
546 | ret = lenovo_send_cmd_cptkbd(hdev, byte2: 0x02, byte3: cptkbd_data->sensitivity); |
547 | if (ret) |
548 | hid_err(hdev, "Sensitivity setting failed: %d\n" , ret); |
549 | } |
550 | |
551 | static ssize_t attr_fn_lock_show(struct device *dev, |
552 | struct device_attribute *attr, |
553 | char *buf) |
554 | { |
555 | struct hid_device *hdev = to_hid_device(dev); |
556 | struct lenovo_drvdata *data = hid_get_drvdata(hdev); |
557 | |
558 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , data->fn_lock); |
559 | } |
560 | |
561 | static ssize_t attr_fn_lock_store(struct device *dev, |
562 | struct device_attribute *attr, |
563 | const char *buf, |
564 | size_t count) |
565 | { |
566 | struct hid_device *hdev = to_hid_device(dev); |
567 | struct lenovo_drvdata *data = hid_get_drvdata(hdev); |
568 | int value, ret; |
569 | |
570 | if (kstrtoint(s: buf, base: 10, res: &value)) |
571 | return -EINVAL; |
572 | if (value < 0 || value > 1) |
573 | return -EINVAL; |
574 | |
575 | data->fn_lock = !!value; |
576 | |
577 | switch (hdev->product) { |
578 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
579 | case USB_DEVICE_ID_LENOVO_CBTKBD: |
580 | case USB_DEVICE_ID_LENOVO_TPIIUSBKBD: |
581 | case USB_DEVICE_ID_LENOVO_TPIIBTKBD: |
582 | lenovo_features_set_cptkbd(hdev); |
583 | break; |
584 | case USB_DEVICE_ID_LENOVO_TP10UBKBD: |
585 | case USB_DEVICE_ID_LENOVO_X1_TAB: |
586 | ret = lenovo_led_set_tp10ubkbd(hdev, TP10UBKBD_FN_LOCK_LED, value); |
587 | if (ret) |
588 | return ret; |
589 | break; |
590 | } |
591 | |
592 | return count; |
593 | } |
594 | |
595 | static ssize_t attr_sensitivity_show_cptkbd(struct device *dev, |
596 | struct device_attribute *attr, |
597 | char *buf) |
598 | { |
599 | struct hid_device *hdev = to_hid_device(dev); |
600 | struct lenovo_drvdata *cptkbd_data = hid_get_drvdata(hdev); |
601 | |
602 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , |
603 | cptkbd_data->sensitivity); |
604 | } |
605 | |
606 | static ssize_t attr_sensitivity_store_cptkbd(struct device *dev, |
607 | struct device_attribute *attr, |
608 | const char *buf, |
609 | size_t count) |
610 | { |
611 | struct hid_device *hdev = to_hid_device(dev); |
612 | struct lenovo_drvdata *cptkbd_data = hid_get_drvdata(hdev); |
613 | int value; |
614 | |
615 | if (kstrtoint(s: buf, base: 10, res: &value) || value < 1 || value > 255) |
616 | return -EINVAL; |
617 | |
618 | cptkbd_data->sensitivity = value; |
619 | lenovo_features_set_cptkbd(hdev); |
620 | |
621 | return count; |
622 | } |
623 | |
624 | |
625 | static struct device_attribute dev_attr_fn_lock = |
626 | __ATTR(fn_lock, S_IWUSR | S_IRUGO, |
627 | attr_fn_lock_show, |
628 | attr_fn_lock_store); |
629 | |
630 | static struct device_attribute dev_attr_sensitivity_cptkbd = |
631 | __ATTR(sensitivity, S_IWUSR | S_IRUGO, |
632 | attr_sensitivity_show_cptkbd, |
633 | attr_sensitivity_store_cptkbd); |
634 | |
635 | |
636 | static struct attribute *lenovo_attributes_cptkbd[] = { |
637 | &dev_attr_fn_lock.attr, |
638 | &dev_attr_sensitivity_cptkbd.attr, |
639 | NULL |
640 | }; |
641 | |
642 | static const struct attribute_group lenovo_attr_group_cptkbd = { |
643 | .attrs = lenovo_attributes_cptkbd, |
644 | }; |
645 | |
646 | static int lenovo_raw_event(struct hid_device *hdev, |
647 | struct hid_report *report, u8 *data, int size) |
648 | { |
649 | /* |
650 | * Compact USB keyboard's Fn-F12 report holds down many other keys, and |
651 | * its own key is outside the usage page range. Remove extra |
652 | * keypresses and remap to inside usage page. |
653 | */ |
654 | if (unlikely(hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD |
655 | && size == 3 |
656 | && data[0] == 0x15 |
657 | && data[1] == 0x94 |
658 | && data[2] == 0x01)) { |
659 | data[1] = 0x00; |
660 | data[2] = 0x01; |
661 | } |
662 | |
663 | return 0; |
664 | } |
665 | |
666 | static int lenovo_event_tp10ubkbd(struct hid_device *hdev, |
667 | struct hid_field *field, struct hid_usage *usage, __s32 value) |
668 | { |
669 | struct lenovo_drvdata *data = hid_get_drvdata(hdev); |
670 | |
671 | if (usage->type == EV_KEY && usage->code == KEY_FN_ESC && value == 1) { |
672 | /* |
673 | * The user has toggled the Fn-lock state. Toggle our own |
674 | * cached value of it and sync our value to the keyboard to |
675 | * ensure things are in sync (the sycning should be a no-op). |
676 | */ |
677 | data->fn_lock = !data->fn_lock; |
678 | schedule_work(work: &data->fn_lock_sync_work); |
679 | } |
680 | |
681 | return 0; |
682 | } |
683 | |
684 | static int lenovo_event_cptkbd(struct hid_device *hdev, |
685 | struct hid_field *field, struct hid_usage *usage, __s32 value) |
686 | { |
687 | struct lenovo_drvdata *cptkbd_data = hid_get_drvdata(hdev); |
688 | |
689 | if (cptkbd_data->middlebutton_state != 3) { |
690 | /* REL_X and REL_Y events during middle button pressed |
691 | * are only possible on patched, bug-free firmware |
692 | * so set middlebutton_state to 3 |
693 | * to never apply workaround anymore |
694 | */ |
695 | if (cptkbd_data->middlebutton_state == 1 && |
696 | usage->type == EV_REL && |
697 | (usage->code == REL_X || usage->code == REL_Y)) { |
698 | cptkbd_data->middlebutton_state = 3; |
699 | /* send middle button press which was hold before */ |
700 | input_event(dev: field->hidinput->input, |
701 | EV_KEY, BTN_MIDDLE, value: 1); |
702 | input_sync(dev: field->hidinput->input); |
703 | } |
704 | |
705 | /* "wheel" scroll events */ |
706 | if (usage->type == EV_REL && (usage->code == REL_WHEEL || |
707 | usage->code == REL_HWHEEL)) { |
708 | /* Scroll events disable middle-click event */ |
709 | cptkbd_data->middlebutton_state = 2; |
710 | return 0; |
711 | } |
712 | |
713 | /* Middle click events */ |
714 | if (usage->type == EV_KEY && usage->code == BTN_MIDDLE) { |
715 | if (value == 1) { |
716 | cptkbd_data->middlebutton_state = 1; |
717 | } else if (value == 0) { |
718 | if (cptkbd_data->middlebutton_state == 1) { |
719 | /* No scrolling inbetween, send middle-click */ |
720 | input_event(dev: field->hidinput->input, |
721 | EV_KEY, BTN_MIDDLE, value: 1); |
722 | input_sync(dev: field->hidinput->input); |
723 | input_event(dev: field->hidinput->input, |
724 | EV_KEY, BTN_MIDDLE, value: 0); |
725 | input_sync(dev: field->hidinput->input); |
726 | } |
727 | cptkbd_data->middlebutton_state = 0; |
728 | } |
729 | return 1; |
730 | } |
731 | } |
732 | |
733 | if (usage->type == EV_KEY && usage->code == KEY_FN_ESC && value == 1) { |
734 | /* |
735 | * The user has toggled the Fn-lock state. Toggle our own |
736 | * cached value of it and sync our value to the keyboard to |
737 | * ensure things are in sync (the syncing should be a no-op). |
738 | */ |
739 | cptkbd_data->fn_lock = !cptkbd_data->fn_lock; |
740 | } |
741 | |
742 | return 0; |
743 | } |
744 | |
745 | static int lenovo_event(struct hid_device *hdev, struct hid_field *field, |
746 | struct hid_usage *usage, __s32 value) |
747 | { |
748 | if (!hid_get_drvdata(hdev)) |
749 | return 0; |
750 | |
751 | switch (hdev->product) { |
752 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
753 | case USB_DEVICE_ID_LENOVO_CBTKBD: |
754 | case USB_DEVICE_ID_LENOVO_TPIIUSBKBD: |
755 | case USB_DEVICE_ID_LENOVO_TPIIBTKBD: |
756 | return lenovo_event_cptkbd(hdev, field, usage, value); |
757 | case USB_DEVICE_ID_LENOVO_TP10UBKBD: |
758 | case USB_DEVICE_ID_LENOVO_X1_TAB: |
759 | return lenovo_event_tp10ubkbd(hdev, field, usage, value); |
760 | default: |
761 | return 0; |
762 | } |
763 | } |
764 | |
765 | static int lenovo_features_set_tpkbd(struct hid_device *hdev) |
766 | { |
767 | struct hid_report *report; |
768 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
769 | |
770 | report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[4]; |
771 | |
772 | report->field[0]->value[0] = data_pointer->press_to_select ? 0x01 : 0x02; |
773 | report->field[0]->value[0] |= data_pointer->dragging ? 0x04 : 0x08; |
774 | report->field[0]->value[0] |= data_pointer->release_to_select ? 0x10 : 0x20; |
775 | report->field[0]->value[0] |= data_pointer->select_right ? 0x80 : 0x40; |
776 | report->field[1]->value[0] = 0x03; // unknown setting, imitate windows driver |
777 | report->field[2]->value[0] = data_pointer->sensitivity; |
778 | report->field[3]->value[0] = data_pointer->press_speed; |
779 | |
780 | hid_hw_request(hdev, report, reqtype: HID_REQ_SET_REPORT); |
781 | return 0; |
782 | } |
783 | |
784 | static ssize_t attr_press_to_select_show_tpkbd(struct device *dev, |
785 | struct device_attribute *attr, |
786 | char *buf) |
787 | { |
788 | struct hid_device *hdev = to_hid_device(dev); |
789 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
790 | |
791 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , data_pointer->press_to_select); |
792 | } |
793 | |
794 | static ssize_t attr_press_to_select_store_tpkbd(struct device *dev, |
795 | struct device_attribute *attr, |
796 | const char *buf, |
797 | size_t count) |
798 | { |
799 | struct hid_device *hdev = to_hid_device(dev); |
800 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
801 | int value; |
802 | |
803 | if (kstrtoint(s: buf, base: 10, res: &value)) |
804 | return -EINVAL; |
805 | if (value < 0 || value > 1) |
806 | return -EINVAL; |
807 | |
808 | data_pointer->press_to_select = value; |
809 | lenovo_features_set_tpkbd(hdev); |
810 | |
811 | return count; |
812 | } |
813 | |
814 | static ssize_t attr_dragging_show_tpkbd(struct device *dev, |
815 | struct device_attribute *attr, |
816 | char *buf) |
817 | { |
818 | struct hid_device *hdev = to_hid_device(dev); |
819 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
820 | |
821 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , data_pointer->dragging); |
822 | } |
823 | |
824 | static ssize_t attr_dragging_store_tpkbd(struct device *dev, |
825 | struct device_attribute *attr, |
826 | const char *buf, |
827 | size_t count) |
828 | { |
829 | struct hid_device *hdev = to_hid_device(dev); |
830 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
831 | int value; |
832 | |
833 | if (kstrtoint(s: buf, base: 10, res: &value)) |
834 | return -EINVAL; |
835 | if (value < 0 || value > 1) |
836 | return -EINVAL; |
837 | |
838 | data_pointer->dragging = value; |
839 | lenovo_features_set_tpkbd(hdev); |
840 | |
841 | return count; |
842 | } |
843 | |
844 | static ssize_t attr_release_to_select_show_tpkbd(struct device *dev, |
845 | struct device_attribute *attr, |
846 | char *buf) |
847 | { |
848 | struct hid_device *hdev = to_hid_device(dev); |
849 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
850 | |
851 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , data_pointer->release_to_select); |
852 | } |
853 | |
854 | static ssize_t attr_release_to_select_store_tpkbd(struct device *dev, |
855 | struct device_attribute *attr, |
856 | const char *buf, |
857 | size_t count) |
858 | { |
859 | struct hid_device *hdev = to_hid_device(dev); |
860 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
861 | int value; |
862 | |
863 | if (kstrtoint(s: buf, base: 10, res: &value)) |
864 | return -EINVAL; |
865 | if (value < 0 || value > 1) |
866 | return -EINVAL; |
867 | |
868 | data_pointer->release_to_select = value; |
869 | lenovo_features_set_tpkbd(hdev); |
870 | |
871 | return count; |
872 | } |
873 | |
874 | static ssize_t attr_select_right_show_tpkbd(struct device *dev, |
875 | struct device_attribute *attr, |
876 | char *buf) |
877 | { |
878 | struct hid_device *hdev = to_hid_device(dev); |
879 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
880 | |
881 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , data_pointer->select_right); |
882 | } |
883 | |
884 | static ssize_t attr_select_right_store_tpkbd(struct device *dev, |
885 | struct device_attribute *attr, |
886 | const char *buf, |
887 | size_t count) |
888 | { |
889 | struct hid_device *hdev = to_hid_device(dev); |
890 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
891 | int value; |
892 | |
893 | if (kstrtoint(s: buf, base: 10, res: &value)) |
894 | return -EINVAL; |
895 | if (value < 0 || value > 1) |
896 | return -EINVAL; |
897 | |
898 | data_pointer->select_right = value; |
899 | lenovo_features_set_tpkbd(hdev); |
900 | |
901 | return count; |
902 | } |
903 | |
904 | static ssize_t attr_sensitivity_show_tpkbd(struct device *dev, |
905 | struct device_attribute *attr, |
906 | char *buf) |
907 | { |
908 | struct hid_device *hdev = to_hid_device(dev); |
909 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
910 | |
911 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , |
912 | data_pointer->sensitivity); |
913 | } |
914 | |
915 | static ssize_t attr_sensitivity_store_tpkbd(struct device *dev, |
916 | struct device_attribute *attr, |
917 | const char *buf, |
918 | size_t count) |
919 | { |
920 | struct hid_device *hdev = to_hid_device(dev); |
921 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
922 | int value; |
923 | |
924 | if (kstrtoint(s: buf, base: 10, res: &value) || value < 1 || value > 255) |
925 | return -EINVAL; |
926 | |
927 | data_pointer->sensitivity = value; |
928 | lenovo_features_set_tpkbd(hdev); |
929 | |
930 | return count; |
931 | } |
932 | |
933 | static ssize_t attr_press_speed_show_tpkbd(struct device *dev, |
934 | struct device_attribute *attr, |
935 | char *buf) |
936 | { |
937 | struct hid_device *hdev = to_hid_device(dev); |
938 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
939 | |
940 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , |
941 | data_pointer->press_speed); |
942 | } |
943 | |
944 | static ssize_t attr_press_speed_store_tpkbd(struct device *dev, |
945 | struct device_attribute *attr, |
946 | const char *buf, |
947 | size_t count) |
948 | { |
949 | struct hid_device *hdev = to_hid_device(dev); |
950 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
951 | int value; |
952 | |
953 | if (kstrtoint(s: buf, base: 10, res: &value) || value < 1 || value > 255) |
954 | return -EINVAL; |
955 | |
956 | data_pointer->press_speed = value; |
957 | lenovo_features_set_tpkbd(hdev); |
958 | |
959 | return count; |
960 | } |
961 | |
962 | static struct device_attribute dev_attr_press_to_select_tpkbd = |
963 | __ATTR(press_to_select, S_IWUSR | S_IRUGO, |
964 | attr_press_to_select_show_tpkbd, |
965 | attr_press_to_select_store_tpkbd); |
966 | |
967 | static struct device_attribute dev_attr_dragging_tpkbd = |
968 | __ATTR(dragging, S_IWUSR | S_IRUGO, |
969 | attr_dragging_show_tpkbd, |
970 | attr_dragging_store_tpkbd); |
971 | |
972 | static struct device_attribute dev_attr_release_to_select_tpkbd = |
973 | __ATTR(release_to_select, S_IWUSR | S_IRUGO, |
974 | attr_release_to_select_show_tpkbd, |
975 | attr_release_to_select_store_tpkbd); |
976 | |
977 | static struct device_attribute dev_attr_select_right_tpkbd = |
978 | __ATTR(select_right, S_IWUSR | S_IRUGO, |
979 | attr_select_right_show_tpkbd, |
980 | attr_select_right_store_tpkbd); |
981 | |
982 | static struct device_attribute dev_attr_sensitivity_tpkbd = |
983 | __ATTR(sensitivity, S_IWUSR | S_IRUGO, |
984 | attr_sensitivity_show_tpkbd, |
985 | attr_sensitivity_store_tpkbd); |
986 | |
987 | static struct device_attribute dev_attr_press_speed_tpkbd = |
988 | __ATTR(press_speed, S_IWUSR | S_IRUGO, |
989 | attr_press_speed_show_tpkbd, |
990 | attr_press_speed_store_tpkbd); |
991 | |
992 | static struct attribute *lenovo_attributes_tpkbd[] = { |
993 | &dev_attr_press_to_select_tpkbd.attr, |
994 | &dev_attr_dragging_tpkbd.attr, |
995 | &dev_attr_release_to_select_tpkbd.attr, |
996 | &dev_attr_select_right_tpkbd.attr, |
997 | &dev_attr_sensitivity_tpkbd.attr, |
998 | &dev_attr_press_speed_tpkbd.attr, |
999 | NULL |
1000 | }; |
1001 | |
1002 | static const struct attribute_group lenovo_attr_group_tpkbd = { |
1003 | .attrs = lenovo_attributes_tpkbd, |
1004 | }; |
1005 | |
1006 | static void lenovo_led_set_tpkbd(struct hid_device *hdev) |
1007 | { |
1008 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
1009 | struct hid_report *report; |
1010 | |
1011 | report = hdev->report_enum[HID_OUTPUT_REPORT].report_id_hash[3]; |
1012 | report->field[0]->value[0] = (data_pointer->led_state >> 0) & 1; |
1013 | report->field[0]->value[1] = (data_pointer->led_state >> 1) & 1; |
1014 | hid_hw_request(hdev, report, reqtype: HID_REQ_SET_REPORT); |
1015 | } |
1016 | |
1017 | static int lenovo_led_brightness_set(struct led_classdev *led_cdev, |
1018 | enum led_brightness value) |
1019 | { |
1020 | struct device *dev = led_cdev->dev->parent; |
1021 | struct hid_device *hdev = to_hid_device(dev); |
1022 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
1023 | static const u8 tp10ubkbd_led[] = { TP10UBKBD_MUTE_LED, TP10UBKBD_MICMUTE_LED }; |
1024 | int led_nr = 0; |
1025 | int ret = 0; |
1026 | |
1027 | if (led_cdev == &data_pointer->led_micmute) |
1028 | led_nr = 1; |
1029 | |
1030 | if (value == LED_OFF) |
1031 | data_pointer->led_state &= ~(1 << led_nr); |
1032 | else |
1033 | data_pointer->led_state |= 1 << led_nr; |
1034 | |
1035 | switch (hdev->product) { |
1036 | case USB_DEVICE_ID_LENOVO_TPKBD: |
1037 | lenovo_led_set_tpkbd(hdev); |
1038 | break; |
1039 | case USB_DEVICE_ID_LENOVO_TP10UBKBD: |
1040 | case USB_DEVICE_ID_LENOVO_X1_TAB: |
1041 | ret = lenovo_led_set_tp10ubkbd(hdev, led_code: tp10ubkbd_led[led_nr], value); |
1042 | break; |
1043 | } |
1044 | |
1045 | return ret; |
1046 | } |
1047 | |
1048 | static int lenovo_register_leds(struct hid_device *hdev) |
1049 | { |
1050 | struct lenovo_drvdata *data = hid_get_drvdata(hdev); |
1051 | size_t name_sz = strlen(dev_name(&hdev->dev)) + 16; |
1052 | char *name_mute, *name_micm; |
1053 | int ret; |
1054 | |
1055 | name_mute = devm_kzalloc(dev: &hdev->dev, size: name_sz, GFP_KERNEL); |
1056 | name_micm = devm_kzalloc(dev: &hdev->dev, size: name_sz, GFP_KERNEL); |
1057 | if (name_mute == NULL || name_micm == NULL) { |
1058 | hid_err(hdev, "Could not allocate memory for led data\n" ); |
1059 | return -ENOMEM; |
1060 | } |
1061 | snprintf(buf: name_mute, size: name_sz, fmt: "%s:amber:mute" , dev_name(dev: &hdev->dev)); |
1062 | snprintf(buf: name_micm, size: name_sz, fmt: "%s:amber:micmute" , dev_name(dev: &hdev->dev)); |
1063 | |
1064 | data->led_mute.name = name_mute; |
1065 | data->led_mute.default_trigger = "audio-mute" ; |
1066 | data->led_mute.brightness_set_blocking = lenovo_led_brightness_set; |
1067 | data->led_mute.max_brightness = 1; |
1068 | data->led_mute.flags = LED_HW_PLUGGABLE; |
1069 | data->led_mute.dev = &hdev->dev; |
1070 | ret = led_classdev_register(parent: &hdev->dev, led_cdev: &data->led_mute); |
1071 | if (ret < 0) |
1072 | return ret; |
1073 | |
1074 | data->led_micmute.name = name_micm; |
1075 | data->led_micmute.default_trigger = "audio-micmute" ; |
1076 | data->led_micmute.brightness_set_blocking = lenovo_led_brightness_set; |
1077 | data->led_micmute.max_brightness = 1; |
1078 | data->led_micmute.flags = LED_HW_PLUGGABLE; |
1079 | data->led_micmute.dev = &hdev->dev; |
1080 | ret = led_classdev_register(parent: &hdev->dev, led_cdev: &data->led_micmute); |
1081 | if (ret < 0) { |
1082 | led_classdev_unregister(led_cdev: &data->led_mute); |
1083 | return ret; |
1084 | } |
1085 | |
1086 | return 0; |
1087 | } |
1088 | |
1089 | static int lenovo_probe_tpkbd(struct hid_device *hdev) |
1090 | { |
1091 | struct lenovo_drvdata *data_pointer; |
1092 | int i, ret; |
1093 | |
1094 | /* |
1095 | * Only register extra settings against subdevice where input_mapping |
1096 | * set drvdata to 1, i.e. the trackpoint. |
1097 | */ |
1098 | if (!hid_get_drvdata(hdev)) |
1099 | return 0; |
1100 | |
1101 | hid_set_drvdata(hdev, NULL); |
1102 | |
1103 | /* Validate required reports. */ |
1104 | for (i = 0; i < 4; i++) { |
1105 | if (!hid_validate_values(hid: hdev, type: HID_FEATURE_REPORT, id: 4, field_index: i, report_counts: 1)) |
1106 | return -ENODEV; |
1107 | } |
1108 | if (!hid_validate_values(hid: hdev, type: HID_OUTPUT_REPORT, id: 3, field_index: 0, report_counts: 2)) |
1109 | return -ENODEV; |
1110 | |
1111 | ret = sysfs_create_group(kobj: &hdev->dev.kobj, grp: &lenovo_attr_group_tpkbd); |
1112 | if (ret) |
1113 | hid_warn(hdev, "Could not create sysfs group: %d\n" , ret); |
1114 | |
1115 | data_pointer = devm_kzalloc(dev: &hdev->dev, |
1116 | size: sizeof(struct lenovo_drvdata), |
1117 | GFP_KERNEL); |
1118 | if (data_pointer == NULL) { |
1119 | hid_err(hdev, "Could not allocate memory for driver data\n" ); |
1120 | ret = -ENOMEM; |
1121 | goto err; |
1122 | } |
1123 | |
1124 | // set same default values as windows driver |
1125 | data_pointer->sensitivity = 0xa0; |
1126 | data_pointer->press_speed = 0x38; |
1127 | |
1128 | hid_set_drvdata(hdev, data: data_pointer); |
1129 | |
1130 | ret = lenovo_register_leds(hdev); |
1131 | if (ret) |
1132 | goto err; |
1133 | |
1134 | lenovo_features_set_tpkbd(hdev); |
1135 | |
1136 | return 0; |
1137 | err: |
1138 | sysfs_remove_group(kobj: &hdev->dev.kobj, grp: &lenovo_attr_group_tpkbd); |
1139 | return ret; |
1140 | } |
1141 | |
1142 | static int lenovo_probe_cptkbd(struct hid_device *hdev) |
1143 | { |
1144 | int ret; |
1145 | struct lenovo_drvdata *cptkbd_data; |
1146 | |
1147 | /* All the custom action happens on the USBMOUSE device for USB */ |
1148 | if (((hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD) || |
1149 | (hdev->product == USB_DEVICE_ID_LENOVO_TPIIUSBKBD)) && |
1150 | hdev->type != HID_TYPE_USBMOUSE) { |
1151 | hid_dbg(hdev, "Ignoring keyboard half of device\n" ); |
1152 | return 0; |
1153 | } |
1154 | |
1155 | cptkbd_data = devm_kzalloc(dev: &hdev->dev, |
1156 | size: sizeof(*cptkbd_data), |
1157 | GFP_KERNEL); |
1158 | if (cptkbd_data == NULL) { |
1159 | hid_err(hdev, "can't alloc keyboard descriptor\n" ); |
1160 | return -ENOMEM; |
1161 | } |
1162 | hid_set_drvdata(hdev, data: cptkbd_data); |
1163 | |
1164 | /* Set keyboard settings to known state */ |
1165 | cptkbd_data->middlebutton_state = 0; |
1166 | cptkbd_data->fn_lock = true; |
1167 | cptkbd_data->sensitivity = 0x05; |
1168 | lenovo_features_set_cptkbd(hdev); |
1169 | |
1170 | ret = sysfs_create_group(kobj: &hdev->dev.kobj, grp: &lenovo_attr_group_cptkbd); |
1171 | if (ret) |
1172 | hid_warn(hdev, "Could not create sysfs group: %d\n" , ret); |
1173 | |
1174 | return 0; |
1175 | } |
1176 | |
1177 | static struct attribute *lenovo_attributes_tp10ubkbd[] = { |
1178 | &dev_attr_fn_lock.attr, |
1179 | NULL |
1180 | }; |
1181 | |
1182 | static const struct attribute_group lenovo_attr_group_tp10ubkbd = { |
1183 | .attrs = lenovo_attributes_tp10ubkbd, |
1184 | }; |
1185 | |
1186 | static int lenovo_probe_tp10ubkbd(struct hid_device *hdev) |
1187 | { |
1188 | struct hid_report_enum *rep_enum; |
1189 | struct lenovo_drvdata *data; |
1190 | struct hid_report *rep; |
1191 | bool found; |
1192 | int ret; |
1193 | |
1194 | /* |
1195 | * The LEDs and the Fn-lock functionality use output report 9, |
1196 | * with an application of 0xffa0001, add the LEDs on the interface |
1197 | * with this output report. |
1198 | */ |
1199 | found = false; |
1200 | rep_enum = &hdev->report_enum[HID_OUTPUT_REPORT]; |
1201 | list_for_each_entry(rep, &rep_enum->report_list, list) { |
1202 | if (rep->application == 0xffa00001) |
1203 | found = true; |
1204 | } |
1205 | if (!found) |
1206 | return 0; |
1207 | |
1208 | data = devm_kzalloc(dev: &hdev->dev, size: sizeof(*data), GFP_KERNEL); |
1209 | if (!data) |
1210 | return -ENOMEM; |
1211 | |
1212 | mutex_init(&data->led_report_mutex); |
1213 | INIT_WORK(&data->fn_lock_sync_work, lenovo_tp10ubkbd_sync_fn_lock); |
1214 | data->hdev = hdev; |
1215 | |
1216 | hid_set_drvdata(hdev, data); |
1217 | |
1218 | /* |
1219 | * The Thinkpad 10 ultrabook USB kbd dock's Fn-lock defaults to on. |
1220 | * We cannot read the state, only set it, so we force it to on here |
1221 | * (which should be a no-op) to make sure that our state matches the |
1222 | * keyboard's FN-lock state. This is the same as what Windows does. |
1223 | */ |
1224 | data->fn_lock = true; |
1225 | lenovo_led_set_tp10ubkbd(hdev, TP10UBKBD_FN_LOCK_LED, value: data->fn_lock); |
1226 | |
1227 | ret = sysfs_create_group(kobj: &hdev->dev.kobj, grp: &lenovo_attr_group_tp10ubkbd); |
1228 | if (ret) |
1229 | return ret; |
1230 | |
1231 | ret = lenovo_register_leds(hdev); |
1232 | if (ret) |
1233 | goto err; |
1234 | |
1235 | return 0; |
1236 | err: |
1237 | sysfs_remove_group(kobj: &hdev->dev.kobj, grp: &lenovo_attr_group_tp10ubkbd); |
1238 | return ret; |
1239 | } |
1240 | |
1241 | static int lenovo_probe(struct hid_device *hdev, |
1242 | const struct hid_device_id *id) |
1243 | { |
1244 | int ret; |
1245 | |
1246 | ret = hid_parse(hdev); |
1247 | if (ret) { |
1248 | hid_err(hdev, "hid_parse failed\n" ); |
1249 | goto err; |
1250 | } |
1251 | |
1252 | ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); |
1253 | if (ret) { |
1254 | hid_err(hdev, "hid_hw_start failed\n" ); |
1255 | goto err; |
1256 | } |
1257 | |
1258 | switch (hdev->product) { |
1259 | case USB_DEVICE_ID_LENOVO_TPKBD: |
1260 | ret = lenovo_probe_tpkbd(hdev); |
1261 | break; |
1262 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
1263 | case USB_DEVICE_ID_LENOVO_CBTKBD: |
1264 | case USB_DEVICE_ID_LENOVO_TPIIUSBKBD: |
1265 | case USB_DEVICE_ID_LENOVO_TPIIBTKBD: |
1266 | ret = lenovo_probe_cptkbd(hdev); |
1267 | break; |
1268 | case USB_DEVICE_ID_LENOVO_TP10UBKBD: |
1269 | case USB_DEVICE_ID_LENOVO_X1_TAB: |
1270 | ret = lenovo_probe_tp10ubkbd(hdev); |
1271 | break; |
1272 | default: |
1273 | ret = 0; |
1274 | break; |
1275 | } |
1276 | if (ret) |
1277 | goto err_hid; |
1278 | |
1279 | return 0; |
1280 | err_hid: |
1281 | hid_hw_stop(hdev); |
1282 | err: |
1283 | return ret; |
1284 | } |
1285 | |
1286 | #ifdef CONFIG_PM |
1287 | static int lenovo_reset_resume(struct hid_device *hdev) |
1288 | { |
1289 | switch (hdev->product) { |
1290 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
1291 | case USB_DEVICE_ID_LENOVO_TPIIUSBKBD: |
1292 | if (hdev->type == HID_TYPE_USBMOUSE) |
1293 | lenovo_features_set_cptkbd(hdev); |
1294 | |
1295 | break; |
1296 | default: |
1297 | break; |
1298 | } |
1299 | |
1300 | return 0; |
1301 | } |
1302 | #endif |
1303 | |
1304 | static void lenovo_remove_tpkbd(struct hid_device *hdev) |
1305 | { |
1306 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
1307 | |
1308 | /* |
1309 | * Only the trackpoint half of the keyboard has drvdata and stuff that |
1310 | * needs unregistering. |
1311 | */ |
1312 | if (data_pointer == NULL) |
1313 | return; |
1314 | |
1315 | sysfs_remove_group(kobj: &hdev->dev.kobj, |
1316 | grp: &lenovo_attr_group_tpkbd); |
1317 | |
1318 | led_classdev_unregister(led_cdev: &data_pointer->led_micmute); |
1319 | led_classdev_unregister(led_cdev: &data_pointer->led_mute); |
1320 | } |
1321 | |
1322 | static void lenovo_remove_cptkbd(struct hid_device *hdev) |
1323 | { |
1324 | sysfs_remove_group(kobj: &hdev->dev.kobj, |
1325 | grp: &lenovo_attr_group_cptkbd); |
1326 | } |
1327 | |
1328 | static void lenovo_remove_tp10ubkbd(struct hid_device *hdev) |
1329 | { |
1330 | struct lenovo_drvdata *data = hid_get_drvdata(hdev); |
1331 | |
1332 | if (data == NULL) |
1333 | return; |
1334 | |
1335 | led_classdev_unregister(led_cdev: &data->led_micmute); |
1336 | led_classdev_unregister(led_cdev: &data->led_mute); |
1337 | |
1338 | sysfs_remove_group(kobj: &hdev->dev.kobj, grp: &lenovo_attr_group_tp10ubkbd); |
1339 | cancel_work_sync(work: &data->fn_lock_sync_work); |
1340 | } |
1341 | |
1342 | static void lenovo_remove(struct hid_device *hdev) |
1343 | { |
1344 | switch (hdev->product) { |
1345 | case USB_DEVICE_ID_LENOVO_TPKBD: |
1346 | lenovo_remove_tpkbd(hdev); |
1347 | break; |
1348 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
1349 | case USB_DEVICE_ID_LENOVO_CBTKBD: |
1350 | case USB_DEVICE_ID_LENOVO_TPIIUSBKBD: |
1351 | case USB_DEVICE_ID_LENOVO_TPIIBTKBD: |
1352 | lenovo_remove_cptkbd(hdev); |
1353 | break; |
1354 | case USB_DEVICE_ID_LENOVO_TP10UBKBD: |
1355 | case USB_DEVICE_ID_LENOVO_X1_TAB: |
1356 | lenovo_remove_tp10ubkbd(hdev); |
1357 | break; |
1358 | } |
1359 | |
1360 | hid_hw_stop(hdev); |
1361 | } |
1362 | |
1363 | static int lenovo_input_configured(struct hid_device *hdev, |
1364 | struct hid_input *hi) |
1365 | { |
1366 | switch (hdev->product) { |
1367 | case USB_DEVICE_ID_LENOVO_TPKBD: |
1368 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
1369 | case USB_DEVICE_ID_LENOVO_CBTKBD: |
1370 | case USB_DEVICE_ID_LENOVO_TPIIUSBKBD: |
1371 | case USB_DEVICE_ID_LENOVO_TPIIBTKBD: |
1372 | if (test_bit(EV_REL, hi->input->evbit)) { |
1373 | /* set only for trackpoint device */ |
1374 | __set_bit(INPUT_PROP_POINTER, hi->input->propbit); |
1375 | __set_bit(INPUT_PROP_POINTING_STICK, |
1376 | hi->input->propbit); |
1377 | } |
1378 | break; |
1379 | } |
1380 | |
1381 | return 0; |
1382 | } |
1383 | |
1384 | |
1385 | static const struct hid_device_id lenovo_devices[] = { |
1386 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) }, |
1387 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) }, |
1388 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPIIUSBKBD) }, |
1389 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) }, |
1390 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPIIBTKBD) }, |
1391 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) }, |
1392 | { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_III) }, |
1393 | { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_PRO) }, |
1394 | { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_OPTICAL) }, |
1395 | { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL) }, |
1396 | { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL_PRO) }, |
1397 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_SCROLLPOINT_OPTICAL) }, |
1398 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TP10UBKBD) }, |
1399 | /* |
1400 | * Note bind to the HID_GROUP_GENERIC group, so that we only bind to the keyboard |
1401 | * part, while letting hid-multitouch.c handle the touchpad and trackpoint. |
1402 | */ |
1403 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, |
1404 | USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_TAB) }, |
1405 | { } |
1406 | }; |
1407 | |
1408 | MODULE_DEVICE_TABLE(hid, lenovo_devices); |
1409 | |
1410 | static struct hid_driver lenovo_driver = { |
1411 | .name = "lenovo" , |
1412 | .id_table = lenovo_devices, |
1413 | .input_configured = lenovo_input_configured, |
1414 | .input_mapping = lenovo_input_mapping, |
1415 | .probe = lenovo_probe, |
1416 | .remove = lenovo_remove, |
1417 | .raw_event = lenovo_raw_event, |
1418 | .event = lenovo_event, |
1419 | .report_fixup = lenovo_report_fixup, |
1420 | #ifdef CONFIG_PM |
1421 | .reset_resume = lenovo_reset_resume, |
1422 | #endif |
1423 | }; |
1424 | module_hid_driver(lenovo_driver); |
1425 | |
1426 | MODULE_LICENSE("GPL" ); |
1427 | |