2 * HID driver for Lenovo:
3 * - ThinkPad USB Keyboard with TrackPoint (tpkbd)
4 * - ThinkPad Compact Bluetooth Keyboard with TrackPoint (cptkbd)
5 * - ThinkPad Compact USB Keyboard with TrackPoint (cptkbd)
7 * Copyright (c) 2012 Bernhard Seibold
8 * Copyright (c) 2014 Jamie Lentin <jm@lentin.co.uk>
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)
18 #include <linux/module.h>
19 #include <linux/sysfs.h>
20 #include <linux/device.h>
21 #include <linux/hid.h>
22 #include <linux/input.h>
23 #include <linux/leds.h>
27 struct lenovo_drvdata_tpkbd {
29 struct led_classdev led_mute;
30 struct led_classdev led_micmute;
33 int release_to_select;
39 struct lenovo_drvdata_cptkbd {
40 u8 middlebutton_state; /* 0:Up, 1:Down (undecided), 2:Scrolling */
45 #define map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, EV_KEY, (c))
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) */
56 static __u8 *lenovo_report_fixup(struct hid_device *hdev, __u8 *rdesc,
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
66 memcmp(&rdesc[140], lenovo_pro_dock_need_fixup_collection,
67 sizeof(lenovo_pro_dock_need_fixup_collection)) == 0) {
76 static int lenovo_input_mapping_tpkbd(struct hid_device *hdev,
77 struct hid_input *hi, struct hid_field *field,
78 struct hid_usage *usage, unsigned long **bit, int *max)
80 if (usage->hid == (HID_UP_BUTTON | 0x0010)) {
81 /* This sub-device contains trackpoint, mark it */
82 hid_set_drvdata(hdev, (void *)1);
83 map_key_clear(KEY_MICMUTE);
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)
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) {
96 switch (usage->hid & HID_USAGE) {
97 case 0x00f1: /* Fn-F4: Mic mute */
98 map_key_clear(KEY_MICMUTE);
100 case 0x00f2: /* Fn-F5: Brightness down */
101 map_key_clear(KEY_BRIGHTNESSDOWN);
103 case 0x00f3: /* Fn-F6: Brightness up */
104 map_key_clear(KEY_BRIGHTNESSUP);
106 case 0x00f4: /* Fn-F7: External display (projector) */
107 map_key_clear(KEY_SWITCHVIDEOMODE);
109 case 0x00f5: /* Fn-F8: Wireless */
110 map_key_clear(KEY_WLAN);
112 case 0x00f6: /* Fn-F9: Control panel */
113 map_key_clear(KEY_CONFIG);
115 case 0x00f8: /* Fn-F11: View open applications (3 boxes) */
116 map_key_clear(KEY_SCALE);
118 case 0x00f9: /* Fn-F12: Open My computer (6 boxes) USB-only */
119 /* NB: This mapping is invented in raw_event below */
120 map_key_clear(KEY_FILE);
122 case 0x00fa: /* Fn-Esc: Fn-lock toggle */
123 map_key_clear(KEY_FN_ESC);
125 case 0x00fb: /* Middle mouse button (in native mode) */
126 map_key_clear(BTN_MIDDLE);
131 /* Compatibility middle/wheel mappings should be ignored */
132 if (usage->hid == HID_GD_WHEEL)
134 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON &&
135 (usage->hid & HID_USAGE) == 0x003)
137 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER &&
138 (usage->hid & HID_USAGE) == 0x238)
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;
148 switch (usage->hid & HID_USAGE) {
150 hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
153 hid_map_usage(hi, usage, bit, max, EV_REL, REL_WHEEL);
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)
167 switch (hdev->product) {
168 case USB_DEVICE_ID_LENOVO_TPKBD:
169 return lenovo_input_mapping_tpkbd(hdev, hi, field,
171 case USB_DEVICE_ID_LENOVO_CUSBKBD:
172 case USB_DEVICE_ID_LENOVO_CBTKBD:
173 return lenovo_input_mapping_cptkbd(hdev, hi, field,
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)
189 buf = kzalloc(3, GFP_KERNEL);
197 switch (hdev->product) {
198 case USB_DEVICE_ID_LENOVO_CUSBKBD:
199 ret = hid_hw_raw_request(hdev, 0x13, buf, 3,
200 HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
202 case USB_DEVICE_ID_LENOVO_CBTKBD:
203 ret = hid_hw_output_report(hdev, buf, 3);
212 return ret < 0 ? ret : 0; /* BT returns 0, USB returns sizeof(buf) */
215 static void lenovo_features_set_cptkbd(struct hid_device *hdev)
218 struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
220 ret = lenovo_send_cmd_cptkbd(hdev, 0x05, cptkbd_data->fn_lock);
222 hid_err(hdev, "Fn-lock setting failed: %d\n", ret);
224 ret = lenovo_send_cmd_cptkbd(hdev, 0x02, cptkbd_data->sensitivity);
226 hid_err(hdev, "Sensitivity setting failed: %d\n", ret);
229 static ssize_t attr_fn_lock_show_cptkbd(struct device *dev,
230 struct device_attribute *attr,
233 struct hid_device *hdev = to_hid_device(dev);
234 struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
236 return snprintf(buf, PAGE_SIZE, "%u\n", cptkbd_data->fn_lock);
239 static ssize_t attr_fn_lock_store_cptkbd(struct device *dev,
240 struct device_attribute *attr,
244 struct hid_device *hdev = to_hid_device(dev);
245 struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
248 if (kstrtoint(buf, 10, &value))
250 if (value < 0 || value > 1)
253 cptkbd_data->fn_lock = !!value;
254 lenovo_features_set_cptkbd(hdev);
259 static ssize_t attr_sensitivity_show_cptkbd(struct device *dev,
260 struct device_attribute *attr,
263 struct hid_device *hdev = to_hid_device(dev);
264 struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
266 return snprintf(buf, PAGE_SIZE, "%u\n",
267 cptkbd_data->sensitivity);
270 static ssize_t attr_sensitivity_store_cptkbd(struct device *dev,
271 struct device_attribute *attr,
275 struct hid_device *hdev = to_hid_device(dev);
276 struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
279 if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
282 cptkbd_data->sensitivity = value;
283 lenovo_features_set_cptkbd(hdev);
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);
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);
300 static struct attribute *lenovo_attributes_cptkbd[] = {
301 &dev_attr_fn_lock_cptkbd.attr,
302 &dev_attr_sensitivity_cptkbd.attr,
306 static const struct attribute_group lenovo_attr_group_cptkbd = {
307 .attrs = lenovo_attributes_cptkbd,
310 static int lenovo_raw_event(struct hid_device *hdev,
311 struct hid_report *report, u8 *data, int size)
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.
318 if (unlikely(hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD
322 && data[2] == 0x01)) {
330 static int lenovo_event_cptkbd(struct hid_device *hdev,
331 struct hid_field *field, struct hid_usage *usage, __s32 value)
333 struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
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;
343 /* Middle click events */
344 if (usage->type == EV_KEY && usage->code == BTN_MIDDLE) {
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);
357 cptkbd_data->middlebutton_state = 0;
365 static int lenovo_event(struct hid_device *hdev, struct hid_field *field,
366 struct hid_usage *usage, __s32 value)
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);
377 static int lenovo_features_set_tpkbd(struct hid_device *hdev)
379 struct hid_report *report;
380 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
382 report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[4];
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;
392 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
396 static ssize_t attr_press_to_select_show_tpkbd(struct device *dev,
397 struct device_attribute *attr,
400 struct hid_device *hdev = to_hid_device(dev);
401 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
403 return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->press_to_select);
406 static ssize_t attr_press_to_select_store_tpkbd(struct device *dev,
407 struct device_attribute *attr,
411 struct hid_device *hdev = to_hid_device(dev);
412 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
415 if (kstrtoint(buf, 10, &value))
417 if (value < 0 || value > 1)
420 data_pointer->press_to_select = value;
421 lenovo_features_set_tpkbd(hdev);
426 static ssize_t attr_dragging_show_tpkbd(struct device *dev,
427 struct device_attribute *attr,
430 struct hid_device *hdev = to_hid_device(dev);
431 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
433 return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->dragging);
436 static ssize_t attr_dragging_store_tpkbd(struct device *dev,
437 struct device_attribute *attr,
441 struct hid_device *hdev = to_hid_device(dev);
442 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
445 if (kstrtoint(buf, 10, &value))
447 if (value < 0 || value > 1)
450 data_pointer->dragging = value;
451 lenovo_features_set_tpkbd(hdev);
456 static ssize_t attr_release_to_select_show_tpkbd(struct device *dev,
457 struct device_attribute *attr,
460 struct hid_device *hdev = to_hid_device(dev);
461 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
463 return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->release_to_select);
466 static ssize_t attr_release_to_select_store_tpkbd(struct device *dev,
467 struct device_attribute *attr,
471 struct hid_device *hdev = to_hid_device(dev);
472 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
475 if (kstrtoint(buf, 10, &value))
477 if (value < 0 || value > 1)
480 data_pointer->release_to_select = value;
481 lenovo_features_set_tpkbd(hdev);
486 static ssize_t attr_select_right_show_tpkbd(struct device *dev,
487 struct device_attribute *attr,
490 struct hid_device *hdev = to_hid_device(dev);
491 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
493 return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->select_right);
496 static ssize_t attr_select_right_store_tpkbd(struct device *dev,
497 struct device_attribute *attr,
501 struct hid_device *hdev = to_hid_device(dev);
502 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
505 if (kstrtoint(buf, 10, &value))
507 if (value < 0 || value > 1)
510 data_pointer->select_right = value;
511 lenovo_features_set_tpkbd(hdev);
516 static ssize_t attr_sensitivity_show_tpkbd(struct device *dev,
517 struct device_attribute *attr,
520 struct hid_device *hdev = to_hid_device(dev);
521 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
523 return snprintf(buf, PAGE_SIZE, "%u\n",
524 data_pointer->sensitivity);
527 static ssize_t attr_sensitivity_store_tpkbd(struct device *dev,
528 struct device_attribute *attr,
532 struct hid_device *hdev = to_hid_device(dev);
533 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
536 if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
539 data_pointer->sensitivity = value;
540 lenovo_features_set_tpkbd(hdev);
545 static ssize_t attr_press_speed_show_tpkbd(struct device *dev,
546 struct device_attribute *attr,
549 struct hid_device *hdev = to_hid_device(dev);
550 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
552 return snprintf(buf, PAGE_SIZE, "%u\n",
553 data_pointer->press_speed);
556 static ssize_t attr_press_speed_store_tpkbd(struct device *dev,
557 struct device_attribute *attr,
561 struct hid_device *hdev = to_hid_device(dev);
562 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
565 if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
568 data_pointer->press_speed = value;
569 lenovo_features_set_tpkbd(hdev);
574 static struct device_attribute dev_attr_press_to_select_tpkbd =
575 __ATTR(press_to_select, S_IWUSR | S_IRUGO,
576 attr_press_to_select_show_tpkbd,
577 attr_press_to_select_store_tpkbd);
579 static struct device_attribute dev_attr_dragging_tpkbd =
580 __ATTR(dragging, S_IWUSR | S_IRUGO,
581 attr_dragging_show_tpkbd,
582 attr_dragging_store_tpkbd);
584 static struct device_attribute dev_attr_release_to_select_tpkbd =
585 __ATTR(release_to_select, S_IWUSR | S_IRUGO,
586 attr_release_to_select_show_tpkbd,
587 attr_release_to_select_store_tpkbd);
589 static struct device_attribute dev_attr_select_right_tpkbd =
590 __ATTR(select_right, S_IWUSR | S_IRUGO,
591 attr_select_right_show_tpkbd,
592 attr_select_right_store_tpkbd);
594 static struct device_attribute dev_attr_sensitivity_tpkbd =
595 __ATTR(sensitivity, S_IWUSR | S_IRUGO,
596 attr_sensitivity_show_tpkbd,
597 attr_sensitivity_store_tpkbd);
599 static struct device_attribute dev_attr_press_speed_tpkbd =
600 __ATTR(press_speed, S_IWUSR | S_IRUGO,
601 attr_press_speed_show_tpkbd,
602 attr_press_speed_store_tpkbd);
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,
614 static const struct attribute_group lenovo_attr_group_tpkbd = {
615 .attrs = lenovo_attributes_tpkbd,
618 static enum led_brightness lenovo_led_brightness_get_tpkbd(
619 struct led_classdev *led_cdev)
621 struct device *dev = led_cdev->dev->parent;
622 struct hid_device *hdev = to_hid_device(dev);
623 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
626 if (led_cdev == &data_pointer->led_micmute)
629 return data_pointer->led_state & (1 << led_nr)
634 static void lenovo_led_brightness_set_tpkbd(struct led_classdev *led_cdev,
635 enum led_brightness value)
637 struct device *dev = led_cdev->dev->parent;
638 struct hid_device *hdev = to_hid_device(dev);
639 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
640 struct hid_report *report;
643 if (led_cdev == &data_pointer->led_micmute)
646 if (value == LED_OFF)
647 data_pointer->led_state &= ~(1 << led_nr);
649 data_pointer->led_state |= 1 << led_nr;
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;
654 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
657 static int lenovo_probe_tpkbd(struct hid_device *hdev)
659 struct device *dev = &hdev->dev;
660 struct lenovo_drvdata_tpkbd *data_pointer;
661 size_t name_sz = strlen(dev_name(dev)) + 16;
662 char *name_mute, *name_micmute;
667 * Only register extra settings against subdevice where input_mapping
668 * set drvdata to 1, i.e. the trackpoint.
670 if (!hid_get_drvdata(hdev))
673 hid_set_drvdata(hdev, NULL);
675 /* Validate required reports. */
676 for (i = 0; i < 4; i++) {
677 if (!hid_validate_values(hdev, HID_FEATURE_REPORT, 4, i, 1))
680 if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 3, 0, 2))
683 ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd);
685 hid_warn(hdev, "Could not create sysfs group: %d\n", ret);
687 data_pointer = devm_kzalloc(&hdev->dev,
688 sizeof(struct lenovo_drvdata_tpkbd),
690 if (data_pointer == NULL) {
691 hid_err(hdev, "Could not allocate memory for driver data\n");
696 // set same default values as windows driver
697 data_pointer->sensitivity = 0xa0;
698 data_pointer->press_speed = 0x38;
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) {
703 hid_err(hdev, "Could not allocate memory for led data\n");
707 snprintf(name_mute, name_sz, "%s:amber:mute", dev_name(dev));
708 snprintf(name_micmute, name_sz, "%s:amber:micmute", dev_name(dev));
710 hid_set_drvdata(hdev, data_pointer);
712 data_pointer->led_mute.name = name_mute;
713 data_pointer->led_mute.brightness_get = lenovo_led_brightness_get_tpkbd;
714 data_pointer->led_mute.brightness_set = lenovo_led_brightness_set_tpkbd;
715 data_pointer->led_mute.dev = dev;
716 led_classdev_register(dev, &data_pointer->led_mute);
718 data_pointer->led_micmute.name = name_micmute;
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;
723 data_pointer->led_micmute.dev = dev;
724 led_classdev_register(dev, &data_pointer->led_micmute);
726 lenovo_features_set_tpkbd(hdev);
730 sysfs_remove_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd);
734 static int lenovo_probe_cptkbd(struct hid_device *hdev)
737 struct lenovo_drvdata_cptkbd *cptkbd_data;
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");
746 cptkbd_data = devm_kzalloc(&hdev->dev,
747 sizeof(*cptkbd_data),
749 if (cptkbd_data == NULL) {
750 hid_err(hdev, "can't alloc keyboard descriptor\n");
753 hid_set_drvdata(hdev, cptkbd_data);
756 * Tell the keyboard a driver understands it, and turn F7, F9, F11 into
759 ret = lenovo_send_cmd_cptkbd(hdev, 0x01, 0x03);
761 hid_warn(hdev, "Failed to switch F7/9/11 mode: %d\n", ret);
763 /* Switch middle button to native mode */
764 ret = lenovo_send_cmd_cptkbd(hdev, 0x09, 0x01);
766 hid_warn(hdev, "Failed to switch middle button: %d\n", ret);
768 /* Set keyboard settings to known state */
769 cptkbd_data->middlebutton_state = 0;
770 cptkbd_data->fn_lock = true;
771 cptkbd_data->sensitivity = 0x05;
772 lenovo_features_set_cptkbd(hdev);
774 ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_cptkbd);
776 hid_warn(hdev, "Could not create sysfs group: %d\n", ret);
781 static int lenovo_probe(struct hid_device *hdev,
782 const struct hid_device_id *id)
786 ret = hid_parse(hdev);
788 hid_err(hdev, "hid_parse failed\n");
792 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
794 hid_err(hdev, "hid_hw_start failed\n");
798 switch (hdev->product) {
799 case USB_DEVICE_ID_LENOVO_TPKBD:
800 ret = lenovo_probe_tpkbd(hdev);
802 case USB_DEVICE_ID_LENOVO_CUSBKBD:
803 case USB_DEVICE_ID_LENOVO_CBTKBD:
804 ret = lenovo_probe_cptkbd(hdev);
820 static void lenovo_remove_tpkbd(struct hid_device *hdev)
822 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
825 * Only the trackpoint half of the keyboard has drvdata and stuff that
826 * needs unregistering.
828 if (data_pointer == NULL)
831 sysfs_remove_group(&hdev->dev.kobj,
832 &lenovo_attr_group_tpkbd);
834 led_classdev_unregister(&data_pointer->led_micmute);
835 led_classdev_unregister(&data_pointer->led_mute);
837 hid_set_drvdata(hdev, NULL);
840 static void lenovo_remove_cptkbd(struct hid_device *hdev)
842 sysfs_remove_group(&hdev->dev.kobj,
843 &lenovo_attr_group_cptkbd);
846 static void lenovo_remove(struct hid_device *hdev)
848 switch (hdev->product) {
849 case USB_DEVICE_ID_LENOVO_TPKBD:
850 lenovo_remove_tpkbd(hdev);
852 case USB_DEVICE_ID_LENOVO_CUSBKBD:
853 case USB_DEVICE_ID_LENOVO_CBTKBD:
854 lenovo_remove_cptkbd(hdev);
861 static int lenovo_input_configured(struct hid_device *hdev,
862 struct hid_input *hi)
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,
881 static const struct hid_device_id lenovo_devices[] = {
882 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) },
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) },
885 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) },
889 MODULE_DEVICE_TABLE(hid, lenovo_devices);
891 static struct hid_driver lenovo_driver = {
893 .id_table = lenovo_devices,
894 .input_configured = lenovo_input_configured,
895 .input_mapping = lenovo_input_mapping,
896 .probe = lenovo_probe,
897 .remove = lenovo_remove,
898 .raw_event = lenovo_raw_event,
899 .event = lenovo_event,
900 .report_fixup = lenovo_report_fixup,
902 module_hid_driver(lenovo_driver);
904 MODULE_LICENSE("GPL");