[mirror_ubuntu-artful-kernel.git] / drivers / hid / hid-corsair.c

/*
 * HID driver for Corsair devices
 *
 * Supported devices:
 *  - Vengeance K90 Keyboard
 *  - Scimitar PRO RGB Gaming Mouse
 *
 * Copyright (c) 2015 Clement Vuchener
 * Copyright (c) 2017 Oscar Campos
 */

/*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 */

#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 = snprintf(buf, PAGE_SIZE, "%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 = snprintf(buf, PAGE_SIZE, "%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(sizeof(struct k90_led), GFP_KERNEL);
	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(sizeof(struct k90_drvdata), GFP_KERNEL);
	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 = 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 Corsair Scimitar RGB Pro gaming mouse 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 b1c:1b3e, sold as Scimitar RGB Pro Gaming mouse
 */

static __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 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_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_SCIMITAR_PRO_RGB) },
	{}
};

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