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 | */ |
58 | u8 middlebutton_state; |
59 | bool fn_lock; |
60 | bool middleclick_workaround_cptkbd; |
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 | static ssize_t attr_middleclick_workaround_show_cptkbd(struct device *dev, |
625 | struct device_attribute *attr, |
626 | char *buf) |
627 | { |
628 | struct hid_device *hdev = to_hid_device(dev); |
629 | struct lenovo_drvdata *cptkbd_data = hid_get_drvdata(hdev); |
630 | |
631 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , |
632 | cptkbd_data->middleclick_workaround_cptkbd); |
633 | } |
634 | |
635 | static ssize_t attr_middleclick_workaround_store_cptkbd(struct device *dev, |
636 | struct device_attribute *attr, |
637 | const char *buf, |
638 | size_t count) |
639 | { |
640 | struct hid_device *hdev = to_hid_device(dev); |
641 | struct lenovo_drvdata *cptkbd_data = hid_get_drvdata(hdev); |
642 | int value; |
643 | |
644 | if (kstrtoint(s: buf, base: 10, res: &value)) |
645 | return -EINVAL; |
646 | if (value < 0 || value > 1) |
647 | return -EINVAL; |
648 | |
649 | cptkbd_data->middleclick_workaround_cptkbd = !!value; |
650 | |
651 | return count; |
652 | } |
653 | |
654 | |
655 | static struct device_attribute dev_attr_fn_lock = |
656 | __ATTR(fn_lock, S_IWUSR | S_IRUGO, |
657 | attr_fn_lock_show, |
658 | attr_fn_lock_store); |
659 | |
660 | static struct device_attribute dev_attr_sensitivity_cptkbd = |
661 | __ATTR(sensitivity, S_IWUSR | S_IRUGO, |
662 | attr_sensitivity_show_cptkbd, |
663 | attr_sensitivity_store_cptkbd); |
664 | |
665 | static struct device_attribute dev_attr_middleclick_workaround_cptkbd = |
666 | __ATTR(middleclick_workaround, S_IWUSR | S_IRUGO, |
667 | attr_middleclick_workaround_show_cptkbd, |
668 | attr_middleclick_workaround_store_cptkbd); |
669 | |
670 | |
671 | static struct attribute *lenovo_attributes_cptkbd[] = { |
672 | &dev_attr_fn_lock.attr, |
673 | &dev_attr_sensitivity_cptkbd.attr, |
674 | &dev_attr_middleclick_workaround_cptkbd.attr, |
675 | NULL |
676 | }; |
677 | |
678 | static const struct attribute_group lenovo_attr_group_cptkbd = { |
679 | .attrs = lenovo_attributes_cptkbd, |
680 | }; |
681 | |
682 | static int lenovo_raw_event(struct hid_device *hdev, |
683 | struct hid_report *report, u8 *data, int size) |
684 | { |
685 | /* |
686 | * Compact USB keyboard's Fn-F12 report holds down many other keys, and |
687 | * its own key is outside the usage page range. Remove extra |
688 | * keypresses and remap to inside usage page. |
689 | */ |
690 | if (unlikely(hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD |
691 | && size == 3 |
692 | && data[0] == 0x15 |
693 | && data[1] == 0x94 |
694 | && data[2] == 0x01)) { |
695 | data[1] = 0x00; |
696 | data[2] = 0x01; |
697 | } |
698 | |
699 | return 0; |
700 | } |
701 | |
702 | static int lenovo_event_tp10ubkbd(struct hid_device *hdev, |
703 | struct hid_field *field, struct hid_usage *usage, __s32 value) |
704 | { |
705 | struct lenovo_drvdata *data = hid_get_drvdata(hdev); |
706 | |
707 | if (usage->type == EV_KEY && usage->code == KEY_FN_ESC && value == 1) { |
708 | /* |
709 | * The user has toggled the Fn-lock state. Toggle our own |
710 | * cached value of it and sync our value to the keyboard to |
711 | * ensure things are in sync (the sycning should be a no-op). |
712 | */ |
713 | data->fn_lock = !data->fn_lock; |
714 | schedule_work(work: &data->fn_lock_sync_work); |
715 | } |
716 | |
717 | return 0; |
718 | } |
719 | |
720 | static int lenovo_event_cptkbd(struct hid_device *hdev, |
721 | struct hid_field *field, struct hid_usage *usage, __s32 value) |
722 | { |
723 | struct lenovo_drvdata *cptkbd_data = hid_get_drvdata(hdev); |
724 | |
725 | if (cptkbd_data->middleclick_workaround_cptkbd) { |
726 | /* "wheel" scroll events */ |
727 | if (usage->type == EV_REL && (usage->code == REL_WHEEL || |
728 | usage->code == REL_HWHEEL)) { |
729 | /* Scroll events disable middle-click event */ |
730 | cptkbd_data->middlebutton_state = 2; |
731 | return 0; |
732 | } |
733 | |
734 | /* Middle click events */ |
735 | if (usage->type == EV_KEY && usage->code == BTN_MIDDLE) { |
736 | if (value == 1) { |
737 | cptkbd_data->middlebutton_state = 1; |
738 | } else if (value == 0) { |
739 | if (cptkbd_data->middlebutton_state == 1) { |
740 | /* No scrolling inbetween, send middle-click */ |
741 | input_event(dev: field->hidinput->input, |
742 | EV_KEY, BTN_MIDDLE, value: 1); |
743 | input_sync(dev: field->hidinput->input); |
744 | input_event(dev: field->hidinput->input, |
745 | EV_KEY, BTN_MIDDLE, value: 0); |
746 | input_sync(dev: field->hidinput->input); |
747 | } |
748 | cptkbd_data->middlebutton_state = 0; |
749 | } |
750 | return 1; |
751 | } |
752 | } |
753 | |
754 | if (usage->type == EV_KEY && usage->code == KEY_FN_ESC && value == 1) { |
755 | /* |
756 | * The user has toggled the Fn-lock state. Toggle our own |
757 | * cached value of it and sync our value to the keyboard to |
758 | * ensure things are in sync (the syncing should be a no-op). |
759 | */ |
760 | cptkbd_data->fn_lock = !cptkbd_data->fn_lock; |
761 | } |
762 | |
763 | return 0; |
764 | } |
765 | |
766 | static int lenovo_event(struct hid_device *hdev, struct hid_field *field, |
767 | struct hid_usage *usage, __s32 value) |
768 | { |
769 | if (!hid_get_drvdata(hdev)) |
770 | return 0; |
771 | |
772 | switch (hdev->product) { |
773 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
774 | case USB_DEVICE_ID_LENOVO_CBTKBD: |
775 | case USB_DEVICE_ID_LENOVO_TPIIUSBKBD: |
776 | case USB_DEVICE_ID_LENOVO_TPIIBTKBD: |
777 | return lenovo_event_cptkbd(hdev, field, usage, value); |
778 | case USB_DEVICE_ID_LENOVO_TP10UBKBD: |
779 | case USB_DEVICE_ID_LENOVO_X1_TAB: |
780 | return lenovo_event_tp10ubkbd(hdev, field, usage, value); |
781 | default: |
782 | return 0; |
783 | } |
784 | } |
785 | |
786 | static int lenovo_features_set_tpkbd(struct hid_device *hdev) |
787 | { |
788 | struct hid_report *report; |
789 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
790 | |
791 | report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[4]; |
792 | |
793 | report->field[0]->value[0] = data_pointer->press_to_select ? 0x01 : 0x02; |
794 | report->field[0]->value[0] |= data_pointer->dragging ? 0x04 : 0x08; |
795 | report->field[0]->value[0] |= data_pointer->release_to_select ? 0x10 : 0x20; |
796 | report->field[0]->value[0] |= data_pointer->select_right ? 0x80 : 0x40; |
797 | report->field[1]->value[0] = 0x03; // unknown setting, imitate windows driver |
798 | report->field[2]->value[0] = data_pointer->sensitivity; |
799 | report->field[3]->value[0] = data_pointer->press_speed; |
800 | |
801 | hid_hw_request(hdev, report, reqtype: HID_REQ_SET_REPORT); |
802 | return 0; |
803 | } |
804 | |
805 | static ssize_t attr_press_to_select_show_tpkbd(struct device *dev, |
806 | struct device_attribute *attr, |
807 | char *buf) |
808 | { |
809 | struct hid_device *hdev = to_hid_device(dev); |
810 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
811 | |
812 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , data_pointer->press_to_select); |
813 | } |
814 | |
815 | static ssize_t attr_press_to_select_store_tpkbd(struct device *dev, |
816 | struct device_attribute *attr, |
817 | const char *buf, |
818 | size_t count) |
819 | { |
820 | struct hid_device *hdev = to_hid_device(dev); |
821 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
822 | int value; |
823 | |
824 | if (kstrtoint(s: buf, base: 10, res: &value)) |
825 | return -EINVAL; |
826 | if (value < 0 || value > 1) |
827 | return -EINVAL; |
828 | |
829 | data_pointer->press_to_select = value; |
830 | lenovo_features_set_tpkbd(hdev); |
831 | |
832 | return count; |
833 | } |
834 | |
835 | static ssize_t attr_dragging_show_tpkbd(struct device *dev, |
836 | struct device_attribute *attr, |
837 | char *buf) |
838 | { |
839 | struct hid_device *hdev = to_hid_device(dev); |
840 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
841 | |
842 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , data_pointer->dragging); |
843 | } |
844 | |
845 | static ssize_t attr_dragging_store_tpkbd(struct device *dev, |
846 | struct device_attribute *attr, |
847 | const char *buf, |
848 | size_t count) |
849 | { |
850 | struct hid_device *hdev = to_hid_device(dev); |
851 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
852 | int value; |
853 | |
854 | if (kstrtoint(s: buf, base: 10, res: &value)) |
855 | return -EINVAL; |
856 | if (value < 0 || value > 1) |
857 | return -EINVAL; |
858 | |
859 | data_pointer->dragging = value; |
860 | lenovo_features_set_tpkbd(hdev); |
861 | |
862 | return count; |
863 | } |
864 | |
865 | static ssize_t attr_release_to_select_show_tpkbd(struct device *dev, |
866 | struct device_attribute *attr, |
867 | char *buf) |
868 | { |
869 | struct hid_device *hdev = to_hid_device(dev); |
870 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
871 | |
872 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , data_pointer->release_to_select); |
873 | } |
874 | |
875 | static ssize_t attr_release_to_select_store_tpkbd(struct device *dev, |
876 | struct device_attribute *attr, |
877 | const char *buf, |
878 | size_t count) |
879 | { |
880 | struct hid_device *hdev = to_hid_device(dev); |
881 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
882 | int value; |
883 | |
884 | if (kstrtoint(s: buf, base: 10, res: &value)) |
885 | return -EINVAL; |
886 | if (value < 0 || value > 1) |
887 | return -EINVAL; |
888 | |
889 | data_pointer->release_to_select = value; |
890 | lenovo_features_set_tpkbd(hdev); |
891 | |
892 | return count; |
893 | } |
894 | |
895 | static ssize_t attr_select_right_show_tpkbd(struct device *dev, |
896 | struct device_attribute *attr, |
897 | char *buf) |
898 | { |
899 | struct hid_device *hdev = to_hid_device(dev); |
900 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
901 | |
902 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , data_pointer->select_right); |
903 | } |
904 | |
905 | static ssize_t attr_select_right_store_tpkbd(struct device *dev, |
906 | struct device_attribute *attr, |
907 | const char *buf, |
908 | size_t count) |
909 | { |
910 | struct hid_device *hdev = to_hid_device(dev); |
911 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
912 | int value; |
913 | |
914 | if (kstrtoint(s: buf, base: 10, res: &value)) |
915 | return -EINVAL; |
916 | if (value < 0 || value > 1) |
917 | return -EINVAL; |
918 | |
919 | data_pointer->select_right = value; |
920 | lenovo_features_set_tpkbd(hdev); |
921 | |
922 | return count; |
923 | } |
924 | |
925 | static ssize_t attr_sensitivity_show_tpkbd(struct device *dev, |
926 | struct device_attribute *attr, |
927 | char *buf) |
928 | { |
929 | struct hid_device *hdev = to_hid_device(dev); |
930 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
931 | |
932 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , |
933 | data_pointer->sensitivity); |
934 | } |
935 | |
936 | static ssize_t attr_sensitivity_store_tpkbd(struct device *dev, |
937 | struct device_attribute *attr, |
938 | const char *buf, |
939 | size_t count) |
940 | { |
941 | struct hid_device *hdev = to_hid_device(dev); |
942 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
943 | int value; |
944 | |
945 | if (kstrtoint(s: buf, base: 10, res: &value) || value < 1 || value > 255) |
946 | return -EINVAL; |
947 | |
948 | data_pointer->sensitivity = value; |
949 | lenovo_features_set_tpkbd(hdev); |
950 | |
951 | return count; |
952 | } |
953 | |
954 | static ssize_t attr_press_speed_show_tpkbd(struct device *dev, |
955 | struct device_attribute *attr, |
956 | char *buf) |
957 | { |
958 | struct hid_device *hdev = to_hid_device(dev); |
959 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
960 | |
961 | return snprintf(buf, PAGE_SIZE, fmt: "%u\n" , |
962 | data_pointer->press_speed); |
963 | } |
964 | |
965 | static ssize_t attr_press_speed_store_tpkbd(struct device *dev, |
966 | struct device_attribute *attr, |
967 | const char *buf, |
968 | size_t count) |
969 | { |
970 | struct hid_device *hdev = to_hid_device(dev); |
971 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
972 | int value; |
973 | |
974 | if (kstrtoint(s: buf, base: 10, res: &value) || value < 1 || value > 255) |
975 | return -EINVAL; |
976 | |
977 | data_pointer->press_speed = value; |
978 | lenovo_features_set_tpkbd(hdev); |
979 | |
980 | return count; |
981 | } |
982 | |
983 | static struct device_attribute dev_attr_press_to_select_tpkbd = |
984 | __ATTR(press_to_select, S_IWUSR | S_IRUGO, |
985 | attr_press_to_select_show_tpkbd, |
986 | attr_press_to_select_store_tpkbd); |
987 | |
988 | static struct device_attribute dev_attr_dragging_tpkbd = |
989 | __ATTR(dragging, S_IWUSR | S_IRUGO, |
990 | attr_dragging_show_tpkbd, |
991 | attr_dragging_store_tpkbd); |
992 | |
993 | static struct device_attribute dev_attr_release_to_select_tpkbd = |
994 | __ATTR(release_to_select, S_IWUSR | S_IRUGO, |
995 | attr_release_to_select_show_tpkbd, |
996 | attr_release_to_select_store_tpkbd); |
997 | |
998 | static struct device_attribute dev_attr_select_right_tpkbd = |
999 | __ATTR(select_right, S_IWUSR | S_IRUGO, |
1000 | attr_select_right_show_tpkbd, |
1001 | attr_select_right_store_tpkbd); |
1002 | |
1003 | static struct device_attribute dev_attr_sensitivity_tpkbd = |
1004 | __ATTR(sensitivity, S_IWUSR | S_IRUGO, |
1005 | attr_sensitivity_show_tpkbd, |
1006 | attr_sensitivity_store_tpkbd); |
1007 | |
1008 | static struct device_attribute dev_attr_press_speed_tpkbd = |
1009 | __ATTR(press_speed, S_IWUSR | S_IRUGO, |
1010 | attr_press_speed_show_tpkbd, |
1011 | attr_press_speed_store_tpkbd); |
1012 | |
1013 | static struct attribute *lenovo_attributes_tpkbd[] = { |
1014 | &dev_attr_press_to_select_tpkbd.attr, |
1015 | &dev_attr_dragging_tpkbd.attr, |
1016 | &dev_attr_release_to_select_tpkbd.attr, |
1017 | &dev_attr_select_right_tpkbd.attr, |
1018 | &dev_attr_sensitivity_tpkbd.attr, |
1019 | &dev_attr_press_speed_tpkbd.attr, |
1020 | NULL |
1021 | }; |
1022 | |
1023 | static const struct attribute_group lenovo_attr_group_tpkbd = { |
1024 | .attrs = lenovo_attributes_tpkbd, |
1025 | }; |
1026 | |
1027 | static void lenovo_led_set_tpkbd(struct hid_device *hdev) |
1028 | { |
1029 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
1030 | struct hid_report *report; |
1031 | |
1032 | report = hdev->report_enum[HID_OUTPUT_REPORT].report_id_hash[3]; |
1033 | report->field[0]->value[0] = (data_pointer->led_state >> 0) & 1; |
1034 | report->field[0]->value[1] = (data_pointer->led_state >> 1) & 1; |
1035 | hid_hw_request(hdev, report, reqtype: HID_REQ_SET_REPORT); |
1036 | } |
1037 | |
1038 | static int lenovo_led_brightness_set(struct led_classdev *led_cdev, |
1039 | enum led_brightness value) |
1040 | { |
1041 | struct device *dev = led_cdev->dev->parent; |
1042 | struct hid_device *hdev = to_hid_device(dev); |
1043 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
1044 | static const u8 tp10ubkbd_led[] = { TP10UBKBD_MUTE_LED, TP10UBKBD_MICMUTE_LED }; |
1045 | int led_nr = 0; |
1046 | int ret = 0; |
1047 | |
1048 | if (led_cdev == &data_pointer->led_micmute) |
1049 | led_nr = 1; |
1050 | |
1051 | if (value == LED_OFF) |
1052 | data_pointer->led_state &= ~(1 << led_nr); |
1053 | else |
1054 | data_pointer->led_state |= 1 << led_nr; |
1055 | |
1056 | switch (hdev->product) { |
1057 | case USB_DEVICE_ID_LENOVO_TPKBD: |
1058 | lenovo_led_set_tpkbd(hdev); |
1059 | break; |
1060 | case USB_DEVICE_ID_LENOVO_TP10UBKBD: |
1061 | case USB_DEVICE_ID_LENOVO_X1_TAB: |
1062 | ret = lenovo_led_set_tp10ubkbd(hdev, led_code: tp10ubkbd_led[led_nr], value); |
1063 | break; |
1064 | } |
1065 | |
1066 | return ret; |
1067 | } |
1068 | |
1069 | static int lenovo_register_leds(struct hid_device *hdev) |
1070 | { |
1071 | struct lenovo_drvdata *data = hid_get_drvdata(hdev); |
1072 | size_t name_sz = strlen(dev_name(&hdev->dev)) + 16; |
1073 | char *name_mute, *name_micm; |
1074 | int ret; |
1075 | |
1076 | name_mute = devm_kzalloc(dev: &hdev->dev, size: name_sz, GFP_KERNEL); |
1077 | name_micm = devm_kzalloc(dev: &hdev->dev, size: name_sz, GFP_KERNEL); |
1078 | if (name_mute == NULL || name_micm == NULL) { |
1079 | hid_err(hdev, "Could not allocate memory for led data\n" ); |
1080 | return -ENOMEM; |
1081 | } |
1082 | snprintf(buf: name_mute, size: name_sz, fmt: "%s:amber:mute" , dev_name(dev: &hdev->dev)); |
1083 | snprintf(buf: name_micm, size: name_sz, fmt: "%s:amber:micmute" , dev_name(dev: &hdev->dev)); |
1084 | |
1085 | data->led_mute.name = name_mute; |
1086 | data->led_mute.default_trigger = "audio-mute" ; |
1087 | data->led_mute.brightness_set_blocking = lenovo_led_brightness_set; |
1088 | data->led_mute.max_brightness = 1; |
1089 | data->led_mute.flags = LED_HW_PLUGGABLE; |
1090 | data->led_mute.dev = &hdev->dev; |
1091 | ret = led_classdev_register(parent: &hdev->dev, led_cdev: &data->led_mute); |
1092 | if (ret < 0) |
1093 | return ret; |
1094 | |
1095 | data->led_micmute.name = name_micm; |
1096 | data->led_micmute.default_trigger = "audio-micmute" ; |
1097 | data->led_micmute.brightness_set_blocking = lenovo_led_brightness_set; |
1098 | data->led_micmute.max_brightness = 1; |
1099 | data->led_micmute.flags = LED_HW_PLUGGABLE; |
1100 | data->led_micmute.dev = &hdev->dev; |
1101 | ret = led_classdev_register(parent: &hdev->dev, led_cdev: &data->led_micmute); |
1102 | if (ret < 0) { |
1103 | led_classdev_unregister(led_cdev: &data->led_mute); |
1104 | return ret; |
1105 | } |
1106 | |
1107 | return 0; |
1108 | } |
1109 | |
1110 | static int lenovo_probe_tpkbd(struct hid_device *hdev) |
1111 | { |
1112 | struct lenovo_drvdata *data_pointer; |
1113 | int i, ret; |
1114 | |
1115 | /* |
1116 | * Only register extra settings against subdevice where input_mapping |
1117 | * set drvdata to 1, i.e. the trackpoint. |
1118 | */ |
1119 | if (!hid_get_drvdata(hdev)) |
1120 | return 0; |
1121 | |
1122 | hid_set_drvdata(hdev, NULL); |
1123 | |
1124 | /* Validate required reports. */ |
1125 | for (i = 0; i < 4; i++) { |
1126 | if (!hid_validate_values(hid: hdev, type: HID_FEATURE_REPORT, id: 4, field_index: i, report_counts: 1)) |
1127 | return -ENODEV; |
1128 | } |
1129 | if (!hid_validate_values(hid: hdev, type: HID_OUTPUT_REPORT, id: 3, field_index: 0, report_counts: 2)) |
1130 | return -ENODEV; |
1131 | |
1132 | ret = sysfs_create_group(kobj: &hdev->dev.kobj, grp: &lenovo_attr_group_tpkbd); |
1133 | if (ret) |
1134 | hid_warn(hdev, "Could not create sysfs group: %d\n" , ret); |
1135 | |
1136 | data_pointer = devm_kzalloc(dev: &hdev->dev, |
1137 | size: sizeof(struct lenovo_drvdata), |
1138 | GFP_KERNEL); |
1139 | if (data_pointer == NULL) { |
1140 | hid_err(hdev, "Could not allocate memory for driver data\n" ); |
1141 | ret = -ENOMEM; |
1142 | goto err; |
1143 | } |
1144 | |
1145 | // set same default values as windows driver |
1146 | data_pointer->sensitivity = 0xa0; |
1147 | data_pointer->press_speed = 0x38; |
1148 | |
1149 | hid_set_drvdata(hdev, data: data_pointer); |
1150 | |
1151 | ret = lenovo_register_leds(hdev); |
1152 | if (ret) |
1153 | goto err; |
1154 | |
1155 | lenovo_features_set_tpkbd(hdev); |
1156 | |
1157 | return 0; |
1158 | err: |
1159 | sysfs_remove_group(kobj: &hdev->dev.kobj, grp: &lenovo_attr_group_tpkbd); |
1160 | return ret; |
1161 | } |
1162 | |
1163 | static int lenovo_probe_cptkbd(struct hid_device *hdev) |
1164 | { |
1165 | int ret; |
1166 | struct lenovo_drvdata *cptkbd_data; |
1167 | |
1168 | /* All the custom action happens on the USBMOUSE device for USB */ |
1169 | if (((hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD) || |
1170 | (hdev->product == USB_DEVICE_ID_LENOVO_TPIIUSBKBD)) && |
1171 | hdev->type != HID_TYPE_USBMOUSE) { |
1172 | hid_dbg(hdev, "Ignoring keyboard half of device\n" ); |
1173 | return 0; |
1174 | } |
1175 | |
1176 | cptkbd_data = devm_kzalloc(dev: &hdev->dev, |
1177 | size: sizeof(*cptkbd_data), |
1178 | GFP_KERNEL); |
1179 | if (cptkbd_data == NULL) { |
1180 | hid_err(hdev, "can't alloc keyboard descriptor\n" ); |
1181 | return -ENOMEM; |
1182 | } |
1183 | hid_set_drvdata(hdev, data: cptkbd_data); |
1184 | |
1185 | /* Set keyboard settings to known state */ |
1186 | cptkbd_data->middlebutton_state = 0; |
1187 | cptkbd_data->fn_lock = true; |
1188 | cptkbd_data->sensitivity = 0x05; |
1189 | cptkbd_data->middleclick_workaround_cptkbd = true; |
1190 | lenovo_features_set_cptkbd(hdev); |
1191 | |
1192 | ret = sysfs_create_group(kobj: &hdev->dev.kobj, grp: &lenovo_attr_group_cptkbd); |
1193 | if (ret) |
1194 | hid_warn(hdev, "Could not create sysfs group: %d\n" , ret); |
1195 | |
1196 | return 0; |
1197 | } |
1198 | |
1199 | static struct attribute *lenovo_attributes_tp10ubkbd[] = { |
1200 | &dev_attr_fn_lock.attr, |
1201 | NULL |
1202 | }; |
1203 | |
1204 | static const struct attribute_group lenovo_attr_group_tp10ubkbd = { |
1205 | .attrs = lenovo_attributes_tp10ubkbd, |
1206 | }; |
1207 | |
1208 | static int lenovo_probe_tp10ubkbd(struct hid_device *hdev) |
1209 | { |
1210 | struct hid_report_enum *rep_enum; |
1211 | struct lenovo_drvdata *data; |
1212 | struct hid_report *rep; |
1213 | bool found; |
1214 | int ret; |
1215 | |
1216 | /* |
1217 | * The LEDs and the Fn-lock functionality use output report 9, |
1218 | * with an application of 0xffa0001, add the LEDs on the interface |
1219 | * with this output report. |
1220 | */ |
1221 | found = false; |
1222 | rep_enum = &hdev->report_enum[HID_OUTPUT_REPORT]; |
1223 | list_for_each_entry(rep, &rep_enum->report_list, list) { |
1224 | if (rep->application == 0xffa00001) |
1225 | found = true; |
1226 | } |
1227 | if (!found) |
1228 | return 0; |
1229 | |
1230 | data = devm_kzalloc(dev: &hdev->dev, size: sizeof(*data), GFP_KERNEL); |
1231 | if (!data) |
1232 | return -ENOMEM; |
1233 | |
1234 | mutex_init(&data->led_report_mutex); |
1235 | INIT_WORK(&data->fn_lock_sync_work, lenovo_tp10ubkbd_sync_fn_lock); |
1236 | data->hdev = hdev; |
1237 | |
1238 | hid_set_drvdata(hdev, data); |
1239 | |
1240 | /* |
1241 | * The Thinkpad 10 ultrabook USB kbd dock's Fn-lock defaults to on. |
1242 | * We cannot read the state, only set it, so we force it to on here |
1243 | * (which should be a no-op) to make sure that our state matches the |
1244 | * keyboard's FN-lock state. This is the same as what Windows does. |
1245 | */ |
1246 | data->fn_lock = true; |
1247 | lenovo_led_set_tp10ubkbd(hdev, TP10UBKBD_FN_LOCK_LED, value: data->fn_lock); |
1248 | |
1249 | ret = sysfs_create_group(kobj: &hdev->dev.kobj, grp: &lenovo_attr_group_tp10ubkbd); |
1250 | if (ret) |
1251 | return ret; |
1252 | |
1253 | ret = lenovo_register_leds(hdev); |
1254 | if (ret) |
1255 | goto err; |
1256 | |
1257 | return 0; |
1258 | err: |
1259 | sysfs_remove_group(kobj: &hdev->dev.kobj, grp: &lenovo_attr_group_tp10ubkbd); |
1260 | return ret; |
1261 | } |
1262 | |
1263 | static int lenovo_probe(struct hid_device *hdev, |
1264 | const struct hid_device_id *id) |
1265 | { |
1266 | int ret; |
1267 | |
1268 | ret = hid_parse(hdev); |
1269 | if (ret) { |
1270 | hid_err(hdev, "hid_parse failed\n" ); |
1271 | goto err; |
1272 | } |
1273 | |
1274 | ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); |
1275 | if (ret) { |
1276 | hid_err(hdev, "hid_hw_start failed\n" ); |
1277 | goto err; |
1278 | } |
1279 | |
1280 | switch (hdev->product) { |
1281 | case USB_DEVICE_ID_LENOVO_TPKBD: |
1282 | ret = lenovo_probe_tpkbd(hdev); |
1283 | break; |
1284 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
1285 | case USB_DEVICE_ID_LENOVO_CBTKBD: |
1286 | case USB_DEVICE_ID_LENOVO_TPIIUSBKBD: |
1287 | case USB_DEVICE_ID_LENOVO_TPIIBTKBD: |
1288 | ret = lenovo_probe_cptkbd(hdev); |
1289 | break; |
1290 | case USB_DEVICE_ID_LENOVO_TP10UBKBD: |
1291 | case USB_DEVICE_ID_LENOVO_X1_TAB: |
1292 | ret = lenovo_probe_tp10ubkbd(hdev); |
1293 | break; |
1294 | default: |
1295 | ret = 0; |
1296 | break; |
1297 | } |
1298 | if (ret) |
1299 | goto err_hid; |
1300 | |
1301 | return 0; |
1302 | err_hid: |
1303 | hid_hw_stop(hdev); |
1304 | err: |
1305 | return ret; |
1306 | } |
1307 | |
1308 | #ifdef CONFIG_PM |
1309 | static int lenovo_reset_resume(struct hid_device *hdev) |
1310 | { |
1311 | switch (hdev->product) { |
1312 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
1313 | case USB_DEVICE_ID_LENOVO_TPIIUSBKBD: |
1314 | if (hdev->type == HID_TYPE_USBMOUSE) |
1315 | lenovo_features_set_cptkbd(hdev); |
1316 | |
1317 | break; |
1318 | default: |
1319 | break; |
1320 | } |
1321 | |
1322 | return 0; |
1323 | } |
1324 | #endif |
1325 | |
1326 | static void lenovo_remove_tpkbd(struct hid_device *hdev) |
1327 | { |
1328 | struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev); |
1329 | |
1330 | /* |
1331 | * Only the trackpoint half of the keyboard has drvdata and stuff that |
1332 | * needs unregistering. |
1333 | */ |
1334 | if (data_pointer == NULL) |
1335 | return; |
1336 | |
1337 | sysfs_remove_group(kobj: &hdev->dev.kobj, |
1338 | grp: &lenovo_attr_group_tpkbd); |
1339 | |
1340 | led_classdev_unregister(led_cdev: &data_pointer->led_micmute); |
1341 | led_classdev_unregister(led_cdev: &data_pointer->led_mute); |
1342 | } |
1343 | |
1344 | static void lenovo_remove_cptkbd(struct hid_device *hdev) |
1345 | { |
1346 | sysfs_remove_group(kobj: &hdev->dev.kobj, |
1347 | grp: &lenovo_attr_group_cptkbd); |
1348 | } |
1349 | |
1350 | static void lenovo_remove_tp10ubkbd(struct hid_device *hdev) |
1351 | { |
1352 | struct lenovo_drvdata *data = hid_get_drvdata(hdev); |
1353 | |
1354 | if (data == NULL) |
1355 | return; |
1356 | |
1357 | led_classdev_unregister(led_cdev: &data->led_micmute); |
1358 | led_classdev_unregister(led_cdev: &data->led_mute); |
1359 | |
1360 | sysfs_remove_group(kobj: &hdev->dev.kobj, grp: &lenovo_attr_group_tp10ubkbd); |
1361 | cancel_work_sync(work: &data->fn_lock_sync_work); |
1362 | } |
1363 | |
1364 | static void lenovo_remove(struct hid_device *hdev) |
1365 | { |
1366 | switch (hdev->product) { |
1367 | case USB_DEVICE_ID_LENOVO_TPKBD: |
1368 | lenovo_remove_tpkbd(hdev); |
1369 | break; |
1370 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
1371 | case USB_DEVICE_ID_LENOVO_CBTKBD: |
1372 | case USB_DEVICE_ID_LENOVO_TPIIUSBKBD: |
1373 | case USB_DEVICE_ID_LENOVO_TPIIBTKBD: |
1374 | lenovo_remove_cptkbd(hdev); |
1375 | break; |
1376 | case USB_DEVICE_ID_LENOVO_TP10UBKBD: |
1377 | case USB_DEVICE_ID_LENOVO_X1_TAB: |
1378 | lenovo_remove_tp10ubkbd(hdev); |
1379 | break; |
1380 | } |
1381 | |
1382 | hid_hw_stop(hdev); |
1383 | } |
1384 | |
1385 | static int lenovo_input_configured(struct hid_device *hdev, |
1386 | struct hid_input *hi) |
1387 | { |
1388 | switch (hdev->product) { |
1389 | case USB_DEVICE_ID_LENOVO_TPKBD: |
1390 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
1391 | case USB_DEVICE_ID_LENOVO_CBTKBD: |
1392 | case USB_DEVICE_ID_LENOVO_TPIIUSBKBD: |
1393 | case USB_DEVICE_ID_LENOVO_TPIIBTKBD: |
1394 | if (test_bit(EV_REL, hi->input->evbit)) { |
1395 | /* set only for trackpoint device */ |
1396 | __set_bit(INPUT_PROP_POINTER, hi->input->propbit); |
1397 | __set_bit(INPUT_PROP_POINTING_STICK, |
1398 | hi->input->propbit); |
1399 | } |
1400 | break; |
1401 | } |
1402 | |
1403 | return 0; |
1404 | } |
1405 | |
1406 | |
1407 | static const struct hid_device_id lenovo_devices[] = { |
1408 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) }, |
1409 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) }, |
1410 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPIIUSBKBD) }, |
1411 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) }, |
1412 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPIIBTKBD) }, |
1413 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) }, |
1414 | { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_III) }, |
1415 | { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_PRO) }, |
1416 | { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_OPTICAL) }, |
1417 | { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL) }, |
1418 | { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL_PRO) }, |
1419 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_SCROLLPOINT_OPTICAL) }, |
1420 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TP10UBKBD) }, |
1421 | /* |
1422 | * Note bind to the HID_GROUP_GENERIC group, so that we only bind to the keyboard |
1423 | * part, while letting hid-multitouch.c handle the touchpad and trackpoint. |
1424 | */ |
1425 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, |
1426 | USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_X1_TAB) }, |
1427 | { } |
1428 | }; |
1429 | |
1430 | MODULE_DEVICE_TABLE(hid, lenovo_devices); |
1431 | |
1432 | static struct hid_driver lenovo_driver = { |
1433 | .name = "lenovo" , |
1434 | .id_table = lenovo_devices, |
1435 | .input_configured = lenovo_input_configured, |
1436 | .input_mapping = lenovo_input_mapping, |
1437 | .probe = lenovo_probe, |
1438 | .remove = lenovo_remove, |
1439 | .raw_event = lenovo_raw_event, |
1440 | .event = lenovo_event, |
1441 | .report_fixup = lenovo_report_fixup, |
1442 | #ifdef CONFIG_PM |
1443 | .reset_resume = lenovo_reset_resume, |
1444 | #endif |
1445 | }; |
1446 | module_hid_driver(lenovo_driver); |
1447 | |
1448 | MODULE_LICENSE("GPL" ); |
1449 | |