1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
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>
24
25#include "hid-ids.h"
26
27struct lenovo_drvdata_tpkbd {
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
39struct lenovo_drvdata_cptkbd {
40 u8 middlebutton_state;
41 bool fn_lock;
42 int sensitivity;
43};
44
45#define map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, EV_KEY, (c))
46
47static const __u8 lenovo_pro_dock_need_fixup_collection[] = {
48 0x05, 0x88,
49 0x09, 0x01,
50 0xa1, 0x01,
51 0x85, 0x04,
52 0x19, 0x00,
53 0x2a, 0xff, 0xff,
54};
55
56static __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
62
63
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
76static 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)
79{
80 if (usage->hid == (HID_UP_BUTTON | 0x0010)) {
81
82 hid_set_drvdata(hdev, (void *)1);
83 map_key_clear(KEY_MICMUTE);
84 return 1;
85 }
86 return 0;
87}
88
89static 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
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:
98 map_key_clear(KEY_MICMUTE);
99 return 1;
100 case 0x00f2:
101 map_key_clear(KEY_BRIGHTNESSDOWN);
102 return 1;
103 case 0x00f3:
104 map_key_clear(KEY_BRIGHTNESSUP);
105 return 1;
106 case 0x00f4:
107 map_key_clear(KEY_SWITCHVIDEOMODE);
108 return 1;
109 case 0x00f5:
110 map_key_clear(KEY_WLAN);
111 return 1;
112 case 0x00f6:
113 map_key_clear(KEY_CONFIG);
114 return 1;
115 case 0x00f8:
116 map_key_clear(KEY_SCALE);
117 return 1;
118 case 0x00f9:
119
120 map_key_clear(KEY_FILE);
121 return 1;
122 case 0x00fa:
123 map_key_clear(KEY_FN_ESC);
124 return 1;
125 case 0x00fb:
126 map_key_clear(BTN_MIDDLE);
127 return 1;
128 }
129 }
130
131
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
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:
150 hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
151 return 1;
152 case 0x0001:
153 hid_map_usage(hi, usage, bit, max, EV_REL, REL_WHEEL);
154 return 1;
155 default:
156 return -1;
157 }
158 }
159
160 return 0;
161}
162
163static 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);
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);
175 default:
176 return 0;
177 }
178}
179
180#undef map_key_clear
181
182
183static int lenovo_send_cmd_cptkbd(struct hid_device *hdev,
184 unsigned char byte2, unsigned char byte3)
185{
186 int ret;
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;
196
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);
201 break;
202 case USB_DEVICE_ID_LENOVO_CBTKBD:
203 ret = hid_hw_output_report(hdev, buf, 3);
204 break;
205 default:
206 ret = -EINVAL;
207 break;
208 }
209
210 kfree(buf);
211
212 return ret < 0 ? ret : 0;
213}
214
215static 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);
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);
227}
228
229static ssize_t attr_fn_lock_show_cptkbd(struct device *dev,
230 struct device_attribute *attr,
231 char *buf)
232{
233 struct hid_device *hdev = to_hid_device(dev);
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
239static ssize_t attr_fn_lock_store_cptkbd(struct device *dev,
240 struct device_attribute *attr,
241 const char *buf,
242 size_t count)
243{
244 struct hid_device *hdev = to_hid_device(dev);
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
259static ssize_t attr_sensitivity_show_cptkbd(struct device *dev,
260 struct device_attribute *attr,
261 char *buf)
262{
263 struct hid_device *hdev = to_hid_device(dev);
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
270static ssize_t attr_sensitivity_store_cptkbd(struct device *dev,
271 struct device_attribute *attr,
272 const char *buf,
273 size_t count)
274{
275 struct hid_device *hdev = to_hid_device(dev);
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
289static 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
294static 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
300static struct attribute *lenovo_attributes_cptkbd[] = {
301 &dev_attr_fn_lock_cptkbd.attr,
302 &dev_attr_sensitivity_cptkbd.attr,
303 NULL
304};
305
306static const struct attribute_group lenovo_attr_group_cptkbd = {
307 .attrs = lenovo_attributes_cptkbd,
308};
309
310static int lenovo_raw_event(struct hid_device *hdev,
311 struct hid_report *report, u8 *data, int size)
312{
313
314
315
316
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)) {
323 data[1] = 0x00;
324 data[2] = 0x01;
325 }
326
327 return 0;
328}
329
330static 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
336 if (usage->type == EV_REL && (usage->code == REL_WHEEL ||
337 usage->code == REL_HWHEEL)) {
338
339 cptkbd_data->middlebutton_state = 2;
340 return 0;
341 }
342
343
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
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
365static 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
377static int lenovo_features_set_tpkbd(struct hid_device *hdev)
378{
379 struct hid_report *report;
380 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
381
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;
389 report->field[2]->value[0] = data_pointer->sensitivity;
390 report->field[3]->value[0] = data_pointer->press_speed;
391
392 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
393 return 0;
394}
395
396static ssize_t attr_press_to_select_show_tpkbd(struct device *dev,
397 struct device_attribute *attr,
398 char *buf)
399{
400 struct hid_device *hdev = to_hid_device(dev);
401 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
402
403 return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->press_to_select);
404}
405
406static ssize_t attr_press_to_select_store_tpkbd(struct device *dev,
407 struct device_attribute *attr,
408 const char *buf,
409 size_t count)
410{
411 struct hid_device *hdev = to_hid_device(dev);
412 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
413 int value;
414
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;
421 lenovo_features_set_tpkbd(hdev);
422
423 return count;
424}
425
426static ssize_t attr_dragging_show_tpkbd(struct device *dev,
427 struct device_attribute *attr,
428 char *buf)
429{
430 struct hid_device *hdev = to_hid_device(dev);
431 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
432
433 return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->dragging);
434}
435
436static ssize_t attr_dragging_store_tpkbd(struct device *dev,
437 struct device_attribute *attr,
438 const char *buf,
439 size_t count)
440{
441 struct hid_device *hdev = to_hid_device(dev);
442 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
443 int value;
444
445 if (kstrtoint(buf, 10, &value))
446 return -EINVAL;
447 if (value < 0 || value > 1)
448 return -EINVAL;
449
450 data_pointer->dragging = value;
451 lenovo_features_set_tpkbd(hdev);
452
453 return count;
454}
455
456static ssize_t attr_release_to_select_show_tpkbd(struct device *dev,
457 struct device_attribute *attr,
458 char *buf)
459{
460 struct hid_device *hdev = to_hid_device(dev);
461 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
462
463 return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->release_to_select);
464}
465
466static ssize_t attr_release_to_select_store_tpkbd(struct device *dev,
467 struct device_attribute *attr,
468 const char *buf,
469 size_t count)
470{
471 struct hid_device *hdev = to_hid_device(dev);
472 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
473 int value;
474
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;
481 lenovo_features_set_tpkbd(hdev);
482
483 return count;
484}
485
486static ssize_t attr_select_right_show_tpkbd(struct device *dev,
487 struct device_attribute *attr,
488 char *buf)
489{
490 struct hid_device *hdev = to_hid_device(dev);
491 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
492
493 return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->select_right);
494}
495
496static ssize_t attr_select_right_store_tpkbd(struct device *dev,
497 struct device_attribute *attr,
498 const char *buf,
499 size_t count)
500{
501 struct hid_device *hdev = to_hid_device(dev);
502 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
503 int value;
504
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;
511 lenovo_features_set_tpkbd(hdev);
512
513 return count;
514}
515
516static ssize_t attr_sensitivity_show_tpkbd(struct device *dev,
517 struct device_attribute *attr,
518 char *buf)
519{
520 struct hid_device *hdev = to_hid_device(dev);
521 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
522
523 return snprintf(buf, PAGE_SIZE, "%u\n",
524 data_pointer->sensitivity);
525}
526
527static ssize_t attr_sensitivity_store_tpkbd(struct device *dev,
528 struct device_attribute *attr,
529 const char *buf,
530 size_t count)
531{
532 struct hid_device *hdev = to_hid_device(dev);
533 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
534 int value;
535
536 if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
537 return -EINVAL;
538
539 data_pointer->sensitivity = value;
540 lenovo_features_set_tpkbd(hdev);
541
542 return count;
543}
544
545static ssize_t attr_press_speed_show_tpkbd(struct device *dev,
546 struct device_attribute *attr,
547 char *buf)
548{
549 struct hid_device *hdev = to_hid_device(dev);
550 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
551
552 return snprintf(buf, PAGE_SIZE, "%u\n",
553 data_pointer->press_speed);
554}
555
556static ssize_t attr_press_speed_store_tpkbd(struct device *dev,
557 struct device_attribute *attr,
558 const char *buf,
559 size_t count)
560{
561 struct hid_device *hdev = to_hid_device(dev);
562 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
563 int value;
564
565 if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
566 return -EINVAL;
567
568 data_pointer->press_speed = value;
569 lenovo_features_set_tpkbd(hdev);
570
571 return count;
572}
573
574static 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);
578
579static struct device_attribute dev_attr_dragging_tpkbd =
580 __ATTR(dragging, S_IWUSR | S_IRUGO,
581 attr_dragging_show_tpkbd,
582 attr_dragging_store_tpkbd);
583
584static 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);
588
589static 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);
593
594static struct device_attribute dev_attr_sensitivity_tpkbd =
595 __ATTR(sensitivity, S_IWUSR | S_IRUGO,
596 attr_sensitivity_show_tpkbd,
597 attr_sensitivity_store_tpkbd);
598
599static 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);
603
604static 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,
611 NULL
612};
613
614static const struct attribute_group lenovo_attr_group_tpkbd = {
615 .attrs = lenovo_attributes_tpkbd,
616};
617
618static enum led_brightness lenovo_led_brightness_get_tpkbd(
619 struct led_classdev *led_cdev)
620{
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);
624 int led_nr = 0;
625
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
634static void lenovo_led_brightness_set_tpkbd(struct led_classdev *led_cdev,
635 enum led_brightness value)
636{
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;
641 int led_nr = 0;
642
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;
654 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
655}
656
657static int lenovo_probe_tpkbd(struct hid_device *hdev)
658{
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;
663 int i;
664 int ret;
665
666
667
668
669
670 if (!hid_get_drvdata(hdev))
671 return 0;
672
673 hid_set_drvdata(hdev, NULL);
674
675
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;
682
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);
686
687 data_pointer = devm_kzalloc(&hdev->dev,
688 sizeof(struct lenovo_drvdata_tpkbd),
689 GFP_KERNEL);
690 if (data_pointer == NULL) {
691 hid_err(hdev, "Could not allocate memory for driver data\n");
692 ret = -ENOMEM;
693 goto err;
694 }
695
696
697 data_pointer->sensitivity = 0xa0;
698 data_pointer->press_speed = 0x38;
699
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");
704 ret = -ENOMEM;
705 goto err;
706 }
707 snprintf(name_mute, name_sz, "%s:amber:mute", dev_name(dev));
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;
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);
717
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);
725
726 lenovo_features_set_tpkbd(hdev);
727
728 return 0;
729err:
730 sysfs_remove_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd);
731 return ret;
732}
733
734static int lenovo_probe_cptkbd(struct hid_device *hdev)
735{
736 int ret;
737 struct lenovo_drvdata_cptkbd *cptkbd_data;
738
739
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
757
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
763
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
768
769 cptkbd_data->middlebutton_state = 0;
770 cptkbd_data->fn_lock = true;
771 cptkbd_data->sensitivity = 0x05;
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
781static int lenovo_probe(struct hid_device *hdev,
782 const struct hid_device_id *id)
783{
784 int ret;
785
786 ret = hid_parse(hdev);
787 if (ret) {
788 hid_err(hdev, "hid_parse failed\n");
789 goto err;
790 }
791
792 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
793 if (ret) {
794 hid_err(hdev, "hid_hw_start failed\n");
795 goto err;
796 }
797
798 switch (hdev->product) {
799 case USB_DEVICE_ID_LENOVO_TPKBD:
800 ret = lenovo_probe_tpkbd(hdev);
801 break;
802 case USB_DEVICE_ID_LENOVO_CUSBKBD:
803 case USB_DEVICE_ID_LENOVO_CBTKBD:
804 ret = lenovo_probe_cptkbd(hdev);
805 break;
806 default:
807 ret = 0;
808 break;
809 }
810 if (ret)
811 goto err_hid;
812
813 return 0;
814err_hid:
815 hid_hw_stop(hdev);
816err:
817 return ret;
818}
819
820static void lenovo_remove_tpkbd(struct hid_device *hdev)
821{
822 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
823
824
825
826
827
828 if (data_pointer == NULL)
829 return;
830
831 sysfs_remove_group(&hdev->dev.kobj,
832 &lenovo_attr_group_tpkbd);
833
834 led_classdev_unregister(&data_pointer->led_micmute);
835 led_classdev_unregister(&data_pointer->led_mute);
836
837 hid_set_drvdata(hdev, NULL);
838}
839
840static void lenovo_remove_cptkbd(struct hid_device *hdev)
841{
842 sysfs_remove_group(&hdev->dev.kobj,
843 &lenovo_attr_group_cptkbd);
844}
845
846static void lenovo_remove(struct hid_device *hdev)
847{
848 switch (hdev->product) {
849 case USB_DEVICE_ID_LENOVO_TPKBD:
850 lenovo_remove_tpkbd(hdev);
851 break;
852 case USB_DEVICE_ID_LENOVO_CUSBKBD:
853 case USB_DEVICE_ID_LENOVO_CBTKBD:
854 lenovo_remove_cptkbd(hdev);
855 break;
856 }
857
858 hid_hw_stop(hdev);
859}
860
861static int lenovo_input_configured(struct hid_device *hdev,
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
870 __set_bit(INPUT_PROP_POINTER, hi->input->propbit);
871 __set_bit(INPUT_PROP_POINTING_STICK,
872 hi->input->propbit);
873 }
874 break;
875 }
876
877 return 0;
878}
879
880
881static 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) },
886 { }
887};
888
889MODULE_DEVICE_TABLE(hid, lenovo_devices);
890
891static struct hid_driver lenovo_driver = {
892 .name = "lenovo",
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,
901};
902module_hid_driver(lenovo_driver);
903
904MODULE_LICENSE("GPL");
905
