GNU Linux-libre 4.4.289-gnu1
[releases.git] / drivers / hid / hid-lenovo.c
1 /*
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)
6  *
7  *  Copyright (c) 2012 Bernhard Seibold
8  *  Copyright (c) 2014 Jamie Lentin <jm@lentin.co.uk>
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>
21 #include <linux/hid.h>
22 #include <linux/input.h>
23 #include <linux/leds.h>
24
25 #include "hid-ids.h"
26
27 struct 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
39 struct lenovo_drvdata_cptkbd {
40         u8 middlebutton_state; /* 0:Up, 1:Down (undecided), 2:Scrolling */
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
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
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)
79 {
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);
84                 return 1;
85         }
86         return 0;
87 }
88
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) {
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;
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);
121                         return 1;
122                 case 0x00fa: /* Fn-Esc: Fn-lock toggle */
123                         map_key_clear(KEY_FN_ESC);
124                         return 1;
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:
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
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);
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 /* 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);
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
219 static 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
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 {
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
249 static 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
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 {
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
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
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
290 static struct attribute *lenovo_attributes_cptkbd[] = {
291         &dev_attr_fn_lock_cptkbd.attr,
292         &dev_attr_sensitivity_cptkbd.attr,
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)) {
313                 data[1] = 0x00;
314                 data[2] = 0x01;
315         }
316
317         return 0;
318 }
319
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
367 static 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; // 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
382         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
383         return 0;
384 }
385
386 static 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
396 static 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
416 static 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
426 static 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
446 static 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
456 static 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
476 static 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
486 static 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
506 static 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
517 static 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
535 static 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
546 static 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
564 static 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
569 static 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
574 static 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
579 static 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
584 static 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
589 static 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
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,
601         NULL
602 };
603
604 static const struct attribute_group lenovo_attr_group_tpkbd = {
605         .attrs = lenovo_attributes_tpkbd,
606 };
607
608 static 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
624 static 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
647 static 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          * 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
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;
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         // set same default values as windows driver
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         ret = led_classdev_register(dev, &data_pointer->led_mute);
707         if (ret < 0)
708                 goto err;
709
710         data_pointer->led_micmute.name = name_micmute;
711         data_pointer->led_micmute.brightness_get =
712                 lenovo_led_brightness_get_tpkbd;
713         data_pointer->led_micmute.brightness_set =
714                 lenovo_led_brightness_set_tpkbd;
715         data_pointer->led_micmute.dev = dev;
716         ret = led_classdev_register(dev, &data_pointer->led_micmute);
717         if (ret < 0) {
718                 led_classdev_unregister(&data_pointer->led_mute);
719                 goto err;
720         }
721
722         lenovo_features_set_tpkbd(hdev);
723
724         return 0;
725 err:
726         sysfs_remove_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd);
727         return ret;
728 }
729
730 static int lenovo_probe_cptkbd(struct hid_device *hdev)
731 {
732         int ret;
733         struct lenovo_drvdata_cptkbd *cptkbd_data;
734
735         /* All the custom action happens on the USBMOUSE device for USB */
736         if (hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD
737                         && hdev->type != HID_TYPE_USBMOUSE) {
738                 hid_dbg(hdev, "Ignoring keyboard half of device\n");
739                 return 0;
740         }
741
742         cptkbd_data = devm_kzalloc(&hdev->dev,
743                                         sizeof(*cptkbd_data),
744                                         GFP_KERNEL);
745         if (cptkbd_data == NULL) {
746                 hid_err(hdev, "can't alloc keyboard descriptor\n");
747                 return -ENOMEM;
748         }
749         hid_set_drvdata(hdev, cptkbd_data);
750
751         /*
752          * Tell the keyboard a driver understands it, and turn F7, F9, F11 into
753          * regular keys
754          */
755         ret = lenovo_send_cmd_cptkbd(hdev, 0x01, 0x03);
756         if (ret)
757                 hid_warn(hdev, "Failed to switch F7/9/11 mode: %d\n", ret);
758
759         /* Switch middle button to native mode */
760         ret = lenovo_send_cmd_cptkbd(hdev, 0x09, 0x01);
761         if (ret)
762                 hid_warn(hdev, "Failed to switch middle button: %d\n", ret);
763
764         /* Set keyboard settings to known state */
765         cptkbd_data->middlebutton_state = 0;
766         cptkbd_data->fn_lock = true;
767         cptkbd_data->sensitivity = 0x05;
768         lenovo_features_set_cptkbd(hdev);
769
770         ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_cptkbd);
771         if (ret)
772                 hid_warn(hdev, "Could not create sysfs group: %d\n", ret);
773
774         return 0;
775 }
776
777 static int lenovo_probe(struct hid_device *hdev,
778                 const struct hid_device_id *id)
779 {
780         int ret;
781
782         ret = hid_parse(hdev);
783         if (ret) {
784                 hid_err(hdev, "hid_parse failed\n");
785                 goto err;
786         }
787
788         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
789         if (ret) {
790                 hid_err(hdev, "hid_hw_start failed\n");
791                 goto err;
792         }
793
794         switch (hdev->product) {
795         case USB_DEVICE_ID_LENOVO_TPKBD:
796                 ret = lenovo_probe_tpkbd(hdev);
797                 break;
798         case USB_DEVICE_ID_LENOVO_CUSBKBD:
799         case USB_DEVICE_ID_LENOVO_CBTKBD:
800                 ret = lenovo_probe_cptkbd(hdev);
801                 break;
802         default:
803                 ret = 0;
804                 break;
805         }
806         if (ret)
807                 goto err_hid;
808
809         return 0;
810 err_hid:
811         hid_hw_stop(hdev);
812 err:
813         return ret;
814 }
815
816 static void lenovo_remove_tpkbd(struct hid_device *hdev)
817 {
818         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
819
820         /*
821          * Only the trackpoint half of the keyboard has drvdata and stuff that
822          * needs unregistering.
823          */
824         if (data_pointer == NULL)
825                 return;
826
827         sysfs_remove_group(&hdev->dev.kobj,
828                         &lenovo_attr_group_tpkbd);
829
830         led_classdev_unregister(&data_pointer->led_micmute);
831         led_classdev_unregister(&data_pointer->led_mute);
832
833         hid_set_drvdata(hdev, NULL);
834 }
835
836 static void lenovo_remove_cptkbd(struct hid_device *hdev)
837 {
838         sysfs_remove_group(&hdev->dev.kobj,
839                         &lenovo_attr_group_cptkbd);
840 }
841
842 static void lenovo_remove(struct hid_device *hdev)
843 {
844         switch (hdev->product) {
845         case USB_DEVICE_ID_LENOVO_TPKBD:
846                 lenovo_remove_tpkbd(hdev);
847                 break;
848         case USB_DEVICE_ID_LENOVO_CUSBKBD:
849         case USB_DEVICE_ID_LENOVO_CBTKBD:
850                 lenovo_remove_cptkbd(hdev);
851                 break;
852         }
853
854         hid_hw_stop(hdev);
855 }
856
857 static int lenovo_input_configured(struct hid_device *hdev,
858                 struct hid_input *hi)
859 {
860         switch (hdev->product) {
861                 case USB_DEVICE_ID_LENOVO_TPKBD:
862                 case USB_DEVICE_ID_LENOVO_CUSBKBD:
863                 case USB_DEVICE_ID_LENOVO_CBTKBD:
864                         if (test_bit(EV_REL, hi->input->evbit)) {
865                                 /* set only for trackpoint device */
866                                 __set_bit(INPUT_PROP_POINTER, hi->input->propbit);
867                                 __set_bit(INPUT_PROP_POINTING_STICK,
868                                                 hi->input->propbit);
869                         }
870                         break;
871         }
872
873         return 0;
874 }
875
876
877 static const struct hid_device_id lenovo_devices[] = {
878         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) },
879         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) },
880         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) },
881         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) },
882         { }
883 };
884
885 MODULE_DEVICE_TABLE(hid, lenovo_devices);
886
887 static struct hid_driver lenovo_driver = {
888         .name = "lenovo",
889         .id_table = lenovo_devices,
890         .input_configured = lenovo_input_configured,
891         .input_mapping = lenovo_input_mapping,
892         .probe = lenovo_probe,
893         .remove = lenovo_remove,
894         .raw_event = lenovo_raw_event,
895         .event = lenovo_event,
896         .report_fixup = lenovo_report_fixup,
897 };
898 module_hid_driver(lenovo_driver);
899
900 MODULE_LICENSE("GPL");