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[] = {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;
203}
204
205static 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);
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);
217}
218
219static ssize_t attr_fn_lock_show_cptkbd(struct device *dev,
220 struct device_attribute *attr,
221 char *buf)
222{
223 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
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
229static ssize_t attr_fn_lock_store_cptkbd(struct device *dev,
230 struct device_attribute *attr,
231 const char *buf,
232 size_t count)
233{
234 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
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
249static ssize_t attr_sensitivity_show_cptkbd(struct device *dev,
250 struct device_attribute *attr,
251 char *buf)
252{
253 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
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
260static ssize_t attr_sensitivity_store_cptkbd(struct device *dev,
261 struct device_attribute *attr,
262 const char *buf,
263 size_t count)
264{
265 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
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
279static 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
284static 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
290static struct attribute *lenovo_attributes_cptkbd[] = {
291 &dev_attr_fn_lock_cptkbd.attr,
292 &dev_attr_sensitivity_cptkbd.attr,
293 NULL
294};
295
296static const struct attribute_group lenovo_attr_group_cptkbd = {
297 .attrs = lenovo_attributes_cptkbd,
298};
299
300static int lenovo_raw_event(struct hid_device *hdev,
301 struct hid_report *report, u8 *data, int size)
302{
303
304
305
306
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)) {
313 data[1] = 0x00;
314 data[2] = 0x01;
315 }
316
317 return 0;
318}
319
320static 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
326 if (usage->type == EV_REL && (usage->code == REL_WHEEL ||
327 usage->code == REL_HWHEEL)) {
328
329 cptkbd_data->middlebutton_state = 2;
330 return 0;
331 }
332
333
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
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
355static 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
367static int lenovo_features_set_tpkbd(struct hid_device *hdev)
368{
369 struct hid_report *report;
370 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
371
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;
379 report->field[2]->value[0] = data_pointer->sensitivity;
380 report->field[3]->value[0] = data_pointer->press_speed;
381
382 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
383 return 0;
384}
385
386static ssize_t attr_press_to_select_show_tpkbd(struct device *dev,
387 struct device_attribute *attr,
388 char *buf)
389{
390 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
391 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
392
393 return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->press_to_select);
394}
395
396static ssize_t attr_press_to_select_store_tpkbd(struct device *dev,
397 struct device_attribute *attr,
398 const char *buf,
399 size_t count)
400{
401 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
402 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
403 int value;
404
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;
411 lenovo_features_set_tpkbd(hdev);
412
413 return count;
414}
415
416static ssize_t attr_dragging_show_tpkbd(struct device *dev,
417 struct device_attribute *attr,
418 char *buf)
419{
420 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
421 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
422
423 return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->dragging);
424}
425
426static ssize_t attr_dragging_store_tpkbd(struct device *dev,
427 struct device_attribute *attr,
428 const char *buf,
429 size_t count)
430{
431 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
432 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
433 int value;
434
435 if (kstrtoint(buf, 10, &value))
436 return -EINVAL;
437 if (value < 0 || value > 1)
438 return -EINVAL;
439
440 data_pointer->dragging = value;
441 lenovo_features_set_tpkbd(hdev);
442
443 return count;
444}
445
446static ssize_t attr_release_to_select_show_tpkbd(struct device *dev,
447 struct device_attribute *attr,
448 char *buf)
449{
450 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
451 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
452
453 return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->release_to_select);
454}
455
456static ssize_t attr_release_to_select_store_tpkbd(struct device *dev,
457 struct device_attribute *attr,
458 const char *buf,
459 size_t count)
460{
461 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
462 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
463 int value;
464
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;
471 lenovo_features_set_tpkbd(hdev);
472
473 return count;
474}
475
476static ssize_t attr_select_right_show_tpkbd(struct device *dev,
477 struct device_attribute *attr,
478 char *buf)
479{
480 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
481 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
482
483 return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->select_right);
484}
485
486static ssize_t attr_select_right_store_tpkbd(struct device *dev,
487 struct device_attribute *attr,
488 const char *buf,
489 size_t count)
490{
491 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
492 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
493 int value;
494
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;
501 lenovo_features_set_tpkbd(hdev);
502
503 return count;
504}
505
506static ssize_t attr_sensitivity_show_tpkbd(struct device *dev,
507 struct device_attribute *attr,
508 char *buf)
509{
510 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
511 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
512
513 return snprintf(buf, PAGE_SIZE, "%u\n",
514 data_pointer->sensitivity);
515}
516
517static ssize_t attr_sensitivity_store_tpkbd(struct device *dev,
518 struct device_attribute *attr,
519 const char *buf,
520 size_t count)
521{
522 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
523 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
524 int value;
525
526 if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
527 return -EINVAL;
528
529 data_pointer->sensitivity = value;
530 lenovo_features_set_tpkbd(hdev);
531
532 return count;
533}
534
535static ssize_t attr_press_speed_show_tpkbd(struct device *dev,
536 struct device_attribute *attr,
537 char *buf)
538{
539 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
540 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
541
542 return snprintf(buf, PAGE_SIZE, "%u\n",
543 data_pointer->press_speed);
544}
545
546static ssize_t attr_press_speed_store_tpkbd(struct device *dev,
547 struct device_attribute *attr,
548 const char *buf,
549 size_t count)
550{
551 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
552 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
553 int value;
554
555 if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
556 return -EINVAL;
557
558 data_pointer->press_speed = value;
559 lenovo_features_set_tpkbd(hdev);
560
561 return count;
562}
563
564static struct device_attribute dev_attr_press_to_select_tpkbd =
565 __ATTR(press_to_select, S_IWUSR | S_IRUGO,
566 attr_press_to_select_show_tpkbd,
567 attr_press_to_select_store_tpkbd);
568
569static struct device_attribute dev_attr_dragging_tpkbd =
570 __ATTR(dragging, S_IWUSR | S_IRUGO,
571 attr_dragging_show_tpkbd,
572 attr_dragging_store_tpkbd);
573
574static struct device_attribute dev_attr_release_to_select_tpkbd =
575 __ATTR(release_to_select, S_IWUSR | S_IRUGO,
576 attr_release_to_select_show_tpkbd,
577 attr_release_to_select_store_tpkbd);
578
579static struct device_attribute dev_attr_select_right_tpkbd =
580 __ATTR(select_right, S_IWUSR | S_IRUGO,
581 attr_select_right_show_tpkbd,
582 attr_select_right_store_tpkbd);
583
584static struct device_attribute dev_attr_sensitivity_tpkbd =
585 __ATTR(sensitivity, S_IWUSR | S_IRUGO,
586 attr_sensitivity_show_tpkbd,
587 attr_sensitivity_store_tpkbd);
588
589static struct device_attribute dev_attr_press_speed_tpkbd =
590 __ATTR(press_speed, S_IWUSR | S_IRUGO,
591 attr_press_speed_show_tpkbd,
592 attr_press_speed_store_tpkbd);
593
594static 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,
601 NULL
602};
603
604static const struct attribute_group lenovo_attr_group_tpkbd = {
605 .attrs = lenovo_attributes_tpkbd,
606};
607
608static enum led_brightness lenovo_led_brightness_get_tpkbd(
609 struct led_classdev *led_cdev)
610{
611 struct device *dev = led_cdev->dev->parent;
612 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
613 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
614 int led_nr = 0;
615
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
624static void lenovo_led_brightness_set_tpkbd(struct led_classdev *led_cdev,
625 enum led_brightness value)
626{
627 struct device *dev = led_cdev->dev->parent;
628 struct hid_device *hdev = container_of(dev, struct hid_device, dev);
629 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
630 struct hid_report *report;
631 int led_nr = 0;
632
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;
644 hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
645}
646
647static int lenovo_probe_tpkbd(struct hid_device *hdev)
648{
649 struct device *dev = &hdev->dev;
650 struct lenovo_drvdata_tpkbd *data_pointer;
651 size_t name_sz = strlen(dev_name(dev)) + 16;
652 char *name_mute, *name_micmute;
653 int i;
654 int ret;
655
656
657
658
659
660 if (!hid_get_drvdata(hdev))
661 return 0;
662
663 hid_set_drvdata(hdev, NULL);
664
665
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;
672
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);
676
677 data_pointer = devm_kzalloc(&hdev->dev,
678 sizeof(struct lenovo_drvdata_tpkbd),
679 GFP_KERNEL);
680 if (data_pointer == NULL) {
681 hid_err(hdev, "Could not allocate memory for driver data\n");
682 ret = -ENOMEM;
683 goto err;
684 }
685
686
687 data_pointer->sensitivity = 0xa0;
688 data_pointer->press_speed = 0x38;
689
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) {
693 hid_err(hdev, "Could not allocate memory for led data\n");
694 ret = -ENOMEM;
695 goto err;
696 }
697 snprintf(name_mute, name_sz, "%s:amber:mute", dev_name(dev));
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;
703 data_pointer->led_mute.brightness_get = lenovo_led_brightness_get_tpkbd;
704 data_pointer->led_mute.brightness_set = lenovo_led_brightness_set_tpkbd;
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;
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;
713 data_pointer->led_micmute.dev = dev;
714 led_classdev_register(dev, &data_pointer->led_micmute);
715
716 lenovo_features_set_tpkbd(hdev);
717
718 return 0;
719err:
720 sysfs_remove_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd);
721 return ret;
722}
723
724static int lenovo_probe_cptkbd(struct hid_device *hdev)
725{
726 int ret;
727 struct lenovo_drvdata_cptkbd *cptkbd_data;
728
729
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
747
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
753
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
758
759 cptkbd_data->middlebutton_state = 0;
760 cptkbd_data->fn_lock = true;
761 cptkbd_data->sensitivity = 0x05;
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
771static int lenovo_probe(struct hid_device *hdev,
772 const struct hid_device_id *id)
773{
774 int ret;
775
776 ret = hid_parse(hdev);
777 if (ret) {
778 hid_err(hdev, "hid_parse failed\n");
779 goto err;
780 }
781
782 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
783 if (ret) {
784 hid_err(hdev, "hid_hw_start failed\n");
785 goto err;
786 }
787
788 switch (hdev->product) {
789 case USB_DEVICE_ID_LENOVO_TPKBD:
790 ret = lenovo_probe_tpkbd(hdev);
791 break;
792 case USB_DEVICE_ID_LENOVO_CUSBKBD:
793 case USB_DEVICE_ID_LENOVO_CBTKBD:
794 ret = lenovo_probe_cptkbd(hdev);
795 break;
796 default:
797 ret = 0;
798 break;
799 }
800 if (ret)
801 goto err_hid;
802
803 return 0;
804err_hid:
805 hid_hw_stop(hdev);
806err:
807 return ret;
808}
809
810static void lenovo_remove_tpkbd(struct hid_device *hdev)
811{
812 struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
813
814
815
816
817
818 if (data_pointer == NULL)
819 return;
820
821 sysfs_remove_group(&hdev->dev.kobj,
822 &lenovo_attr_group_tpkbd);
823
824 led_classdev_unregister(&data_pointer->led_micmute);
825 led_classdev_unregister(&data_pointer->led_mute);
826
827 hid_set_drvdata(hdev, NULL);
828}
829
830static void lenovo_remove_cptkbd(struct hid_device *hdev)
831{
832 sysfs_remove_group(&hdev->dev.kobj,
833 &lenovo_attr_group_cptkbd);
834}
835
836static void lenovo_remove(struct hid_device *hdev)
837{
838 switch (hdev->product) {
839 case USB_DEVICE_ID_LENOVO_TPKBD:
840 lenovo_remove_tpkbd(hdev);
841 break;
842 case USB_DEVICE_ID_LENOVO_CUSBKBD:
843 case USB_DEVICE_ID_LENOVO_CBTKBD:
844 lenovo_remove_cptkbd(hdev);
845 break;
846 }
847
848 hid_hw_stop(hdev);
849}
850
851static int lenovo_input_configured(struct hid_device *hdev,
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
860 __set_bit(INPUT_PROP_POINTER, hi->input->propbit);
861 __set_bit(INPUT_PROP_POINTING_STICK,
862 hi->input->propbit);
863 }
864 break;
865 }
866
867 return 0;
868}
869
870
871static const struct hid_device_id lenovo_devices[] = {
872 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) },
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) },
875 { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) },
876 { }
877};
878
879MODULE_DEVICE_TABLE(hid, lenovo_devices);
880
881static struct hid_driver lenovo_driver = {
882 .name = "lenovo",
883 .id_table = lenovo_devices,
884 .input_configured = lenovo_input_configured,
885 .input_mapping = lenovo_input_mapping,
886 .probe = lenovo_probe,
887 .remove = lenovo_remove,
888 .raw_event = lenovo_raw_event,
889 .event = lenovo_event,
890 .report_fixup = lenovo_report_fixup,
891};
892module_hid_driver(lenovo_driver);
893
894MODULE_LICENSE("GPL");
895
