]>
Commit | Line | Data |
---|---|---|
2874c5fd | 1 | // SPDX-License-Identifier: GPL-2.0-or-later |
6f3a1936 SA |
2 | /* |
3 | * Roccat Ryos driver for Linux | |
4 | * | |
5 | * Copyright (c) 2013 Stefan Achatz <erazor_de@users.sourceforge.net> | |
6 | */ | |
7 | ||
8 | /* | |
6f3a1936 SA |
9 | */ |
10 | ||
11 | #include <linux/types.h> | |
12 | #include <linux/device.h> | |
13 | #include <linux/input.h> | |
14 | #include <linux/hid.h> | |
15 | #include <linux/module.h> | |
16 | #include <linux/slab.h> | |
17 | #include <linux/hid-roccat.h> | |
18 | #include "hid-ids.h" | |
19 | #include "hid-roccat-common.h" | |
20 | ||
21 | enum { | |
22 | RYOS_REPORT_NUMBER_SPECIAL = 3, | |
23 | RYOS_USB_INTERFACE_PROTOCOL = 0, | |
24 | }; | |
25 | ||
26 | struct ryos_report_special { | |
27 | uint8_t number; /* RYOS_REPORT_NUMBER_SPECIAL */ | |
28 | uint8_t data[4]; | |
29 | } __packed; | |
30 | ||
31 | static struct class *ryos_class; | |
32 | ||
33 | ROCCAT_COMMON2_BIN_ATTRIBUTE_W(control, 0x04, 0x03); | |
34 | ROCCAT_COMMON2_BIN_ATTRIBUTE_RW(profile, 0x05, 0x03); | |
35 | ROCCAT_COMMON2_BIN_ATTRIBUTE_RW(keys_primary, 0x06, 0x7d); | |
36 | ROCCAT_COMMON2_BIN_ATTRIBUTE_RW(keys_function, 0x07, 0x5f); | |
37 | ROCCAT_COMMON2_BIN_ATTRIBUTE_RW(keys_macro, 0x08, 0x23); | |
38 | ROCCAT_COMMON2_BIN_ATTRIBUTE_RW(keys_thumbster, 0x09, 0x17); | |
39 | ROCCAT_COMMON2_BIN_ATTRIBUTE_RW(keys_extra, 0x0a, 0x08); | |
40 | ROCCAT_COMMON2_BIN_ATTRIBUTE_RW(keys_easyzone, 0x0b, 0x126); | |
41 | ROCCAT_COMMON2_BIN_ATTRIBUTE_RW(key_mask, 0x0c, 0x06); | |
42 | ROCCAT_COMMON2_BIN_ATTRIBUTE_RW(light, 0x0d, 0x10); | |
43 | ROCCAT_COMMON2_BIN_ATTRIBUTE_RW(macro, 0x0e, 0x7d2); | |
44 | ROCCAT_COMMON2_BIN_ATTRIBUTE_R(info, 0x0f, 0x08); | |
45 | ROCCAT_COMMON2_BIN_ATTRIBUTE_W(reset, 0x11, 0x03); | |
46 | ROCCAT_COMMON2_BIN_ATTRIBUTE_W(light_control, 0x13, 0x08); | |
47 | ROCCAT_COMMON2_BIN_ATTRIBUTE_W(talk, 0x16, 0x10); | |
48 | ROCCAT_COMMON2_BIN_ATTRIBUTE_RW(stored_lights, 0x17, 0x0566); | |
49 | ROCCAT_COMMON2_BIN_ATTRIBUTE_W(custom_lights, 0x18, 0x14); | |
50 | ROCCAT_COMMON2_BIN_ATTRIBUTE_RW(light_macro, 0x19, 0x07d2); | |
51 | ||
52 | static struct bin_attribute *ryos_bin_attrs[] = { | |
53 | &bin_attr_control, | |
54 | &bin_attr_profile, | |
55 | &bin_attr_keys_primary, | |
56 | &bin_attr_keys_function, | |
57 | &bin_attr_keys_macro, | |
58 | &bin_attr_keys_thumbster, | |
59 | &bin_attr_keys_extra, | |
60 | &bin_attr_keys_easyzone, | |
61 | &bin_attr_key_mask, | |
62 | &bin_attr_light, | |
63 | &bin_attr_macro, | |
64 | &bin_attr_info, | |
65 | &bin_attr_reset, | |
66 | &bin_attr_light_control, | |
67 | &bin_attr_talk, | |
68 | &bin_attr_stored_lights, | |
69 | &bin_attr_custom_lights, | |
70 | &bin_attr_light_macro, | |
71 | NULL, | |
72 | }; | |
73 | ||
74 | static const struct attribute_group ryos_group = { | |
75 | .bin_attrs = ryos_bin_attrs, | |
76 | }; | |
77 | ||
78 | static const struct attribute_group *ryos_groups[] = { | |
79 | &ryos_group, | |
80 | NULL, | |
81 | }; | |
82 | ||
83 | static int ryos_init_specials(struct hid_device *hdev) | |
84 | { | |
85 | struct usb_interface *intf = to_usb_interface(hdev->dev.parent); | |
86 | struct usb_device *usb_dev = interface_to_usbdev(intf); | |
87 | struct roccat_common2_device *ryos; | |
88 | int retval; | |
89 | ||
90 | if (intf->cur_altsetting->desc.bInterfaceProtocol | |
91 | != RYOS_USB_INTERFACE_PROTOCOL) { | |
92 | hid_set_drvdata(hdev, NULL); | |
93 | return 0; | |
94 | } | |
95 | ||
96 | ryos = kzalloc(sizeof(*ryos), GFP_KERNEL); | |
97 | if (!ryos) { | |
98 | hid_err(hdev, "can't alloc device descriptor\n"); | |
99 | return -ENOMEM; | |
100 | } | |
101 | hid_set_drvdata(hdev, ryos); | |
102 | ||
103 | retval = roccat_common2_device_init_struct(usb_dev, ryos); | |
104 | if (retval) { | |
105 | hid_err(hdev, "couldn't init Ryos device\n"); | |
106 | goto exit_free; | |
107 | } | |
108 | ||
109 | retval = roccat_connect(ryos_class, hdev, | |
110 | sizeof(struct ryos_report_special)); | |
111 | if (retval < 0) { | |
112 | hid_err(hdev, "couldn't init char dev\n"); | |
113 | } else { | |
114 | ryos->chrdev_minor = retval; | |
115 | ryos->roccat_claimed = 1; | |
116 | } | |
117 | ||
118 | return 0; | |
119 | exit_free: | |
120 | kfree(ryos); | |
121 | return retval; | |
122 | } | |
123 | ||
124 | static void ryos_remove_specials(struct hid_device *hdev) | |
125 | { | |
126 | struct usb_interface *intf = to_usb_interface(hdev->dev.parent); | |
127 | struct roccat_common2_device *ryos; | |
128 | ||
129 | if (intf->cur_altsetting->desc.bInterfaceProtocol | |
130 | != RYOS_USB_INTERFACE_PROTOCOL) | |
131 | return; | |
132 | ||
133 | ryos = hid_get_drvdata(hdev); | |
134 | if (ryos->roccat_claimed) | |
135 | roccat_disconnect(ryos->chrdev_minor); | |
136 | kfree(ryos); | |
137 | } | |
138 | ||
139 | static int ryos_probe(struct hid_device *hdev, | |
140 | const struct hid_device_id *id) | |
141 | { | |
142 | int retval; | |
143 | ||
144 | retval = hid_parse(hdev); | |
145 | if (retval) { | |
146 | hid_err(hdev, "parse failed\n"); | |
147 | goto exit; | |
148 | } | |
149 | ||
150 | retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT); | |
151 | if (retval) { | |
152 | hid_err(hdev, "hw start failed\n"); | |
153 | goto exit; | |
154 | } | |
155 | ||
156 | retval = ryos_init_specials(hdev); | |
157 | if (retval) { | |
158 | hid_err(hdev, "couldn't install mouse\n"); | |
159 | goto exit_stop; | |
160 | } | |
161 | ||
162 | return 0; | |
163 | ||
164 | exit_stop: | |
165 | hid_hw_stop(hdev); | |
166 | exit: | |
167 | return retval; | |
168 | } | |
169 | ||
170 | static void ryos_remove(struct hid_device *hdev) | |
171 | { | |
172 | ryos_remove_specials(hdev); | |
173 | hid_hw_stop(hdev); | |
174 | } | |
175 | ||
176 | static int ryos_raw_event(struct hid_device *hdev, | |
177 | struct hid_report *report, u8 *data, int size) | |
178 | { | |
179 | struct usb_interface *intf = to_usb_interface(hdev->dev.parent); | |
180 | struct roccat_common2_device *ryos = hid_get_drvdata(hdev); | |
181 | ||
182 | if (intf->cur_altsetting->desc.bInterfaceProtocol | |
183 | != RYOS_USB_INTERFACE_PROTOCOL) | |
184 | return 0; | |
185 | ||
186 | if (data[0] != RYOS_REPORT_NUMBER_SPECIAL) | |
187 | return 0; | |
188 | ||
189 | if (ryos != NULL && ryos->roccat_claimed) | |
190 | roccat_report_event(ryos->chrdev_minor, data); | |
191 | ||
192 | return 0; | |
193 | } | |
194 | ||
195 | static const struct hid_device_id ryos_devices[] = { | |
196 | { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK) }, | |
197 | { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK_GLOW) }, | |
198 | { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_RYOS_MK_PRO) }, | |
199 | { } | |
200 | }; | |
201 | ||
202 | MODULE_DEVICE_TABLE(hid, ryos_devices); | |
203 | ||
204 | static struct hid_driver ryos_driver = { | |
205 | .name = "ryos", | |
206 | .id_table = ryos_devices, | |
207 | .probe = ryos_probe, | |
208 | .remove = ryos_remove, | |
209 | .raw_event = ryos_raw_event | |
210 | }; | |
211 | ||
212 | static int __init ryos_init(void) | |
213 | { | |
214 | int retval; | |
215 | ||
216 | ryos_class = class_create(THIS_MODULE, "ryos"); | |
217 | if (IS_ERR(ryos_class)) | |
218 | return PTR_ERR(ryos_class); | |
219 | ryos_class->dev_groups = ryos_groups; | |
220 | ||
221 | retval = hid_register_driver(&ryos_driver); | |
222 | if (retval) | |
223 | class_destroy(ryos_class); | |
224 | return retval; | |
225 | } | |
226 | ||
227 | static void __exit ryos_exit(void) | |
228 | { | |
229 | hid_unregister_driver(&ryos_driver); | |
230 | class_destroy(ryos_class); | |
231 | } | |
232 | ||
233 | module_init(ryos_init); | |
234 | module_exit(ryos_exit); | |
235 | ||
236 | MODULE_AUTHOR("Stefan Achatz"); | |
237 | MODULE_DESCRIPTION("USB Roccat Ryos MK/Glow/Pro driver"); | |
238 | MODULE_LICENSE("GPL v2"); |