// SPDX-License-Identifier: GPL-2.0-or-later
/*
 * HID driver for Corsair devices
 *
 * Supported devices:
 *  - Vengeance K70 Keyboard
 *  - K70 RAPIDFIRE Keyboard
 *  - Vengeance K90 Keyboard
 *  - Scimitar PRO RGB Gaming Mouse
 *
 * Copyright (c) 2015 Clement Vuchener
 * Copyright (c) 2017 Oscar Campos
 * Copyright (c) 2017 Aaron Bottegal
 */

/*
 */

#include <linux/hid.h>
#include <linux/module.h>
#include <linux/usb.h>
#include <linux/leds.h>

#include "hid-ids.h"

#define CORSAIR_USE_K90_MACRO   (1<<0)
#define CORSAIR_USE_K90_BACKLIGHT       (1<<1)

struct k90_led {
        struct led_classdev cdev;
        int brightness;
        struct work_struct work;
        bool removed;
};

struct k90_drvdata {
        struct k90_led record_led;
};

struct corsair_drvdata {
        unsigned long quirks;
        struct k90_drvdata *k90;
        struct k90_led *backlight;
};

#define K90_GKEY_COUNT  18

static int corsair_usage_to_gkey(unsigned int usage)
{
        /* G1 (0xd0) to G16 (0xdf) */
        if (usage >= 0xd0 && usage <= 0xdf)
                return usage - 0xd0 + 1;
        /* G17 (0xe8) to G18 (0xe9) */
        if (usage >= 0xe8 && usage <= 0xe9)
                return usage - 0xe8 + 17;
        return 0;
}

static unsigned short corsair_gkey_map[K90_GKEY_COUNT] = {
        BTN_TRIGGER_HAPPY1,
        BTN_TRIGGER_HAPPY2,
        BTN_TRIGGER_HAPPY3,
        BTN_TRIGGER_HAPPY4,
        BTN_TRIGGER_HAPPY5,
        BTN_TRIGGER_HAPPY6,
        BTN_TRIGGER_HAPPY7,
        BTN_TRIGGER_HAPPY8,
        BTN_TRIGGER_HAPPY9,
        BTN_TRIGGER_HAPPY10,
        BTN_TRIGGER_HAPPY11,
        BTN_TRIGGER_HAPPY12,
        BTN_TRIGGER_HAPPY13,
        BTN_TRIGGER_HAPPY14,
        BTN_TRIGGER_HAPPY15,
        BTN_TRIGGER_HAPPY16,
        BTN_TRIGGER_HAPPY17,
        BTN_TRIGGER_HAPPY18,
};

module_param_array_named(gkey_codes, corsair_gkey_map, ushort, NULL, S_IRUGO);
MODULE_PARM_DESC(gkey_codes, "Key codes for the G-keys");

static unsigned short corsair_record_keycodes[2] = {
        BTN_TRIGGER_HAPPY19,
        BTN_TRIGGER_HAPPY20
};

module_param_array_named(recordkey_codes, corsair_record_keycodes, ushort,
                         NULL, S_IRUGO);
MODULE_PARM_DESC(recordkey_codes, "Key codes for the MR (start and stop record) button");

static unsigned short corsair_profile_keycodes[3] = {
        BTN_TRIGGER_HAPPY21,
        BTN_TRIGGER_HAPPY22,
        BTN_TRIGGER_HAPPY23
};

module_param_array_named(profilekey_codes, corsair_profile_keycodes, ushort,
                         NULL, S_IRUGO);
MODULE_PARM_DESC(profilekey_codes, "Key codes for the profile buttons");

#define CORSAIR_USAGE_SPECIAL_MIN 0xf0
#define CORSAIR_USAGE_SPECIAL_MAX 0xff

#define CORSAIR_USAGE_MACRO_RECORD_START 0xf6
#define CORSAIR_USAGE_MACRO_RECORD_STOP 0xf7

#define CORSAIR_USAGE_PROFILE 0xf1
#define CORSAIR_USAGE_M1 0xf1
#define CORSAIR_USAGE_M2 0xf2
#define CORSAIR_USAGE_M3 0xf3
#define CORSAIR_USAGE_PROFILE_MAX 0xf3

#define CORSAIR_USAGE_META_OFF 0xf4
#define CORSAIR_USAGE_META_ON  0xf5

#define CORSAIR_USAGE_LIGHT 0xfa
#define CORSAIR_USAGE_LIGHT_OFF 0xfa
#define CORSAIR_USAGE_LIGHT_DIM 0xfb
#define CORSAIR_USAGE_LIGHT_MEDIUM 0xfc
#define CORSAIR_USAGE_LIGHT_BRIGHT 0xfd
#define CORSAIR_USAGE_LIGHT_MAX 0xfd

/* USB control protocol */

#define K90_REQUEST_BRIGHTNESS 49
#define K90_REQUEST_MACRO_MODE 2
#define K90_REQUEST_STATUS 4
#define K90_REQUEST_GET_MODE 5
#define K90_REQUEST_PROFILE 20

#define K90_MACRO_MODE_SW 0x0030
#define K90_MACRO_MODE_HW 0x0001

#define K90_MACRO_LED_ON  0x0020
#define K90_MACRO_LED_OFF 0x0040

/*
 * LED class devices
 */

#define K90_BACKLIGHT_LED_SUFFIX "::backlight"
#define K90_RECORD_LED_SUFFIX "::record"

static enum led_brightness k90_backlight_get(struct led_classdev *led_cdev)
{
        int ret;
        struct k90_led *led = container_of(led_cdev, struct k90_led, cdev);
        struct device *dev = led->cdev.dev->parent;
        struct usb_interface *usbif = to_usb_interface(dev->parent);
        struct usb_device *usbdev = interface_to_usbdev(usbif);
        int brightness;
        char *data;

        data = kmalloc(8, GFP_KERNEL);
        if (!data)
                return -ENOMEM;

        ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
                              K90_REQUEST_STATUS,
                              USB_DIR_IN | USB_TYPE_VENDOR |
                              USB_RECIP_DEVICE, 0, 0, data, 8,
                              USB_CTRL_SET_TIMEOUT);
        if (ret < 5) {
                dev_warn(dev, "Failed to get K90 initial state (error %d).\n",
                         ret);
                ret = -EIO;
                goto out;
        }
        brightness = data[4];
        if (brightness < 0 || brightness > 3) {
                dev_warn(dev,
                         "Read invalid backlight brightness: %02hhx.\n",
                         data[4]);
                ret = -EIO;
                goto out;
        }
        ret = brightness;
out:
        kfree(data);

        return ret;
}

static enum led_brightness k90_record_led_get(struct led_classdev *led_cdev)
{
        struct k90_led *led = container_of(led_cdev, struct k90_led, cdev);

        return led->brightness;
}

static void k90_brightness_set(struct led_classdev *led_cdev,
                               enum led_brightness brightness)
{
        struct k90_led *led = container_of(led_cdev, struct k90_led, cdev);

        led->brightness = brightness;
        schedule_work(&led->work);
}

static void k90_backlight_work(struct work_struct *work)
{
        int ret;
        struct k90_led *led = container_of(work, struct k90_led, work);
        struct device *dev;
        struct usb_interface *usbif;
        struct usb_device *usbdev;

        if (led->removed)
                return;

        dev = led->cdev.dev->parent;
        usbif = to_usb_interface(dev->parent);
        usbdev = interface_to_usbdev(usbif);

        ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
                              K90_REQUEST_BRIGHTNESS,
                              USB_DIR_OUT | USB_TYPE_VENDOR |
                              USB_RECIP_DEVICE, led->brightness, 0,
                              NULL, 0, USB_CTRL_SET_TIMEOUT);
        if (ret != 0)
                dev_warn(dev, "Failed to set backlight brightness (error: %d).\n",
                         ret);
}

static void k90_record_led_work(struct work_struct *work)
{
        int ret;
        struct k90_led *led = container_of(work, struct k90_led, work);
        struct device *dev;
        struct usb_interface *usbif;
        struct usb_device *usbdev;
        int value;

        if (led->removed)
                return;

        dev = led->cdev.dev->parent;
        usbif = to_usb_interface(dev->parent);
        usbdev = interface_to_usbdev(usbif);

        if (led->brightness > 0)
                value = K90_MACRO_LED_ON;
        else
                value = K90_MACRO_LED_OFF;

        ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
                              K90_REQUEST_MACRO_MODE,
                              USB_DIR_OUT | USB_TYPE_VENDOR |
                              USB_RECIP_DEVICE, value, 0, NULL, 0,
                              USB_CTRL_SET_TIMEOUT);
        if (ret != 0)
                dev_warn(dev, "Failed to set record LED state (error: %d).\n",
                         ret);
}

/*
 * Keyboard attributes
 */

static ssize_t k90_show_macro_mode(struct device *dev,
                                   struct device_attribute *attr, char *buf)
{
        int ret;
        struct usb_interface *usbif = to_usb_interface(dev->parent);
        struct usb_device *usbdev = interface_to_usbdev(usbif);
        const char *macro_mode;
        char *data;

        data = kmalloc(2, GFP_KERNEL);
        if (!data)
                return -ENOMEM;

        ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
                              K90_REQUEST_GET_MODE,
                              USB_DIR_IN | USB_TYPE_VENDOR |
                              USB_RECIP_DEVICE, 0, 0, data, 2,
                              USB_CTRL_SET_TIMEOUT);
        if (ret < 1) {
                dev_warn(dev, "Failed to get K90 initial mode (error %d).\n",
                         ret);
                ret = -EIO;
                goto out;
        }

        switch (data[0]) {
        case K90_MACRO_MODE_HW:
                macro_mode = "HW";
                break;

        case K90_MACRO_MODE_SW:
                macro_mode = "SW";
                break;
        default:
                dev_warn(dev, "K90 in unknown mode: %02hhx.\n",
                         data[0]);
                ret = -EIO;
                goto out;
        }

        ret = sysfs_emit(buf, "%s\n", macro_mode);
out:
        kfree(data);

        return ret;
}

static ssize_t k90_store_macro_mode(struct device *dev,
                                    struct device_attribute *attr,
                                    const char *buf, size_t count)
{
        int ret;
        struct usb_interface *usbif = to_usb_interface(dev->parent);
        struct usb_device *usbdev = interface_to_usbdev(usbif);
        __u16 value;

        if (strncmp(buf, "SW", 2) == 0)
                value = K90_MACRO_MODE_SW;
        else if (strncmp(buf, "HW", 2) == 0)
                value = K90_MACRO_MODE_HW;
        else
                return -EINVAL;

        ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
                              K90_REQUEST_MACRO_MODE,
                              USB_DIR_OUT | USB_TYPE_VENDOR |
                              USB_RECIP_DEVICE, value, 0, NULL, 0,
                              USB_CTRL_SET_TIMEOUT);
        if (ret != 0) {
                dev_warn(dev, "Failed to set macro mode.\n");
                return ret;
        }

        return count;
}

static ssize_t k90_show_current_profile(struct device *dev,
                                        struct device_attribute *attr,
                                        char *buf)
{
        int ret;
        struct usb_interface *usbif = to_usb_interface(dev->parent);
        struct usb_device *usbdev = interface_to_usbdev(usbif);
        int current_profile;
        char *data;

        data = kmalloc(8, GFP_KERNEL);
        if (!data)
                return -ENOMEM;

        ret = usb_control_msg(usbdev, usb_rcvctrlpipe(usbdev, 0),
                              K90_REQUEST_STATUS,
                              USB_DIR_IN | USB_TYPE_VENDOR |
                              USB_RECIP_DEVICE, 0, 0, data, 8,
                              USB_CTRL_SET_TIMEOUT);
        if (ret < 8) {
                dev_warn(dev, "Failed to get K90 initial state (error %d).\n",
                         ret);
                ret = -EIO;
                goto out;
        }
        current_profile = data[7];
        if (current_profile < 1 || current_profile > 3) {
                dev_warn(dev, "Read invalid current profile: %02hhx.\n",
                         data[7]);
                ret = -EIO;
                goto out;
        }

        ret = sysfs_emit(buf, "%d\n", current_profile);
out:
        kfree(data);

        return ret;
}

static ssize_t k90_store_current_profile(struct device *dev,
                                         struct device_attribute *attr,
                                         const char *buf, size_t count)
{
        int ret;
        struct usb_interface *usbif = to_usb_interface(dev->parent);
        struct usb_device *usbdev = interface_to_usbdev(usbif);
        int profile;

        if (kstrtoint(buf, 10, &profile))
                return -EINVAL;
        if (profile < 1 || profile > 3)
                return -EINVAL;

        ret = usb_control_msg(usbdev, usb_sndctrlpipe(usbdev, 0),
                              K90_REQUEST_PROFILE,
                              USB_DIR_OUT | USB_TYPE_VENDOR |
                              USB_RECIP_DEVICE, profile, 0, NULL, 0,
                              USB_CTRL_SET_TIMEOUT);
        if (ret != 0) {
                dev_warn(dev, "Failed to change current profile (error %d).\n",
                         ret);
                return ret;
        }

        return count;
}

static DEVICE_ATTR(macro_mode, 0644, k90_show_macro_mode, k90_store_macro_mode);
static DEVICE_ATTR(current_profile, 0644, k90_show_current_profile,
                   k90_store_current_profile);

static struct attribute *k90_attrs[] = {
        &dev_attr_macro_mode.attr,
        &dev_attr_current_profile.attr,
        NULL
};

static const struct attribute_group k90_attr_group = {
        .attrs = k90_attrs,
};

/*
 * Driver functions
 */

static int k90_init_backlight(struct hid_device *dev)
{
        int ret;
        struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
        size_t name_sz;
        char *name;

        drvdata->backlight = kzalloc_obj(struct k90_led);
        if (!drvdata->backlight) {
                ret = -ENOMEM;
                goto fail_backlight_alloc;
        }

        name_sz =
            strlen(dev_name(&dev->dev)) + sizeof(K90_BACKLIGHT_LED_SUFFIX);
        name = kzalloc(name_sz, GFP_KERNEL);
        if (!name) {
                ret = -ENOMEM;
                goto fail_name_alloc;
        }
        snprintf(name, name_sz, "%s" K90_BACKLIGHT_LED_SUFFIX,
                 dev_name(&dev->dev));
        drvdata->backlight->removed = false;
        drvdata->backlight->cdev.name = name;
        drvdata->backlight->cdev.max_brightness = 3;
        drvdata->backlight->cdev.brightness_set = k90_brightness_set;
        drvdata->backlight->cdev.brightness_get = k90_backlight_get;
        INIT_WORK(&drvdata->backlight->work, k90_backlight_work);
        ret = led_classdev_register(&dev->dev, &drvdata->backlight->cdev);
        if (ret != 0)
                goto fail_register_cdev;

        return 0;

fail_register_cdev:
        kfree(drvdata->backlight->cdev.name);
fail_name_alloc:
        kfree(drvdata->backlight);
        drvdata->backlight = NULL;
fail_backlight_alloc:
        return ret;
}

static int k90_init_macro_functions(struct hid_device *dev)
{
        int ret;
        struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
        struct k90_drvdata *k90;
        size_t name_sz;
        char *name;

        k90 = kzalloc_obj(struct k90_drvdata);
        if (!k90) {
                ret = -ENOMEM;
                goto fail_drvdata;
        }
        drvdata->k90 = k90;

        /* Init LED device for record LED */
        name_sz = strlen(dev_name(&dev->dev)) + sizeof(K90_RECORD_LED_SUFFIX);
        name = kzalloc(name_sz, GFP_KERNEL);
        if (!name) {
                ret = -ENOMEM;
                goto fail_record_led_alloc;
        }
        snprintf(name, name_sz, "%s" K90_RECORD_LED_SUFFIX,
                 dev_name(&dev->dev));
        k90->record_led.removed = false;
        k90->record_led.cdev.name = name;
        k90->record_led.cdev.max_brightness = 1;
        k90->record_led.cdev.brightness_set = k90_brightness_set;
        k90->record_led.cdev.brightness_get = k90_record_led_get;
        INIT_WORK(&k90->record_led.work, k90_record_led_work);
        k90->record_led.brightness = 0;
        ret = led_classdev_register(&dev->dev, &k90->record_led.cdev);
        if (ret != 0)
                goto fail_record_led;

        /* Init attributes */
        ret = sysfs_create_group(&dev->dev.kobj, &k90_attr_group);
        if (ret != 0)
                goto fail_sysfs;

        return 0;

fail_sysfs:
        k90->record_led.removed = true;
        led_classdev_unregister(&k90->record_led.cdev);
        cancel_work_sync(&k90->record_led.work);
fail_record_led:
        kfree(k90->record_led.cdev.name);
fail_record_led_alloc:
        kfree(k90);
fail_drvdata:
        drvdata->k90 = NULL;
        return ret;
}

static void k90_cleanup_backlight(struct hid_device *dev)
{
        struct corsair_drvdata *drvdata = hid_get_drvdata(dev);

        if (drvdata->backlight) {
                drvdata->backlight->removed = true;
                led_classdev_unregister(&drvdata->backlight->cdev);
                cancel_work_sync(&drvdata->backlight->work);
                kfree(drvdata->backlight->cdev.name);
                kfree(drvdata->backlight);
        }
}

static void k90_cleanup_macro_functions(struct hid_device *dev)
{
        struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
        struct k90_drvdata *k90 = drvdata->k90;

        if (k90) {
                sysfs_remove_group(&dev->dev.kobj, &k90_attr_group);

                k90->record_led.removed = true;
                led_classdev_unregister(&k90->record_led.cdev);
                cancel_work_sync(&k90->record_led.work);
                kfree(k90->record_led.cdev.name);

                kfree(k90);
        }
}

static int corsair_probe(struct hid_device *dev, const struct hid_device_id *id)
{
        int ret;
        unsigned long quirks = id->driver_data;
        struct corsair_drvdata *drvdata;
        struct usb_interface *usbif;

        if (!hid_is_usb(dev))
                return -EINVAL;

        usbif = to_usb_interface(dev->dev.parent);

        drvdata = devm_kzalloc(&dev->dev, sizeof(struct corsair_drvdata),
                               GFP_KERNEL);
        if (drvdata == NULL)
                return -ENOMEM;
        drvdata->quirks = quirks;
        hid_set_drvdata(dev, drvdata);

        ret = hid_parse(dev);
        if (ret != 0) {
                hid_err(dev, "parse failed\n");
                return ret;
        }
        ret = hid_hw_start(dev, HID_CONNECT_DEFAULT);
        if (ret != 0) {
                hid_err(dev, "hw start failed\n");
                return ret;
        }

        if (usbif->cur_altsetting->desc.bInterfaceNumber == 0) {
                if (quirks & CORSAIR_USE_K90_MACRO) {
                        ret = k90_init_macro_functions(dev);
                        if (ret != 0)
                                hid_warn(dev, "Failed to initialize K90 macro functions.\n");
                }
                if (quirks & CORSAIR_USE_K90_BACKLIGHT) {
                        ret = k90_init_backlight(dev);
                        if (ret != 0)
                                hid_warn(dev, "Failed to initialize K90 backlight.\n");
                }
        }

        return 0;
}

static void corsair_remove(struct hid_device *dev)
{
        k90_cleanup_macro_functions(dev);
        k90_cleanup_backlight(dev);

        hid_hw_stop(dev);
}

static int corsair_event(struct hid_device *dev, struct hid_field *field,
                         struct hid_usage *usage, __s32 value)
{
        struct corsair_drvdata *drvdata = hid_get_drvdata(dev);

        if (!drvdata->k90)
                return 0;

        switch (usage->hid & HID_USAGE) {
        case CORSAIR_USAGE_MACRO_RECORD_START:
                drvdata->k90->record_led.brightness = 1;
                break;
        case CORSAIR_USAGE_MACRO_RECORD_STOP:
                drvdata->k90->record_led.brightness = 0;
                break;
        default:
                break;
        }

        return 0;
}

static int corsair_input_mapping(struct hid_device *dev,
                                 struct hid_input *input,
                                 struct hid_field *field,
                                 struct hid_usage *usage, unsigned long **bit,
                                 int *max)
{
        int gkey;

        if ((usage->hid & HID_USAGE_PAGE) != HID_UP_KEYBOARD)
                return 0;

        gkey = corsair_usage_to_gkey(usage->hid & HID_USAGE);
        if (gkey != 0) {
                hid_map_usage_clear(input, usage, bit, max, EV_KEY,
                                    corsair_gkey_map[gkey - 1]);
                return 1;
        }
        if ((usage->hid & HID_USAGE) >= CORSAIR_USAGE_SPECIAL_MIN &&
            (usage->hid & HID_USAGE) <= CORSAIR_USAGE_SPECIAL_MAX) {
                switch (usage->hid & HID_USAGE) {
                case CORSAIR_USAGE_MACRO_RECORD_START:
                        hid_map_usage_clear(input, usage, bit, max, EV_KEY,
                                            corsair_record_keycodes[0]);
                        return 1;

                case CORSAIR_USAGE_MACRO_RECORD_STOP:
                        hid_map_usage_clear(input, usage, bit, max, EV_KEY,
                                            corsair_record_keycodes[1]);
                        return 1;

                case CORSAIR_USAGE_M1:
                        hid_map_usage_clear(input, usage, bit, max, EV_KEY,
                                            corsair_profile_keycodes[0]);
                        return 1;

                case CORSAIR_USAGE_M2:
                        hid_map_usage_clear(input, usage, bit, max, EV_KEY,
                                            corsair_profile_keycodes[1]);
                        return 1;

                case CORSAIR_USAGE_M3:
                        hid_map_usage_clear(input, usage, bit, max, EV_KEY,
                                            corsair_profile_keycodes[2]);
                        return 1;

                default:
                        return -1;
                }
        }

        return 0;
}

/*
 * The report descriptor of some of the Corsair gaming mice is
 * non parseable as they define two consecutive Logical Minimum for
 * the Usage Page (Consumer) in rdescs bytes 75 and 77 being 77 0x16
 * that should be obviousy 0x26 for Logical Magimum of 16 bits. This
 * prevents poper parsing of the report descriptor due Logical
 * Minimum being larger than Logical Maximum.
 *
 * This driver fixes the report descriptor for:
 * - USB ID 1b1c:1b34, sold as GLAIVE RGB Gaming mouse
 * - USB ID 1b1c:1b3e, sold as Scimitar RGB Pro Gaming mouse
 */

static const __u8 *corsair_mouse_report_fixup(struct hid_device *hdev,
        __u8 *rdesc, unsigned int *rsize)
{
        struct usb_interface *intf = to_usb_interface(hdev->dev.parent);

        if (intf->cur_altsetting->desc.bInterfaceNumber == 1) {
                /*
                 * Corsair GLAIVE RGB and Scimitar RGB Pro report descriptor is
                 * broken and defines two different Logical Minimum for the
                 * Consumer Application. The byte 77 should be a 0x26 defining
                 * a 16 bits integer for the Logical Maximum but it is a 0x16
                 * instead (Logical Minimum)
                 */
                switch (hdev->product) {
                case USB_DEVICE_ID_CORSAIR_GLAIVE_RGB:
                case USB_DEVICE_ID_CORSAIR_SCIMITAR_PRO_RGB:
                        if (*rsize >= 172 && rdesc[75] == 0x15 && rdesc[77] == 0x16
                        && rdesc[78] == 0xff && rdesc[79] == 0x0f) {
                                hid_info(hdev, "Fixing up report descriptor\n");
                                rdesc[77] = 0x26;
                        }
                        break;
                }

        }
        return rdesc;
}

static const struct hid_device_id corsair_devices[] = {
        { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_K90),
                .driver_data = CORSAIR_USE_K90_MACRO |
                               CORSAIR_USE_K90_BACKLIGHT },
        { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR,
            USB_DEVICE_ID_CORSAIR_GLAIVE_RGB) },
        { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR,
            USB_DEVICE_ID_CORSAIR_SCIMITAR_PRO_RGB) },
        /*
         * Vengeance K70 and K70 RAPIDFIRE share product IDs.
         */
        { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR,
            USB_DEVICE_ID_CORSAIR_K70R) },
        {}
};

MODULE_DEVICE_TABLE(hid, corsair_devices);

static struct hid_driver corsair_driver = {
        .name = "corsair",
        .id_table = corsair_devices,
        .probe = corsair_probe,
        .event = corsair_event,
        .remove = corsair_remove,
        .input_mapping = corsair_input_mapping,
        .report_fixup = corsair_mouse_report_fixup,
};

module_hid_driver(corsair_driver);

MODULE_LICENSE("GPL");
/* Original K90 driver author */
MODULE_AUTHOR("Clement Vuchener");
/* Scimitar PRO RGB driver author */
MODULE_AUTHOR("Oscar Campos");
MODULE_DESCRIPTION("HID driver for Corsair devices");