root/drivers/hid/hid-lenovo.c

DEFINITIONS

1. lenovo_report_fixup
2. lenovo_input_mapping_tpkbd
3. lenovo_input_mapping_cptkbd
4. lenovo_input_mapping_scrollpoint
5. lenovo_input_mapping
6. lenovo_send_cmd_cptkbd
7. lenovo_features_set_cptkbd
8. attr_fn_lock_show_cptkbd
9. attr_fn_lock_store_cptkbd
10. attr_sensitivity_show_cptkbd
11. attr_sensitivity_store_cptkbd
12. lenovo_raw_event
13. lenovo_event_cptkbd
14. lenovo_event
15. lenovo_features_set_tpkbd
16. attr_press_to_select_show_tpkbd
17. attr_press_to_select_store_tpkbd
18. attr_dragging_show_tpkbd
19. attr_dragging_store_tpkbd
20. attr_release_to_select_show_tpkbd
21. attr_release_to_select_store_tpkbd
22. attr_select_right_show_tpkbd
23. attr_select_right_store_tpkbd
24. attr_sensitivity_show_tpkbd
25. attr_sensitivity_store_tpkbd
26. attr_press_speed_show_tpkbd
27. attr_press_speed_store_tpkbd
28. lenovo_led_brightness_get_tpkbd
29. lenovo_led_brightness_set_tpkbd
30. lenovo_probe_tpkbd
31. lenovo_probe_cptkbd
32. lenovo_probe
33. lenovo_remove_tpkbd
34. lenovo_remove_cptkbd
35. lenovo_remove
36. lenovo_input_configured

   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 
  33 #include "hid-ids.h"
  34 
  35 struct lenovo_drvdata_tpkbd {
  36         int led_state;
  37         struct led_classdev led_mute;
  38         struct led_classdev led_micmute;
  39         int press_to_select;
  40         int dragging;
  41         int release_to_select;
  42         int select_right;
  43         int sensitivity;
  44         int press_speed;
  45 };
  46 
  47 struct lenovo_drvdata_cptkbd {
  48         u8 middlebutton_state; /* 0:Up, 1:Down (undecided), 2:Scrolling */
  49         bool fn_lock;
  50         int sensitivity;
  51 };
  52 
  53 #define map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, EV_KEY, (c))
  54 
  55 static const __u8 lenovo_pro_dock_need_fixup_collection[] = {
  56         0x05, 0x88,             /* Usage Page (Vendor Usage Page 0x88)  */
  57         0x09, 0x01,             /* Usage (Vendor Usage 0x01)            */
  58         0xa1, 0x01,             /* Collection (Application)             */
  59         0x85, 0x04,             /*  Report ID (4)                       */
  60         0x19, 0x00,             /*  Usage Minimum (0)                   */
  61         0x2a, 0xff, 0xff,       /*  Usage Maximum (65535)               */
  62 };
  63 
  64 static __u8 *lenovo_report_fixup(struct hid_device *hdev, __u8 *rdesc,
  65                 unsigned int *rsize)
  66 {
  67         switch (hdev->product) {
  68         case USB_DEVICE_ID_LENOVO_TPPRODOCK:
  69                 /* the fixups that need to be done:
  70                  *   - get a reasonable usage max for the vendor collection
  71                  *     0x8801 from the report ID 4
  72                  */
  73                 if (*rsize >= 153 &&
  74                     memcmp(&rdesc[140], lenovo_pro_dock_need_fixup_collection,
  75                           sizeof(lenovo_pro_dock_need_fixup_collection)) == 0) {
  76                         rdesc[151] = 0x01;
  77                         rdesc[152] = 0x00;
  78                 }
  79                 break;
  80         }
  81         return rdesc;
  82 }
  83 
  84 static int lenovo_input_mapping_tpkbd(struct hid_device *hdev,
  85                 struct hid_input *hi, struct hid_field *field,
  86                 struct hid_usage *usage, unsigned long **bit, int *max)
  87 {
  88         if (usage->hid == (HID_UP_BUTTON | 0x0010)) {
  89                 /* This sub-device contains trackpoint, mark it */
  90                 hid_set_drvdata(hdev, (void *)1);
  91                 map_key_clear(KEY_MICMUTE);
  92                 return 1;
  93         }
  94         return 0;
  95 }
  96 
  97 static int lenovo_input_mapping_cptkbd(struct hid_device *hdev,
  98                 struct hid_input *hi, struct hid_field *field,
  99                 struct hid_usage *usage, unsigned long **bit, int *max)
 100 {
 101         /* HID_UP_LNVENDOR = USB, HID_UP_MSVENDOR = BT */
 102         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR ||
 103             (usage->hid & HID_USAGE_PAGE) == HID_UP_LNVENDOR) {
 104                 switch (usage->hid & HID_USAGE) {
 105                 case 0x00f1: /* Fn-F4: Mic mute */
 106                         map_key_clear(KEY_MICMUTE);
 107                         return 1;
 108                 case 0x00f2: /* Fn-F5: Brightness down */
 109                         map_key_clear(KEY_BRIGHTNESSDOWN);
 110                         return 1;
 111                 case 0x00f3: /* Fn-F6: Brightness up */
 112                         map_key_clear(KEY_BRIGHTNESSUP);
 113                         return 1;
 114                 case 0x00f4: /* Fn-F7: External display (projector) */
 115                         map_key_clear(KEY_SWITCHVIDEOMODE);
 116                         return 1;
 117                 case 0x00f5: /* Fn-F8: Wireless */
 118                         map_key_clear(KEY_WLAN);
 119                         return 1;
 120                 case 0x00f6: /* Fn-F9: Control panel */
 121                         map_key_clear(KEY_CONFIG);
 122                         return 1;
 123                 case 0x00f8: /* Fn-F11: View open applications (3 boxes) */
 124                         map_key_clear(KEY_SCALE);
 125                         return 1;
 126                 case 0x00f9: /* Fn-F12: Open My computer (6 boxes) USB-only */
 127                         /* NB: This mapping is invented in raw_event below */
 128                         map_key_clear(KEY_FILE);
 129                         return 1;
 130                 case 0x00fa: /* Fn-Esc: Fn-lock toggle */
 131                         map_key_clear(KEY_FN_ESC);
 132                         return 1;
 133                 case 0x00fb: /* Middle mouse button (in native mode) */
 134                         map_key_clear(BTN_MIDDLE);
 135                         return 1;
 136                 }
 137         }
 138 
 139         /* Compatibility middle/wheel mappings should be ignored */
 140         if (usage->hid == HID_GD_WHEEL)
 141                 return -1;
 142         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_BUTTON &&
 143                         (usage->hid & HID_USAGE) == 0x003)
 144                 return -1;
 145         if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER &&
 146                         (usage->hid & HID_USAGE) == 0x238)
 147                 return -1;
 148 
 149         /* Map wheel emulation reports: 0xffa1 = USB, 0xff10 = BT */
 150         if ((usage->hid & HID_USAGE_PAGE) == 0xff100000 ||
 151             (usage->hid & HID_USAGE_PAGE) == 0xffa10000) {
 152                 field->flags |= HID_MAIN_ITEM_RELATIVE | HID_MAIN_ITEM_VARIABLE;
 153                 field->logical_minimum = -127;
 154                 field->logical_maximum = 127;
 155 
 156                 switch (usage->hid & HID_USAGE) {
 157                 case 0x0000:
 158                         hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
 159                         return 1;
 160                 case 0x0001:
 161                         hid_map_usage(hi, usage, bit, max, EV_REL, REL_WHEEL);
 162                         return 1;
 163                 default:
 164                         return -1;
 165                 }
 166         }
 167 
 168         return 0;
 169 }
 170 
 171 static int lenovo_input_mapping_scrollpoint(struct hid_device *hdev,
 172                 struct hid_input *hi, struct hid_field *field,
 173                 struct hid_usage *usage, unsigned long **bit, int *max)
 174 {
 175         if (usage->hid == HID_GD_Z) {
 176                 hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
 177                 return 1;
 178         }
 179         return 0;
 180 }
 181 
 182 static int lenovo_input_mapping(struct hid_device *hdev,
 183                 struct hid_input *hi, struct hid_field *field,
 184                 struct hid_usage *usage, unsigned long **bit, int *max)
 185 {
 186         switch (hdev->product) {
 187         case USB_DEVICE_ID_LENOVO_TPKBD:
 188                 return lenovo_input_mapping_tpkbd(hdev, hi, field,
 189                                                         usage, bit, max);
 190         case USB_DEVICE_ID_LENOVO_CUSBKBD:
 191         case USB_DEVICE_ID_LENOVO_CBTKBD:
 192                 return lenovo_input_mapping_cptkbd(hdev, hi, field,
 193                                                         usage, bit, max);
 194         case USB_DEVICE_ID_IBM_SCROLLPOINT_III:
 195         case USB_DEVICE_ID_IBM_SCROLLPOINT_PRO:
 196         case USB_DEVICE_ID_IBM_SCROLLPOINT_OPTICAL:
 197         case USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL:
 198         case USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL_PRO:
 199         case USB_DEVICE_ID_LENOVO_SCROLLPOINT_OPTICAL:
 200                 return lenovo_input_mapping_scrollpoint(hdev, hi, field,
 201                                                         usage, bit, max);
 202         default:
 203                 return 0;
 204         }
 205 }
 206 
 207 #undef map_key_clear
 208 
 209 /* Send a config command to the keyboard */
 210 static int lenovo_send_cmd_cptkbd(struct hid_device *hdev,
 211                         unsigned char byte2, unsigned char byte3)
 212 {
 213         int ret;
 214         unsigned char *buf;
 215 
 216         buf = kzalloc(3, GFP_KERNEL);
 217         if (!buf)
 218                 return -ENOMEM;
 219 
 220         buf[0] = 0x18;
 221         buf[1] = byte2;
 222         buf[2] = byte3;
 223 
 224         switch (hdev->product) {
 225         case USB_DEVICE_ID_LENOVO_CUSBKBD:
 226                 ret = hid_hw_raw_request(hdev, 0x13, buf, 3,
 227                                         HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
 228                 break;
 229         case USB_DEVICE_ID_LENOVO_CBTKBD:
 230                 ret = hid_hw_output_report(hdev, buf, 3);
 231                 break;
 232         default:
 233                 ret = -EINVAL;
 234                 break;
 235         }
 236 
 237         kfree(buf);
 238 
 239         return ret < 0 ? ret : 0; /* BT returns 0, USB returns sizeof(buf) */
 240 }
 241 
 242 static void lenovo_features_set_cptkbd(struct hid_device *hdev)
 243 {
 244         int ret;
 245         struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
 246 
 247         ret = lenovo_send_cmd_cptkbd(hdev, 0x05, cptkbd_data->fn_lock);
 248         if (ret)
 249                 hid_err(hdev, "Fn-lock setting failed: %d\n", ret);
 250 
 251         ret = lenovo_send_cmd_cptkbd(hdev, 0x02, cptkbd_data->sensitivity);
 252         if (ret)
 253                 hid_err(hdev, "Sensitivity setting failed: %d\n", ret);
 254 }
 255 
 256 static ssize_t attr_fn_lock_show_cptkbd(struct device *dev,
 257                 struct device_attribute *attr,
 258                 char *buf)
 259 {
 260         struct hid_device *hdev = to_hid_device(dev);
 261         struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
 262 
 263         return snprintf(buf, PAGE_SIZE, "%u\n", cptkbd_data->fn_lock);
 264 }
 265 
 266 static ssize_t attr_fn_lock_store_cptkbd(struct device *dev,
 267                 struct device_attribute *attr,
 268                 const char *buf,
 269                 size_t count)
 270 {
 271         struct hid_device *hdev = to_hid_device(dev);
 272         struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
 273         int value;
 274 
 275         if (kstrtoint(buf, 10, &value))
 276                 return -EINVAL;
 277         if (value < 0 || value > 1)
 278                 return -EINVAL;
 279 
 280         cptkbd_data->fn_lock = !!value;
 281         lenovo_features_set_cptkbd(hdev);
 282 
 283         return count;
 284 }
 285 
 286 static ssize_t attr_sensitivity_show_cptkbd(struct device *dev,
 287                 struct device_attribute *attr,
 288                 char *buf)
 289 {
 290         struct hid_device *hdev = to_hid_device(dev);
 291         struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
 292 
 293         return snprintf(buf, PAGE_SIZE, "%u\n",
 294                 cptkbd_data->sensitivity);
 295 }
 296 
 297 static ssize_t attr_sensitivity_store_cptkbd(struct device *dev,
 298                 struct device_attribute *attr,
 299                 const char *buf,
 300                 size_t count)
 301 {
 302         struct hid_device *hdev = to_hid_device(dev);
 303         struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
 304         int value;
 305 
 306         if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
 307                 return -EINVAL;
 308 
 309         cptkbd_data->sensitivity = value;
 310         lenovo_features_set_cptkbd(hdev);
 311 
 312         return count;
 313 }
 314 
 315 
 316 static struct device_attribute dev_attr_fn_lock_cptkbd =
 317         __ATTR(fn_lock, S_IWUSR | S_IRUGO,
 318                         attr_fn_lock_show_cptkbd,
 319                         attr_fn_lock_store_cptkbd);
 320 
 321 static struct device_attribute dev_attr_sensitivity_cptkbd =
 322         __ATTR(sensitivity, S_IWUSR | S_IRUGO,
 323                         attr_sensitivity_show_cptkbd,
 324                         attr_sensitivity_store_cptkbd);
 325 
 326 
 327 static struct attribute *lenovo_attributes_cptkbd[] = {
 328         &dev_attr_fn_lock_cptkbd.attr,
 329         &dev_attr_sensitivity_cptkbd.attr,
 330         NULL
 331 };
 332 
 333 static const struct attribute_group lenovo_attr_group_cptkbd = {
 334         .attrs = lenovo_attributes_cptkbd,
 335 };
 336 
 337 static int lenovo_raw_event(struct hid_device *hdev,
 338                         struct hid_report *report, u8 *data, int size)
 339 {
 340         /*
 341          * Compact USB keyboard's Fn-F12 report holds down many other keys, and
 342          * its own key is outside the usage page range. Remove extra
 343          * keypresses and remap to inside usage page.
 344          */
 345         if (unlikely(hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD
 346                         && size == 3
 347                         && data[0] == 0x15
 348                         && data[1] == 0x94
 349                         && data[2] == 0x01)) {
 350                 data[1] = 0x00;
 351                 data[2] = 0x01;
 352         }
 353 
 354         return 0;
 355 }
 356 
 357 static int lenovo_event_cptkbd(struct hid_device *hdev,
 358                 struct hid_field *field, struct hid_usage *usage, __s32 value)
 359 {
 360         struct lenovo_drvdata_cptkbd *cptkbd_data = hid_get_drvdata(hdev);
 361 
 362         /* "wheel" scroll events */
 363         if (usage->type == EV_REL && (usage->code == REL_WHEEL ||
 364                         usage->code == REL_HWHEEL)) {
 365                 /* Scroll events disable middle-click event */
 366                 cptkbd_data->middlebutton_state = 2;
 367                 return 0;
 368         }
 369 
 370         /* Middle click events */
 371         if (usage->type == EV_KEY && usage->code == BTN_MIDDLE) {
 372                 if (value == 1) {
 373                         cptkbd_data->middlebutton_state = 1;
 374                 } else if (value == 0) {
 375                         if (cptkbd_data->middlebutton_state == 1) {
 376                                 /* No scrolling inbetween, send middle-click */
 377                                 input_event(field->hidinput->input,
 378                                         EV_KEY, BTN_MIDDLE, 1);
 379                                 input_sync(field->hidinput->input);
 380                                 input_event(field->hidinput->input,
 381                                         EV_KEY, BTN_MIDDLE, 0);
 382                                 input_sync(field->hidinput->input);
 383                         }
 384                         cptkbd_data->middlebutton_state = 0;
 385                 }
 386                 return 1;
 387         }
 388 
 389         return 0;
 390 }
 391 
 392 static int lenovo_event(struct hid_device *hdev, struct hid_field *field,
 393                 struct hid_usage *usage, __s32 value)
 394 {
 395         switch (hdev->product) {
 396         case USB_DEVICE_ID_LENOVO_CUSBKBD:
 397         case USB_DEVICE_ID_LENOVO_CBTKBD:
 398                 return lenovo_event_cptkbd(hdev, field, usage, value);
 399         default:
 400                 return 0;
 401         }
 402 }
 403 
 404 static int lenovo_features_set_tpkbd(struct hid_device *hdev)
 405 {
 406         struct hid_report *report;
 407         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 408 
 409         report = hdev->report_enum[HID_FEATURE_REPORT].report_id_hash[4];
 410 
 411         report->field[0]->value[0]  = data_pointer->press_to_select   ? 0x01 : 0x02;
 412         report->field[0]->value[0] |= data_pointer->dragging          ? 0x04 : 0x08;
 413         report->field[0]->value[0] |= data_pointer->release_to_select ? 0x10 : 0x20;
 414         report->field[0]->value[0] |= data_pointer->select_right      ? 0x80 : 0x40;
 415         report->field[1]->value[0] = 0x03; // unknown setting, imitate windows driver
 416         report->field[2]->value[0] = data_pointer->sensitivity;
 417         report->field[3]->value[0] = data_pointer->press_speed;
 418 
 419         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 420         return 0;
 421 }
 422 
 423 static ssize_t attr_press_to_select_show_tpkbd(struct device *dev,
 424                 struct device_attribute *attr,
 425                 char *buf)
 426 {
 427         struct hid_device *hdev = to_hid_device(dev);
 428         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 429 
 430         return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->press_to_select);
 431 }
 432 
 433 static ssize_t attr_press_to_select_store_tpkbd(struct device *dev,
 434                 struct device_attribute *attr,
 435                 const char *buf,
 436                 size_t count)
 437 {
 438         struct hid_device *hdev = to_hid_device(dev);
 439         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 440         int value;
 441 
 442         if (kstrtoint(buf, 10, &value))
 443                 return -EINVAL;
 444         if (value < 0 || value > 1)
 445                 return -EINVAL;
 446 
 447         data_pointer->press_to_select = value;
 448         lenovo_features_set_tpkbd(hdev);
 449 
 450         return count;
 451 }
 452 
 453 static ssize_t attr_dragging_show_tpkbd(struct device *dev,
 454                 struct device_attribute *attr,
 455                 char *buf)
 456 {
 457         struct hid_device *hdev = to_hid_device(dev);
 458         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 459 
 460         return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->dragging);
 461 }
 462 
 463 static ssize_t attr_dragging_store_tpkbd(struct device *dev,
 464                 struct device_attribute *attr,
 465                 const char *buf,
 466                 size_t count)
 467 {
 468         struct hid_device *hdev = to_hid_device(dev);
 469         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 470         int value;
 471 
 472         if (kstrtoint(buf, 10, &value))
 473                 return -EINVAL;
 474         if (value < 0 || value > 1)
 475                 return -EINVAL;
 476 
 477         data_pointer->dragging = value;
 478         lenovo_features_set_tpkbd(hdev);
 479 
 480         return count;
 481 }
 482 
 483 static ssize_t attr_release_to_select_show_tpkbd(struct device *dev,
 484                 struct device_attribute *attr,
 485                 char *buf)
 486 {
 487         struct hid_device *hdev = to_hid_device(dev);
 488         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 489 
 490         return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->release_to_select);
 491 }
 492 
 493 static ssize_t attr_release_to_select_store_tpkbd(struct device *dev,
 494                 struct device_attribute *attr,
 495                 const char *buf,
 496                 size_t count)
 497 {
 498         struct hid_device *hdev = to_hid_device(dev);
 499         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 500         int value;
 501 
 502         if (kstrtoint(buf, 10, &value))
 503                 return -EINVAL;
 504         if (value < 0 || value > 1)
 505                 return -EINVAL;
 506 
 507         data_pointer->release_to_select = value;
 508         lenovo_features_set_tpkbd(hdev);
 509 
 510         return count;
 511 }
 512 
 513 static ssize_t attr_select_right_show_tpkbd(struct device *dev,
 514                 struct device_attribute *attr,
 515                 char *buf)
 516 {
 517         struct hid_device *hdev = to_hid_device(dev);
 518         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 519 
 520         return snprintf(buf, PAGE_SIZE, "%u\n", data_pointer->select_right);
 521 }
 522 
 523 static ssize_t attr_select_right_store_tpkbd(struct device *dev,
 524                 struct device_attribute *attr,
 525                 const char *buf,
 526                 size_t count)
 527 {
 528         struct hid_device *hdev = to_hid_device(dev);
 529         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 530         int value;
 531 
 532         if (kstrtoint(buf, 10, &value))
 533                 return -EINVAL;
 534         if (value < 0 || value > 1)
 535                 return -EINVAL;
 536 
 537         data_pointer->select_right = value;
 538         lenovo_features_set_tpkbd(hdev);
 539 
 540         return count;
 541 }
 542 
 543 static ssize_t attr_sensitivity_show_tpkbd(struct device *dev,
 544                 struct device_attribute *attr,
 545                 char *buf)
 546 {
 547         struct hid_device *hdev = to_hid_device(dev);
 548         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 549 
 550         return snprintf(buf, PAGE_SIZE, "%u\n",
 551                 data_pointer->sensitivity);
 552 }
 553 
 554 static ssize_t attr_sensitivity_store_tpkbd(struct device *dev,
 555                 struct device_attribute *attr,
 556                 const char *buf,
 557                 size_t count)
 558 {
 559         struct hid_device *hdev = to_hid_device(dev);
 560         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 561         int value;
 562 
 563         if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
 564                 return -EINVAL;
 565 
 566         data_pointer->sensitivity = value;
 567         lenovo_features_set_tpkbd(hdev);
 568 
 569         return count;
 570 }
 571 
 572 static ssize_t attr_press_speed_show_tpkbd(struct device *dev,
 573                 struct device_attribute *attr,
 574                 char *buf)
 575 {
 576         struct hid_device *hdev = to_hid_device(dev);
 577         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 578 
 579         return snprintf(buf, PAGE_SIZE, "%u\n",
 580                 data_pointer->press_speed);
 581 }
 582 
 583 static ssize_t attr_press_speed_store_tpkbd(struct device *dev,
 584                 struct device_attribute *attr,
 585                 const char *buf,
 586                 size_t count)
 587 {
 588         struct hid_device *hdev = to_hid_device(dev);
 589         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 590         int value;
 591 
 592         if (kstrtoint(buf, 10, &value) || value < 1 || value > 255)
 593                 return -EINVAL;
 594 
 595         data_pointer->press_speed = value;
 596         lenovo_features_set_tpkbd(hdev);
 597 
 598         return count;
 599 }
 600 
 601 static struct device_attribute dev_attr_press_to_select_tpkbd =
 602         __ATTR(press_to_select, S_IWUSR | S_IRUGO,
 603                         attr_press_to_select_show_tpkbd,
 604                         attr_press_to_select_store_tpkbd);
 605 
 606 static struct device_attribute dev_attr_dragging_tpkbd =
 607         __ATTR(dragging, S_IWUSR | S_IRUGO,
 608                         attr_dragging_show_tpkbd,
 609                         attr_dragging_store_tpkbd);
 610 
 611 static struct device_attribute dev_attr_release_to_select_tpkbd =
 612         __ATTR(release_to_select, S_IWUSR | S_IRUGO,
 613                         attr_release_to_select_show_tpkbd,
 614                         attr_release_to_select_store_tpkbd);
 615 
 616 static struct device_attribute dev_attr_select_right_tpkbd =
 617         __ATTR(select_right, S_IWUSR | S_IRUGO,
 618                         attr_select_right_show_tpkbd,
 619                         attr_select_right_store_tpkbd);
 620 
 621 static struct device_attribute dev_attr_sensitivity_tpkbd =
 622         __ATTR(sensitivity, S_IWUSR | S_IRUGO,
 623                         attr_sensitivity_show_tpkbd,
 624                         attr_sensitivity_store_tpkbd);
 625 
 626 static struct device_attribute dev_attr_press_speed_tpkbd =
 627         __ATTR(press_speed, S_IWUSR | S_IRUGO,
 628                         attr_press_speed_show_tpkbd,
 629                         attr_press_speed_store_tpkbd);
 630 
 631 static struct attribute *lenovo_attributes_tpkbd[] = {
 632         &dev_attr_press_to_select_tpkbd.attr,
 633         &dev_attr_dragging_tpkbd.attr,
 634         &dev_attr_release_to_select_tpkbd.attr,
 635         &dev_attr_select_right_tpkbd.attr,
 636         &dev_attr_sensitivity_tpkbd.attr,
 637         &dev_attr_press_speed_tpkbd.attr,
 638         NULL
 639 };
 640 
 641 static const struct attribute_group lenovo_attr_group_tpkbd = {
 642         .attrs = lenovo_attributes_tpkbd,
 643 };
 644 
 645 static enum led_brightness lenovo_led_brightness_get_tpkbd(
 646                         struct led_classdev *led_cdev)
 647 {
 648         struct device *dev = led_cdev->dev->parent;
 649         struct hid_device *hdev = to_hid_device(dev);
 650         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 651         int led_nr = 0;
 652 
 653         if (led_cdev == &data_pointer->led_micmute)
 654                 led_nr = 1;
 655 
 656         return data_pointer->led_state & (1 << led_nr)
 657                                 ? LED_FULL
 658                                 : LED_OFF;
 659 }
 660 
 661 static void lenovo_led_brightness_set_tpkbd(struct led_classdev *led_cdev,
 662                         enum led_brightness value)
 663 {
 664         struct device *dev = led_cdev->dev->parent;
 665         struct hid_device *hdev = to_hid_device(dev);
 666         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 667         struct hid_report *report;
 668         int led_nr = 0;
 669 
 670         if (led_cdev == &data_pointer->led_micmute)
 671                 led_nr = 1;
 672 
 673         if (value == LED_OFF)
 674                 data_pointer->led_state &= ~(1 << led_nr);
 675         else
 676                 data_pointer->led_state |= 1 << led_nr;
 677 
 678         report = hdev->report_enum[HID_OUTPUT_REPORT].report_id_hash[3];
 679         report->field[0]->value[0] = (data_pointer->led_state >> 0) & 1;
 680         report->field[0]->value[1] = (data_pointer->led_state >> 1) & 1;
 681         hid_hw_request(hdev, report, HID_REQ_SET_REPORT);
 682 }
 683 
 684 static int lenovo_probe_tpkbd(struct hid_device *hdev)
 685 {
 686         struct device *dev = &hdev->dev;
 687         struct lenovo_drvdata_tpkbd *data_pointer;
 688         size_t name_sz = strlen(dev_name(dev)) + 16;
 689         char *name_mute, *name_micmute;
 690         int i;
 691         int ret;
 692 
 693         /*
 694          * Only register extra settings against subdevice where input_mapping
 695          * set drvdata to 1, i.e. the trackpoint.
 696          */
 697         if (!hid_get_drvdata(hdev))
 698                 return 0;
 699 
 700         hid_set_drvdata(hdev, NULL);
 701 
 702         /* Validate required reports. */
 703         for (i = 0; i < 4; i++) {
 704                 if (!hid_validate_values(hdev, HID_FEATURE_REPORT, 4, i, 1))
 705                         return -ENODEV;
 706         }
 707         if (!hid_validate_values(hdev, HID_OUTPUT_REPORT, 3, 0, 2))
 708                 return -ENODEV;
 709 
 710         ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd);
 711         if (ret)
 712                 hid_warn(hdev, "Could not create sysfs group: %d\n", ret);
 713 
 714         data_pointer = devm_kzalloc(&hdev->dev,
 715                                     sizeof(struct lenovo_drvdata_tpkbd),
 716                                     GFP_KERNEL);
 717         if (data_pointer == NULL) {
 718                 hid_err(hdev, "Could not allocate memory for driver data\n");
 719                 ret = -ENOMEM;
 720                 goto err;
 721         }
 722 
 723         // set same default values as windows driver
 724         data_pointer->sensitivity = 0xa0;
 725         data_pointer->press_speed = 0x38;
 726 
 727         name_mute = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL);
 728         name_micmute = devm_kzalloc(&hdev->dev, name_sz, GFP_KERNEL);
 729         if (name_mute == NULL || name_micmute == NULL) {
 730                 hid_err(hdev, "Could not allocate memory for led data\n");
 731                 ret = -ENOMEM;
 732                 goto err;
 733         }
 734         snprintf(name_mute, name_sz, "%s:amber:mute", dev_name(dev));
 735         snprintf(name_micmute, name_sz, "%s:amber:micmute", dev_name(dev));
 736 
 737         hid_set_drvdata(hdev, data_pointer);
 738 
 739         data_pointer->led_mute.name = name_mute;
 740         data_pointer->led_mute.brightness_get = lenovo_led_brightness_get_tpkbd;
 741         data_pointer->led_mute.brightness_set = lenovo_led_brightness_set_tpkbd;
 742         data_pointer->led_mute.dev = dev;
 743         ret = led_classdev_register(dev, &data_pointer->led_mute);
 744         if (ret < 0)
 745                 goto err;
 746 
 747         data_pointer->led_micmute.name = name_micmute;
 748         data_pointer->led_micmute.brightness_get =
 749                 lenovo_led_brightness_get_tpkbd;
 750         data_pointer->led_micmute.brightness_set =
 751                 lenovo_led_brightness_set_tpkbd;
 752         data_pointer->led_micmute.dev = dev;
 753         ret = led_classdev_register(dev, &data_pointer->led_micmute);
 754         if (ret < 0) {
 755                 led_classdev_unregister(&data_pointer->led_mute);
 756                 goto err;
 757         }
 758 
 759         lenovo_features_set_tpkbd(hdev);
 760 
 761         return 0;
 762 err:
 763         sysfs_remove_group(&hdev->dev.kobj, &lenovo_attr_group_tpkbd);
 764         return ret;
 765 }
 766 
 767 static int lenovo_probe_cptkbd(struct hid_device *hdev)
 768 {
 769         int ret;
 770         struct lenovo_drvdata_cptkbd *cptkbd_data;
 771 
 772         /* All the custom action happens on the USBMOUSE device for USB */
 773         if (hdev->product == USB_DEVICE_ID_LENOVO_CUSBKBD
 774                         && hdev->type != HID_TYPE_USBMOUSE) {
 775                 hid_dbg(hdev, "Ignoring keyboard half of device\n");
 776                 return 0;
 777         }
 778 
 779         cptkbd_data = devm_kzalloc(&hdev->dev,
 780                                         sizeof(*cptkbd_data),
 781                                         GFP_KERNEL);
 782         if (cptkbd_data == NULL) {
 783                 hid_err(hdev, "can't alloc keyboard descriptor\n");
 784                 return -ENOMEM;
 785         }
 786         hid_set_drvdata(hdev, cptkbd_data);
 787 
 788         /*
 789          * Tell the keyboard a driver understands it, and turn F7, F9, F11 into
 790          * regular keys
 791          */
 792         ret = lenovo_send_cmd_cptkbd(hdev, 0x01, 0x03);
 793         if (ret)
 794                 hid_warn(hdev, "Failed to switch F7/9/11 mode: %d\n", ret);
 795 
 796         /* Switch middle button to native mode */
 797         ret = lenovo_send_cmd_cptkbd(hdev, 0x09, 0x01);
 798         if (ret)
 799                 hid_warn(hdev, "Failed to switch middle button: %d\n", ret);
 800 
 801         /* Set keyboard settings to known state */
 802         cptkbd_data->middlebutton_state = 0;
 803         cptkbd_data->fn_lock = true;
 804         cptkbd_data->sensitivity = 0x05;
 805         lenovo_features_set_cptkbd(hdev);
 806 
 807         ret = sysfs_create_group(&hdev->dev.kobj, &lenovo_attr_group_cptkbd);
 808         if (ret)
 809                 hid_warn(hdev, "Could not create sysfs group: %d\n", ret);
 810 
 811         return 0;
 812 }
 813 
 814 static int lenovo_probe(struct hid_device *hdev,
 815                 const struct hid_device_id *id)
 816 {
 817         int ret;
 818 
 819         ret = hid_parse(hdev);
 820         if (ret) {
 821                 hid_err(hdev, "hid_parse failed\n");
 822                 goto err;
 823         }
 824 
 825         ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
 826         if (ret) {
 827                 hid_err(hdev, "hid_hw_start failed\n");
 828                 goto err;
 829         }
 830 
 831         switch (hdev->product) {
 832         case USB_DEVICE_ID_LENOVO_TPKBD:
 833                 ret = lenovo_probe_tpkbd(hdev);
 834                 break;
 835         case USB_DEVICE_ID_LENOVO_CUSBKBD:
 836         case USB_DEVICE_ID_LENOVO_CBTKBD:
 837                 ret = lenovo_probe_cptkbd(hdev);
 838                 break;
 839         default:
 840                 ret = 0;
 841                 break;
 842         }
 843         if (ret)
 844                 goto err_hid;
 845 
 846         return 0;
 847 err_hid:
 848         hid_hw_stop(hdev);
 849 err:
 850         return ret;
 851 }
 852 
 853 static void lenovo_remove_tpkbd(struct hid_device *hdev)
 854 {
 855         struct lenovo_drvdata_tpkbd *data_pointer = hid_get_drvdata(hdev);
 856 
 857         /*
 858          * Only the trackpoint half of the keyboard has drvdata and stuff that
 859          * needs unregistering.
 860          */
 861         if (data_pointer == NULL)
 862                 return;
 863 
 864         sysfs_remove_group(&hdev->dev.kobj,
 865                         &lenovo_attr_group_tpkbd);
 866 
 867         led_classdev_unregister(&data_pointer->led_micmute);
 868         led_classdev_unregister(&data_pointer->led_mute);
 869 }
 870 
 871 static void lenovo_remove_cptkbd(struct hid_device *hdev)
 872 {
 873         sysfs_remove_group(&hdev->dev.kobj,
 874                         &lenovo_attr_group_cptkbd);
 875 }
 876 
 877 static void lenovo_remove(struct hid_device *hdev)
 878 {
 879         switch (hdev->product) {
 880         case USB_DEVICE_ID_LENOVO_TPKBD:
 881                 lenovo_remove_tpkbd(hdev);
 882                 break;
 883         case USB_DEVICE_ID_LENOVO_CUSBKBD:
 884         case USB_DEVICE_ID_LENOVO_CBTKBD:
 885                 lenovo_remove_cptkbd(hdev);
 886                 break;
 887         }
 888 
 889         hid_hw_stop(hdev);
 890 }
 891 
 892 static int lenovo_input_configured(struct hid_device *hdev,
 893                 struct hid_input *hi)
 894 {
 895         switch (hdev->product) {
 896                 case USB_DEVICE_ID_LENOVO_TPKBD:
 897                 case USB_DEVICE_ID_LENOVO_CUSBKBD:
 898                 case USB_DEVICE_ID_LENOVO_CBTKBD:
 899                         if (test_bit(EV_REL, hi->input->evbit)) {
 900                                 /* set only for trackpoint device */
 901                                 __set_bit(INPUT_PROP_POINTER, hi->input->propbit);
 902                                 __set_bit(INPUT_PROP_POINTING_STICK,
 903                                                 hi->input->propbit);
 904                         }
 905                         break;
 906         }
 907 
 908         return 0;
 909 }
 910 
 911 
 912 static const struct hid_device_id lenovo_devices[] = {
 913         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPKBD) },
 914         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CUSBKBD) },
 915         { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_CBTKBD) },
 916         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_TPPRODOCK) },
 917         { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_III) },
 918         { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_PRO) },
 919         { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_OPTICAL) },
 920         { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL) },
 921         { HID_USB_DEVICE(USB_VENDOR_ID_IBM, USB_DEVICE_ID_IBM_SCROLLPOINT_800DPI_OPTICAL_PRO) },
 922         { HID_USB_DEVICE(USB_VENDOR_ID_LENOVO, USB_DEVICE_ID_LENOVO_SCROLLPOINT_OPTICAL) },
 923         { }
 924 };
 925 
 926 MODULE_DEVICE_TABLE(hid, lenovo_devices);
 927 
 928 static struct hid_driver lenovo_driver = {
 929         .name = "lenovo",
 930         .id_table = lenovo_devices,
 931         .input_configured = lenovo_input_configured,
 932         .input_mapping = lenovo_input_mapping,
 933         .probe = lenovo_probe,
 934         .remove = lenovo_remove,
 935         .raw_event = lenovo_raw_event,
 936         .event = lenovo_event,
 937         .report_fixup = lenovo_report_fixup,
 938 };
 939 module_hid_driver(lenovo_driver);
 940 
 941 MODULE_LICENSE("GPL");