drivers/hid/hid-corsair.c

   1 /*
   2  * HID driver for Corsair devices
   3  *
   4  * Supported devices:
   5  *  - Vengeance K70 Keyboard
   6  *  - K70 RAPIDFIRE Keyboard
   7  *  - Vengeance K90 Keyboard
   8  *  - Scimitar PRO RGB Gaming Mouse
   9  *
  10  * Copyright (c) 2015 Clement Vuchener
  11  * Copyright (c) 2017 Oscar Campos
  12  * Copyright (c) 2017 Aaron Bottegal
  13  */
  14
  15 /*
  16  * This program is free software; you can redistribute it and/or modify it
  17  * under the terms of the GNU General Public License as published by the Free
  18  * Software Foundation; either version 2 of the License, or (at your option)
  19  * any later version.
  20  */
  21
  22 #include <linux/hid.h>
  23 #include <linux/module.h>
  24 #include <linux/usb.h>
  25 #include <linux/leds.h>
  26
  27 #include "hid-ids.h"
  28
  29 #define CORSAIR_USE_K90_MACRO   (1<<0)
  30 #define CORSAIR_USE_K90_BACKLIGHT       (1<<1)
  31
  32 struct k90_led {
  33         struct led_classdev cdev;
  34         int brightness;
  35         struct work_struct work;
  36         bool removed;
  37 };
  38
  39 struct k90_drvdata {
  40         struct k90_led record_led;
  41 };
  42
  43 struct corsair_drvdata {
  44         unsigned long quirks;
  45         struct k90_drvdata *k90;
  46         struct k90_led *backlight;
  47 };
  48
  49 #define K90_GKEY_COUNT  18
  50
  51 static int corsair_usage_to_gkey(unsigned int usage)
  52 {
  53         /* G1 (0xd0) to G16 (0xdf) */
  54         if (usage >= 0xd0 && usage <= 0xdf)
  55                 return usage - 0xd0 + 1;
  56         /* G17 (0xe8) to G18 (0xe9) */
  57         if (usage >= 0xe8 && usage <= 0xe9)
  58                 return usage - 0xe8 + 17;
  59         return 0;
  60 }
  61
  62 static unsigned short corsair_gkey_map[K90_GKEY_COUNT] = {
  63         BTN_TRIGGER_HAPPY1,
  64         BTN_TRIGGER_HAPPY2,
  65         BTN_TRIGGER_HAPPY3,
  66         BTN_TRIGGER_HAPPY4,
  67         BTN_TRIGGER_HAPPY5,
  68         BTN_TRIGGER_HAPPY6,
  69         BTN_TRIGGER_HAPPY7,
  70         BTN_TRIGGER_HAPPY8,
  71         BTN_TRIGGER_HAPPY9,
  72         BTN_TRIGGER_HAPPY10,
  73         BTN_TRIGGER_HAPPY11,
  74         BTN_TRIGGER_HAPPY12,
  75         BTN_TRIGGER_HAPPY13,
  76         BTN_TRIGGER_HAPPY14,
  77         BTN_TRIGGER_HAPPY15,
  78         BTN_TRIGGER_HAPPY16,
  79         BTN_TRIGGER_HAPPY17,
  80         BTN_TRIGGER_HAPPY18,
  81 };
  82
  83 module_param_array_named(gkey_codes, corsair_gkey_map, ushort, NULL, S_IRUGO);
  84 MODULE_PARM_DESC(gkey_codes, "Key codes for the G-keys");
  85
  86 static unsigned short corsair_record_keycodes[2] = {
  87         BTN_TRIGGER_HAPPY19,
  88         BTN_TRIGGER_HAPPY20
  89 };
  90
  91 module_param_array_named(recordkey_codes, corsair_record_keycodes, ushort,
  92                          NULL, S_IRUGO);
  93 MODULE_PARM_DESC(recordkey_codes, "Key codes for the MR (start and stop record) button");
  94
  95 static unsigned short corsair_profile_keycodes[3] = {
  96         BTN_TRIGGER_HAPPY21,
  97         BTN_TRIGGER_HAPPY22,
  98         BTN_TRIGGER_HAPPY23
  99 };
 100
 101 module_param_array_named(profilekey_codes, corsair_profile_keycodes, ushort,
 102                          NULL, S_IRUGO);
 103 MODULE_PARM_DESC(profilekey_codes, "Key codes for the profile buttons");
 104
 105 #define CORSAIR_USAGE_SPECIAL_MIN 0xf0
 106 #define CORSAIR_USAGE_SPECIAL_MAX 0xff
 107
 108 #define CORSAIR_USAGE_MACRO_RECORD_START 0xf6
 109 #define CORSAIR_USAGE_MACRO_RECORD_STOP 0xf7
 110
 111 #define CORSAIR_USAGE_PROFILE 0xf1
 112 #define CORSAIR_USAGE_M1 0xf1
 113 #define CORSAIR_USAGE_M2 0xf2
 114 #define CORSAIR_USAGE_M3 0xf3
 115 #define CORSAIR_USAGE_PROFILE_MAX 0xf3
 116
 117 #define CORSAIR_USAGE_META_OFF 0xf4
 118 #define CORSAIR_USAGE_META_ON  0xf5
 119
 120 #define CORSAIR_USAGE_LIGHT 0xfa
 121 #define CORSAIR_USAGE_LIGHT_OFF 0xfa
 122 #define CORSAIR_USAGE_LIGHT_DIM 0xfb
 123 #define CORSAIR_USAGE_LIGHT_MEDIUM 0xfc
 124 #define CORSAIR_USAGE_LIGHT_BRIGHT 0xfd
 125 #define CORSAIR_USAGE_LIGHT_MAX 0xfd
 126
 127 /* USB control protocol */
 128
 129 #define K90_REQUEST_BRIGHTNESS 49
 130 #define K90_REQUEST_MACRO_MODE 2
 131 #define K90_REQUEST_STATUS 4
 132 #define K90_REQUEST_GET_MODE 5
 133 #define K90_REQUEST_PROFILE 20
 134
 135 #define K90_MACRO_MODE_SW 0x0030
 136 #define K90_MACRO_MODE_HW 0x0001
 137
 138 #define K90_MACRO_LED_ON  0x0020
 139 #define K90_MACRO_LED_OFF 0x0040
 140
 141 /*
 142  * LED class devices
 143  */
 144
 145 #define K90_BACKLIGHT_LED_SUFFIX "::backlight"
 146 #define K90_RECORD_LED_SUFFIX "::record"
 147
 148 static enum led_brightness k90_backlight_get(struct led_classdev *led_cdev)
 149 {
 150         int ret;
 151         struct k90_led *led = container_of(led_cdev, struct k90_led, cdev);
 152         struct device *dev = led->cdev.dev->parent;
 153         struct usb_interface *usbif = to_usb_interface(dev->parent);
 154         struct usb_device *usbdev = interface_to_usbdev(usbif);
 155         int brightness;
 156         char *data;
 157
 158         data = kmalloc(8, GFP_KERNEL);
 159         if (!data)
 160                 return -ENOMEM;
 161
 162         ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
 163                               K90_REQUEST_STATUS,
 164                               USB_DIR_IN | USB_TYPE_VENDOR |
 165                               USB_RECIP_DEVICE, 0, 0, data, 8,
 166                               USB_CTRL_SET_TIMEOUT);
 167         if (ret < 5) {
 168                 dev_warn(dev, "Failed to get K90 initial state (error %d).\n",
 169                          ret);
 170                 ret = -EIO;
 171                 goto out;
 172         }
 173         brightness = data[4];
 174         if (brightness < 0 || brightness > 3) {
 175                 dev_warn(dev,
 176                          "Read invalid backlight brightness: %02hhx.\n",
 177                          data[4]);
 178                 ret = -EIO;
 179                 goto out;
 180         }
 181         ret = brightness;
 182 out:
 183         kfree(data);
 184
 185         return ret;
 186 }
 187
 188 static enum led_brightness k90_record_led_get(struct led_classdev *led_cdev)
 189 {
 190         struct k90_led *led = container_of(led_cdev, struct k90_led, cdev);
 191
 192         return led->brightness;
 193 }
 194
 195 static void k90_brightness_set(struct led_classdev *led_cdev,
 196                                enum led_brightness brightness)
 197 {
 198         struct k90_led *led = container_of(led_cdev, struct k90_led, cdev);
 199
 200         led->brightness = brightness;
 201         schedule_work(&led->work);
 202 }
 203
 204 static void k90_backlight_work(struct work_struct *work)
 205 {
 206         int ret;
 207         struct k90_led *led = container_of(work, struct k90_led, work);
 208         struct device *dev;
 209         struct usb_interface *usbif;
 210         struct usb_device *usbdev;
 211
 212         if (led->removed)
 213                 return;
 214
 215         dev = led->cdev.dev->parent;
 216         usbif = to_usb_interface(dev->parent);
 217         usbdev = interface_to_usbdev(usbif);
 218
 219         ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
 220                               K90_REQUEST_BRIGHTNESS,
 221                               USB_DIR_OUT | USB_TYPE_VENDOR |
 222                               USB_RECIP_DEVICE, led->brightness, 0,
 223                               NULL, 0, USB_CTRL_SET_TIMEOUT);
 224         if (ret != 0)
 225                 dev_warn(dev, "Failed to set backlight brightness (error: %d).\n",
 226                          ret);
 227 }
 228
 229 static void k90_record_led_work(struct work_struct *work)
 230 {
 231         int ret;
 232         struct k90_led *led = container_of(work, struct k90_led, work);
 233         struct device *dev;
 234         struct usb_interface *usbif;
 235         struct usb_device *usbdev;
 236         int value;
 237
 238         if (led->removed)
 239                 return;
 240
 241         dev = led->cdev.dev->parent;
 242         usbif = to_usb_interface(dev->parent);
 243         usbdev = interface_to_usbdev(usbif);
 244
 245         if (led->brightness > 0)
 246                 value = K90_MACRO_LED_ON;
 247         else
 248                 value = K90_MACRO_LED_OFF;
 249
 250         ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
 251                               K90_REQUEST_MACRO_MODE,
 252                               USB_DIR_OUT | USB_TYPE_VENDOR |
 253                               USB_RECIP_DEVICE, value, 0, NULL, 0,
 254                               USB_CTRL_SET_TIMEOUT);
 255         if (ret != 0)
 256                 dev_warn(dev, "Failed to set record LED state (error: %d).\n",
 257                          ret);
 258 }
 259
 260 /*
 261  * Keyboard attributes
 262  */
 263
 264 static ssize_t k90_show_macro_mode(struct device *dev,
 265                                    struct device_attribute *attr, char *buf)
 266 {
 267         int ret;
 268         struct usb_interface *usbif = to_usb_interface(dev->parent);
 269         struct usb_device *usbdev = interface_to_usbdev(usbif);
 270         const char *macro_mode;
 271         char *data;
 272
 273         data = kmalloc(2, GFP_KERNEL);
 274         if (!data)
 275                 return -ENOMEM;
 276
 277         ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
 278                               K90_REQUEST_GET_MODE,
 279                               USB_DIR_IN | USB_TYPE_VENDOR |
 280                               USB_RECIP_DEVICE, 0, 0, data, 2,
 281                               USB_CTRL_SET_TIMEOUT);
 282         if (ret < 1) {
 283                 dev_warn(dev, "Failed to get K90 initial mode (error %d).\n",
 284                          ret);
 285                 ret = -EIO;
 286                 goto out;
 287         }
 288
 289         switch (data[0]) {
 290         case K90_MACRO_MODE_HW:
 291                 macro_mode = "HW";
 292                 break;
 293
 294         case K90_MACRO_MODE_SW:
 295                 macro_mode = "SW";
 296                 break;
 297         default:
 298                 dev_warn(dev, "K90 in unknown mode: %02hhx.\n",
 299                          data[0]);
 300                 ret = -EIO;
 301                 goto out;
 302         }
 303
 304         ret = snprintf(buf, PAGE_SIZE, "%s\n", macro_mode);
 305 out:
 306         kfree(data);
 307
 308         return ret;
 309 }
 310
 311 static ssize_t k90_store_macro_mode(struct device *dev,
 312                                     struct device_attribute *attr,
 313                                     const char *buf, size_t count)
 314 {
 315         int ret;
 316         struct usb_interface *usbif = to_usb_interface(dev->parent);
 317         struct usb_device *usbdev = interface_to_usbdev(usbif);
 318         __u16 value;
 319
 320         if (strncmp(buf, "SW", 2) == 0)
 321                 value = K90_MACRO_MODE_SW;
 322         else if (strncmp(buf, "HW", 2) == 0)
 323                 value = K90_MACRO_MODE_HW;
 324         else
 325                 return -EINVAL;
 326
 327         ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
 328                               K90_REQUEST_MACRO_MODE,
 329                               USB_DIR_OUT | USB_TYPE_VENDOR |
 330                               USB_RECIP_DEVICE, value, 0, NULL, 0,
 331                               USB_CTRL_SET_TIMEOUT);
 332         if (ret != 0) {
 333                 dev_warn(dev, "Failed to set macro mode.\n");
 334                 return ret;
 335         }
 336
 337         return count;
 338 }
 339
 340 static ssize_t k90_show_current_profile(struct device *dev,
 341                                         struct device_attribute *attr,
 342                                         char *buf)
 343 {
 344         int ret;
 345         struct usb_interface *usbif = to_usb_interface(dev->parent);
 346         struct usb_device *usbdev = interface_to_usbdev(usbif);
 347         int current_profile;
 348         char *data;
 349
 350         data = kmalloc(8, GFP_KERNEL);
 351         if (!data)
 352                 return -ENOMEM;
 353
 354         ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
 355                               K90_REQUEST_STATUS,
 356                               USB_DIR_IN | USB_TYPE_VENDOR |
 357                               USB_RECIP_DEVICE, 0, 0, data, 8,
 358                               USB_CTRL_SET_TIMEOUT);
 359         if (ret < 8) {
 360                 dev_warn(dev, "Failed to get K90 initial state (error %d).\n",
 361                          ret);
 362                 ret = -EIO;
 363                 goto out;
 364         }
 365         current_profile = data[7];
 366         if (current_profile < 1 || current_profile > 3) {
 367                 dev_warn(dev, "Read invalid current profile: %02hhx.\n",
 368                          data[7]);
 369                 ret = -EIO;
 370                 goto out;
 371         }
 372
 373         ret = snprintf(buf, PAGE_SIZE, "%d\n", current_profile);
 374 out:
 375         kfree(data);
 376
 377         return ret;
 378 }
 379
 380 static ssize_t k90_store_current_profile(struct device *dev,
 381                                          struct device_attribute *attr,
 382                                          const char *buf, size_t count)
 383 {
 384         int ret;
 385         struct usb_interface *usbif = to_usb_interface(dev->parent);
 386         struct usb_device *usbdev = interface_to_usbdev(usbif);
 387         int profile;
 388
 389         if (kstrtoint(buf, 10, &profile))
 390                 return -EINVAL;
 391         if (profile < 1 || profile > 3)
 392                 return -EINVAL;
 393
 394         ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
 395                               K90_REQUEST_PROFILE,
 396                               USB_DIR_OUT | USB_TYPE_VENDOR |
 397                               USB_RECIP_DEVICE, profile, 0, NULL, 0,
 398                               USB_CTRL_SET_TIMEOUT);
 399         if (ret != 0) {
 400                 dev_warn(dev, "Failed to change current profile (error %d).\n",
 401                          ret);
 402                 return ret;
 403         }
 404
 405         return count;
 406 }
 407
 408 static DEVICE_ATTR(macro_mode, 0644, k90_show_macro_mode, k90_store_macro_mode);
 409 static DEVICE_ATTR(current_profile, 0644, k90_show_current_profile,
 410                    k90_store_current_profile);
 411
 412 static struct attribute *k90_attrs[] = {
 413         &dev_attr_macro_mode.attr,
 414         &dev_attr_current_profile.attr,
 415         NULL
 416 };
 417
 418 static const struct attribute_group k90_attr_group = {
 419         .attrs = k90_attrs,
 420 };
 421
 422 /*
 423  * Driver functions
 424  */
 425
 426 static int k90_init_backlight(struct hid_device *dev)
 427 {
 428         int ret;
 429         struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
 430         size_t name_sz;
 431         char *name;
 432
 433         drvdata->backlight = kzalloc(sizeof(struct k90_led), GFP_KERNEL);
 434         if (!drvdata->backlight) {
 435                 ret = -ENOMEM;
 436                 goto fail_backlight_alloc;
 437         }
 438
 439         name_sz =
 440             strlen(dev_name(&dev->dev)) + sizeof(K90_BACKLIGHT_LED_SUFFIX);
 441         name = kzalloc(name_sz, GFP_KERNEL);
 442         if (!name) {
 443                 ret = -ENOMEM;
 444                 goto fail_name_alloc;
 445         }
 446         snprintf(name, name_sz, "%s" K90_BACKLIGHT_LED_SUFFIX,
 447                  dev_name(&dev->dev));
 448         drvdata->backlight->removed = false;
 449         drvdata->backlight->cdev.name = name;
 450         drvdata->backlight->cdev.max_brightness = 3;
 451         drvdata->backlight->cdev.brightness_set = k90_brightness_set;
 452         drvdata->backlight->cdev.brightness_get = k90_backlight_get;
 453         INIT_WORK(&drvdata->backlight->work, k90_backlight_work);
 454         ret = led_classdev_register(&dev->dev, &drvdata->backlight->cdev);
 455         if (ret != 0)
 456                 goto fail_register_cdev;
 457
 458         return 0;
 459
 460 fail_register_cdev:
 461         kfree(drvdata->backlight->cdev.name);
 462 fail_name_alloc:
 463         kfree(drvdata->backlight);
 464         drvdata->backlight = NULL;
 465 fail_backlight_alloc:
 466         return ret;
 467 }
 468
 469 static int k90_init_macro_functions(struct hid_device *dev)
 470 {
 471         int ret;
 472         struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
 473         struct k90_drvdata *k90;
 474         size_t name_sz;
 475         char *name;
 476
 477         k90 = kzalloc(sizeof(struct k90_drvdata), GFP_KERNEL);
 478         if (!k90) {
 479                 ret = -ENOMEM;
 480                 goto fail_drvdata;
 481         }
 482         drvdata->k90 = k90;
 483
 484         /* Init LED device for record LED */
 485         name_sz = strlen(dev_name(&dev->dev)) + sizeof(K90_RECORD_LED_SUFFIX);
 486         name = kzalloc(name_sz, GFP_KERNEL);
 487         if (!name) {
 488                 ret = -ENOMEM;
 489                 goto fail_record_led_alloc;
 490         }
 491         snprintf(name, name_sz, "%s" K90_RECORD_LED_SUFFIX,
 492                  dev_name(&dev->dev));
 493         k90->record_led.removed = false;
 494         k90->record_led.cdev.name = name;
 495         k90->record_led.cdev.max_brightness = 1;
 496         k90->record_led.cdev.brightness_set = k90_brightness_set;
 497         k90->record_led.cdev.brightness_get = k90_record_led_get;
 498         INIT_WORK(&k90->record_led.work, k90_record_led_work);
 499         k90->record_led.brightness = 0;
 500         ret = led_classdev_register(&dev->dev, &k90->record_led.cdev);
 501         if (ret != 0)
 502                 goto fail_record_led;
 503
 504         /* Init attributes */
 505         ret = sysfs_create_group(&dev->dev.kobj, &k90_attr_group);
 506         if (ret != 0)
 507                 goto fail_sysfs;
 508
 509         return 0;
 510
 511 fail_sysfs:
 512         k90->record_led.removed = true;
 513         led_classdev_unregister(&k90->record_led.cdev);
 514         cancel_work_sync(&k90->record_led.work);
 515 fail_record_led:
 516         kfree(k90->record_led.cdev.name);
 517 fail_record_led_alloc:
 518         kfree(k90);
 519 fail_drvdata:
 520         drvdata->k90 = NULL;
 521         return ret;
 522 }
 523
 524 static void k90_cleanup_backlight(struct hid_device *dev)
 525 {
 526         struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
 527
 528         if (drvdata->backlight) {
 529                 drvdata->backlight->removed = true;
 530                 led_classdev_unregister(&drvdata->backlight->cdev);
 531                 cancel_work_sync(&drvdata->backlight->work);
 532                 kfree(drvdata->backlight->cdev.name);
 533                 kfree(drvdata->backlight);
 534         }
 535 }
 536
 537 static void k90_cleanup_macro_functions(struct hid_device *dev)
 538 {
 539         struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
 540         struct k90_drvdata *k90 = drvdata->k90;
 541
 542         if (k90) {
 543                 sysfs_remove_group(&dev->dev.kobj, &k90_attr_group);
 544
 545                 k90->record_led.removed = true;
 546                 led_classdev_unregister(&k90->record_led.cdev);
 547                 cancel_work_sync(&k90->record_led.work);
 548                 kfree(k90->record_led.cdev.name);
 549
 550                 kfree(k90);
 551         }
 552 }
 553
 554 static int corsair_probe(struct hid_device *dev, const struct hid_device_id *id)
 555 {
 556         int ret;
 557         unsigned long quirks = id->driver_data;
 558         struct corsair_drvdata *drvdata;
 559         struct usb_interface *usbif = to_usb_interface(dev->dev.parent);
 560
 561         drvdata = devm_kzalloc(&dev->dev, sizeof(struct corsair_drvdata),
 562                                GFP_KERNEL);
 563         if (drvdata == NULL)
 564                 return -ENOMEM;
 565         drvdata->quirks = quirks;
 566         hid_set_drvdata(dev, drvdata);
 567
 568         ret = hid_parse(dev);
 569         if (ret != 0) {
 570                 hid_err(dev, "parse failed\n");
 571                 return ret;
 572         }
 573         ret = hid_hw_start(dev, HID_CONNECT_DEFAULT);
 574         if (ret != 0) {
 575                 hid_err(dev, "hw start failed\n");
 576                 return ret;
 577         }
 578
 579         if (usbif->cur_altsetting->desc.bInterfaceNumber == 0) {
 580                 if (quirks & CORSAIR_USE_K90_MACRO) {
 581                         ret = k90_init_macro_functions(dev);
 582                         if (ret != 0)
 583                                 hid_warn(dev, "Failed to initialize K90 macro functions.\n");
 584                 }
 585                 if (quirks & CORSAIR_USE_K90_BACKLIGHT) {
 586                         ret = k90_init_backlight(dev);
 587                         if (ret != 0)
 588                                 hid_warn(dev, "Failed to initialize K90 backlight.\n");
 589                 }
 590         }
 591
 592         return 0;
 593 }
 594
 595 static void corsair_remove(struct hid_device *dev)
 596 {
 597         k90_cleanup_macro_functions(dev);
 598         k90_cleanup_backlight(dev);
 599
 600         hid_hw_stop(dev);
 601 }
 602
 603 static int corsair_event(struct hid_device *dev, struct hid_field *field,
 604                          struct hid_usage *usage, __s32 value)
 605 {
 606         struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
 607
 608         if (!drvdata->k90)
 609                 return 0;
 610
 611         switch (usage->hid & HID_USAGE) {
 612         case CORSAIR_USAGE_MACRO_RECORD_START:
 613                 drvdata->k90->record_led.brightness = 1;
 614                 break;
 615         case CORSAIR_USAGE_MACRO_RECORD_STOP:
 616                 drvdata->k90->record_led.brightness = 0;
 617                 break;
 618         default:
 619                 break;
 620         }
 621
 622         return 0;
 623 }
 624
 625 static int corsair_input_mapping(struct hid_device *dev,
 626                                  struct hid_input *input,
 627                                  struct hid_field *field,
 628                                  struct hid_usage *usage, unsigned long **bit,
 629                                  int *max)
 630 {
 631         int gkey;
 632
 633         if ((usage->hid & HID_USAGE_PAGE) != HID_UP_KEYBOARD)
 634                 return 0;
 635
 636         gkey = corsair_usage_to_gkey(usage->hid & HID_USAGE);
 637         if (gkey != 0) {
 638                 hid_map_usage_clear(input, usage, bit, max, EV_KEY,
 639                                     corsair_gkey_map[gkey - 1]);
 640                 return 1;
 641         }
 642         if ((usage->hid & HID_USAGE) >= CORSAIR_USAGE_SPECIAL_MIN &&
 643             (usage->hid & HID_USAGE) <= CORSAIR_USAGE_SPECIAL_MAX) {
 644                 switch (usage->hid & HID_USAGE) {
 645                 case CORSAIR_USAGE_MACRO_RECORD_START:
 646                         hid_map_usage_clear(input, usage, bit, max, EV_KEY,
 647                                             corsair_record_keycodes[0]);
 648                         return 1;
 649
 650                 case CORSAIR_USAGE_MACRO_RECORD_STOP:
 651                         hid_map_usage_clear(input, usage, bit, max, EV_KEY,
 652                                             corsair_record_keycodes[1]);
 653                         return 1;
 654
 655                 case CORSAIR_USAGE_M1:
 656                         hid_map_usage_clear(input, usage, bit, max, EV_KEY,
 657                                             corsair_profile_keycodes[0]);
 658                         return 1;
 659
 660                 case CORSAIR_USAGE_M2:
 661                         hid_map_usage_clear(input, usage, bit, max, EV_KEY,
 662                                             corsair_profile_keycodes[1]);
 663                         return 1;
 664
 665                 case CORSAIR_USAGE_M3:
 666                         hid_map_usage_clear(input, usage, bit, max, EV_KEY,
 667                                             corsair_profile_keycodes[2]);
 668                         return 1;
 669
 670                 default:
 671                         return -1;
 672                 }
 673         }
 674
 675         return 0;
 676 }
 677
 678 /*
 679  * The report descriptor of some of the Corsair gaming mice is
 680  * non parseable as they define two consecutive Logical Minimum for
 681  * the Usage Page (Consumer) in rdescs bytes 75 and 77 being 77 0x16
 682  * that should be obviousy 0x26 for Logical Magimum of 16 bits. This
 683  * prevents poper parsing of the report descriptor due Logical
 684  * Minimum being larger than Logical Maximum.
 685  *
 686  * This driver fixes the report descriptor for:
 687  * - USB ID 1b1c:1b34, sold as GLAIVE RGB Gaming mouse
 688  * - USB ID 1b1c:1b3e, sold as Scimitar RGB Pro Gaming mouse
 689  */
 690
 691 static __u8 *corsair_mouse_report_fixup(struct hid_device *hdev, __u8 *rdesc,
 692         unsigned int *rsize)
 693 {
 694         struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
 695
 696         if (intf->cur_altsetting->desc.bInterfaceNumber == 1) {
 697                 /*
 698                  * Corsair GLAIVE RGB and Scimitar RGB Pro report descriptor is
 699                  * broken and defines two different Logical Minimum for the
 700                  * Consumer Application. The byte 77 should be a 0x26 defining
 701                  * a 16 bits integer for the Logical Maximum but it is a 0x16
 702                  * instead (Logical Minimum)
 703                  */
 704                 switch (hdev->product) {
 705                 case USB_DEVICE_ID_CORSAIR_GLAIVE_RGB:
 706                 case USB_DEVICE_ID_CORSAIR_SCIMITAR_PRO_RGB:
 707                         if (*rsize >= 172 && rdesc[75] == 0x15 && rdesc[77] == 0x16
 708                         && rdesc[78] == 0xff && rdesc[79] == 0x0f) {
 709                                 hid_info(hdev, "Fixing up report descriptor\n");
 710                                 rdesc[77] = 0x26;
 711                         }
 712                         break;
 713                 }
 714
 715         }
 716         return rdesc;
 717 }
 718
 719 static const struct hid_device_id corsair_devices[] = {
 720         { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_K90),
 721                 .driver_data = CORSAIR_USE_K90_MACRO |
 722                                CORSAIR_USE_K90_BACKLIGHT },
 723         { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR,
 724             USB_DEVICE_ID_CORSAIR_GLAIVE_RGB) },
 725         { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR,
 726             USB_DEVICE_ID_CORSAIR_SCIMITAR_PRO_RGB) },
 727         /*
 728          * Vengeance K70 and K70 RAPIDFIRE share product IDs.
 729          */
 730         { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR,
 731             USB_DEVICE_ID_CORSAIR_K70R) },
 732         {}
 733 };
 734
 735 MODULE_DEVICE_TABLE(hid, corsair_devices);
 736
 737 static struct hid_driver corsair_driver = {
 738         .name = "corsair",
 739         .id_table = corsair_devices,
 740         .probe = corsair_probe,
 741         .event = corsair_event,
 742         .remove = corsair_remove,
 743         .input_mapping = corsair_input_mapping,
 744         .report_fixup = corsair_mouse_report_fixup,
 745 };
 746
 747 module_hid_driver(corsair_driver);
 748
 749 MODULE_LICENSE("GPL");
 750 /* Original K90 driver author */
 751 MODULE_AUTHOR("Clement Vuchener");
 752 /* Scimitar PRO RGB driver author */
 753 MODULE_AUTHOR("Oscar Campos");
 754 MODULE_DESCRIPTION("HID driver for Corsair devices");