Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * HID driver for Corsair devices
0004  *
0005  * Supported devices:
0006  *  - Vengeance K70 Keyboard
0007  *  - K70 RAPIDFIRE Keyboard
0008  *  - Vengeance K90 Keyboard
0009  *  - Scimitar PRO RGB Gaming Mouse
0010  *
0011  * Copyright (c) 2015 Clement Vuchener
0012  * Copyright (c) 2017 Oscar Campos
0013  * Copyright (c) 2017 Aaron Bottegal
0014  */
0015 
0016 /*
0017  */
0018 
0019 #include <linux/hid.h>
0020 #include <linux/module.h>
0021 #include <linux/usb.h>
0022 #include <linux/leds.h>
0023 
0024 #include "hid-ids.h"
0025 
0026 #define CORSAIR_USE_K90_MACRO   (1<<0)
0027 #define CORSAIR_USE_K90_BACKLIGHT   (1<<1)
0028 
0029 struct k90_led {
0030     struct led_classdev cdev;
0031     int brightness;
0032     struct work_struct work;
0033     bool removed;
0034 };
0035 
0036 struct k90_drvdata {
0037     struct k90_led record_led;
0038 };
0039 
0040 struct corsair_drvdata {
0041     unsigned long quirks;
0042     struct k90_drvdata *k90;
0043     struct k90_led *backlight;
0044 };
0045 
0046 #define K90_GKEY_COUNT  18
0047 
0048 static int corsair_usage_to_gkey(unsigned int usage)
0049 {
0050     /* G1 (0xd0) to G16 (0xdf) */
0051     if (usage >= 0xd0 && usage <= 0xdf)
0052         return usage - 0xd0 + 1;
0053     /* G17 (0xe8) to G18 (0xe9) */
0054     if (usage >= 0xe8 && usage <= 0xe9)
0055         return usage - 0xe8 + 17;
0056     return 0;
0057 }
0058 
0059 static unsigned short corsair_gkey_map[K90_GKEY_COUNT] = {
0060     BTN_TRIGGER_HAPPY1,
0061     BTN_TRIGGER_HAPPY2,
0062     BTN_TRIGGER_HAPPY3,
0063     BTN_TRIGGER_HAPPY4,
0064     BTN_TRIGGER_HAPPY5,
0065     BTN_TRIGGER_HAPPY6,
0066     BTN_TRIGGER_HAPPY7,
0067     BTN_TRIGGER_HAPPY8,
0068     BTN_TRIGGER_HAPPY9,
0069     BTN_TRIGGER_HAPPY10,
0070     BTN_TRIGGER_HAPPY11,
0071     BTN_TRIGGER_HAPPY12,
0072     BTN_TRIGGER_HAPPY13,
0073     BTN_TRIGGER_HAPPY14,
0074     BTN_TRIGGER_HAPPY15,
0075     BTN_TRIGGER_HAPPY16,
0076     BTN_TRIGGER_HAPPY17,
0077     BTN_TRIGGER_HAPPY18,
0078 };
0079 
0080 module_param_array_named(gkey_codes, corsair_gkey_map, ushort, NULL, S_IRUGO);
0081 MODULE_PARM_DESC(gkey_codes, "Key codes for the G-keys");
0082 
0083 static unsigned short corsair_record_keycodes[2] = {
0084     BTN_TRIGGER_HAPPY19,
0085     BTN_TRIGGER_HAPPY20
0086 };
0087 
0088 module_param_array_named(recordkey_codes, corsair_record_keycodes, ushort,
0089              NULL, S_IRUGO);
0090 MODULE_PARM_DESC(recordkey_codes, "Key codes for the MR (start and stop record) button");
0091 
0092 static unsigned short corsair_profile_keycodes[3] = {
0093     BTN_TRIGGER_HAPPY21,
0094     BTN_TRIGGER_HAPPY22,
0095     BTN_TRIGGER_HAPPY23
0096 };
0097 
0098 module_param_array_named(profilekey_codes, corsair_profile_keycodes, ushort,
0099              NULL, S_IRUGO);
0100 MODULE_PARM_DESC(profilekey_codes, "Key codes for the profile buttons");
0101 
0102 #define CORSAIR_USAGE_SPECIAL_MIN 0xf0
0103 #define CORSAIR_USAGE_SPECIAL_MAX 0xff
0104 
0105 #define CORSAIR_USAGE_MACRO_RECORD_START 0xf6
0106 #define CORSAIR_USAGE_MACRO_RECORD_STOP 0xf7
0107 
0108 #define CORSAIR_USAGE_PROFILE 0xf1
0109 #define CORSAIR_USAGE_M1 0xf1
0110 #define CORSAIR_USAGE_M2 0xf2
0111 #define CORSAIR_USAGE_M3 0xf3
0112 #define CORSAIR_USAGE_PROFILE_MAX 0xf3
0113 
0114 #define CORSAIR_USAGE_META_OFF 0xf4
0115 #define CORSAIR_USAGE_META_ON  0xf5
0116 
0117 #define CORSAIR_USAGE_LIGHT 0xfa
0118 #define CORSAIR_USAGE_LIGHT_OFF 0xfa
0119 #define CORSAIR_USAGE_LIGHT_DIM 0xfb
0120 #define CORSAIR_USAGE_LIGHT_MEDIUM 0xfc
0121 #define CORSAIR_USAGE_LIGHT_BRIGHT 0xfd
0122 #define CORSAIR_USAGE_LIGHT_MAX 0xfd
0123 
0124 /* USB control protocol */
0125 
0126 #define K90_REQUEST_BRIGHTNESS 49
0127 #define K90_REQUEST_MACRO_MODE 2
0128 #define K90_REQUEST_STATUS 4
0129 #define K90_REQUEST_GET_MODE 5
0130 #define K90_REQUEST_PROFILE 20
0131 
0132 #define K90_MACRO_MODE_SW 0x0030
0133 #define K90_MACRO_MODE_HW 0x0001
0134 
0135 #define K90_MACRO_LED_ON  0x0020
0136 #define K90_MACRO_LED_OFF 0x0040
0137 
0138 /*
0139  * LED class devices
0140  */
0141 
0142 #define K90_BACKLIGHT_LED_SUFFIX "::backlight"
0143 #define K90_RECORD_LED_SUFFIX "::record"
0144 
0145 static enum led_brightness k90_backlight_get(struct led_classdev *led_cdev)
0146 {
0147     int ret;
0148     struct k90_led *led = container_of(led_cdev, struct k90_led, cdev);
0149     struct device *dev = led->cdev.dev->parent;
0150     struct usb_interface *usbif = to_usb_interface(dev->parent);
0151     struct usb_device *usbdev = interface_to_usbdev(usbif);
0152     int brightness;
0153     char *data;
0154 
0155     data = kmalloc(8, GFP_KERNEL);
0156     if (!data)
0157         return -ENOMEM;
0158 
0159     ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
0160                   K90_REQUEST_STATUS,
0161                   USB_DIR_IN | USB_TYPE_VENDOR |
0162                   USB_RECIP_DEVICE, 0, 0, data, 8,
0163                   USB_CTRL_SET_TIMEOUT);
0164     if (ret < 5) {
0165         dev_warn(dev, "Failed to get K90 initial state (error %d).\n",
0166              ret);
0167         ret = -EIO;
0168         goto out;
0169     }
0170     brightness = data[4];
0171     if (brightness < 0 || brightness > 3) {
0172         dev_warn(dev,
0173              "Read invalid backlight brightness: %02hhx.\n",
0174              data[4]);
0175         ret = -EIO;
0176         goto out;
0177     }
0178     ret = brightness;
0179 out:
0180     kfree(data);
0181 
0182     return ret;
0183 }
0184 
0185 static enum led_brightness k90_record_led_get(struct led_classdev *led_cdev)
0186 {
0187     struct k90_led *led = container_of(led_cdev, struct k90_led, cdev);
0188 
0189     return led->brightness;
0190 }
0191 
0192 static void k90_brightness_set(struct led_classdev *led_cdev,
0193                    enum led_brightness brightness)
0194 {
0195     struct k90_led *led = container_of(led_cdev, struct k90_led, cdev);
0196 
0197     led->brightness = brightness;
0198     schedule_work(&led->work);
0199 }
0200 
0201 static void k90_backlight_work(struct work_struct *work)
0202 {
0203     int ret;
0204     struct k90_led *led = container_of(work, struct k90_led, work);
0205     struct device *dev;
0206     struct usb_interface *usbif;
0207     struct usb_device *usbdev;
0208 
0209     if (led->removed)
0210         return;
0211 
0212     dev = led->cdev.dev->parent;
0213     usbif = to_usb_interface(dev->parent);
0214     usbdev = interface_to_usbdev(usbif);
0215 
0216     ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
0217                   K90_REQUEST_BRIGHTNESS,
0218                   USB_DIR_OUT | USB_TYPE_VENDOR |
0219                   USB_RECIP_DEVICE, led->brightness, 0,
0220                   NULL, 0, USB_CTRL_SET_TIMEOUT);
0221     if (ret != 0)
0222         dev_warn(dev, "Failed to set backlight brightness (error: %d).\n",
0223              ret);
0224 }
0225 
0226 static void k90_record_led_work(struct work_struct *work)
0227 {
0228     int ret;
0229     struct k90_led *led = container_of(work, struct k90_led, work);
0230     struct device *dev;
0231     struct usb_interface *usbif;
0232     struct usb_device *usbdev;
0233     int value;
0234 
0235     if (led->removed)
0236         return;
0237 
0238     dev = led->cdev.dev->parent;
0239     usbif = to_usb_interface(dev->parent);
0240     usbdev = interface_to_usbdev(usbif);
0241 
0242     if (led->brightness > 0)
0243         value = K90_MACRO_LED_ON;
0244     else
0245         value = K90_MACRO_LED_OFF;
0246 
0247     ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
0248                   K90_REQUEST_MACRO_MODE,
0249                   USB_DIR_OUT | USB_TYPE_VENDOR |
0250                   USB_RECIP_DEVICE, value, 0, NULL, 0,
0251                   USB_CTRL_SET_TIMEOUT);
0252     if (ret != 0)
0253         dev_warn(dev, "Failed to set record LED state (error: %d).\n",
0254              ret);
0255 }
0256 
0257 /*
0258  * Keyboard attributes
0259  */
0260 
0261 static ssize_t k90_show_macro_mode(struct device *dev,
0262                    struct device_attribute *attr, char *buf)
0263 {
0264     int ret;
0265     struct usb_interface *usbif = to_usb_interface(dev->parent);
0266     struct usb_device *usbdev = interface_to_usbdev(usbif);
0267     const char *macro_mode;
0268     char *data;
0269 
0270     data = kmalloc(2, GFP_KERNEL);
0271     if (!data)
0272         return -ENOMEM;
0273 
0274     ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
0275                   K90_REQUEST_GET_MODE,
0276                   USB_DIR_IN | USB_TYPE_VENDOR |
0277                   USB_RECIP_DEVICE, 0, 0, data, 2,
0278                   USB_CTRL_SET_TIMEOUT);
0279     if (ret < 1) {
0280         dev_warn(dev, "Failed to get K90 initial mode (error %d).\n",
0281              ret);
0282         ret = -EIO;
0283         goto out;
0284     }
0285 
0286     switch (data[0]) {
0287     case K90_MACRO_MODE_HW:
0288         macro_mode = "HW";
0289         break;
0290 
0291     case K90_MACRO_MODE_SW:
0292         macro_mode = "SW";
0293         break;
0294     default:
0295         dev_warn(dev, "K90 in unknown mode: %02hhx.\n",
0296              data[0]);
0297         ret = -EIO;
0298         goto out;
0299     }
0300 
0301     ret = snprintf(buf, PAGE_SIZE, "%s\n", macro_mode);
0302 out:
0303     kfree(data);
0304 
0305     return ret;
0306 }
0307 
0308 static ssize_t k90_store_macro_mode(struct device *dev,
0309                     struct device_attribute *attr,
0310                     const char *buf, size_t count)
0311 {
0312     int ret;
0313     struct usb_interface *usbif = to_usb_interface(dev->parent);
0314     struct usb_device *usbdev = interface_to_usbdev(usbif);
0315     __u16 value;
0316 
0317     if (strncmp(buf, "SW", 2) == 0)
0318         value = K90_MACRO_MODE_SW;
0319     else if (strncmp(buf, "HW", 2) == 0)
0320         value = K90_MACRO_MODE_HW;
0321     else
0322         return -EINVAL;
0323 
0324     ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
0325                   K90_REQUEST_MACRO_MODE,
0326                   USB_DIR_OUT | USB_TYPE_VENDOR |
0327                   USB_RECIP_DEVICE, value, 0, NULL, 0,
0328                   USB_CTRL_SET_TIMEOUT);
0329     if (ret != 0) {
0330         dev_warn(dev, "Failed to set macro mode.\n");
0331         return ret;
0332     }
0333 
0334     return count;
0335 }
0336 
0337 static ssize_t k90_show_current_profile(struct device *dev,
0338                     struct device_attribute *attr,
0339                     char *buf)
0340 {
0341     int ret;
0342     struct usb_interface *usbif = to_usb_interface(dev->parent);
0343     struct usb_device *usbdev = interface_to_usbdev(usbif);
0344     int current_profile;
0345     char *data;
0346 
0347     data = kmalloc(8, GFP_KERNEL);
0348     if (!data)
0349         return -ENOMEM;
0350 
0351     ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
0352                   K90_REQUEST_STATUS,
0353                   USB_DIR_IN | USB_TYPE_VENDOR |
0354                   USB_RECIP_DEVICE, 0, 0, data, 8,
0355                   USB_CTRL_SET_TIMEOUT);
0356     if (ret < 8) {
0357         dev_warn(dev, "Failed to get K90 initial state (error %d).\n",
0358              ret);
0359         ret = -EIO;
0360         goto out;
0361     }
0362     current_profile = data[7];
0363     if (current_profile < 1 || current_profile > 3) {
0364         dev_warn(dev, "Read invalid current profile: %02hhx.\n",
0365              data[7]);
0366         ret = -EIO;
0367         goto out;
0368     }
0369 
0370     ret = snprintf(buf, PAGE_SIZE, "%d\n", current_profile);
0371 out:
0372     kfree(data);
0373 
0374     return ret;
0375 }
0376 
0377 static ssize_t k90_store_current_profile(struct device *dev,
0378                      struct device_attribute *attr,
0379                      const char *buf, size_t count)
0380 {
0381     int ret;
0382     struct usb_interface *usbif = to_usb_interface(dev->parent);
0383     struct usb_device *usbdev = interface_to_usbdev(usbif);
0384     int profile;
0385 
0386     if (kstrtoint(buf, 10, &profile))
0387         return -EINVAL;
0388     if (profile < 1 || profile > 3)
0389         return -EINVAL;
0390 
0391     ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
0392                   K90_REQUEST_PROFILE,
0393                   USB_DIR_OUT | USB_TYPE_VENDOR |
0394                   USB_RECIP_DEVICE, profile, 0, NULL, 0,
0395                   USB_CTRL_SET_TIMEOUT);
0396     if (ret != 0) {
0397         dev_warn(dev, "Failed to change current profile (error %d).\n",
0398              ret);
0399         return ret;
0400     }
0401 
0402     return count;
0403 }
0404 
0405 static DEVICE_ATTR(macro_mode, 0644, k90_show_macro_mode, k90_store_macro_mode);
0406 static DEVICE_ATTR(current_profile, 0644, k90_show_current_profile,
0407            k90_store_current_profile);
0408 
0409 static struct attribute *k90_attrs[] = {
0410     &dev_attr_macro_mode.attr,
0411     &dev_attr_current_profile.attr,
0412     NULL
0413 };
0414 
0415 static const struct attribute_group k90_attr_group = {
0416     .attrs = k90_attrs,
0417 };
0418 
0419 /*
0420  * Driver functions
0421  */
0422 
0423 static int k90_init_backlight(struct hid_device *dev)
0424 {
0425     int ret;
0426     struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
0427     size_t name_sz;
0428     char *name;
0429 
0430     drvdata->backlight = kzalloc(sizeof(struct k90_led), GFP_KERNEL);
0431     if (!drvdata->backlight) {
0432         ret = -ENOMEM;
0433         goto fail_backlight_alloc;
0434     }
0435 
0436     name_sz =
0437         strlen(dev_name(&dev->dev)) + sizeof(K90_BACKLIGHT_LED_SUFFIX);
0438     name = kzalloc(name_sz, GFP_KERNEL);
0439     if (!name) {
0440         ret = -ENOMEM;
0441         goto fail_name_alloc;
0442     }
0443     snprintf(name, name_sz, "%s" K90_BACKLIGHT_LED_SUFFIX,
0444          dev_name(&dev->dev));
0445     drvdata->backlight->removed = false;
0446     drvdata->backlight->cdev.name = name;
0447     drvdata->backlight->cdev.max_brightness = 3;
0448     drvdata->backlight->cdev.brightness_set = k90_brightness_set;
0449     drvdata->backlight->cdev.brightness_get = k90_backlight_get;
0450     INIT_WORK(&drvdata->backlight->work, k90_backlight_work);
0451     ret = led_classdev_register(&dev->dev, &drvdata->backlight->cdev);
0452     if (ret != 0)
0453         goto fail_register_cdev;
0454 
0455     return 0;
0456 
0457 fail_register_cdev:
0458     kfree(drvdata->backlight->cdev.name);
0459 fail_name_alloc:
0460     kfree(drvdata->backlight);
0461     drvdata->backlight = NULL;
0462 fail_backlight_alloc:
0463     return ret;
0464 }
0465 
0466 static int k90_init_macro_functions(struct hid_device *dev)
0467 {
0468     int ret;
0469     struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
0470     struct k90_drvdata *k90;
0471     size_t name_sz;
0472     char *name;
0473 
0474     k90 = kzalloc(sizeof(struct k90_drvdata), GFP_KERNEL);
0475     if (!k90) {
0476         ret = -ENOMEM;
0477         goto fail_drvdata;
0478     }
0479     drvdata->k90 = k90;
0480 
0481     /* Init LED device for record LED */
0482     name_sz = strlen(dev_name(&dev->dev)) + sizeof(K90_RECORD_LED_SUFFIX);
0483     name = kzalloc(name_sz, GFP_KERNEL);
0484     if (!name) {
0485         ret = -ENOMEM;
0486         goto fail_record_led_alloc;
0487     }
0488     snprintf(name, name_sz, "%s" K90_RECORD_LED_SUFFIX,
0489          dev_name(&dev->dev));
0490     k90->record_led.removed = false;
0491     k90->record_led.cdev.name = name;
0492     k90->record_led.cdev.max_brightness = 1;
0493     k90->record_led.cdev.brightness_set = k90_brightness_set;
0494     k90->record_led.cdev.brightness_get = k90_record_led_get;
0495     INIT_WORK(&k90->record_led.work, k90_record_led_work);
0496     k90->record_led.brightness = 0;
0497     ret = led_classdev_register(&dev->dev, &k90->record_led.cdev);
0498     if (ret != 0)
0499         goto fail_record_led;
0500 
0501     /* Init attributes */
0502     ret = sysfs_create_group(&dev->dev.kobj, &k90_attr_group);
0503     if (ret != 0)
0504         goto fail_sysfs;
0505 
0506     return 0;
0507 
0508 fail_sysfs:
0509     k90->record_led.removed = true;
0510     led_classdev_unregister(&k90->record_led.cdev);
0511     cancel_work_sync(&k90->record_led.work);
0512 fail_record_led:
0513     kfree(k90->record_led.cdev.name);
0514 fail_record_led_alloc:
0515     kfree(k90);
0516 fail_drvdata:
0517     drvdata->k90 = NULL;
0518     return ret;
0519 }
0520 
0521 static void k90_cleanup_backlight(struct hid_device *dev)
0522 {
0523     struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
0524 
0525     if (drvdata->backlight) {
0526         drvdata->backlight->removed = true;
0527         led_classdev_unregister(&drvdata->backlight->cdev);
0528         cancel_work_sync(&drvdata->backlight->work);
0529         kfree(drvdata->backlight->cdev.name);
0530         kfree(drvdata->backlight);
0531     }
0532 }
0533 
0534 static void k90_cleanup_macro_functions(struct hid_device *dev)
0535 {
0536     struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
0537     struct k90_drvdata *k90 = drvdata->k90;
0538 
0539     if (k90) {
0540         sysfs_remove_group(&dev->dev.kobj, &k90_attr_group);
0541 
0542         k90->record_led.removed = true;
0543         led_classdev_unregister(&k90->record_led.cdev);
0544         cancel_work_sync(&k90->record_led.work);
0545         kfree(k90->record_led.cdev.name);
0546 
0547         kfree(k90);
0548     }
0549 }
0550 
0551 static int corsair_probe(struct hid_device *dev, const struct hid_device_id *id)
0552 {
0553     int ret;
0554     unsigned long quirks = id->driver_data;
0555     struct corsair_drvdata *drvdata;
0556     struct usb_interface *usbif;
0557 
0558     if (!hid_is_usb(dev))
0559         return -EINVAL;
0560 
0561     usbif = to_usb_interface(dev->dev.parent);
0562 
0563     drvdata = devm_kzalloc(&dev->dev, sizeof(struct corsair_drvdata),
0564                    GFP_KERNEL);
0565     if (drvdata == NULL)
0566         return -ENOMEM;
0567     drvdata->quirks = quirks;
0568     hid_set_drvdata(dev, drvdata);
0569 
0570     ret = hid_parse(dev);
0571     if (ret != 0) {
0572         hid_err(dev, "parse failed\n");
0573         return ret;
0574     }
0575     ret = hid_hw_start(dev, HID_CONNECT_DEFAULT);
0576     if (ret != 0) {
0577         hid_err(dev, "hw start failed\n");
0578         return ret;
0579     }
0580 
0581     if (usbif->cur_altsetting->desc.bInterfaceNumber == 0) {
0582         if (quirks & CORSAIR_USE_K90_MACRO) {
0583             ret = k90_init_macro_functions(dev);
0584             if (ret != 0)
0585                 hid_warn(dev, "Failed to initialize K90 macro functions.\n");
0586         }
0587         if (quirks & CORSAIR_USE_K90_BACKLIGHT) {
0588             ret = k90_init_backlight(dev);
0589             if (ret != 0)
0590                 hid_warn(dev, "Failed to initialize K90 backlight.\n");
0591         }
0592     }
0593 
0594     return 0;
0595 }
0596 
0597 static void corsair_remove(struct hid_device *dev)
0598 {
0599     k90_cleanup_macro_functions(dev);
0600     k90_cleanup_backlight(dev);
0601 
0602     hid_hw_stop(dev);
0603 }
0604 
0605 static int corsair_event(struct hid_device *dev, struct hid_field *field,
0606              struct hid_usage *usage, __s32 value)
0607 {
0608     struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
0609 
0610     if (!drvdata->k90)
0611         return 0;
0612 
0613     switch (usage->hid & HID_USAGE) {
0614     case CORSAIR_USAGE_MACRO_RECORD_START:
0615         drvdata->k90->record_led.brightness = 1;
0616         break;
0617     case CORSAIR_USAGE_MACRO_RECORD_STOP:
0618         drvdata->k90->record_led.brightness = 0;
0619         break;
0620     default:
0621         break;
0622     }
0623 
0624     return 0;
0625 }
0626 
0627 static int corsair_input_mapping(struct hid_device *dev,
0628                  struct hid_input *input,
0629                  struct hid_field *field,
0630                  struct hid_usage *usage, unsigned long **bit,
0631                  int *max)
0632 {
0633     int gkey;
0634 
0635     if ((usage->hid & HID_USAGE_PAGE) != HID_UP_KEYBOARD)
0636         return 0;
0637 
0638     gkey = corsair_usage_to_gkey(usage->hid & HID_USAGE);
0639     if (gkey != 0) {
0640         hid_map_usage_clear(input, usage, bit, max, EV_KEY,
0641                     corsair_gkey_map[gkey - 1]);
0642         return 1;
0643     }
0644     if ((usage->hid & HID_USAGE) >= CORSAIR_USAGE_SPECIAL_MIN &&
0645         (usage->hid & HID_USAGE) <= CORSAIR_USAGE_SPECIAL_MAX) {
0646         switch (usage->hid & HID_USAGE) {
0647         case CORSAIR_USAGE_MACRO_RECORD_START:
0648             hid_map_usage_clear(input, usage, bit, max, EV_KEY,
0649                         corsair_record_keycodes[0]);
0650             return 1;
0651 
0652         case CORSAIR_USAGE_MACRO_RECORD_STOP:
0653             hid_map_usage_clear(input, usage, bit, max, EV_KEY,
0654                         corsair_record_keycodes[1]);
0655             return 1;
0656 
0657         case CORSAIR_USAGE_M1:
0658             hid_map_usage_clear(input, usage, bit, max, EV_KEY,
0659                         corsair_profile_keycodes[0]);
0660             return 1;
0661 
0662         case CORSAIR_USAGE_M2:
0663             hid_map_usage_clear(input, usage, bit, max, EV_KEY,
0664                         corsair_profile_keycodes[1]);
0665             return 1;
0666 
0667         case CORSAIR_USAGE_M3:
0668             hid_map_usage_clear(input, usage, bit, max, EV_KEY,
0669                         corsair_profile_keycodes[2]);
0670             return 1;
0671 
0672         default:
0673             return -1;
0674         }
0675     }
0676 
0677     return 0;
0678 }
0679 
0680 /*
0681  * The report descriptor of some of the Corsair gaming mice is
0682  * non parseable as they define two consecutive Logical Minimum for
0683  * the Usage Page (Consumer) in rdescs bytes 75 and 77 being 77 0x16
0684  * that should be obviousy 0x26 for Logical Magimum of 16 bits. This
0685  * prevents poper parsing of the report descriptor due Logical
0686  * Minimum being larger than Logical Maximum.
0687  *
0688  * This driver fixes the report descriptor for:
0689  * - USB ID 1b1c:1b34, sold as GLAIVE RGB Gaming mouse
0690  * - USB ID 1b1c:1b3e, sold as Scimitar RGB Pro Gaming mouse
0691  */
0692 
0693 static __u8 *corsair_mouse_report_fixup(struct hid_device *hdev, __u8 *rdesc,
0694         unsigned int *rsize)
0695 {
0696     struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
0697 
0698     if (intf->cur_altsetting->desc.bInterfaceNumber == 1) {
0699         /*
0700          * Corsair GLAIVE RGB and Scimitar RGB Pro report descriptor is
0701          * broken and defines two different Logical Minimum for the
0702          * Consumer Application. The byte 77 should be a 0x26 defining
0703          * a 16 bits integer for the Logical Maximum but it is a 0x16
0704          * instead (Logical Minimum)
0705          */
0706         switch (hdev->product) {
0707         case USB_DEVICE_ID_CORSAIR_GLAIVE_RGB:
0708         case USB_DEVICE_ID_CORSAIR_SCIMITAR_PRO_RGB:
0709             if (*rsize >= 172 && rdesc[75] == 0x15 && rdesc[77] == 0x16
0710             && rdesc[78] == 0xff && rdesc[79] == 0x0f) {
0711                 hid_info(hdev, "Fixing up report descriptor\n");
0712                 rdesc[77] = 0x26;
0713             }
0714             break;
0715         }
0716 
0717     }
0718     return rdesc;
0719 }
0720 
0721 static const struct hid_device_id corsair_devices[] = {
0722     { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_K90),
0723         .driver_data = CORSAIR_USE_K90_MACRO |
0724                    CORSAIR_USE_K90_BACKLIGHT },
0725     { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR,
0726             USB_DEVICE_ID_CORSAIR_GLAIVE_RGB) },
0727     { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR,
0728             USB_DEVICE_ID_CORSAIR_SCIMITAR_PRO_RGB) },
0729     /*
0730      * Vengeance K70 and K70 RAPIDFIRE share product IDs.
0731      */
0732     { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR,
0733             USB_DEVICE_ID_CORSAIR_K70R) },
0734     {}
0735 };
0736 
0737 MODULE_DEVICE_TABLE(hid, corsair_devices);
0738 
0739 static struct hid_driver corsair_driver = {
0740     .name = "corsair",
0741     .id_table = corsair_devices,
0742     .probe = corsair_probe,
0743     .event = corsair_event,
0744     .remove = corsair_remove,
0745     .input_mapping = corsair_input_mapping,
0746     .report_fixup = corsair_mouse_report_fixup,
0747 };
0748 
0749 module_hid_driver(corsair_driver);
0750 
0751 MODULE_LICENSE("GPL");
0752 /* Original K90 driver author */
0753 MODULE_AUTHOR("Clement Vuchener");
0754 /* Scimitar PRO RGB driver author */
0755 MODULE_AUTHOR("Oscar Campos");
0756 MODULE_DESCRIPTION("HID driver for Corsair devices");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!