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
27 struct k90_led {
28 struct led_classdev cdev;
29 int brightness;
30 struct work_struct work;
31 bool removed;
32 };
33
34 struct k90_drvdata {
35 struct k90_led record_led;
36 };
37
38 struct 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
corsair_usage_to_gkey(unsigned int usage)46 static 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
57 static 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
78 module_param_array_named(gkey_codes, corsair_gkey_map, ushort, NULL, S_IRUGO);
79 MODULE_PARM_DESC(gkey_codes, "Key codes for the G-keys");
80
81 static unsigned short corsair_record_keycodes[2] = {
82 BTN_TRIGGER_HAPPY19,
83 BTN_TRIGGER_HAPPY20
84 };
85
86 module_param_array_named(recordkey_codes, corsair_record_keycodes, ushort,
87 NULL, S_IRUGO);
88 MODULE_PARM_DESC(recordkey_codes, "Key codes for the MR (start and stop record) button");
89
90 static unsigned short corsair_profile_keycodes[3] = {
91 BTN_TRIGGER_HAPPY21,
92 BTN_TRIGGER_HAPPY22,
93 BTN_TRIGGER_HAPPY23
94 };
95
96 module_param_array_named(profilekey_codes, corsair_profile_keycodes, ushort,
97 NULL, S_IRUGO);
98 MODULE_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
k90_backlight_get(struct led_classdev * led_cdev)143 static 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;
177 out:
178 kfree(data);
179
180 return ret;
181 }
182
k90_record_led_get(struct led_classdev * led_cdev)183 static 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
k90_brightness_set(struct led_classdev * led_cdev,enum led_brightness brightness)190 static 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
k90_backlight_work(struct work_struct * work)199 static 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
k90_record_led_work(struct work_struct * work)224 static 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
k90_show_macro_mode(struct device * dev,struct device_attribute * attr,char * buf)259 static 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);
300 out:
301 kfree(data);
302
303 return ret;
304 }
305
k90_store_macro_mode(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)306 static 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
k90_show_current_profile(struct device * dev,struct device_attribute * attr,char * buf)335 static 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);
369 out:
370 kfree(data);
371
372 return ret;
373 }
374
k90_store_current_profile(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)375 static 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
403 static DEVICE_ATTR(macro_mode, 0644, k90_show_macro_mode, k90_store_macro_mode);
404 static DEVICE_ATTR(current_profile, 0644, k90_show_current_profile,
405 k90_store_current_profile);
406
407 static struct attribute *k90_attrs[] = {
408 &dev_attr_macro_mode.attr,
409 &dev_attr_current_profile.attr,
410 NULL
411 };
412
413 static const struct attribute_group k90_attr_group = {
414 .attrs = k90_attrs,
415 };
416
417 /*
418 * Driver functions
419 */
420
k90_init_backlight(struct hid_device * dev)421 static 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
455 fail_register_cdev:
456 kfree(drvdata->backlight->cdev.name);
457 fail_name_alloc:
458 kfree(drvdata->backlight);
459 drvdata->backlight = NULL;
460 fail_backlight_alloc:
461 return ret;
462 }
463
k90_init_macro_functions(struct hid_device * dev)464 static 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
506 fail_sysfs:
507 k90->record_led.removed = true;
508 led_classdev_unregister(&k90->record_led.cdev);
509 cancel_work_sync(&k90->record_led.work);
510 fail_record_led:
511 kfree(k90->record_led.cdev.name);
512 fail_record_led_alloc:
513 kfree(k90);
514 fail_drvdata:
515 drvdata->k90 = NULL;
516 return ret;
517 }
518
k90_cleanup_backlight(struct hid_device * dev)519 static 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
k90_cleanup_macro_functions(struct hid_device * dev)532 static 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
corsair_probe(struct hid_device * dev,const struct hid_device_id * id)549 static 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;
555
556 if (!hid_is_usb(dev))
557 return -EINVAL;
558
559 usbif = to_usb_interface(dev->dev.parent);
560
561 drvdata = devm_kzalloc(&dev->dev, sizeof(struct corsair_drvdata),
562 GFP_KERNEL);
563 if (drvdata == NULL)
564 return -ENOMEM;
565 drvdata->quirks = quirks;
566 hid_set_drvdata(dev, drvdata);
567
568 ret = hid_parse(dev);
569 if (ret != 0) {
570 hid_err(dev, "parse failed\n");
571 return ret;
572 }
573 ret = hid_hw_start(dev, HID_CONNECT_DEFAULT);
574 if (ret != 0) {
575 hid_err(dev, "hw start failed\n");
576 return ret;
577 }
578
579 if (usbif->cur_altsetting->desc.bInterfaceNumber == 0) {
580 if (quirks & CORSAIR_USE_K90_MACRO) {
581 ret = k90_init_macro_functions(dev);
582 if (ret != 0)
583 hid_warn(dev, "Failed to initialize K90 macro functions.\n");
584 }
585 if (quirks & CORSAIR_USE_K90_BACKLIGHT) {
586 ret = k90_init_backlight(dev);
587 if (ret != 0)
588 hid_warn(dev, "Failed to initialize K90 backlight.\n");
589 }
590 }
591
592 return 0;
593 }
594
corsair_remove(struct hid_device * dev)595 static void corsair_remove(struct hid_device *dev)
596 {
597 k90_cleanup_macro_functions(dev);
598 k90_cleanup_backlight(dev);
599
600 hid_hw_stop(dev);
601 }
602
corsair_event(struct hid_device * dev,struct hid_field * field,struct hid_usage * usage,__s32 value)603 static int corsair_event(struct hid_device *dev, struct hid_field *field,
604 struct hid_usage *usage, __s32 value)
605 {
606 struct corsair_drvdata *drvdata = hid_get_drvdata(dev);
607
608 if (!drvdata->k90)
609 return 0;
610
611 switch (usage->hid & HID_USAGE) {
612 case CORSAIR_USAGE_MACRO_RECORD_START:
613 drvdata->k90->record_led.brightness = 1;
614 break;
615 case CORSAIR_USAGE_MACRO_RECORD_STOP:
616 drvdata->k90->record_led.brightness = 0;
617 break;
618 default:
619 break;
620 }
621
622 return 0;
623 }
624
corsair_input_mapping(struct hid_device * dev,struct hid_input * input,struct hid_field * field,struct hid_usage * usage,unsigned long ** bit,int * max)625 static int corsair_input_mapping(struct hid_device *dev,
626 struct hid_input *input,
627 struct hid_field *field,
628 struct hid_usage *usage, unsigned long **bit,
629 int *max)
630 {
631 int gkey;
632
633 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 static const struct hid_device_id corsair_devices[] = {
676 { HID_USB_DEVICE(USB_VENDOR_ID_CORSAIR, USB_DEVICE_ID_CORSAIR_K90),
677 .driver_data = CORSAIR_USE_K90_MACRO |
678 CORSAIR_USE_K90_BACKLIGHT },
679 {}
680 };
681
682 MODULE_DEVICE_TABLE(hid, corsair_devices);
683
684 static struct hid_driver corsair_driver = {
685 .name = "corsair",
686 .id_table = corsair_devices,
687 .probe = corsair_probe,
688 .event = corsair_event,
689 .remove = corsair_remove,
690 .input_mapping = corsair_input_mapping,
691 };
692
corsair_init(void)693 static int __init corsair_init(void)
694 {
695 return hid_register_driver(&corsair_driver);
696 }
697
corsair_exit(void)698 static void corsair_exit(void)
699 {
700 hid_unregister_driver(&corsair_driver);
701 }
702
703 module_init(corsair_init);
704 module_exit(corsair_exit);
705
706 MODULE_LICENSE("GPL");
707 MODULE_AUTHOR("Clement Vuchener");
708 MODULE_DESCRIPTION("HID driver for Corsair devices");
709