Commit | Line | Data |
---|---|---|
c1dcad2d | 1 | /* |
6a5b414b JL |
2 | * HID driver for Lenovo: |
3 | * - ThinkPad USB Keyboard with TrackPoint (tpkbd) | |
f3d4ff0e JL |
4 | * - ThinkPad Compact Bluetooth Keyboard with TrackPoint (cptkbd) |
5 | * - ThinkPad Compact USB Keyboard with TrackPoint (cptkbd) | |
c1dcad2d BS |
6 | * |
7 | * Copyright (c) 2012 Bernhard Seibold | |
f3d4ff0e | 8 | * Copyright (c) 2014 Jamie Lentin <jm@lentin.co.uk> |
c1dcad2d BS |
9 | */ |
10 | ||
11 | /* | |
12 | * This program is free software; you can redistribute it and/or modify it | |
13 | * under the terms of the GNU General Public License as published by the Free | |
14 | * Software Foundation; either version 2 of the License, or (at your option) | |
15 | * any later version. | |
16 | */ | |
17 | ||
18 | #include <linux/module.h> | |
19 | #include <linux/sysfs.h> | |
20 | #include <linux/device.h> | |
c1dcad2d BS |
21 | #include <linux/hid.h> |
22 | #include <linux/input.h> | |
23 | #include <linux/leds.h> | |
c1dcad2d BS |
24 | |
25 | #include "hid-ids.h" | |
26 | ||
94723bfa | 27 | struct lenovo_drvdata_tpkbd { |
c1dcad2d BS |
28 | int led_state; |
29 | struct led_classdev led_mute; | |
30 | struct led_classdev led_micmute; | |
31 | int press_to_select; | |
32 | int dragging; | |
33 | int release_to_select; | |
34 | int select_right; | |
35 | int sensitivity; | |
36 | int press_speed; | |
37 | }; | |
38 | ||
f3d4ff0e | 39 | struct lenovo_drvdata_cptkbd { |
3cb5ff02 | 40 | u8 middlebutton_state; /* 0:Up, 1:Down (undecided), 2:Scrolling */ |
f3d4ff0e | 41 | bool fn_lock; |
e3cb0acd | 42 | int sensitivity; |
f3d4ff0e JL |
43 | }; |
44 | ||
c1dcad2d BS |
45 | #define map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, EV_KEY, (c)) |
46 | ||
181a8b91 BT |
47 | static const __u8 lenovo_pro_dock_need_fixup_collection[] = { |
48 | 0x05, 0x88, /* Usage Page (Vendor Usage Page 0x88) */ | |
49 | 0x09, 0x01, /* Usage (Vendor Usage 0x01) */ | |
50 | 0xa1, 0x01, /* Collection (Application) */ | |
51 | 0x85, 0x04, /* Report ID (4) */ | |
52 | 0x19, 0x00, /* Usage Minimum (0) */ | |
53 | 0x2a, 0xff, 0xff, /* Usage Maximum (65535) */ | |
54 | }; | |
55 | ||
56 | static __u8 *lenovo_report_fixup(struct hid_device *hdev, __u8 *rdesc, | |
57 | unsigned int *rsize) | |
58 | { | |
59 | switch (hdev->product) { | |
60 | case USB_DEVICE_ID_LENOVO_TPPRODOCK: | |
61 | /* the fixups that need to be done: | |
62 | * - get a reasonable usage max for the vendor collection | |
63 | * 0x8801 from the report ID 4 | |
64 | */ | |
65 | if (*rsize >= 153 && | |
66 | memcmp(&rdesc[140], lenovo_pro_dock_need_fixup_collection, | |
67 | sizeof(lenovo_pro_dock_need_fixup_collection)) == 0) { | |
68 | rdesc[151] = 0x01; | |
69 | rdesc[152] = 0x00; | |
70 | } | |
71 | break; | |
72 | } | |
73 | return rdesc; | |
74 | } | |
75 | ||
94723bfa | 76 | static int lenovo_input_mapping_tpkbd(struct hid_device *hdev, |
c1dcad2d BS |
77 | struct hid_input *hi, struct hid_field *field, |
78 | struct hid_usage *usage, unsigned long **bit, int *max) | |
79 | { | |
0c521836 | 80 | if (usage->hid == (HID_UP_BUTTON | 0x0010)) { |
6a5b414b | 81 | /* This sub-device contains trackpoint, mark it */ |
0c521836 | 82 | hid_set_drvdata(hdev, (void *)1); |
c1dcad2d BS |
83 | map_key_clear(KEY_MICMUTE); |
84 | return 1; | |
85 | } | |
86 | return 0; | |
87 | } | |
88 | ||
f3d4ff0e JL |
89 | static int lenovo_input_mapping_cptkbd(struct hid_device *hdev, |
90 | struct hid_input *hi, struct hid_field *field, | |
91 | struct hid_usage *usage, unsigned long **bit, int *max) | |
92 | { | |
93 | /* HID_UP_LNVENDOR = USB, HID_UP_MSVENDOR = BT */ | |
94 | if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR || | |
95 | (usage->hid & HID_USAGE_PAGE) == HID_UP_LNVENDOR) { | |
f3d4ff0e JL |
96 | switch (usage->hid & HID_USAGE) { |
97 | case 0x00f1: /* Fn-F4: Mic mute */ | |
98 | map_key_clear(KEY_MICMUTE); | |
99 | return 1; | |
100 | case 0x00f2: /* Fn-F5: Brightness down */ | |
101 | map_key_clear(KEY_BRIGHTNESSDOWN); | |
102 | return 1; | |
103 | case 0x00f3: /* Fn-F6: Brightness up */ | |
104 | map_key_clear(KEY_BRIGHTNESSUP); | |
105 | return 1; | |
106 | case 0x00f4: /* Fn-F7: External display (projector) */ | |
107 | map_key_clear(KEY_SWITCHVIDEOMODE); | |
108 | return 1; | |
109 | case 0x00f5: /* Fn-F8: Wireless */ | |
110 | map_key_clear(KEY_WLAN); | |
111 | return 1; | |
112 | case 0x00f6: /* Fn-F9: Control panel */ | |
113 | map_key_clear(KEY_CONFIG); | |
114 | return 1; | |
115 | case 0x00f8: /* Fn-F11: View open applications (3 boxes) */ | |
116 | map_key_clear(KEY_SCALE); | |
117 | return 1; | |
5556eb14 | 118 | case 0x00f9: /* Fn-F12: Open My computer (6 boxes) USB-only */ |
f3d4ff0e JL |
119 | /* NB: This mapping is invented in raw_event below */ |
120 | map_key_clear(KEY_FILE); | |
121 | return 1; | |
5556eb14 JL |
122 | case 0x00fa: /* Fn-Esc: Fn-lock toggle */ |
123 | map_key_clear(KEY_FN_ESC); | |
124 | return 1; | |
94eefa27 JL |
125 | case 0x00fb: /* Middle mouse button (in native mode) */ |
126 | map_key_clear(BTN_MIDDLE); | |
127 | return 1; | |
128 | } | |
129 | } | |
130 | ||
131 | /* Compatibility middle/wheel mappings should be ignored */ | |
132 | if (usage->hid == HID_GD_WHEEL) | |
133 | return -1; | |
134 | if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON && | |
135 | (usage->hid & HID_USAGE) == 0x003) | |
136 | return -1; | |
137 | if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER && | |
138 | (usage->hid & HID_USAGE) == 0x238) | |
139 | return -1; | |
140 | ||
141 | /* Map wheel emulation reports: 0xffa1 = USB, 0xff10 = BT */ | |
142 | if ((usage->hid & HID_USAGE_PAGE) == 0xff100000 || | |
143 | (usage->hid & HID_USAGE_PAGE) == 0xffa10000) { | |
144 | field->flags |= HID_MAIN_ITEM_RELATIVE | HID_MAIN_ITEM_VARIABLE; | |
145 | field->logical_minimum = -127; | |
146 | field->logical_maximum = 127; | |
147 | ||
148 | switch (usage->hid & HID_USAGE) { | |
149 | case 0x0000: | |
7f65068f | 150 | hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL); |
94eefa27 JL |
151 | return 1; |
152 | case 0x0001: | |
7f65068f | 153 | hid_map_usage(hi, usage, bit, max, EV_REL, REL_WHEEL); |
94eefa27 JL |
154 | return 1; |
155 | default: | |
156 | return -1; | |
f3d4ff0e JL |
157 | } |
158 | } | |
159 | ||
160 | return 0; | |
161 | } | |
162 | ||
6a5b414b JL |
163 | static int lenovo_input_mapping(struct hid_device *hdev, |
164 | struct hid_input *hi, struct hid_field *field, | |
165 | struct hid_usage *usage, unsigned long **bit, int *max) | |
166 | { | |
167 | switch (hdev->product) { | |
168 | case USB_DEVICE_ID_LENOVO_TPKBD: | |
169 | return lenovo_input_mapping_tpkbd(hdev, hi, field, | |
170 | usage, bit, max); | |
f3d4ff0e JL |
171 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
172 | case USB_DEVICE_ID_LENOVO_CBTKBD: | |
173 | return lenovo_input_mapping_cptkbd(hdev, hi, field, | |
174 | usage, bit, max); | |
6a5b414b JL |
175 | default: |
176 | return 0; | |
177 | } | |
178 | } | |
179 | ||
c1dcad2d BS |
180 | #undef map_key_clear |
181 | ||
f3d4ff0e JL |
182 | /* Send a config command to the keyboard */ |
183 | static int lenovo_send_cmd_cptkbd(struct hid_device *hdev, | |
184 | unsigned char byte2, unsigned char byte3) | |
185 | { | |
186 | int ret; | |
ea36ae09 JB |
187 | unsigned char *buf; |
188 | ||
189 | buf = kzalloc(3, GFP_KERNEL); | |
190 | if (!buf) | |
191 | return -ENOMEM; | |
192 | ||
193 | buf[0] = 0x18; | |
194 | buf[1] = byte2; | |
195 | buf[2] = byte3; | |
f3d4ff0e JL |
196 | |
197 | switch (hdev->product) { | |
198 | case USB_DEVICE_ID_LENOVO_CUSBKBD: | |
ea36ae09 | 199 | ret = hid_hw_raw_request(hdev, 0x13, buf, 3, |
f3d4ff0e JL |
200 | HID_FEATURE_REPORT, HID_REQ_SET_REPORT); |
201 | break; | |
202 | case USB_DEVICE_ID_LENOVO_CBTKBD: | |
ea36ae09 | 203 | ret = hid_hw_output_report(hdev, buf, 3); |
f3d4ff0e JL |
204 | break; |
205 | default: | |
206 | ret = -EINVAL; | |
207 | break; | |
208 | } | |
209 | ||
ea36ae09 JB |
210 | kfree(buf); |
211 | ||
f3d4ff0e JL |
212 | return ret < 0 ? ret : 0; /* BT returns 0, USB returns sizeof(buf) */ |
213 | } | |
214 | ||
215 | static void lenovo_features_set_cptkbd(struct hid_device *hdev) | |
216 | { | |
217 | int ret; | |
218 | struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev); | |
219 | ||
220 | ret = lenovo_send_cmd_cptkbd(hdev, 0x05, cptkbd_data->fn_lock); | |
221 | if (ret) | |
222 | hid_err(hdev, "Fn-lock setting failed: %d\n", ret); | |
dbfebb44 JL |
223 | |
224 | ret = lenovo_send_cmd_cptkbd(hdev, 0x02, cptkbd_data->sensitivity); | |
225 | if (ret) | |
226 | hid_err(hdev, "Sensitivity setting failed: %d\n", ret); | |
f3d4ff0e JL |
227 | } |
228 | ||
229 | static ssize_t attr_fn_lock_show_cptkbd(struct device *dev, | |
230 | struct device_attribute *attr, | |
231 | char *buf) | |
232 | { | |
ee79a8f8 | 233 | struct hid_device *hdev = to_hid_device(dev); |
f3d4ff0e JL |
234 | struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev); |
235 | ||
236 | return snprintf(buf, PAGE_SIZE, "%u\n", cptkbd_data->fn_lock); | |
237 | } | |
238 | ||
239 | static ssize_t attr_fn_lock_store_cptkbd(struct device *dev, | |
240 | struct device_attribute *attr, | |
241 | const char *buf, | |
242 | size_t count) | |
243 | { | |
ee79a8f8 | 244 | struct hid_device *hdev = to_hid_device(dev); |
f3d4ff0e JL |
245 | struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev); |
246 | int value; | |
247 | ||
248 | if (kstrtoint(buf, 10, &value)) | |
249 | return -EINVAL; | |
250 | if (value < 0 || value > 1) | |
251 | return -EINVAL; | |
252 | ||
253 | cptkbd_data->fn_lock = !!value; | |
254 | lenovo_features_set_cptkbd(hdev); | |
255 | ||
256 | return count; | |
257 | } | |
258 | ||
e3cb0acd JL |
259 | static ssize_t attr_sensitivity_show_cptkbd(struct device *dev, |
260 | struct device_attribute *attr, | |
261 | char *buf) | |
262 | { | |
ee79a8f8 | 263 | struct hid_device *hdev = to_hid_device(dev); |
e3cb0acd JL |
264 | struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev); |
265 | ||
266 | return snprintf(buf, PAGE_SIZE, "%u\n", | |
267 | cptkbd_data->sensitivity); | |
268 | } | |
269 | ||
270 | static ssize_t attr_sensitivity_store_cptkbd(struct device *dev, | |
271 | struct device_attribute *attr, | |
272 | const char *buf, | |
273 | size_t count) | |
274 | { | |
ee79a8f8 | 275 | struct hid_device *hdev = to_hid_device(dev); |
e3cb0acd JL |
276 | struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev); |
277 | int value; | |
278 | ||
279 | if (kstrtoint(buf, 10, &value) || value < 1 || value > 255) | |
280 | return -EINVAL; | |
281 | ||
282 | cptkbd_data->sensitivity = value; | |
283 | lenovo_features_set_cptkbd(hdev); | |
284 | ||
285 | return count; | |
286 | } | |
287 | ||
288 | ||
f3d4ff0e JL |
289 | static struct device_attribute dev_attr_fn_lock_cptkbd = |
290 | __ATTR(fn_lock, S_IWUSR | S_IRUGO, | |
291 | attr_fn_lock_show_cptkbd, | |
292 | attr_fn_lock_store_cptkbd); | |
293 | ||
e3cb0acd JL |
294 | static struct device_attribute dev_attr_sensitivity_cptkbd = |
295 | __ATTR(sensitivity, S_IWUSR | S_IRUGO, | |
296 | attr_sensitivity_show_cptkbd, | |
297 | attr_sensitivity_store_cptkbd); | |
298 | ||
299 | ||
f3d4ff0e JL |
300 | static struct attribute *lenovo_attributes_cptkbd[] = { |
301 | &dev_attr_fn_lock_cptkbd.attr, | |
e3cb0acd | 302 | &dev_attr_sensitivity_cptkbd.attr, |
f3d4ff0e JL |
303 | NULL |
304 | }; | |
305 | ||
306 | static const struct attribute_group lenovo_attr_group_cptkbd = { | |
307 | .attrs = lenovo_attributes_cptkbd, | |
308 | }; | |
309 | ||
310 | static int lenovo_raw_event(struct hid_device *hdev, | |
311 | struct hid_report *report, u8 *data, int size) | |
312 | { | |
313 | /* | |
314 | * Compact USB keyboard's Fn-F12 report holds down many other keys, and | |
315 | * its own key is outside the usage page range. Remove extra | |
316 | * keypresses and remap to inside usage page. | |
317 | */ | |
318 | if (unlikely(hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD | |
319 | && size == 3 | |
320 | && data[0] == 0x15 | |
321 | && data[1] == 0x94 | |
322 | && data[2] == 0x01)) { | |
5556eb14 JL |
323 | data[1] = 0x00; |
324 | data[2] = 0x01; | |
f3d4ff0e JL |
325 | } |
326 | ||
327 | return 0; | |
328 | } | |
329 | ||
3cb5ff02 JL |
330 | static int lenovo_event_cptkbd(struct hid_device *hdev, |
331 | struct hid_field *field, struct hid_usage *usage, __s32 value) | |
332 | { | |
333 | struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev); | |
334 | ||
335 | /* "wheel" scroll events */ | |
336 | if (usage->type == EV_REL && (usage->code == REL_WHEEL || | |
337 | usage->code == REL_HWHEEL)) { | |
338 | /* Scroll events disable middle-click event */ | |
339 | cptkbd_data->middlebutton_state = 2; | |
340 | return 0; | |
341 | } | |
342 | ||
343 | /* Middle click events */ | |
344 | if (usage->type == EV_KEY && usage->code == BTN_MIDDLE) { | |
345 | if (value == 1) { | |
346 | cptkbd_data->middlebutton_state = 1; | |
347 | } else if (value == 0) { | |
348 | if (cptkbd_data->middlebutton_state == 1) { | |
349 | /* No scrolling inbetween, send middle-click */ | |
350 | input_event(field->hidinput->input, | |
351 | EV_KEY, BTN_MIDDLE, 1); | |
352 | input_sync(field->hidinput->input); | |
353 | input_event(field->hidinput->input, | |
354 | EV_KEY, BTN_MIDDLE, 0); | |
355 | input_sync(field->hidinput->input); | |
356 | } | |
357 | cptkbd_data->middlebutton_state = 0; | |
358 | } | |
359 | return 1; | |
360 | } | |
361 | ||
362 | return 0; | |
363 | } | |
364 | ||
365 | static int lenovo_event(struct hid_device *hdev, struct hid_field *field, | |
366 | struct hid_usage *usage, __s32 value) | |
367 | { | |
368 | switch (hdev->product) { | |
369 | case USB_DEVICE_ID_LENOVO_CUSBKBD: | |
370 | case USB_DEVICE_ID_LENOVO_CBTKBD: | |
371 | return lenovo_event_cptkbd(hdev, field, usage, value); | |
372 | default: | |
373 | return 0; | |
374 | } | |
375 | } | |
376 | ||
94723bfa | 377 | static int lenovo_features_set_tpkbd(struct hid_device *hdev) |
c1dcad2d BS |
378 | { |
379 | struct hid_report *report; | |
94723bfa | 380 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d | 381 | |
c1dcad2d BS |
382 | report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[4]; |
383 | ||
384 | report->field[0]->value[0] = data_pointer->press_to_select ? 0x01 : 0x02; | |
385 | report->field[0]->value[0] |= data_pointer->dragging ? 0x04 : 0x08; | |
386 | report->field[0]->value[0] |= data_pointer->release_to_select ? 0x10 : 0x20; | |
387 | report->field[0]->value[0] |= data_pointer->select_right ? 0x80 : 0x40; | |
388 | report->field[1]->value[0] = 0x03; // unknown setting, imitate windows driver | |
389 | report->field[2]->value[0] = data_pointer->sensitivity; | |
390 | report->field[3]->value[0] = data_pointer->press_speed; | |
391 | ||
d8814272 | 392 | hid_hw_request(hdev, report, HID_REQ_SET_REPORT); |
c1dcad2d BS |
393 | return 0; |
394 | } | |
395 | ||
94723bfa | 396 | static ssize_t attr_press_to_select_show_tpkbd(struct device *dev, |
c1dcad2d BS |
397 | struct device_attribute *attr, |
398 | char *buf) | |
399 | { | |
ee79a8f8 | 400 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 401 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
402 | |
403 | return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->press_to_select); | |
404 | } | |
405 | ||
94723bfa | 406 | static ssize_t attr_press_to_select_store_tpkbd(struct device *dev, |
c1dcad2d BS |
407 | struct device_attribute *attr, |
408 | const char *buf, | |
409 | size_t count) | |
410 | { | |
ee79a8f8 | 411 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 412 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
413 | int value; |
414 | ||
c1dcad2d BS |
415 | if (kstrtoint(buf, 10, &value)) |
416 | return -EINVAL; | |
417 | if (value < 0 || value > 1) | |
418 | return -EINVAL; | |
419 | ||
420 | data_pointer->press_to_select = value; | |
94723bfa | 421 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
422 | |
423 | return count; | |
424 | } | |
425 | ||
94723bfa | 426 | static ssize_t attr_dragging_show_tpkbd(struct device *dev, |
c1dcad2d BS |
427 | struct device_attribute *attr, |
428 | char *buf) | |
429 | { | |
ee79a8f8 | 430 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 431 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
432 | |
433 | return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->dragging); | |
434 | } | |
435 | ||
94723bfa | 436 | static ssize_t attr_dragging_store_tpkbd(struct device *dev, |
c1dcad2d BS |
437 | struct device_attribute *attr, |
438 | const char *buf, | |
439 | size_t count) | |
440 | { | |
ee79a8f8 | 441 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 442 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
443 | int value; |
444 | ||
c1dcad2d BS |
445 | if (kstrtoint(buf, 10, &value)) |
446 | return -EINVAL; | |
447 | if (value < 0 || value > 1) | |
448 | return -EINVAL; | |
449 | ||
450 | data_pointer->dragging = value; | |
94723bfa | 451 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
452 | |
453 | return count; | |
454 | } | |
455 | ||
94723bfa | 456 | static ssize_t attr_release_to_select_show_tpkbd(struct device *dev, |
c1dcad2d BS |
457 | struct device_attribute *attr, |
458 | char *buf) | |
459 | { | |
ee79a8f8 | 460 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 461 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
462 | |
463 | return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->release_to_select); | |
464 | } | |
465 | ||
94723bfa | 466 | static ssize_t attr_release_to_select_store_tpkbd(struct device *dev, |
c1dcad2d BS |
467 | struct device_attribute *attr, |
468 | const char *buf, | |
469 | size_t count) | |
470 | { | |
ee79a8f8 | 471 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 472 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
473 | int value; |
474 | ||
c1dcad2d BS |
475 | if (kstrtoint(buf, 10, &value)) |
476 | return -EINVAL; | |
477 | if (value < 0 || value > 1) | |
478 | return -EINVAL; | |
479 | ||
480 | data_pointer->release_to_select = value; | |
94723bfa | 481 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
482 | |
483 | return count; | |
484 | } | |
485 | ||
94723bfa | 486 | static ssize_t attr_select_right_show_tpkbd(struct device *dev, |
c1dcad2d BS |
487 | struct device_attribute *attr, |
488 | char *buf) | |
489 | { | |
ee79a8f8 | 490 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 491 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
492 | |
493 | return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->select_right); | |
494 | } | |
495 | ||
94723bfa | 496 | static ssize_t attr_select_right_store_tpkbd(struct device *dev, |
c1dcad2d BS |
497 | struct device_attribute *attr, |
498 | const char *buf, | |
499 | size_t count) | |
500 | { | |
ee79a8f8 | 501 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 502 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
503 | int value; |
504 | ||
c1dcad2d BS |
505 | if (kstrtoint(buf, 10, &value)) |
506 | return -EINVAL; | |
507 | if (value < 0 || value > 1) | |
508 | return -EINVAL; | |
509 | ||
510 | data_pointer->select_right = value; | |
94723bfa | 511 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
512 | |
513 | return count; | |
514 | } | |
515 | ||
94723bfa | 516 | static ssize_t attr_sensitivity_show_tpkbd(struct device *dev, |
c1dcad2d BS |
517 | struct device_attribute *attr, |
518 | char *buf) | |
519 | { | |
ee79a8f8 | 520 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 521 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
522 | |
523 | return snprintf(buf, PAGE_SIZE, "%u\n", | |
524 | data_pointer->sensitivity); | |
525 | } | |
526 | ||
94723bfa | 527 | static ssize_t attr_sensitivity_store_tpkbd(struct device *dev, |
c1dcad2d BS |
528 | struct device_attribute *attr, |
529 | const char *buf, | |
530 | size_t count) | |
531 | { | |
ee79a8f8 | 532 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 533 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
534 | int value; |
535 | ||
c1dcad2d BS |
536 | if (kstrtoint(buf, 10, &value) || value < 1 || value > 255) |
537 | return -EINVAL; | |
538 | ||
539 | data_pointer->sensitivity = value; | |
94723bfa | 540 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
541 | |
542 | return count; | |
543 | } | |
544 | ||
94723bfa | 545 | static ssize_t attr_press_speed_show_tpkbd(struct device *dev, |
c1dcad2d BS |
546 | struct device_attribute *attr, |
547 | char *buf) | |
548 | { | |
ee79a8f8 | 549 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 550 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d | 551 | |
c1dcad2d BS |
552 | return snprintf(buf, PAGE_SIZE, "%u\n", |
553 | data_pointer->press_speed); | |
554 | } | |
555 | ||
94723bfa | 556 | static ssize_t attr_press_speed_store_tpkbd(struct device *dev, |
c1dcad2d BS |
557 | struct device_attribute *attr, |
558 | const char *buf, | |
559 | size_t count) | |
560 | { | |
ee79a8f8 | 561 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 562 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
563 | int value; |
564 | ||
c1dcad2d BS |
565 | if (kstrtoint(buf, 10, &value) || value < 1 || value > 255) |
566 | return -EINVAL; | |
567 | ||
568 | data_pointer->press_speed = value; | |
94723bfa | 569 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
570 | |
571 | return count; | |
572 | } | |
573 | ||
94723bfa | 574 | static struct device_attribute dev_attr_press_to_select_tpkbd = |
c1dcad2d | 575 | __ATTR(press_to_select, S_IWUSR | S_IRUGO, |
94723bfa JL |
576 | attr_press_to_select_show_tpkbd, |
577 | attr_press_to_select_store_tpkbd); | |
c1dcad2d | 578 | |
94723bfa | 579 | static struct device_attribute dev_attr_dragging_tpkbd = |
c1dcad2d | 580 | __ATTR(dragging, S_IWUSR | S_IRUGO, |
94723bfa JL |
581 | attr_dragging_show_tpkbd, |
582 | attr_dragging_store_tpkbd); | |
c1dcad2d | 583 | |
94723bfa | 584 | static struct device_attribute dev_attr_release_to_select_tpkbd = |
c1dcad2d | 585 | __ATTR(release_to_select, S_IWUSR | S_IRUGO, |
94723bfa JL |
586 | attr_release_to_select_show_tpkbd, |
587 | attr_release_to_select_store_tpkbd); | |
c1dcad2d | 588 | |
94723bfa | 589 | static struct device_attribute dev_attr_select_right_tpkbd = |
c1dcad2d | 590 | __ATTR(select_right, S_IWUSR | S_IRUGO, |
94723bfa JL |
591 | attr_select_right_show_tpkbd, |
592 | attr_select_right_store_tpkbd); | |
c1dcad2d | 593 | |
94723bfa | 594 | static struct device_attribute dev_attr_sensitivity_tpkbd = |
c1dcad2d | 595 | __ATTR(sensitivity, S_IWUSR | S_IRUGO, |
94723bfa JL |
596 | attr_sensitivity_show_tpkbd, |
597 | attr_sensitivity_store_tpkbd); | |
c1dcad2d | 598 | |
94723bfa | 599 | static struct device_attribute dev_attr_press_speed_tpkbd = |
c1dcad2d | 600 | __ATTR(press_speed, S_IWUSR | S_IRUGO, |
94723bfa JL |
601 | attr_press_speed_show_tpkbd, |
602 | attr_press_speed_store_tpkbd); | |
603 | ||
604 | static struct attribute *lenovo_attributes_tpkbd[] = { | |
605 | &dev_attr_press_to_select_tpkbd.attr, | |
606 | &dev_attr_dragging_tpkbd.attr, | |
607 | &dev_attr_release_to_select_tpkbd.attr, | |
608 | &dev_attr_select_right_tpkbd.attr, | |
609 | &dev_attr_sensitivity_tpkbd.attr, | |
610 | &dev_attr_press_speed_tpkbd.attr, | |
c1dcad2d BS |
611 | NULL |
612 | }; | |
613 | ||
94723bfa JL |
614 | static const struct attribute_group lenovo_attr_group_tpkbd = { |
615 | .attrs = lenovo_attributes_tpkbd, | |
c1dcad2d BS |
616 | }; |
617 | ||
94723bfa | 618 | static enum led_brightness lenovo_led_brightness_get_tpkbd( |
c1dcad2d BS |
619 | struct led_classdev *led_cdev) |
620 | { | |
832fbeae | 621 | struct device *dev = led_cdev->dev->parent; |
ee79a8f8 | 622 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 623 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
624 | int led_nr = 0; |
625 | ||
c1dcad2d BS |
626 | if (led_cdev == &data_pointer->led_micmute) |
627 | led_nr = 1; | |
628 | ||
629 | return data_pointer->led_state & (1 << led_nr) | |
630 | ? LED_FULL | |
631 | : LED_OFF; | |
632 | } | |
633 | ||
94723bfa | 634 | static void lenovo_led_brightness_set_tpkbd(struct led_classdev *led_cdev, |
c1dcad2d BS |
635 | enum led_brightness value) |
636 | { | |
832fbeae | 637 | struct device *dev = led_cdev->dev->parent; |
ee79a8f8 | 638 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 639 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d | 640 | struct hid_report *report; |
c1dcad2d BS |
641 | int led_nr = 0; |
642 | ||
c1dcad2d BS |
643 | if (led_cdev == &data_pointer->led_micmute) |
644 | led_nr = 1; | |
645 | ||
646 | if (value == LED_OFF) | |
647 | data_pointer->led_state &= ~(1 << led_nr); | |
648 | else | |
649 | data_pointer->led_state |= 1 << led_nr; | |
650 | ||
651 | report = hdev->report_enum[HID_OUTPUT_REPORT].report_id_hash[3]; | |
652 | report->field[0]->value[0] = (data_pointer->led_state >> 0) & 1; | |
653 | report->field[0]->value[1] = (data_pointer->led_state >> 1) & 1; | |
d8814272 | 654 | hid_hw_request(hdev, report, HID_REQ_SET_REPORT); |
c1dcad2d BS |
655 | } |
656 | ||
94723bfa | 657 | static int lenovo_probe_tpkbd(struct hid_device *hdev) |
c1dcad2d BS |
658 | { |
659 | struct device *dev = &hdev->dev; | |
94723bfa | 660 | struct lenovo_drvdata_tpkbd *data_pointer; |
c1dcad2d BS |
661 | size_t name_sz = strlen(dev_name(dev)) + 16; |
662 | char *name_mute, *name_micmute; | |
01ab35f1 | 663 | int i; |
e0a6aad6 | 664 | int ret; |
0a9cd0a8 | 665 | |
6a5b414b JL |
666 | /* |
667 | * Only register extra settings against subdevice where input_mapping | |
668 | * set drvdata to 1, i.e. the trackpoint. | |
669 | */ | |
670 | if (!hid_get_drvdata(hdev)) | |
671 | return 0; | |
672 | ||
673 | hid_set_drvdata(hdev, NULL); | |
674 | ||
0a9cd0a8 KC |
675 | /* Validate required reports. */ |
676 | for (i = 0; i < 4; i++) { | |
677 | if (!hid_validate_values(hdev, HID_FEATURE_REPORT, 4, i, 1)) | |
678 | return -ENODEV; | |
679 | } | |
680 | if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 3, 0, 2)) | |
681 | return -ENODEV; | |
c1dcad2d | 682 | |
e0a6aad6 JL |
683 | ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd); |
684 | if (ret) | |
685 | hid_warn(hdev, "Could not create sysfs group: %d\n", ret); | |
c1dcad2d | 686 | |
01ab35f1 | 687 | data_pointer = devm_kzalloc(&hdev->dev, |
94723bfa | 688 | sizeof(struct lenovo_drvdata_tpkbd), |
01ab35f1 | 689 | GFP_KERNEL); |
c1dcad2d BS |
690 | if (data_pointer == NULL) { |
691 | hid_err(hdev, "Could not allocate memory for driver data\n"); | |
b7212600 AK |
692 | ret = -ENOMEM; |
693 | goto err; | |
c1dcad2d BS |
694 | } |
695 | ||
696 | // set same default values as windows driver | |
697 | data_pointer->sensitivity = 0xa0; | |
698 | data_pointer->press_speed = 0x38; | |
699 | ||
01ab35f1 BT |
700 | name_mute = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL); |
701 | name_micmute = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL); | |
702 | if (name_mute == NULL || name_micmute == NULL) { | |
c1dcad2d | 703 | hid_err(hdev, "Could not allocate memory for led data\n"); |
b7212600 AK |
704 | ret = -ENOMEM; |
705 | goto err; | |
c1dcad2d BS |
706 | } |
707 | snprintf(name_mute, name_sz, "%s:amber:mute", dev_name(dev)); | |
c1dcad2d BS |
708 | snprintf(name_micmute, name_sz, "%s:amber:micmute", dev_name(dev)); |
709 | ||
710 | hid_set_drvdata(hdev, data_pointer); | |
711 | ||
712 | data_pointer->led_mute.name = name_mute; | |
94723bfa JL |
713 | data_pointer->led_mute.brightness_get = lenovo_led_brightness_get_tpkbd; |
714 | data_pointer->led_mute.brightness_set = lenovo_led_brightness_set_tpkbd; | |
c1dcad2d BS |
715 | data_pointer->led_mute.dev = dev; |
716 | led_classdev_register(dev, &data_pointer->led_mute); | |
717 | ||
718 | data_pointer->led_micmute.name = name_micmute; | |
94723bfa JL |
719 | data_pointer->led_micmute.brightness_get = |
720 | lenovo_led_brightness_get_tpkbd; | |
721 | data_pointer->led_micmute.brightness_set = | |
722 | lenovo_led_brightness_set_tpkbd; | |
c1dcad2d BS |
723 | data_pointer->led_micmute.dev = dev; |
724 | led_classdev_register(dev, &data_pointer->led_micmute); | |
725 | ||
94723bfa | 726 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
727 | |
728 | return 0; | |
b7212600 AK |
729 | err: |
730 | sysfs_remove_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd); | |
731 | return ret; | |
c1dcad2d BS |
732 | } |
733 | ||
f3d4ff0e JL |
734 | static int lenovo_probe_cptkbd(struct hid_device *hdev) |
735 | { | |
736 | int ret; | |
737 | struct lenovo_drvdata_cptkbd *cptkbd_data; | |
738 | ||
739 | /* All the custom action happens on the USBMOUSE device for USB */ | |
740 | if (hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD | |
741 | && hdev->type != HID_TYPE_USBMOUSE) { | |
742 | hid_dbg(hdev, "Ignoring keyboard half of device\n"); | |
743 | return 0; | |
744 | } | |
745 | ||
746 | cptkbd_data = devm_kzalloc(&hdev->dev, | |
747 | sizeof(*cptkbd_data), | |
748 | GFP_KERNEL); | |
749 | if (cptkbd_data == NULL) { | |
750 | hid_err(hdev, "can't alloc keyboard descriptor\n"); | |
751 | return -ENOMEM; | |
752 | } | |
753 | hid_set_drvdata(hdev, cptkbd_data); | |
754 | ||
755 | /* | |
756 | * Tell the keyboard a driver understands it, and turn F7, F9, F11 into | |
757 | * regular keys | |
758 | */ | |
759 | ret = lenovo_send_cmd_cptkbd(hdev, 0x01, 0x03); | |
760 | if (ret) | |
761 | hid_warn(hdev, "Failed to switch F7/9/11 mode: %d\n", ret); | |
762 | ||
94eefa27 JL |
763 | /* Switch middle button to native mode */ |
764 | ret = lenovo_send_cmd_cptkbd(hdev, 0x09, 0x01); | |
765 | if (ret) | |
766 | hid_warn(hdev, "Failed to switch middle button: %d\n", ret); | |
767 | ||
e3cb0acd | 768 | /* Set keyboard settings to known state */ |
3cb5ff02 | 769 | cptkbd_data->middlebutton_state = 0; |
f3d4ff0e | 770 | cptkbd_data->fn_lock = true; |
e3cb0acd | 771 | cptkbd_data->sensitivity = 0x05; |
f3d4ff0e JL |
772 | lenovo_features_set_cptkbd(hdev); |
773 | ||
774 | ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_cptkbd); | |
775 | if (ret) | |
776 | hid_warn(hdev, "Could not create sysfs group: %d\n", ret); | |
777 | ||
778 | return 0; | |
779 | } | |
780 | ||
94723bfa | 781 | static int lenovo_probe(struct hid_device *hdev, |
c1dcad2d BS |
782 | const struct hid_device_id *id) |
783 | { | |
784 | int ret; | |
c1dcad2d BS |
785 | |
786 | ret = hid_parse(hdev); | |
787 | if (ret) { | |
788 | hid_err(hdev, "hid_parse failed\n"); | |
0ccdd9e7 | 789 | goto err; |
c1dcad2d BS |
790 | } |
791 | ||
792 | ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); | |
793 | if (ret) { | |
794 | hid_err(hdev, "hid_hw_start failed\n"); | |
0ccdd9e7 | 795 | goto err; |
c1dcad2d BS |
796 | } |
797 | ||
6a5b414b JL |
798 | switch (hdev->product) { |
799 | case USB_DEVICE_ID_LENOVO_TPKBD: | |
94723bfa | 800 | ret = lenovo_probe_tpkbd(hdev); |
6a5b414b | 801 | break; |
f3d4ff0e JL |
802 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
803 | case USB_DEVICE_ID_LENOVO_CBTKBD: | |
804 | ret = lenovo_probe_cptkbd(hdev); | |
805 | break; | |
6a5b414b JL |
806 | default: |
807 | ret = 0; | |
808 | break; | |
0ccdd9e7 | 809 | } |
6a5b414b JL |
810 | if (ret) |
811 | goto err_hid; | |
c1dcad2d BS |
812 | |
813 | return 0; | |
0ccdd9e7 BT |
814 | err_hid: |
815 | hid_hw_stop(hdev); | |
816 | err: | |
c1dcad2d BS |
817 | return ret; |
818 | } | |
819 | ||
94723bfa | 820 | static void lenovo_remove_tpkbd(struct hid_device *hdev) |
c1dcad2d | 821 | { |
94723bfa | 822 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d | 823 | |
6a5b414b JL |
824 | /* |
825 | * Only the trackpoint half of the keyboard has drvdata and stuff that | |
826 | * needs unregistering. | |
827 | */ | |
828 | if (data_pointer == NULL) | |
829 | return; | |
830 | ||
c1dcad2d | 831 | sysfs_remove_group(&hdev->dev.kobj, |
94723bfa | 832 | &lenovo_attr_group_tpkbd); |
c1dcad2d | 833 | |
c1dcad2d BS |
834 | led_classdev_unregister(&data_pointer->led_micmute); |
835 | led_classdev_unregister(&data_pointer->led_mute); | |
836 | ||
837 | hid_set_drvdata(hdev, NULL); | |
c1dcad2d BS |
838 | } |
839 | ||
f3d4ff0e JL |
840 | static void lenovo_remove_cptkbd(struct hid_device *hdev) |
841 | { | |
842 | sysfs_remove_group(&hdev->dev.kobj, | |
843 | &lenovo_attr_group_cptkbd); | |
844 | } | |
845 | ||
94723bfa | 846 | static void lenovo_remove(struct hid_device *hdev) |
c1dcad2d | 847 | { |
6a5b414b JL |
848 | switch (hdev->product) { |
849 | case USB_DEVICE_ID_LENOVO_TPKBD: | |
94723bfa | 850 | lenovo_remove_tpkbd(hdev); |
6a5b414b | 851 | break; |
f3d4ff0e JL |
852 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
853 | case USB_DEVICE_ID_LENOVO_CBTKBD: | |
854 | lenovo_remove_cptkbd(hdev); | |
855 | break; | |
6a5b414b | 856 | } |
c1dcad2d BS |
857 | |
858 | hid_hw_stop(hdev); | |
859 | } | |
860 | ||
9154301a | 861 | static int lenovo_input_configured(struct hid_device *hdev, |
d92189eb AF |
862 | struct hid_input *hi) |
863 | { | |
864 | switch (hdev->product) { | |
865 | case USB_DEVICE_ID_LENOVO_TPKBD: | |
866 | case USB_DEVICE_ID_LENOVO_CUSBKBD: | |
867 | case USB_DEVICE_ID_LENOVO_CBTKBD: | |
868 | if (test_bit(EV_REL, hi->input->evbit)) { | |
869 | /* set only for trackpoint device */ | |
870 | __set_bit(INPUT_PROP_POINTER, hi->input->propbit); | |
871 | __set_bit(INPUT_PROP_POINTING_STICK, | |
872 | hi->input->propbit); | |
873 | } | |
874 | break; | |
875 | } | |
9154301a DT |
876 | |
877 | return 0; | |
d92189eb AF |
878 | } |
879 | ||
880 | ||
94723bfa | 881 | static const struct hid_device_id lenovo_devices[] = { |
c1dcad2d | 882 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) }, |
f3d4ff0e JL |
883 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) }, |
884 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) }, | |
181a8b91 | 885 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) }, |
c1dcad2d BS |
886 | { } |
887 | }; | |
888 | ||
94723bfa | 889 | MODULE_DEVICE_TABLE(hid, lenovo_devices); |
c1dcad2d | 890 | |
94723bfa JL |
891 | static struct hid_driver lenovo_driver = { |
892 | .name = "lenovo", | |
893 | .id_table = lenovo_devices, | |
d92189eb | 894 | .input_configured = lenovo_input_configured, |
6a5b414b | 895 | .input_mapping = lenovo_input_mapping, |
94723bfa JL |
896 | .probe = lenovo_probe, |
897 | .remove = lenovo_remove, | |
f3d4ff0e | 898 | .raw_event = lenovo_raw_event, |
3cb5ff02 | 899 | .event = lenovo_event, |
181a8b91 | 900 | .report_fixup = lenovo_report_fixup, |
c1dcad2d | 901 | }; |
94723bfa | 902 | module_hid_driver(lenovo_driver); |
c1dcad2d BS |
903 | |
904 | MODULE_LICENSE("GPL"); |