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; | |
187 | unsigned char buf[] = {0x18, byte2, byte3}; | |
188 | ||
189 | switch (hdev->product) { | |
190 | case USB_DEVICE_ID_LENOVO_CUSBKBD: | |
191 | ret = hid_hw_raw_request(hdev, 0x13, buf, sizeof(buf), | |
192 | HID_FEATURE_REPORT, HID_REQ_SET_REPORT); | |
193 | break; | |
194 | case USB_DEVICE_ID_LENOVO_CBTKBD: | |
195 | ret = hid_hw_output_report(hdev, buf, sizeof(buf)); | |
196 | break; | |
197 | default: | |
198 | ret = -EINVAL; | |
199 | break; | |
200 | } | |
201 | ||
202 | return ret < 0 ? ret : 0; /* BT returns 0, USB returns sizeof(buf) */ | |
203 | } | |
204 | ||
205 | static void lenovo_features_set_cptkbd(struct hid_device *hdev) | |
206 | { | |
207 | int ret; | |
208 | struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev); | |
209 | ||
210 | ret = lenovo_send_cmd_cptkbd(hdev, 0x05, cptkbd_data->fn_lock); | |
211 | if (ret) | |
212 | hid_err(hdev, "Fn-lock setting failed: %d\n", ret); | |
dbfebb44 JL |
213 | |
214 | ret = lenovo_send_cmd_cptkbd(hdev, 0x02, cptkbd_data->sensitivity); | |
215 | if (ret) | |
216 | hid_err(hdev, "Sensitivity setting failed: %d\n", ret); | |
f3d4ff0e JL |
217 | } |
218 | ||
219 | static ssize_t attr_fn_lock_show_cptkbd(struct device *dev, | |
220 | struct device_attribute *attr, | |
221 | char *buf) | |
222 | { | |
ee79a8f8 | 223 | struct hid_device *hdev = to_hid_device(dev); |
f3d4ff0e JL |
224 | struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev); |
225 | ||
226 | return snprintf(buf, PAGE_SIZE, "%u\n", cptkbd_data->fn_lock); | |
227 | } | |
228 | ||
229 | static ssize_t attr_fn_lock_store_cptkbd(struct device *dev, | |
230 | struct device_attribute *attr, | |
231 | const char *buf, | |
232 | size_t count) | |
233 | { | |
ee79a8f8 | 234 | struct hid_device *hdev = to_hid_device(dev); |
f3d4ff0e JL |
235 | struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev); |
236 | int value; | |
237 | ||
238 | if (kstrtoint(buf, 10, &value)) | |
239 | return -EINVAL; | |
240 | if (value < 0 || value > 1) | |
241 | return -EINVAL; | |
242 | ||
243 | cptkbd_data->fn_lock = !!value; | |
244 | lenovo_features_set_cptkbd(hdev); | |
245 | ||
246 | return count; | |
247 | } | |
248 | ||
e3cb0acd JL |
249 | static ssize_t attr_sensitivity_show_cptkbd(struct device *dev, |
250 | struct device_attribute *attr, | |
251 | char *buf) | |
252 | { | |
ee79a8f8 | 253 | struct hid_device *hdev = to_hid_device(dev); |
e3cb0acd JL |
254 | struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev); |
255 | ||
256 | return snprintf(buf, PAGE_SIZE, "%u\n", | |
257 | cptkbd_data->sensitivity); | |
258 | } | |
259 | ||
260 | static ssize_t attr_sensitivity_store_cptkbd(struct device *dev, | |
261 | struct device_attribute *attr, | |
262 | const char *buf, | |
263 | size_t count) | |
264 | { | |
ee79a8f8 | 265 | struct hid_device *hdev = to_hid_device(dev); |
e3cb0acd JL |
266 | struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev); |
267 | int value; | |
268 | ||
269 | if (kstrtoint(buf, 10, &value) || value < 1 || value > 255) | |
270 | return -EINVAL; | |
271 | ||
272 | cptkbd_data->sensitivity = value; | |
273 | lenovo_features_set_cptkbd(hdev); | |
274 | ||
275 | return count; | |
276 | } | |
277 | ||
278 | ||
f3d4ff0e JL |
279 | static struct device_attribute dev_attr_fn_lock_cptkbd = |
280 | __ATTR(fn_lock, S_IWUSR | S_IRUGO, | |
281 | attr_fn_lock_show_cptkbd, | |
282 | attr_fn_lock_store_cptkbd); | |
283 | ||
e3cb0acd JL |
284 | static struct device_attribute dev_attr_sensitivity_cptkbd = |
285 | __ATTR(sensitivity, S_IWUSR | S_IRUGO, | |
286 | attr_sensitivity_show_cptkbd, | |
287 | attr_sensitivity_store_cptkbd); | |
288 | ||
289 | ||
f3d4ff0e JL |
290 | static struct attribute *lenovo_attributes_cptkbd[] = { |
291 | &dev_attr_fn_lock_cptkbd.attr, | |
e3cb0acd | 292 | &dev_attr_sensitivity_cptkbd.attr, |
f3d4ff0e JL |
293 | NULL |
294 | }; | |
295 | ||
296 | static const struct attribute_group lenovo_attr_group_cptkbd = { | |
297 | .attrs = lenovo_attributes_cptkbd, | |
298 | }; | |
299 | ||
300 | static int lenovo_raw_event(struct hid_device *hdev, | |
301 | struct hid_report *report, u8 *data, int size) | |
302 | { | |
303 | /* | |
304 | * Compact USB keyboard's Fn-F12 report holds down many other keys, and | |
305 | * its own key is outside the usage page range. Remove extra | |
306 | * keypresses and remap to inside usage page. | |
307 | */ | |
308 | if (unlikely(hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD | |
309 | && size == 3 | |
310 | && data[0] == 0x15 | |
311 | && data[1] == 0x94 | |
312 | && data[2] == 0x01)) { | |
5556eb14 JL |
313 | data[1] = 0x00; |
314 | data[2] = 0x01; | |
f3d4ff0e JL |
315 | } |
316 | ||
317 | return 0; | |
318 | } | |
319 | ||
3cb5ff02 JL |
320 | static int lenovo_event_cptkbd(struct hid_device *hdev, |
321 | struct hid_field *field, struct hid_usage *usage, __s32 value) | |
322 | { | |
323 | struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev); | |
324 | ||
325 | /* "wheel" scroll events */ | |
326 | if (usage->type == EV_REL && (usage->code == REL_WHEEL || | |
327 | usage->code == REL_HWHEEL)) { | |
328 | /* Scroll events disable middle-click event */ | |
329 | cptkbd_data->middlebutton_state = 2; | |
330 | return 0; | |
331 | } | |
332 | ||
333 | /* Middle click events */ | |
334 | if (usage->type == EV_KEY && usage->code == BTN_MIDDLE) { | |
335 | if (value == 1) { | |
336 | cptkbd_data->middlebutton_state = 1; | |
337 | } else if (value == 0) { | |
338 | if (cptkbd_data->middlebutton_state == 1) { | |
339 | /* No scrolling inbetween, send middle-click */ | |
340 | input_event(field->hidinput->input, | |
341 | EV_KEY, BTN_MIDDLE, 1); | |
342 | input_sync(field->hidinput->input); | |
343 | input_event(field->hidinput->input, | |
344 | EV_KEY, BTN_MIDDLE, 0); | |
345 | input_sync(field->hidinput->input); | |
346 | } | |
347 | cptkbd_data->middlebutton_state = 0; | |
348 | } | |
349 | return 1; | |
350 | } | |
351 | ||
352 | return 0; | |
353 | } | |
354 | ||
355 | static int lenovo_event(struct hid_device *hdev, struct hid_field *field, | |
356 | struct hid_usage *usage, __s32 value) | |
357 | { | |
358 | switch (hdev->product) { | |
359 | case USB_DEVICE_ID_LENOVO_CUSBKBD: | |
360 | case USB_DEVICE_ID_LENOVO_CBTKBD: | |
361 | return lenovo_event_cptkbd(hdev, field, usage, value); | |
362 | default: | |
363 | return 0; | |
364 | } | |
365 | } | |
366 | ||
94723bfa | 367 | static int lenovo_features_set_tpkbd(struct hid_device *hdev) |
c1dcad2d BS |
368 | { |
369 | struct hid_report *report; | |
94723bfa | 370 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d | 371 | |
c1dcad2d BS |
372 | report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[4]; |
373 | ||
374 | report->field[0]->value[0] = data_pointer->press_to_select ? 0x01 : 0x02; | |
375 | report->field[0]->value[0] |= data_pointer->dragging ? 0x04 : 0x08; | |
376 | report->field[0]->value[0] |= data_pointer->release_to_select ? 0x10 : 0x20; | |
377 | report->field[0]->value[0] |= data_pointer->select_right ? 0x80 : 0x40; | |
378 | report->field[1]->value[0] = 0x03; // unknown setting, imitate windows driver | |
379 | report->field[2]->value[0] = data_pointer->sensitivity; | |
380 | report->field[3]->value[0] = data_pointer->press_speed; | |
381 | ||
d8814272 | 382 | hid_hw_request(hdev, report, HID_REQ_SET_REPORT); |
c1dcad2d BS |
383 | return 0; |
384 | } | |
385 | ||
94723bfa | 386 | static ssize_t attr_press_to_select_show_tpkbd(struct device *dev, |
c1dcad2d BS |
387 | struct device_attribute *attr, |
388 | char *buf) | |
389 | { | |
ee79a8f8 | 390 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 391 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
392 | |
393 | return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->press_to_select); | |
394 | } | |
395 | ||
94723bfa | 396 | static ssize_t attr_press_to_select_store_tpkbd(struct device *dev, |
c1dcad2d BS |
397 | struct device_attribute *attr, |
398 | const char *buf, | |
399 | size_t count) | |
400 | { | |
ee79a8f8 | 401 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 402 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
403 | int value; |
404 | ||
c1dcad2d BS |
405 | if (kstrtoint(buf, 10, &value)) |
406 | return -EINVAL; | |
407 | if (value < 0 || value > 1) | |
408 | return -EINVAL; | |
409 | ||
410 | data_pointer->press_to_select = value; | |
94723bfa | 411 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
412 | |
413 | return count; | |
414 | } | |
415 | ||
94723bfa | 416 | static ssize_t attr_dragging_show_tpkbd(struct device *dev, |
c1dcad2d BS |
417 | struct device_attribute *attr, |
418 | char *buf) | |
419 | { | |
ee79a8f8 | 420 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 421 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
422 | |
423 | return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->dragging); | |
424 | } | |
425 | ||
94723bfa | 426 | static ssize_t attr_dragging_store_tpkbd(struct device *dev, |
c1dcad2d BS |
427 | struct device_attribute *attr, |
428 | const char *buf, | |
429 | size_t count) | |
430 | { | |
ee79a8f8 | 431 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 432 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
433 | int value; |
434 | ||
c1dcad2d BS |
435 | if (kstrtoint(buf, 10, &value)) |
436 | return -EINVAL; | |
437 | if (value < 0 || value > 1) | |
438 | return -EINVAL; | |
439 | ||
440 | data_pointer->dragging = value; | |
94723bfa | 441 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
442 | |
443 | return count; | |
444 | } | |
445 | ||
94723bfa | 446 | static ssize_t attr_release_to_select_show_tpkbd(struct device *dev, |
c1dcad2d BS |
447 | struct device_attribute *attr, |
448 | char *buf) | |
449 | { | |
ee79a8f8 | 450 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 451 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
452 | |
453 | return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->release_to_select); | |
454 | } | |
455 | ||
94723bfa | 456 | static ssize_t attr_release_to_select_store_tpkbd(struct device *dev, |
c1dcad2d BS |
457 | struct device_attribute *attr, |
458 | const char *buf, | |
459 | size_t count) | |
460 | { | |
ee79a8f8 | 461 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 462 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
463 | int value; |
464 | ||
c1dcad2d BS |
465 | if (kstrtoint(buf, 10, &value)) |
466 | return -EINVAL; | |
467 | if (value < 0 || value > 1) | |
468 | return -EINVAL; | |
469 | ||
470 | data_pointer->release_to_select = value; | |
94723bfa | 471 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
472 | |
473 | return count; | |
474 | } | |
475 | ||
94723bfa | 476 | static ssize_t attr_select_right_show_tpkbd(struct device *dev, |
c1dcad2d BS |
477 | struct device_attribute *attr, |
478 | char *buf) | |
479 | { | |
ee79a8f8 | 480 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 481 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
482 | |
483 | return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->select_right); | |
484 | } | |
485 | ||
94723bfa | 486 | static ssize_t attr_select_right_store_tpkbd(struct device *dev, |
c1dcad2d BS |
487 | struct device_attribute *attr, |
488 | const char *buf, | |
489 | size_t count) | |
490 | { | |
ee79a8f8 | 491 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 492 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
493 | int value; |
494 | ||
c1dcad2d BS |
495 | if (kstrtoint(buf, 10, &value)) |
496 | return -EINVAL; | |
497 | if (value < 0 || value > 1) | |
498 | return -EINVAL; | |
499 | ||
500 | data_pointer->select_right = value; | |
94723bfa | 501 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
502 | |
503 | return count; | |
504 | } | |
505 | ||
94723bfa | 506 | static ssize_t attr_sensitivity_show_tpkbd(struct device *dev, |
c1dcad2d BS |
507 | struct device_attribute *attr, |
508 | char *buf) | |
509 | { | |
ee79a8f8 | 510 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 511 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
512 | |
513 | return snprintf(buf, PAGE_SIZE, "%u\n", | |
514 | data_pointer->sensitivity); | |
515 | } | |
516 | ||
94723bfa | 517 | static ssize_t attr_sensitivity_store_tpkbd(struct device *dev, |
c1dcad2d BS |
518 | struct device_attribute *attr, |
519 | const char *buf, | |
520 | size_t count) | |
521 | { | |
ee79a8f8 | 522 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 523 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
524 | int value; |
525 | ||
c1dcad2d BS |
526 | if (kstrtoint(buf, 10, &value) || value < 1 || value > 255) |
527 | return -EINVAL; | |
528 | ||
529 | data_pointer->sensitivity = value; | |
94723bfa | 530 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
531 | |
532 | return count; | |
533 | } | |
534 | ||
94723bfa | 535 | static ssize_t attr_press_speed_show_tpkbd(struct device *dev, |
c1dcad2d BS |
536 | struct device_attribute *attr, |
537 | char *buf) | |
538 | { | |
ee79a8f8 | 539 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 540 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d | 541 | |
c1dcad2d BS |
542 | return snprintf(buf, PAGE_SIZE, "%u\n", |
543 | data_pointer->press_speed); | |
544 | } | |
545 | ||
94723bfa | 546 | static ssize_t attr_press_speed_store_tpkbd(struct device *dev, |
c1dcad2d BS |
547 | struct device_attribute *attr, |
548 | const char *buf, | |
549 | size_t count) | |
550 | { | |
ee79a8f8 | 551 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 552 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
553 | int value; |
554 | ||
c1dcad2d BS |
555 | if (kstrtoint(buf, 10, &value) || value < 1 || value > 255) |
556 | return -EINVAL; | |
557 | ||
558 | data_pointer->press_speed = value; | |
94723bfa | 559 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
560 | |
561 | return count; | |
562 | } | |
563 | ||
94723bfa | 564 | static struct device_attribute dev_attr_press_to_select_tpkbd = |
c1dcad2d | 565 | __ATTR(press_to_select, S_IWUSR | S_IRUGO, |
94723bfa JL |
566 | attr_press_to_select_show_tpkbd, |
567 | attr_press_to_select_store_tpkbd); | |
c1dcad2d | 568 | |
94723bfa | 569 | static struct device_attribute dev_attr_dragging_tpkbd = |
c1dcad2d | 570 | __ATTR(dragging, S_IWUSR | S_IRUGO, |
94723bfa JL |
571 | attr_dragging_show_tpkbd, |
572 | attr_dragging_store_tpkbd); | |
c1dcad2d | 573 | |
94723bfa | 574 | static struct device_attribute dev_attr_release_to_select_tpkbd = |
c1dcad2d | 575 | __ATTR(release_to_select, S_IWUSR | S_IRUGO, |
94723bfa JL |
576 | attr_release_to_select_show_tpkbd, |
577 | attr_release_to_select_store_tpkbd); | |
c1dcad2d | 578 | |
94723bfa | 579 | static struct device_attribute dev_attr_select_right_tpkbd = |
c1dcad2d | 580 | __ATTR(select_right, S_IWUSR | S_IRUGO, |
94723bfa JL |
581 | attr_select_right_show_tpkbd, |
582 | attr_select_right_store_tpkbd); | |
c1dcad2d | 583 | |
94723bfa | 584 | static struct device_attribute dev_attr_sensitivity_tpkbd = |
c1dcad2d | 585 | __ATTR(sensitivity, S_IWUSR | S_IRUGO, |
94723bfa JL |
586 | attr_sensitivity_show_tpkbd, |
587 | attr_sensitivity_store_tpkbd); | |
c1dcad2d | 588 | |
94723bfa | 589 | static struct device_attribute dev_attr_press_speed_tpkbd = |
c1dcad2d | 590 | __ATTR(press_speed, S_IWUSR | S_IRUGO, |
94723bfa JL |
591 | attr_press_speed_show_tpkbd, |
592 | attr_press_speed_store_tpkbd); | |
593 | ||
594 | static struct attribute *lenovo_attributes_tpkbd[] = { | |
595 | &dev_attr_press_to_select_tpkbd.attr, | |
596 | &dev_attr_dragging_tpkbd.attr, | |
597 | &dev_attr_release_to_select_tpkbd.attr, | |
598 | &dev_attr_select_right_tpkbd.attr, | |
599 | &dev_attr_sensitivity_tpkbd.attr, | |
600 | &dev_attr_press_speed_tpkbd.attr, | |
c1dcad2d BS |
601 | NULL |
602 | }; | |
603 | ||
94723bfa JL |
604 | static const struct attribute_group lenovo_attr_group_tpkbd = { |
605 | .attrs = lenovo_attributes_tpkbd, | |
c1dcad2d BS |
606 | }; |
607 | ||
94723bfa | 608 | static enum led_brightness lenovo_led_brightness_get_tpkbd( |
c1dcad2d BS |
609 | struct led_classdev *led_cdev) |
610 | { | |
832fbeae | 611 | struct device *dev = led_cdev->dev->parent; |
ee79a8f8 | 612 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 613 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
614 | int led_nr = 0; |
615 | ||
c1dcad2d BS |
616 | if (led_cdev == &data_pointer->led_micmute) |
617 | led_nr = 1; | |
618 | ||
619 | return data_pointer->led_state & (1 << led_nr) | |
620 | ? LED_FULL | |
621 | : LED_OFF; | |
622 | } | |
623 | ||
94723bfa | 624 | static void lenovo_led_brightness_set_tpkbd(struct led_classdev *led_cdev, |
c1dcad2d BS |
625 | enum led_brightness value) |
626 | { | |
832fbeae | 627 | struct device *dev = led_cdev->dev->parent; |
ee79a8f8 | 628 | struct hid_device *hdev = to_hid_device(dev); |
94723bfa | 629 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d | 630 | struct hid_report *report; |
c1dcad2d BS |
631 | int led_nr = 0; |
632 | ||
c1dcad2d BS |
633 | if (led_cdev == &data_pointer->led_micmute) |
634 | led_nr = 1; | |
635 | ||
636 | if (value == LED_OFF) | |
637 | data_pointer->led_state &= ~(1 << led_nr); | |
638 | else | |
639 | data_pointer->led_state |= 1 << led_nr; | |
640 | ||
641 | report = hdev->report_enum[HID_OUTPUT_REPORT].report_id_hash[3]; | |
642 | report->field[0]->value[0] = (data_pointer->led_state >> 0) & 1; | |
643 | report->field[0]->value[1] = (data_pointer->led_state >> 1) & 1; | |
d8814272 | 644 | hid_hw_request(hdev, report, HID_REQ_SET_REPORT); |
c1dcad2d BS |
645 | } |
646 | ||
94723bfa | 647 | static int lenovo_probe_tpkbd(struct hid_device *hdev) |
c1dcad2d BS |
648 | { |
649 | struct device *dev = &hdev->dev; | |
94723bfa | 650 | struct lenovo_drvdata_tpkbd *data_pointer; |
c1dcad2d BS |
651 | size_t name_sz = strlen(dev_name(dev)) + 16; |
652 | char *name_mute, *name_micmute; | |
01ab35f1 | 653 | int i; |
e0a6aad6 | 654 | int ret; |
0a9cd0a8 | 655 | |
6a5b414b JL |
656 | /* |
657 | * Only register extra settings against subdevice where input_mapping | |
658 | * set drvdata to 1, i.e. the trackpoint. | |
659 | */ | |
660 | if (!hid_get_drvdata(hdev)) | |
661 | return 0; | |
662 | ||
663 | hid_set_drvdata(hdev, NULL); | |
664 | ||
0a9cd0a8 KC |
665 | /* Validate required reports. */ |
666 | for (i = 0; i < 4; i++) { | |
667 | if (!hid_validate_values(hdev, HID_FEATURE_REPORT, 4, i, 1)) | |
668 | return -ENODEV; | |
669 | } | |
670 | if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 3, 0, 2)) | |
671 | return -ENODEV; | |
c1dcad2d | 672 | |
e0a6aad6 JL |
673 | ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd); |
674 | if (ret) | |
675 | hid_warn(hdev, "Could not create sysfs group: %d\n", ret); | |
c1dcad2d | 676 | |
01ab35f1 | 677 | data_pointer = devm_kzalloc(&hdev->dev, |
94723bfa | 678 | sizeof(struct lenovo_drvdata_tpkbd), |
01ab35f1 | 679 | GFP_KERNEL); |
c1dcad2d BS |
680 | if (data_pointer == NULL) { |
681 | hid_err(hdev, "Could not allocate memory for driver data\n"); | |
b7212600 AK |
682 | ret = -ENOMEM; |
683 | goto err; | |
c1dcad2d BS |
684 | } |
685 | ||
686 | // set same default values as windows driver | |
687 | data_pointer->sensitivity = 0xa0; | |
688 | data_pointer->press_speed = 0x38; | |
689 | ||
01ab35f1 BT |
690 | name_mute = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL); |
691 | name_micmute = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL); | |
692 | if (name_mute == NULL || name_micmute == NULL) { | |
c1dcad2d | 693 | hid_err(hdev, "Could not allocate memory for led data\n"); |
b7212600 AK |
694 | ret = -ENOMEM; |
695 | goto err; | |
c1dcad2d BS |
696 | } |
697 | snprintf(name_mute, name_sz, "%s:amber:mute", dev_name(dev)); | |
c1dcad2d BS |
698 | snprintf(name_micmute, name_sz, "%s:amber:micmute", dev_name(dev)); |
699 | ||
700 | hid_set_drvdata(hdev, data_pointer); | |
701 | ||
702 | data_pointer->led_mute.name = name_mute; | |
94723bfa JL |
703 | data_pointer->led_mute.brightness_get = lenovo_led_brightness_get_tpkbd; |
704 | data_pointer->led_mute.brightness_set = lenovo_led_brightness_set_tpkbd; | |
c1dcad2d BS |
705 | data_pointer->led_mute.dev = dev; |
706 | led_classdev_register(dev, &data_pointer->led_mute); | |
707 | ||
708 | data_pointer->led_micmute.name = name_micmute; | |
94723bfa JL |
709 | data_pointer->led_micmute.brightness_get = |
710 | lenovo_led_brightness_get_tpkbd; | |
711 | data_pointer->led_micmute.brightness_set = | |
712 | lenovo_led_brightness_set_tpkbd; | |
c1dcad2d BS |
713 | data_pointer->led_micmute.dev = dev; |
714 | led_classdev_register(dev, &data_pointer->led_micmute); | |
715 | ||
94723bfa | 716 | lenovo_features_set_tpkbd(hdev); |
c1dcad2d BS |
717 | |
718 | return 0; | |
b7212600 AK |
719 | err: |
720 | sysfs_remove_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd); | |
721 | return ret; | |
c1dcad2d BS |
722 | } |
723 | ||
f3d4ff0e JL |
724 | static int lenovo_probe_cptkbd(struct hid_device *hdev) |
725 | { | |
726 | int ret; | |
727 | struct lenovo_drvdata_cptkbd *cptkbd_data; | |
728 | ||
729 | /* All the custom action happens on the USBMOUSE device for USB */ | |
730 | if (hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD | |
731 | && hdev->type != HID_TYPE_USBMOUSE) { | |
732 | hid_dbg(hdev, "Ignoring keyboard half of device\n"); | |
733 | return 0; | |
734 | } | |
735 | ||
736 | cptkbd_data = devm_kzalloc(&hdev->dev, | |
737 | sizeof(*cptkbd_data), | |
738 | GFP_KERNEL); | |
739 | if (cptkbd_data == NULL) { | |
740 | hid_err(hdev, "can't alloc keyboard descriptor\n"); | |
741 | return -ENOMEM; | |
742 | } | |
743 | hid_set_drvdata(hdev, cptkbd_data); | |
744 | ||
745 | /* | |
746 | * Tell the keyboard a driver understands it, and turn F7, F9, F11 into | |
747 | * regular keys | |
748 | */ | |
749 | ret = lenovo_send_cmd_cptkbd(hdev, 0x01, 0x03); | |
750 | if (ret) | |
751 | hid_warn(hdev, "Failed to switch F7/9/11 mode: %d\n", ret); | |
752 | ||
94eefa27 JL |
753 | /* Switch middle button to native mode */ |
754 | ret = lenovo_send_cmd_cptkbd(hdev, 0x09, 0x01); | |
755 | if (ret) | |
756 | hid_warn(hdev, "Failed to switch middle button: %d\n", ret); | |
757 | ||
e3cb0acd | 758 | /* Set keyboard settings to known state */ |
3cb5ff02 | 759 | cptkbd_data->middlebutton_state = 0; |
f3d4ff0e | 760 | cptkbd_data->fn_lock = true; |
e3cb0acd | 761 | cptkbd_data->sensitivity = 0x05; |
f3d4ff0e JL |
762 | lenovo_features_set_cptkbd(hdev); |
763 | ||
764 | ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_cptkbd); | |
765 | if (ret) | |
766 | hid_warn(hdev, "Could not create sysfs group: %d\n", ret); | |
767 | ||
768 | return 0; | |
769 | } | |
770 | ||
94723bfa | 771 | static int lenovo_probe(struct hid_device *hdev, |
c1dcad2d BS |
772 | const struct hid_device_id *id) |
773 | { | |
774 | int ret; | |
c1dcad2d BS |
775 | |
776 | ret = hid_parse(hdev); | |
777 | if (ret) { | |
778 | hid_err(hdev, "hid_parse failed\n"); | |
0ccdd9e7 | 779 | goto err; |
c1dcad2d BS |
780 | } |
781 | ||
782 | ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); | |
783 | if (ret) { | |
784 | hid_err(hdev, "hid_hw_start failed\n"); | |
0ccdd9e7 | 785 | goto err; |
c1dcad2d BS |
786 | } |
787 | ||
6a5b414b JL |
788 | switch (hdev->product) { |
789 | case USB_DEVICE_ID_LENOVO_TPKBD: | |
94723bfa | 790 | ret = lenovo_probe_tpkbd(hdev); |
6a5b414b | 791 | break; |
f3d4ff0e JL |
792 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
793 | case USB_DEVICE_ID_LENOVO_CBTKBD: | |
794 | ret = lenovo_probe_cptkbd(hdev); | |
795 | break; | |
6a5b414b JL |
796 | default: |
797 | ret = 0; | |
798 | break; | |
0ccdd9e7 | 799 | } |
6a5b414b JL |
800 | if (ret) |
801 | goto err_hid; | |
c1dcad2d BS |
802 | |
803 | return 0; | |
0ccdd9e7 BT |
804 | err_hid: |
805 | hid_hw_stop(hdev); | |
806 | err: | |
c1dcad2d BS |
807 | return ret; |
808 | } | |
809 | ||
94723bfa | 810 | static void lenovo_remove_tpkbd(struct hid_device *hdev) |
c1dcad2d | 811 | { |
94723bfa | 812 | struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d | 813 | |
6a5b414b JL |
814 | /* |
815 | * Only the trackpoint half of the keyboard has drvdata and stuff that | |
816 | * needs unregistering. | |
817 | */ | |
818 | if (data_pointer == NULL) | |
819 | return; | |
820 | ||
c1dcad2d | 821 | sysfs_remove_group(&hdev->dev.kobj, |
94723bfa | 822 | &lenovo_attr_group_tpkbd); |
c1dcad2d | 823 | |
c1dcad2d BS |
824 | led_classdev_unregister(&data_pointer->led_micmute); |
825 | led_classdev_unregister(&data_pointer->led_mute); | |
826 | ||
827 | hid_set_drvdata(hdev, NULL); | |
c1dcad2d BS |
828 | } |
829 | ||
f3d4ff0e JL |
830 | static void lenovo_remove_cptkbd(struct hid_device *hdev) |
831 | { | |
832 | sysfs_remove_group(&hdev->dev.kobj, | |
833 | &lenovo_attr_group_cptkbd); | |
834 | } | |
835 | ||
94723bfa | 836 | static void lenovo_remove(struct hid_device *hdev) |
c1dcad2d | 837 | { |
6a5b414b JL |
838 | switch (hdev->product) { |
839 | case USB_DEVICE_ID_LENOVO_TPKBD: | |
94723bfa | 840 | lenovo_remove_tpkbd(hdev); |
6a5b414b | 841 | break; |
f3d4ff0e JL |
842 | case USB_DEVICE_ID_LENOVO_CUSBKBD: |
843 | case USB_DEVICE_ID_LENOVO_CBTKBD: | |
844 | lenovo_remove_cptkbd(hdev); | |
845 | break; | |
6a5b414b | 846 | } |
c1dcad2d BS |
847 | |
848 | hid_hw_stop(hdev); | |
849 | } | |
850 | ||
9154301a | 851 | static int lenovo_input_configured(struct hid_device *hdev, |
d92189eb AF |
852 | struct hid_input *hi) |
853 | { | |
854 | switch (hdev->product) { | |
855 | case USB_DEVICE_ID_LENOVO_TPKBD: | |
856 | case USB_DEVICE_ID_LENOVO_CUSBKBD: | |
857 | case USB_DEVICE_ID_LENOVO_CBTKBD: | |
858 | if (test_bit(EV_REL, hi->input->evbit)) { | |
859 | /* set only for trackpoint device */ | |
860 | __set_bit(INPUT_PROP_POINTER, hi->input->propbit); | |
861 | __set_bit(INPUT_PROP_POINTING_STICK, | |
862 | hi->input->propbit); | |
863 | } | |
864 | break; | |
865 | } | |
9154301a DT |
866 | |
867 | return 0; | |
d92189eb AF |
868 | } |
869 | ||
870 | ||
94723bfa | 871 | static const struct hid_device_id lenovo_devices[] = { |
c1dcad2d | 872 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) }, |
f3d4ff0e JL |
873 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) }, |
874 | { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) }, | |
181a8b91 | 875 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) }, |
c1dcad2d BS |
876 | { } |
877 | }; | |
878 | ||
94723bfa | 879 | MODULE_DEVICE_TABLE(hid, lenovo_devices); |
c1dcad2d | 880 | |
94723bfa JL |
881 | static struct hid_driver lenovo_driver = { |
882 | .name = "lenovo", | |
883 | .id_table = lenovo_devices, | |
d92189eb | 884 | .input_configured = lenovo_input_configured, |
6a5b414b | 885 | .input_mapping = lenovo_input_mapping, |
94723bfa JL |
886 | .probe = lenovo_probe, |
887 | .remove = lenovo_remove, | |
f3d4ff0e | 888 | .raw_event = lenovo_raw_event, |
3cb5ff02 | 889 | .event = lenovo_event, |
181a8b91 | 890 | .report_fixup = lenovo_report_fixup, |
c1dcad2d | 891 | }; |
94723bfa | 892 | module_hid_driver(lenovo_driver); |
c1dcad2d BS |
893 | |
894 | MODULE_LICENSE("GPL"); |