HID: lenovo: Rework how the tp10ubkbd code decides which USB interface to use
[linux-2.6-microblaze.git] / drivers / hid / hid-lenovo.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  *  HID driver for Lenovo:
4  *  - ThinkPad USB Keyboard with TrackPoint (tpkbd)
5  *  - ThinkPad Compact Bluetooth Keyboard with TrackPoint (cptkbd)
6  *  - ThinkPad Compact USB Keyboard with TrackPoint (cptkbd)
7  *
8  *  Copyright (c) 2012 Bernhard Seibold
9  *  Copyright (c) 2014 Jamie Lentin <jm@lentin.co.uk>
10  *
11  * Linux IBM/Lenovo Scrollpoint mouse driver:
12  * - IBM Scrollpoint III
13  * - IBM Scrollpoint Pro
14  * - IBM Scrollpoint Optical
15  * - IBM Scrollpoint Optical 800dpi
16  * - IBM Scrollpoint Optical 800dpi Pro
17  * - Lenovo Scrollpoint Optical
18  *
19  *  Copyright (c) 2012 Peter De Wachter <pdewacht@gmail.com>
20  *  Copyright (c) 2018 Peter Ganzhorn <peter.ganzhorn@gmail.com>
21  */
22
23 /*
24  */
25
26 #include <linux/module.h>
27 #include <linux/sysfs.h>
28 #include <linux/device.h>
29 #include <linux/hid.h>
30 #include <linux/input.h>
31 #include <linux/leds.h>
32 #include <linux/workqueue.h>
33
34 #include "hid-ids.h"
35
36 /* Userspace expects F20 for mic-mute KEY_MICMUTE does not work */
37 #define LENOVO_KEY_MICMUTE KEY_F20
38
39 struct lenovo_drvdata {
40         u8 led_report[3]; /* Must be first for proper alignment */
41         int led_state;
42         struct mutex led_report_mutex;
43         struct led_classdev led_mute;
44         struct led_classdev led_micmute;
45         struct work_struct fn_lock_sync_work;
46         struct hid_device *hdev;
47         int press_to_select;
48         int dragging;
49         int release_to_select;
50         int select_right;
51         int sensitivity;
52         int press_speed;
53         u8 middlebutton_state; /* 0:Up, 1:Down (undecided), 2:Scrolling */
54         bool fn_lock;
55 };
56
57 #define map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, EV_KEY, (c))
58
59 #define TP10UBKBD_LED_OUTPUT_REPORT     9
60
61 #define TP10UBKBD_FN_LOCK_LED           0x54
62 #define TP10UBKBD_MUTE_LED              0x64
63 #define TP10UBKBD_MICMUTE_LED           0x74
64
65 #define TP10UBKBD_LED_OFF               1
66 #define TP10UBKBD_LED_ON                2
67
68 static int lenovo_led_set_tp10ubkbd(struct hid_device *hdev, u8 led_code,
69                                     enum led_brightness value)
70 {
71         struct lenovo_drvdata *data = hid_get_drvdata(hdev);
72         int ret;
73
74         mutex_lock(&data->led_report_mutex);
75
76         data->led_report[0] = TP10UBKBD_LED_OUTPUT_REPORT;
77         data->led_report[1] = led_code;
78         data->led_report[2] = value ? TP10UBKBD_LED_ON : TP10UBKBD_LED_OFF;
79         ret = hid_hw_raw_request(hdev, data->led_report[0], data->led_report, 3,
80                                  HID_OUTPUT_REPORT, HID_REQ_SET_REPORT);
81         if (ret != 3) {
82                 if (ret != -ENODEV)
83                         hid_err(hdev, "Set LED output report error: %d\n", ret);
84
85                 ret = ret < 0 ? ret : -EIO;
86         } else {
87                 ret = 0;
88         }
89
90         mutex_unlock(&data->led_report_mutex);
91
92         return ret;
93 }
94
95 static void lenovo_tp10ubkbd_sync_fn_lock(struct work_struct *work)
96 {
97         struct lenovo_drvdata *data =
98                 container_of(work, struct lenovo_drvdata, fn_lock_sync_work);
99
100         lenovo_led_set_tp10ubkbd(data->hdev, TP10UBKBD_FN_LOCK_LED,
101                                  data->fn_lock);
102 }
103
104 static const __u8 lenovo_pro_dock_need_fixup_collection[] = {
105         0x05, 0x88,             /* Usage Page (Vendor Usage Page 0x88)  */
106         0x09, 0x01,             /* Usage (Vendor Usage 0x01)            */
107         0xa1, 0x01,             /* Collection (Application)             */
108         0x85, 0x04,             /*  Report ID (4)                       */
109         0x19, 0x00,             /*  Usage Minimum (0)                   */
110         0x2a, 0xff, 0xff,       /*  Usage Maximum (65535)               */
111 };
112
113 static __u8 *lenovo_report_fixup(struct hid_device *hdev, __u8 *rdesc,
114                 unsigned int *rsize)
115 {
116         switch (hdev->product) {
117         case USB_DEVICE_ID_LENOVO_TPPRODOCK:
118                 /* the fixups that need to be done:
119                  *   - get a reasonable usage max for the vendor collection
120                  *     0x8801 from the report ID 4
121                  */
122                 if (*rsize >= 153 &&
123                     memcmp(&rdesc[140], lenovo_pro_dock_need_fixup_collection,
124                           sizeof(lenovo_pro_dock_need_fixup_collection)) == 0) {
125                         rdesc[151] = 0x01;
126                         rdesc[152] = 0x00;
127                 }
128                 break;
129         }
130         return rdesc;
131 }
132
133 static int lenovo_input_mapping_tpkbd(struct hid_device *hdev,
134                 struct hid_input *hi, struct hid_field *field,
135                 struct hid_usage *usage, unsigned long **bit, int *max)
136 {
137         if (usage->hid == (HID_UP_BUTTON | 0x0010)) {
138                 /* This sub-device contains trackpoint, mark it */
139                 hid_set_drvdata(hdev, (void *)1);
140                 map_key_clear(LENOVO_KEY_MICMUTE);
141                 return 1;
142         }
143         return 0;
144 }
145
146 static int lenovo_input_mapping_cptkbd(struct hid_device *hdev,
147                 struct hid_input *hi, struct hid_field *field,
148                 struct hid_usage *usage, unsigned long **bit, int *max)
149 {
150         /* HID_UP_LNVENDOR = USB, HID_UP_MSVENDOR = BT */
151         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR ||
152             (usage->hid & HID_USAGE_PAGE) == HID_UP_LNVENDOR) {
153                 switch (usage->hid & HID_USAGE) {
154                 case 0x00f1: /* Fn-F4: Mic mute */
155                         map_key_clear(LENOVO_KEY_MICMUTE);
156                         return 1;
157                 case 0x00f2: /* Fn-F5: Brightness down */
158                         map_key_clear(KEY_BRIGHTNESSDOWN);
159                         return 1;
160                 case 0x00f3: /* Fn-F6: Brightness up */
161                         map_key_clear(KEY_BRIGHTNESSUP);
162                         return 1;
163                 case 0x00f4: /* Fn-F7: External display (projector) */
164                         map_key_clear(KEY_SWITCHVIDEOMODE);
165                         return 1;
166                 case 0x00f5: /* Fn-F8: Wireless */
167                         map_key_clear(KEY_WLAN);
168                         return 1;
169                 case 0x00f6: /* Fn-F9: Control panel */
170                         map_key_clear(KEY_CONFIG);
171                         return 1;
172                 case 0x00f8: /* Fn-F11: View open applications (3 boxes) */
173                         map_key_clear(KEY_SCALE);
174                         return 1;
175                 case 0x00f9: /* Fn-F12: Open My computer (6 boxes) USB-only */
176                         /* NB: This mapping is invented in raw_event below */
177                         map_key_clear(KEY_FILE);
178                         return 1;
179                 case 0x00fa: /* Fn-Esc: Fn-lock toggle */
180                         map_key_clear(KEY_FN_ESC);
181                         return 1;
182                 case 0x00fb: /* Middle mouse button (in native mode) */
183                         map_key_clear(BTN_MIDDLE);
184                         return 1;
185                 }
186         }
187
188         /* Compatibility middle/wheel mappings should be ignored */
189         if (usage->hid == HID_GD_WHEEL)
190                 return -1;
191         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON &&
192                         (usage->hid & HID_USAGE) == 0x003)
193                 return -1;
194         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER &&
195                         (usage->hid & HID_USAGE) == 0x238)
196                 return -1;
197
198         /* Map wheel emulation reports: 0xffa1 = USB, 0xff10 = BT */
199         if ((usage->hid & HID_USAGE_PAGE) == 0xff100000 ||
200             (usage->hid & HID_USAGE_PAGE) == 0xffa10000) {
201                 field->flags |= HID_MAIN_ITEM_RELATIVE | HID_MAIN_ITEM_VARIABLE;
202                 field->logical_minimum = -127;
203                 field->logical_maximum = 127;
204
205                 switch (usage->hid & HID_USAGE) {
206                 case 0x0000:
207                         hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
208                         return 1;
209                 case 0x0001:
210                         hid_map_usage(hi, usage, bit, max, EV_REL, REL_WHEEL);
211                         return 1;
212                 default:
213                         return -1;
214                 }
215         }
216
217         return 0;
218 }
219
220 static int lenovo_input_mapping_scrollpoint(struct hid_device *hdev,
221                 struct hid_input *hi, struct hid_field *field,
222                 struct hid_usage *usage, unsigned long **bit, int *max)
223 {
224         if (usage->hid == HID_GD_Z) {
225                 hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
226                 return 1;
227         }
228         return 0;
229 }
230
231 static int lenovo_input_mapping_tp10_ultrabook_kbd(struct hid_device *hdev,
232                 struct hid_input *hi, struct hid_field *field,
233                 struct hid_usage *usage, unsigned long **bit, int *max)
234 {
235         /*
236          * The ThinkPad 10 Ultrabook Keyboard uses 0x000c0001 usage for
237          * a bunch of keys which have no standard consumer page code.
238          */
239         if (usage->hid == 0x000c0001) {
240                 switch (usage->usage_index) {
241                 case 8: /* Fn-Esc: Fn-lock toggle */
242                         map_key_clear(KEY_FN_ESC);
243                         return 1;
244                 case 9: /* Fn-F4: Mic mute */
245                         map_key_clear(LENOVO_KEY_MICMUTE);
246                         return 1;
247                 case 10: /* Fn-F7: Control panel */
248                         map_key_clear(KEY_CONFIG);
249                         return 1;
250                 case 11: /* Fn-F8: Search (magnifier glass) */
251                         map_key_clear(KEY_SEARCH);
252                         return 1;
253                 case 12: /* Fn-F10: Open My computer (6 boxes) */
254                         map_key_clear(KEY_FILE);
255                         return 1;
256                 }
257         }
258
259         /*
260          * The Ultrabook Keyboard sends a spurious F23 key-press when resuming
261          * from suspend and it does not actually have a F23 key, ignore it.
262          */
263         if (usage->hid == 0x00070072)
264                 return -1;
265
266         return 0;
267 }
268
269 static int lenovo_input_mapping(struct hid_device *hdev,
270                 struct hid_input *hi, struct hid_field *field,
271                 struct hid_usage *usage, unsigned long **bit, int *max)
272 {
273         switch (hdev->product) {
274         case USB_DEVICE_ID_LENOVO_TPKBD:
275                 return lenovo_input_mapping_tpkbd(hdev, hi, field,
276                                                         usage, bit, max);
277         case USB_DEVICE_ID_LENOVO_CUSBKBD:
278         case USB_DEVICE_ID_LENOVO_CBTKBD:
279                 return lenovo_input_mapping_cptkbd(hdev, hi, field,
280                                                         usage, bit, max);
281         case USB_DEVICE_ID_IBM_SCROLLPOINT_III:
282         case USB_DEVICE_ID_IBM_SCROLLPOINT_PRO:
283         case USB_DEVICE_ID_IBM_SCROLLPOINT_OPTICAL:
284         case USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL:
285         case USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL_PRO:
286         case USB_DEVICE_ID_LENOVO_SCROLLPOINT_OPTICAL:
287                 return lenovo_input_mapping_scrollpoint(hdev, hi, field,
288                                                         usage, bit, max);
289         case USB_DEVICE_ID_LENOVO_TP10UBKBD:
290                 return lenovo_input_mapping_tp10_ultrabook_kbd(hdev, hi, field,
291                                                                usage, bit, max);
292         default:
293                 return 0;
294         }
295 }
296
297 #undef map_key_clear
298
299 /* Send a config command to the keyboard */
300 static int lenovo_send_cmd_cptkbd(struct hid_device *hdev,
301                         unsigned char byte2, unsigned char byte3)
302 {
303         int ret;
304         unsigned char *buf;
305
306         buf = kzalloc(3, GFP_KERNEL);
307         if (!buf)
308                 return -ENOMEM;
309
310         buf[0] = 0x18;
311         buf[1] = byte2;
312         buf[2] = byte3;
313
314         switch (hdev->product) {
315         case USB_DEVICE_ID_LENOVO_CUSBKBD:
316                 ret = hid_hw_raw_request(hdev, 0x13, buf, 3,
317                                         HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
318                 break;
319         case USB_DEVICE_ID_LENOVO_CBTKBD:
320                 ret = hid_hw_output_report(hdev, buf, 3);
321                 break;
322         default:
323                 ret = -EINVAL;
324                 break;
325         }
326
327         kfree(buf);
328
329         return ret < 0 ? ret : 0; /* BT returns 0, USB returns sizeof(buf) */
330 }
331
332 static void lenovo_features_set_cptkbd(struct hid_device *hdev)
333 {
334         int ret;
335         struct lenovo_drvdata *cptkbd_data = hid_get_drvdata(hdev);
336
337         ret = lenovo_send_cmd_cptkbd(hdev, 0x05, cptkbd_data->fn_lock);
338         if (ret)
339                 hid_err(hdev, "Fn-lock setting failed: %d\n", ret);
340
341         ret = lenovo_send_cmd_cptkbd(hdev, 0x02, cptkbd_data->sensitivity);
342         if (ret)
343                 hid_err(hdev, "Sensitivity setting failed: %d\n", ret);
344 }
345
346 static ssize_t attr_fn_lock_show(struct device *dev,
347                 struct device_attribute *attr,
348                 char *buf)
349 {
350         struct hid_device *hdev = to_hid_device(dev);
351         struct lenovo_drvdata *data = hid_get_drvdata(hdev);
352
353         return snprintf(buf, PAGE_SIZE, "%u\n", data->fn_lock);
354 }
355
356 static ssize_t attr_fn_lock_store(struct device *dev,
357                 struct device_attribute *attr,
358                 const char *buf,
359                 size_t count)
360 {
361         struct hid_device *hdev = to_hid_device(dev);
362         struct lenovo_drvdata *data = hid_get_drvdata(hdev);
363         int value, ret;
364
365         if (kstrtoint(buf, 10, &value))
366                 return -EINVAL;
367         if (value < 0 || value > 1)
368                 return -EINVAL;
369
370         data->fn_lock = !!value;
371
372         switch (hdev->product) {
373         case USB_DEVICE_ID_LENOVO_CUSBKBD:
374         case USB_DEVICE_ID_LENOVO_CBTKBD:
375                 lenovo_features_set_cptkbd(hdev);
376                 break;
377         case USB_DEVICE_ID_LENOVO_TP10UBKBD:
378                 ret = lenovo_led_set_tp10ubkbd(hdev, TP10UBKBD_FN_LOCK_LED, value);
379                 if (ret)
380                         return ret;
381                 break;
382         }
383
384         return count;
385 }
386
387 static ssize_t attr_sensitivity_show_cptkbd(struct device *dev,
388                 struct device_attribute *attr,
389                 char *buf)
390 {
391         struct hid_device *hdev = to_hid_device(dev);
392         struct lenovo_drvdata *cptkbd_data = hid_get_drvdata(hdev);
393
394         return snprintf(buf, PAGE_SIZE, "%u\n",
395                 cptkbd_data->sensitivity);
396 }
397
398 static ssize_t attr_sensitivity_store_cptkbd(struct device *dev,
399                 struct device_attribute *attr,
400                 const char *buf,
401                 size_t count)
402 {
403         struct hid_device *hdev = to_hid_device(dev);
404         struct lenovo_drvdata *cptkbd_data = hid_get_drvdata(hdev);
405         int value;
406
407         if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
408                 return -EINVAL;
409
410         cptkbd_data->sensitivity = value;
411         lenovo_features_set_cptkbd(hdev);
412
413         return count;
414 }
415
416
417 static struct device_attribute dev_attr_fn_lock =
418         __ATTR(fn_lock, S_IWUSR | S_IRUGO,
419                         attr_fn_lock_show,
420                         attr_fn_lock_store);
421
422 static struct device_attribute dev_attr_sensitivity_cptkbd =
423         __ATTR(sensitivity, S_IWUSR | S_IRUGO,
424                         attr_sensitivity_show_cptkbd,
425                         attr_sensitivity_store_cptkbd);
426
427
428 static struct attribute *lenovo_attributes_cptkbd[] = {
429         &dev_attr_fn_lock.attr,
430         &dev_attr_sensitivity_cptkbd.attr,
431         NULL
432 };
433
434 static const struct attribute_group lenovo_attr_group_cptkbd = {
435         .attrs = lenovo_attributes_cptkbd,
436 };
437
438 static int lenovo_raw_event(struct hid_device *hdev,
439                         struct hid_report *report, u8 *data, int size)
440 {
441         /*
442          * Compact USB keyboard's Fn-F12 report holds down many other keys, and
443          * its own key is outside the usage page range. Remove extra
444          * keypresses and remap to inside usage page.
445          */
446         if (unlikely(hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD
447                         && size == 3
448                         && data[0] == 0x15
449                         && data[1] == 0x94
450                         && data[2] == 0x01)) {
451                 data[1] = 0x00;
452                 data[2] = 0x01;
453         }
454
455         return 0;
456 }
457
458 static int lenovo_event_tp10ubkbd(struct hid_device *hdev,
459                 struct hid_field *field, struct hid_usage *usage, __s32 value)
460 {
461         struct lenovo_drvdata *data = hid_get_drvdata(hdev);
462
463         if (usage->type == EV_KEY && usage->code == KEY_FN_ESC && value == 1) {
464                 /*
465                  * The user has toggled the Fn-lock state. Toggle our own
466                  * cached value of it and sync our value to the keyboard to
467                  * ensure things are in sync (the sycning should be a no-op).
468                  */
469                 data->fn_lock = !data->fn_lock;
470                 schedule_work(&data->fn_lock_sync_work);
471         }
472
473         return 0;
474 }
475
476 static int lenovo_event_cptkbd(struct hid_device *hdev,
477                 struct hid_field *field, struct hid_usage *usage, __s32 value)
478 {
479         struct lenovo_drvdata *cptkbd_data = hid_get_drvdata(hdev);
480
481         /* "wheel" scroll events */
482         if (usage->type == EV_REL && (usage->code == REL_WHEEL ||
483                         usage->code == REL_HWHEEL)) {
484                 /* Scroll events disable middle-click event */
485                 cptkbd_data->middlebutton_state = 2;
486                 return 0;
487         }
488
489         /* Middle click events */
490         if (usage->type == EV_KEY && usage->code == BTN_MIDDLE) {
491                 if (value == 1) {
492                         cptkbd_data->middlebutton_state = 1;
493                 } else if (value == 0) {
494                         if (cptkbd_data->middlebutton_state == 1) {
495                                 /* No scrolling inbetween, send middle-click */
496                                 input_event(field->hidinput->input,
497                                         EV_KEY, BTN_MIDDLE, 1);
498                                 input_sync(field->hidinput->input);
499                                 input_event(field->hidinput->input,
500                                         EV_KEY, BTN_MIDDLE, 0);
501                                 input_sync(field->hidinput->input);
502                         }
503                         cptkbd_data->middlebutton_state = 0;
504                 }
505                 return 1;
506         }
507
508         return 0;
509 }
510
511 static int lenovo_event(struct hid_device *hdev, struct hid_field *field,
512                 struct hid_usage *usage, __s32 value)
513 {
514         if (!hid_get_drvdata(hdev))
515                 return 0;
516
517         switch (hdev->product) {
518         case USB_DEVICE_ID_LENOVO_CUSBKBD:
519         case USB_DEVICE_ID_LENOVO_CBTKBD:
520                 return lenovo_event_cptkbd(hdev, field, usage, value);
521         case USB_DEVICE_ID_LENOVO_TP10UBKBD:
522                 return lenovo_event_tp10ubkbd(hdev, field, usage, value);
523         default:
524                 return 0;
525         }
526 }
527
528 static int lenovo_features_set_tpkbd(struct hid_device *hdev)
529 {
530         struct hid_report *report;
531         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
532
533         report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[4];
534
535         report->field[0]->value[0]  = data_pointer->press_to_select   ? 0x01 : 0x02;
536         report->field[0]->value[0] |= data_pointer->dragging          ? 0x04 : 0x08;
537         report->field[0]->value[0] |= data_pointer->release_to_select ? 0x10 : 0x20;
538         report->field[0]->value[0] |= data_pointer->select_right      ? 0x80 : 0x40;
539         report->field[1]->value[0] = 0x03; // unknown setting, imitate windows driver
540         report->field[2]->value[0] = data_pointer->sensitivity;
541         report->field[3]->value[0] = data_pointer->press_speed;
542
543         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
544         return 0;
545 }
546
547 static ssize_t attr_press_to_select_show_tpkbd(struct device *dev,
548                 struct device_attribute *attr,
549                 char *buf)
550 {
551         struct hid_device *hdev = to_hid_device(dev);
552         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
553
554         return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->press_to_select);
555 }
556
557 static ssize_t attr_press_to_select_store_tpkbd(struct device *dev,
558                 struct device_attribute *attr,
559                 const char *buf,
560                 size_t count)
561 {
562         struct hid_device *hdev = to_hid_device(dev);
563         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
564         int value;
565
566         if (kstrtoint(buf, 10, &value))
567                 return -EINVAL;
568         if (value < 0 || value > 1)
569                 return -EINVAL;
570
571         data_pointer->press_to_select = value;
572         lenovo_features_set_tpkbd(hdev);
573
574         return count;
575 }
576
577 static ssize_t attr_dragging_show_tpkbd(struct device *dev,
578                 struct device_attribute *attr,
579                 char *buf)
580 {
581         struct hid_device *hdev = to_hid_device(dev);
582         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
583
584         return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->dragging);
585 }
586
587 static ssize_t attr_dragging_store_tpkbd(struct device *dev,
588                 struct device_attribute *attr,
589                 const char *buf,
590                 size_t count)
591 {
592         struct hid_device *hdev = to_hid_device(dev);
593         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
594         int value;
595
596         if (kstrtoint(buf, 10, &value))
597                 return -EINVAL;
598         if (value < 0 || value > 1)
599                 return -EINVAL;
600
601         data_pointer->dragging = value;
602         lenovo_features_set_tpkbd(hdev);
603
604         return count;
605 }
606
607 static ssize_t attr_release_to_select_show_tpkbd(struct device *dev,
608                 struct device_attribute *attr,
609                 char *buf)
610 {
611         struct hid_device *hdev = to_hid_device(dev);
612         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
613
614         return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->release_to_select);
615 }
616
617 static ssize_t attr_release_to_select_store_tpkbd(struct device *dev,
618                 struct device_attribute *attr,
619                 const char *buf,
620                 size_t count)
621 {
622         struct hid_device *hdev = to_hid_device(dev);
623         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
624         int value;
625
626         if (kstrtoint(buf, 10, &value))
627                 return -EINVAL;
628         if (value < 0 || value > 1)
629                 return -EINVAL;
630
631         data_pointer->release_to_select = value;
632         lenovo_features_set_tpkbd(hdev);
633
634         return count;
635 }
636
637 static ssize_t attr_select_right_show_tpkbd(struct device *dev,
638                 struct device_attribute *attr,
639                 char *buf)
640 {
641         struct hid_device *hdev = to_hid_device(dev);
642         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
643
644         return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->select_right);
645 }
646
647 static ssize_t attr_select_right_store_tpkbd(struct device *dev,
648                 struct device_attribute *attr,
649                 const char *buf,
650                 size_t count)
651 {
652         struct hid_device *hdev = to_hid_device(dev);
653         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
654         int value;
655
656         if (kstrtoint(buf, 10, &value))
657                 return -EINVAL;
658         if (value < 0 || value > 1)
659                 return -EINVAL;
660
661         data_pointer->select_right = value;
662         lenovo_features_set_tpkbd(hdev);
663
664         return count;
665 }
666
667 static ssize_t attr_sensitivity_show_tpkbd(struct device *dev,
668                 struct device_attribute *attr,
669                 char *buf)
670 {
671         struct hid_device *hdev = to_hid_device(dev);
672         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
673
674         return snprintf(buf, PAGE_SIZE, "%u\n",
675                 data_pointer->sensitivity);
676 }
677
678 static ssize_t attr_sensitivity_store_tpkbd(struct device *dev,
679                 struct device_attribute *attr,
680                 const char *buf,
681                 size_t count)
682 {
683         struct hid_device *hdev = to_hid_device(dev);
684         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
685         int value;
686
687         if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
688                 return -EINVAL;
689
690         data_pointer->sensitivity = value;
691         lenovo_features_set_tpkbd(hdev);
692
693         return count;
694 }
695
696 static ssize_t attr_press_speed_show_tpkbd(struct device *dev,
697                 struct device_attribute *attr,
698                 char *buf)
699 {
700         struct hid_device *hdev = to_hid_device(dev);
701         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
702
703         return snprintf(buf, PAGE_SIZE, "%u\n",
704                 data_pointer->press_speed);
705 }
706
707 static ssize_t attr_press_speed_store_tpkbd(struct device *dev,
708                 struct device_attribute *attr,
709                 const char *buf,
710                 size_t count)
711 {
712         struct hid_device *hdev = to_hid_device(dev);
713         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
714         int value;
715
716         if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
717                 return -EINVAL;
718
719         data_pointer->press_speed = value;
720         lenovo_features_set_tpkbd(hdev);
721
722         return count;
723 }
724
725 static struct device_attribute dev_attr_press_to_select_tpkbd =
726         __ATTR(press_to_select, S_IWUSR | S_IRUGO,
727                         attr_press_to_select_show_tpkbd,
728                         attr_press_to_select_store_tpkbd);
729
730 static struct device_attribute dev_attr_dragging_tpkbd =
731         __ATTR(dragging, S_IWUSR | S_IRUGO,
732                         attr_dragging_show_tpkbd,
733                         attr_dragging_store_tpkbd);
734
735 static struct device_attribute dev_attr_release_to_select_tpkbd =
736         __ATTR(release_to_select, S_IWUSR | S_IRUGO,
737                         attr_release_to_select_show_tpkbd,
738                         attr_release_to_select_store_tpkbd);
739
740 static struct device_attribute dev_attr_select_right_tpkbd =
741         __ATTR(select_right, S_IWUSR | S_IRUGO,
742                         attr_select_right_show_tpkbd,
743                         attr_select_right_store_tpkbd);
744
745 static struct device_attribute dev_attr_sensitivity_tpkbd =
746         __ATTR(sensitivity, S_IWUSR | S_IRUGO,
747                         attr_sensitivity_show_tpkbd,
748                         attr_sensitivity_store_tpkbd);
749
750 static struct device_attribute dev_attr_press_speed_tpkbd =
751         __ATTR(press_speed, S_IWUSR | S_IRUGO,
752                         attr_press_speed_show_tpkbd,
753                         attr_press_speed_store_tpkbd);
754
755 static struct attribute *lenovo_attributes_tpkbd[] = {
756         &dev_attr_press_to_select_tpkbd.attr,
757         &dev_attr_dragging_tpkbd.attr,
758         &dev_attr_release_to_select_tpkbd.attr,
759         &dev_attr_select_right_tpkbd.attr,
760         &dev_attr_sensitivity_tpkbd.attr,
761         &dev_attr_press_speed_tpkbd.attr,
762         NULL
763 };
764
765 static const struct attribute_group lenovo_attr_group_tpkbd = {
766         .attrs = lenovo_attributes_tpkbd,
767 };
768
769 static void lenovo_led_set_tpkbd(struct hid_device *hdev)
770 {
771         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
772         struct hid_report *report;
773
774         report = hdev->report_enum[HID_OUTPUT_REPORT].report_id_hash[3];
775         report->field[0]->value[0] = (data_pointer->led_state >> 0) & 1;
776         report->field[0]->value[1] = (data_pointer->led_state >> 1) & 1;
777         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
778 }
779
780 static int lenovo_led_brightness_set(struct led_classdev *led_cdev,
781                         enum led_brightness value)
782 {
783         struct device *dev = led_cdev->dev->parent;
784         struct hid_device *hdev = to_hid_device(dev);
785         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
786         u8 tp10ubkbd_led[] = { TP10UBKBD_MUTE_LED, TP10UBKBD_MICMUTE_LED };
787         int led_nr = 0;
788         int ret = 0;
789
790         if (led_cdev == &data_pointer->led_micmute)
791                 led_nr = 1;
792
793         if (value == LED_OFF)
794                 data_pointer->led_state &= ~(1 << led_nr);
795         else
796                 data_pointer->led_state |= 1 << led_nr;
797
798         switch (hdev->product) {
799         case USB_DEVICE_ID_LENOVO_TPKBD:
800                 lenovo_led_set_tpkbd(hdev);
801                 break;
802         case USB_DEVICE_ID_LENOVO_TP10UBKBD:
803                 ret = lenovo_led_set_tp10ubkbd(hdev, tp10ubkbd_led[led_nr], value);
804                 break;
805         }
806
807         return ret;
808 }
809
810 static int lenovo_register_leds(struct hid_device *hdev)
811 {
812         struct lenovo_drvdata *data = hid_get_drvdata(hdev);
813         size_t name_sz = strlen(dev_name(&hdev->dev)) + 16;
814         char *name_mute, *name_micm;
815         int ret;
816
817         name_mute = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL);
818         name_micm = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL);
819         if (name_mute == NULL || name_micm == NULL) {
820                 hid_err(hdev, "Could not allocate memory for led data\n");
821                 return -ENOMEM;
822         }
823         snprintf(name_mute, name_sz, "%s:amber:mute", dev_name(&hdev->dev));
824         snprintf(name_micm, name_sz, "%s:amber:micmute", dev_name(&hdev->dev));
825
826         data->led_mute.name = name_mute;
827         data->led_mute.default_trigger = "audio-mute";
828         data->led_mute.brightness_set_blocking = lenovo_led_brightness_set;
829         data->led_mute.max_brightness = 1;
830         data->led_mute.flags = LED_HW_PLUGGABLE;
831         data->led_mute.dev = &hdev->dev;
832         ret = led_classdev_register(&hdev->dev, &data->led_mute);
833         if (ret < 0)
834                 return ret;
835
836         data->led_micmute.name = name_micm;
837         data->led_micmute.default_trigger = "audio-micmute";
838         data->led_micmute.brightness_set_blocking = lenovo_led_brightness_set;
839         data->led_micmute.max_brightness = 1;
840         data->led_micmute.flags = LED_HW_PLUGGABLE;
841         data->led_micmute.dev = &hdev->dev;
842         ret = led_classdev_register(&hdev->dev, &data->led_micmute);
843         if (ret < 0) {
844                 led_classdev_unregister(&data->led_mute);
845                 return ret;
846         }
847
848         return 0;
849 }
850
851 static int lenovo_probe_tpkbd(struct hid_device *hdev)
852 {
853         struct lenovo_drvdata *data_pointer;
854         int i, ret;
855
856         /*
857          * Only register extra settings against subdevice where input_mapping
858          * set drvdata to 1, i.e. the trackpoint.
859          */
860         if (!hid_get_drvdata(hdev))
861                 return 0;
862
863         hid_set_drvdata(hdev, NULL);
864
865         /* Validate required reports. */
866         for (i = 0; i < 4; i++) {
867                 if (!hid_validate_values(hdev, HID_FEATURE_REPORT, 4, i, 1))
868                         return -ENODEV;
869         }
870         if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 3, 0, 2))
871                 return -ENODEV;
872
873         ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd);
874         if (ret)
875                 hid_warn(hdev, "Could not create sysfs group: %d\n", ret);
876
877         data_pointer = devm_kzalloc(&hdev->dev,
878                                     sizeof(struct lenovo_drvdata),
879                                     GFP_KERNEL);
880         if (data_pointer == NULL) {
881                 hid_err(hdev, "Could not allocate memory for driver data\n");
882                 ret = -ENOMEM;
883                 goto err;
884         }
885
886         // set same default values as windows driver
887         data_pointer->sensitivity = 0xa0;
888         data_pointer->press_speed = 0x38;
889
890         hid_set_drvdata(hdev, data_pointer);
891
892         ret = lenovo_register_leds(hdev);
893         if (ret)
894                 goto err;
895
896         lenovo_features_set_tpkbd(hdev);
897
898         return 0;
899 err:
900         sysfs_remove_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd);
901         return ret;
902 }
903
904 static int lenovo_probe_cptkbd(struct hid_device *hdev)
905 {
906         int ret;
907         struct lenovo_drvdata *cptkbd_data;
908
909         /* All the custom action happens on the USBMOUSE device for USB */
910         if (hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD
911                         && hdev->type != HID_TYPE_USBMOUSE) {
912                 hid_dbg(hdev, "Ignoring keyboard half of device\n");
913                 return 0;
914         }
915
916         cptkbd_data = devm_kzalloc(&hdev->dev,
917                                         sizeof(*cptkbd_data),
918                                         GFP_KERNEL);
919         if (cptkbd_data == NULL) {
920                 hid_err(hdev, "can't alloc keyboard descriptor\n");
921                 return -ENOMEM;
922         }
923         hid_set_drvdata(hdev, cptkbd_data);
924
925         /*
926          * Tell the keyboard a driver understands it, and turn F7, F9, F11 into
927          * regular keys
928          */
929         ret = lenovo_send_cmd_cptkbd(hdev, 0x01, 0x03);
930         if (ret)
931                 hid_warn(hdev, "Failed to switch F7/9/11 mode: %d\n", ret);
932
933         /* Switch middle button to native mode */
934         ret = lenovo_send_cmd_cptkbd(hdev, 0x09, 0x01);
935         if (ret)
936                 hid_warn(hdev, "Failed to switch middle button: %d\n", ret);
937
938         /* Set keyboard settings to known state */
939         cptkbd_data->middlebutton_state = 0;
940         cptkbd_data->fn_lock = true;
941         cptkbd_data->sensitivity = 0x05;
942         lenovo_features_set_cptkbd(hdev);
943
944         ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_cptkbd);
945         if (ret)
946                 hid_warn(hdev, "Could not create sysfs group: %d\n", ret);
947
948         return 0;
949 }
950
951 static struct attribute *lenovo_attributes_tp10ubkbd[] = {
952         &dev_attr_fn_lock.attr,
953         NULL
954 };
955
956 static const struct attribute_group lenovo_attr_group_tp10ubkbd = {
957         .attrs = lenovo_attributes_tp10ubkbd,
958 };
959
960 static int lenovo_probe_tp10ubkbd(struct hid_device *hdev)
961 {
962         struct hid_report_enum *rep_enum;
963         struct lenovo_drvdata *data;
964         struct hid_report *rep;
965         bool found;
966         int ret;
967
968         /*
969          * The LEDs and the Fn-lock functionality use output report 9,
970          * with an application of 0xffa0001, add the LEDs on the interface
971          * with this output report.
972          */
973         found = false;
974         rep_enum = &hdev->report_enum[HID_OUTPUT_REPORT];
975         list_for_each_entry(rep, &rep_enum->report_list, list) {
976                 if (rep->application == 0xffa00001)
977                         found = true;
978         }
979         if (!found)
980                 return 0;
981
982         data = devm_kzalloc(&hdev->dev, sizeof(*data), GFP_KERNEL);
983         if (!data)
984                 return -ENOMEM;
985
986         mutex_init(&data->led_report_mutex);
987         INIT_WORK(&data->fn_lock_sync_work, lenovo_tp10ubkbd_sync_fn_lock);
988         data->hdev = hdev;
989
990         hid_set_drvdata(hdev, data);
991
992         /*
993          * The Thinkpad 10 ultrabook USB kbd dock's Fn-lock defaults to on.
994          * We cannot read the state, only set it, so we force it to on here
995          * (which should be a no-op) to make sure that our state matches the
996          * keyboard's FN-lock state. This is the same as what Windows does.
997          */
998         data->fn_lock = true;
999         lenovo_led_set_tp10ubkbd(hdev, TP10UBKBD_FN_LOCK_LED, data->fn_lock);
1000
1001         ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_tp10ubkbd);
1002         if (ret)
1003                 return ret;
1004
1005         ret = lenovo_register_leds(hdev);
1006         if (ret)
1007                 goto err;
1008
1009         return 0;
1010 err:
1011         sysfs_remove_group(&hdev->dev.kobj, &lenovo_attr_group_tp10ubkbd);
1012         return ret;
1013 }
1014
1015 static int lenovo_probe(struct hid_device *hdev,
1016                 const struct hid_device_id *id)
1017 {
1018         int ret;
1019
1020         ret = hid_parse(hdev);
1021         if (ret) {
1022                 hid_err(hdev, "hid_parse failed\n");
1023                 goto err;
1024         }
1025
1026         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
1027         if (ret) {
1028                 hid_err(hdev, "hid_hw_start failed\n");
1029                 goto err;
1030         }
1031
1032         switch (hdev->product) {
1033         case USB_DEVICE_ID_LENOVO_TPKBD:
1034                 ret = lenovo_probe_tpkbd(hdev);
1035                 break;
1036         case USB_DEVICE_ID_LENOVO_CUSBKBD:
1037         case USB_DEVICE_ID_LENOVO_CBTKBD:
1038                 ret = lenovo_probe_cptkbd(hdev);
1039                 break;
1040         case USB_DEVICE_ID_LENOVO_TP10UBKBD:
1041                 ret = lenovo_probe_tp10ubkbd(hdev);
1042                 break;
1043         default:
1044                 ret = 0;
1045                 break;
1046         }
1047         if (ret)
1048                 goto err_hid;
1049
1050         return 0;
1051 err_hid:
1052         hid_hw_stop(hdev);
1053 err:
1054         return ret;
1055 }
1056
1057 static void lenovo_remove_tpkbd(struct hid_device *hdev)
1058 {
1059         struct lenovo_drvdata *data_pointer = hid_get_drvdata(hdev);
1060
1061         /*
1062          * Only the trackpoint half of the keyboard has drvdata and stuff that
1063          * needs unregistering.
1064          */
1065         if (data_pointer == NULL)
1066                 return;
1067
1068         sysfs_remove_group(&hdev->dev.kobj,
1069                         &lenovo_attr_group_tpkbd);
1070
1071         led_classdev_unregister(&data_pointer->led_micmute);
1072         led_classdev_unregister(&data_pointer->led_mute);
1073 }
1074
1075 static void lenovo_remove_cptkbd(struct hid_device *hdev)
1076 {
1077         sysfs_remove_group(&hdev->dev.kobj,
1078                         &lenovo_attr_group_cptkbd);
1079 }
1080
1081 static void lenovo_remove_tp10ubkbd(struct hid_device *hdev)
1082 {
1083         struct lenovo_drvdata *data = hid_get_drvdata(hdev);
1084
1085         if (data == NULL)
1086                 return;
1087
1088         led_classdev_unregister(&data->led_micmute);
1089         led_classdev_unregister(&data->led_mute);
1090
1091         sysfs_remove_group(&hdev->dev.kobj, &lenovo_attr_group_tp10ubkbd);
1092         cancel_work_sync(&data->fn_lock_sync_work);
1093 }
1094
1095 static void lenovo_remove(struct hid_device *hdev)
1096 {
1097         switch (hdev->product) {
1098         case USB_DEVICE_ID_LENOVO_TPKBD:
1099                 lenovo_remove_tpkbd(hdev);
1100                 break;
1101         case USB_DEVICE_ID_LENOVO_CUSBKBD:
1102         case USB_DEVICE_ID_LENOVO_CBTKBD:
1103                 lenovo_remove_cptkbd(hdev);
1104                 break;
1105         case USB_DEVICE_ID_LENOVO_TP10UBKBD:
1106                 lenovo_remove_tp10ubkbd(hdev);
1107                 break;
1108         }
1109
1110         hid_hw_stop(hdev);
1111 }
1112
1113 static int lenovo_input_configured(struct hid_device *hdev,
1114                 struct hid_input *hi)
1115 {
1116         switch (hdev->product) {
1117                 case USB_DEVICE_ID_LENOVO_TPKBD:
1118                 case USB_DEVICE_ID_LENOVO_CUSBKBD:
1119                 case USB_DEVICE_ID_LENOVO_CBTKBD:
1120                         if (test_bit(EV_REL, hi->input->evbit)) {
1121                                 /* set only for trackpoint device */
1122                                 __set_bit(INPUT_PROP_POINTER, hi->input->propbit);
1123                                 __set_bit(INPUT_PROP_POINTING_STICK,
1124                                                 hi->input->propbit);
1125                         }
1126                         break;
1127         }
1128
1129         return 0;
1130 }
1131
1132
1133 static const struct hid_device_id lenovo_devices[] = {
1134         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) },
1135         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) },
1136         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) },
1137         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) },
1138         { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_III) },
1139         { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_PRO) },
1140         { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_OPTICAL) },
1141         { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL) },
1142         { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL_PRO) },
1143         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_SCROLLPOINT_OPTICAL) },
1144         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TP10UBKBD) },
1145         { }
1146 };
1147
1148 MODULE_DEVICE_TABLE(hid, lenovo_devices);
1149
1150 static struct hid_driver lenovo_driver = {
1151         .name = "lenovo",
1152         .id_table = lenovo_devices,
1153         .input_configured = lenovo_input_configured,
1154         .input_mapping = lenovo_input_mapping,
1155         .probe = lenovo_probe,
1156         .remove = lenovo_remove,
1157         .raw_event = lenovo_raw_event,
1158         .event = lenovo_event,
1159         .report_fixup = lenovo_report_fixup,
1160 };
1161 module_hid_driver(lenovo_driver);
1162
1163 MODULE_LICENSE("GPL");