Commit | Line | Data |
---|---|---|
c1dcad2d BS |
1 | /* |
2 | * HID driver for Lenovo ThinkPad USB Keyboard with TrackPoint | |
3 | * | |
4 | * Copyright (c) 2012 Bernhard Seibold | |
5 | */ | |
6 | ||
7 | /* | |
8 | * This program is free software; you can redistribute it and/or modify it | |
9 | * under the terms of the GNU General Public License as published by the Free | |
10 | * Software Foundation; either version 2 of the License, or (at your option) | |
11 | * any later version. | |
12 | */ | |
13 | ||
14 | #include <linux/module.h> | |
15 | #include <linux/sysfs.h> | |
16 | #include <linux/device.h> | |
17 | #include <linux/usb.h> | |
18 | #include <linux/hid.h> | |
19 | #include <linux/input.h> | |
20 | #include <linux/leds.h> | |
21 | #include "usbhid/usbhid.h" | |
22 | ||
23 | #include "hid-ids.h" | |
24 | ||
25 | /* This is only used for the trackpoint part of the driver, hence _tp */ | |
26 | struct tpkbd_data_pointer { | |
27 | int led_state; | |
28 | struct led_classdev led_mute; | |
29 | struct led_classdev led_micmute; | |
30 | int press_to_select; | |
31 | int dragging; | |
32 | int release_to_select; | |
33 | int select_right; | |
34 | int sensitivity; | |
35 | int press_speed; | |
36 | }; | |
37 | ||
38 | #define map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, EV_KEY, (c)) | |
39 | ||
40 | static int tpkbd_input_mapping(struct hid_device *hdev, | |
41 | struct hid_input *hi, struct hid_field *field, | |
42 | struct hid_usage *usage, unsigned long **bit, int *max) | |
43 | { | |
44 | struct usbhid_device *uhdev; | |
45 | ||
46 | uhdev = (struct usbhid_device *) hdev->driver_data; | |
47 | if (uhdev->ifnum == 1 && usage->hid == (HID_UP_BUTTON | 0x0010)) { | |
48 | map_key_clear(KEY_MICMUTE); | |
49 | return 1; | |
50 | } | |
51 | return 0; | |
52 | } | |
53 | ||
54 | #undef map_key_clear | |
55 | ||
56 | static int tpkbd_features_set(struct hid_device *hdev) | |
57 | { | |
58 | struct hid_report *report; | |
832fbeae | 59 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d | 60 | |
c1dcad2d BS |
61 | report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[4]; |
62 | ||
63 | report->field[0]->value[0] = data_pointer->press_to_select ? 0x01 : 0x02; | |
64 | report->field[0]->value[0] |= data_pointer->dragging ? 0x04 : 0x08; | |
65 | report->field[0]->value[0] |= data_pointer->release_to_select ? 0x10 : 0x20; | |
66 | report->field[0]->value[0] |= data_pointer->select_right ? 0x80 : 0x40; | |
67 | report->field[1]->value[0] = 0x03; // unknown setting, imitate windows driver | |
68 | report->field[2]->value[0] = data_pointer->sensitivity; | |
69 | report->field[3]->value[0] = data_pointer->press_speed; | |
70 | ||
71 | usbhid_submit_report(hdev, report, USB_DIR_OUT); | |
72 | return 0; | |
73 | } | |
74 | ||
75 | static ssize_t pointer_press_to_select_show(struct device *dev, | |
76 | struct device_attribute *attr, | |
77 | char *buf) | |
78 | { | |
832fbeae AL |
79 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); |
80 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d BS |
81 | |
82 | return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->press_to_select); | |
83 | } | |
84 | ||
85 | static ssize_t pointer_press_to_select_store(struct device *dev, | |
86 | struct device_attribute *attr, | |
87 | const char *buf, | |
88 | size_t count) | |
89 | { | |
832fbeae AL |
90 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); |
91 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d BS |
92 | int value; |
93 | ||
c1dcad2d BS |
94 | if (kstrtoint(buf, 10, &value)) |
95 | return -EINVAL; | |
96 | if (value < 0 || value > 1) | |
97 | return -EINVAL; | |
98 | ||
99 | data_pointer->press_to_select = value; | |
100 | tpkbd_features_set(hdev); | |
101 | ||
102 | return count; | |
103 | } | |
104 | ||
105 | static ssize_t pointer_dragging_show(struct device *dev, | |
106 | struct device_attribute *attr, | |
107 | char *buf) | |
108 | { | |
832fbeae AL |
109 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); |
110 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d BS |
111 | |
112 | return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->dragging); | |
113 | } | |
114 | ||
115 | static ssize_t pointer_dragging_store(struct device *dev, | |
116 | struct device_attribute *attr, | |
117 | const char *buf, | |
118 | size_t count) | |
119 | { | |
832fbeae AL |
120 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); |
121 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d BS |
122 | int value; |
123 | ||
c1dcad2d BS |
124 | if (kstrtoint(buf, 10, &value)) |
125 | return -EINVAL; | |
126 | if (value < 0 || value > 1) | |
127 | return -EINVAL; | |
128 | ||
129 | data_pointer->dragging = value; | |
130 | tpkbd_features_set(hdev); | |
131 | ||
132 | return count; | |
133 | } | |
134 | ||
135 | static ssize_t pointer_release_to_select_show(struct device *dev, | |
136 | struct device_attribute *attr, | |
137 | char *buf) | |
138 | { | |
832fbeae AL |
139 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); |
140 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d BS |
141 | |
142 | return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->release_to_select); | |
143 | } | |
144 | ||
145 | static ssize_t pointer_release_to_select_store(struct device *dev, | |
146 | struct device_attribute *attr, | |
147 | const char *buf, | |
148 | size_t count) | |
149 | { | |
832fbeae AL |
150 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); |
151 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d BS |
152 | int value; |
153 | ||
c1dcad2d BS |
154 | if (kstrtoint(buf, 10, &value)) |
155 | return -EINVAL; | |
156 | if (value < 0 || value > 1) | |
157 | return -EINVAL; | |
158 | ||
159 | data_pointer->release_to_select = value; | |
160 | tpkbd_features_set(hdev); | |
161 | ||
162 | return count; | |
163 | } | |
164 | ||
165 | static ssize_t pointer_select_right_show(struct device *dev, | |
166 | struct device_attribute *attr, | |
167 | char *buf) | |
168 | { | |
832fbeae AL |
169 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); |
170 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d BS |
171 | |
172 | return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->select_right); | |
173 | } | |
174 | ||
175 | static ssize_t pointer_select_right_store(struct device *dev, | |
176 | struct device_attribute *attr, | |
177 | const char *buf, | |
178 | size_t count) | |
179 | { | |
832fbeae AL |
180 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); |
181 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d BS |
182 | int value; |
183 | ||
c1dcad2d BS |
184 | if (kstrtoint(buf, 10, &value)) |
185 | return -EINVAL; | |
186 | if (value < 0 || value > 1) | |
187 | return -EINVAL; | |
188 | ||
189 | data_pointer->select_right = value; | |
190 | tpkbd_features_set(hdev); | |
191 | ||
192 | return count; | |
193 | } | |
194 | ||
195 | static ssize_t pointer_sensitivity_show(struct device *dev, | |
196 | struct device_attribute *attr, | |
197 | char *buf) | |
198 | { | |
832fbeae AL |
199 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); |
200 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d BS |
201 | |
202 | return snprintf(buf, PAGE_SIZE, "%u\n", | |
203 | data_pointer->sensitivity); | |
204 | } | |
205 | ||
206 | static ssize_t pointer_sensitivity_store(struct device *dev, | |
207 | struct device_attribute *attr, | |
208 | const char *buf, | |
209 | size_t count) | |
210 | { | |
832fbeae AL |
211 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); |
212 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d BS |
213 | int value; |
214 | ||
c1dcad2d BS |
215 | if (kstrtoint(buf, 10, &value) || value < 1 || value > 255) |
216 | return -EINVAL; | |
217 | ||
218 | data_pointer->sensitivity = value; | |
219 | tpkbd_features_set(hdev); | |
220 | ||
221 | return count; | |
222 | } | |
223 | ||
224 | static ssize_t pointer_press_speed_show(struct device *dev, | |
225 | struct device_attribute *attr, | |
226 | char *buf) | |
227 | { | |
832fbeae AL |
228 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); |
229 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d | 230 | |
832fbeae | 231 | data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
232 | |
233 | return snprintf(buf, PAGE_SIZE, "%u\n", | |
234 | data_pointer->press_speed); | |
235 | } | |
236 | ||
237 | static ssize_t pointer_press_speed_store(struct device *dev, | |
238 | struct device_attribute *attr, | |
239 | const char *buf, | |
240 | size_t count) | |
241 | { | |
832fbeae AL |
242 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); |
243 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d BS |
244 | int value; |
245 | ||
c1dcad2d BS |
246 | if (kstrtoint(buf, 10, &value) || value < 1 || value > 255) |
247 | return -EINVAL; | |
248 | ||
249 | data_pointer->press_speed = value; | |
250 | tpkbd_features_set(hdev); | |
251 | ||
252 | return count; | |
253 | } | |
254 | ||
255 | static struct device_attribute dev_attr_pointer_press_to_select = | |
256 | __ATTR(press_to_select, S_IWUSR | S_IRUGO, | |
257 | pointer_press_to_select_show, | |
258 | pointer_press_to_select_store); | |
259 | ||
260 | static struct device_attribute dev_attr_pointer_dragging = | |
261 | __ATTR(dragging, S_IWUSR | S_IRUGO, | |
262 | pointer_dragging_show, | |
263 | pointer_dragging_store); | |
264 | ||
265 | static struct device_attribute dev_attr_pointer_release_to_select = | |
266 | __ATTR(release_to_select, S_IWUSR | S_IRUGO, | |
267 | pointer_release_to_select_show, | |
268 | pointer_release_to_select_store); | |
269 | ||
270 | static struct device_attribute dev_attr_pointer_select_right = | |
271 | __ATTR(select_right, S_IWUSR | S_IRUGO, | |
272 | pointer_select_right_show, | |
273 | pointer_select_right_store); | |
274 | ||
275 | static struct device_attribute dev_attr_pointer_sensitivity = | |
276 | __ATTR(sensitivity, S_IWUSR | S_IRUGO, | |
277 | pointer_sensitivity_show, | |
278 | pointer_sensitivity_store); | |
279 | ||
280 | static struct device_attribute dev_attr_pointer_press_speed = | |
281 | __ATTR(press_speed, S_IWUSR | S_IRUGO, | |
282 | pointer_press_speed_show, | |
283 | pointer_press_speed_store); | |
284 | ||
285 | static struct attribute *tpkbd_attributes_pointer[] = { | |
286 | &dev_attr_pointer_press_to_select.attr, | |
287 | &dev_attr_pointer_dragging.attr, | |
288 | &dev_attr_pointer_release_to_select.attr, | |
289 | &dev_attr_pointer_select_right.attr, | |
290 | &dev_attr_pointer_sensitivity.attr, | |
291 | &dev_attr_pointer_press_speed.attr, | |
292 | NULL | |
293 | }; | |
294 | ||
295 | static const struct attribute_group tpkbd_attr_group_pointer = { | |
296 | .attrs = tpkbd_attributes_pointer, | |
297 | }; | |
298 | ||
299 | static enum led_brightness tpkbd_led_brightness_get( | |
300 | struct led_classdev *led_cdev) | |
301 | { | |
832fbeae AL |
302 | struct device *dev = led_cdev->dev->parent; |
303 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); | |
304 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d BS |
305 | int led_nr = 0; |
306 | ||
c1dcad2d BS |
307 | if (led_cdev == &data_pointer->led_micmute) |
308 | led_nr = 1; | |
309 | ||
310 | return data_pointer->led_state & (1 << led_nr) | |
311 | ? LED_FULL | |
312 | : LED_OFF; | |
313 | } | |
314 | ||
315 | static void tpkbd_led_brightness_set(struct led_classdev *led_cdev, | |
316 | enum led_brightness value) | |
317 | { | |
832fbeae AL |
318 | struct device *dev = led_cdev->dev->parent; |
319 | struct hid_device *hdev = container_of(dev, struct hid_device, dev); | |
320 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); | |
c1dcad2d | 321 | struct hid_report *report; |
c1dcad2d BS |
322 | int led_nr = 0; |
323 | ||
c1dcad2d BS |
324 | if (led_cdev == &data_pointer->led_micmute) |
325 | led_nr = 1; | |
326 | ||
327 | if (value == LED_OFF) | |
328 | data_pointer->led_state &= ~(1 << led_nr); | |
329 | else | |
330 | data_pointer->led_state |= 1 << led_nr; | |
331 | ||
332 | report = hdev->report_enum[HID_OUTPUT_REPORT].report_id_hash[3]; | |
333 | report->field[0]->value[0] = (data_pointer->led_state >> 0) & 1; | |
334 | report->field[0]->value[1] = (data_pointer->led_state >> 1) & 1; | |
335 | usbhid_submit_report(hdev, report, USB_DIR_OUT); | |
336 | } | |
337 | ||
338 | static int tpkbd_probe_tp(struct hid_device *hdev) | |
339 | { | |
340 | struct device *dev = &hdev->dev; | |
341 | struct tpkbd_data_pointer *data_pointer; | |
342 | size_t name_sz = strlen(dev_name(dev)) + 16; | |
343 | char *name_mute, *name_micmute; | |
344 | int ret; | |
345 | ||
346 | if (sysfs_create_group(&hdev->dev.kobj, | |
347 | &tpkbd_attr_group_pointer)) { | |
348 | hid_warn(hdev, "Could not create sysfs group\n"); | |
349 | } | |
350 | ||
351 | data_pointer = kzalloc(sizeof(struct tpkbd_data_pointer), GFP_KERNEL); | |
352 | if (data_pointer == NULL) { | |
353 | hid_err(hdev, "Could not allocate memory for driver data\n"); | |
354 | return -ENOMEM; | |
355 | } | |
356 | ||
357 | // set same default values as windows driver | |
358 | data_pointer->sensitivity = 0xa0; | |
359 | data_pointer->press_speed = 0x38; | |
360 | ||
361 | name_mute = kzalloc(name_sz, GFP_KERNEL); | |
362 | if (name_mute == NULL) { | |
363 | hid_err(hdev, "Could not allocate memory for led data\n"); | |
364 | ret = -ENOMEM; | |
365 | goto err; | |
366 | } | |
367 | snprintf(name_mute, name_sz, "%s:amber:mute", dev_name(dev)); | |
368 | ||
369 | name_micmute = kzalloc(name_sz, GFP_KERNEL); | |
370 | if (name_micmute == NULL) { | |
371 | hid_err(hdev, "Could not allocate memory for led data\n"); | |
372 | ret = -ENOMEM; | |
373 | goto err2; | |
374 | } | |
375 | snprintf(name_micmute, name_sz, "%s:amber:micmute", dev_name(dev)); | |
376 | ||
377 | hid_set_drvdata(hdev, data_pointer); | |
378 | ||
379 | data_pointer->led_mute.name = name_mute; | |
380 | data_pointer->led_mute.brightness_get = tpkbd_led_brightness_get; | |
381 | data_pointer->led_mute.brightness_set = tpkbd_led_brightness_set; | |
382 | data_pointer->led_mute.dev = dev; | |
383 | led_classdev_register(dev, &data_pointer->led_mute); | |
384 | ||
385 | data_pointer->led_micmute.name = name_micmute; | |
386 | data_pointer->led_micmute.brightness_get = tpkbd_led_brightness_get; | |
387 | data_pointer->led_micmute.brightness_set = tpkbd_led_brightness_set; | |
388 | data_pointer->led_micmute.dev = dev; | |
389 | led_classdev_register(dev, &data_pointer->led_micmute); | |
390 | ||
391 | tpkbd_features_set(hdev); | |
392 | ||
393 | return 0; | |
394 | ||
395 | err2: | |
396 | kfree(name_mute); | |
397 | err: | |
398 | kfree(data_pointer); | |
399 | return ret; | |
400 | } | |
401 | ||
402 | static int tpkbd_probe(struct hid_device *hdev, | |
403 | const struct hid_device_id *id) | |
404 | { | |
405 | int ret; | |
406 | struct usbhid_device *uhdev; | |
407 | ||
408 | ret = hid_parse(hdev); | |
409 | if (ret) { | |
410 | hid_err(hdev, "hid_parse failed\n"); | |
411 | goto err_free; | |
412 | } | |
413 | ||
414 | ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); | |
415 | if (ret) { | |
416 | hid_err(hdev, "hid_hw_start failed\n"); | |
417 | goto err_free; | |
418 | } | |
419 | ||
420 | uhdev = (struct usbhid_device *) hdev->driver_data; | |
421 | ||
422 | if (uhdev->ifnum == 1) | |
423 | return tpkbd_probe_tp(hdev); | |
424 | ||
425 | return 0; | |
426 | err_free: | |
427 | return ret; | |
428 | } | |
429 | ||
430 | static void tpkbd_remove_tp(struct hid_device *hdev) | |
431 | { | |
832fbeae | 432 | struct tpkbd_data_pointer *data_pointer = hid_get_drvdata(hdev); |
c1dcad2d BS |
433 | |
434 | sysfs_remove_group(&hdev->dev.kobj, | |
435 | &tpkbd_attr_group_pointer); | |
436 | ||
c1dcad2d BS |
437 | led_classdev_unregister(&data_pointer->led_micmute); |
438 | led_classdev_unregister(&data_pointer->led_mute); | |
439 | ||
440 | hid_set_drvdata(hdev, NULL); | |
39149980 AL |
441 | kfree(data_pointer->led_micmute.name); |
442 | kfree(data_pointer->led_mute.name); | |
c1dcad2d BS |
443 | kfree(data_pointer); |
444 | } | |
445 | ||
446 | static void tpkbd_remove(struct hid_device *hdev) | |
447 | { | |
448 | struct usbhid_device *uhdev; | |
449 | ||
450 | uhdev = (struct usbhid_device *) hdev->driver_data; | |
451 | if (uhdev->ifnum == 1) | |
452 | tpkbd_remove_tp(hdev); | |
453 | ||
454 | hid_hw_stop(hdev); | |
455 | } | |
456 | ||
457 | static const struct hid_device_id tpkbd_devices[] = { | |
458 | { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) }, | |
459 | { } | |
460 | }; | |
461 | ||
462 | MODULE_DEVICE_TABLE(hid, tpkbd_devices); | |
463 | ||
464 | static struct hid_driver tpkbd_driver = { | |
465 | .name = "lenovo_tpkbd", | |
466 | .id_table = tpkbd_devices, | |
467 | .input_mapping = tpkbd_input_mapping, | |
468 | .probe = tpkbd_probe, | |
469 | .remove = tpkbd_remove, | |
470 | }; | |
471 | ||
472 | static int __init tpkbd_init(void) | |
473 | { | |
474 | return hid_register_driver(&tpkbd_driver); | |
475 | } | |
476 | ||
477 | static void __exit tpkbd_exit(void) | |
478 | { | |
479 | hid_unregister_driver(&tpkbd_driver); | |
480 | } | |
481 | ||
482 | module_init(tpkbd_init); | |
483 | module_exit(tpkbd_exit); | |
484 | ||
485 | MODULE_LICENSE("GPL"); |