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