drivers/hid/hid-lenovo.c

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