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");