drivers/hid/hid-lenovo.c

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