1 | // SPDX-License-Identifier: GPL-2.0-or-later |
2 | /* |
3 | * Roccat Pyra driver for Linux |
4 | * |
5 | * Copyright (c) 2010 Stefan Achatz <erazor_de@users.sourceforge.net> |
6 | */ |
7 | |
8 | /* |
9 | */ |
10 | |
11 | /* |
12 | * Roccat Pyra is a mobile gamer mouse which comes in wired and wireless |
13 | * variant. Wireless variant is not tested. |
14 | * Userland tools can be found at http://sourceforge.net/projects/roccat |
15 | */ |
16 | |
17 | #include <linux/device.h> |
18 | #include <linux/input.h> |
19 | #include <linux/hid.h> |
20 | #include <linux/module.h> |
21 | #include <linux/slab.h> |
22 | #include <linux/hid-roccat.h> |
23 | #include "hid-ids.h" |
24 | #include "hid-roccat-common.h" |
25 | #include "hid-roccat-pyra.h" |
26 | |
27 | static uint profile_numbers[5] = {0, 1, 2, 3, 4}; |
28 | |
29 | static void profile_activated(struct pyra_device *pyra, |
30 | unsigned int new_profile) |
31 | { |
32 | if (new_profile >= ARRAY_SIZE(pyra->profile_settings)) |
33 | return; |
34 | pyra->actual_profile = new_profile; |
35 | pyra->actual_cpi = pyra->profile_settings[pyra->actual_profile].y_cpi; |
36 | } |
37 | |
38 | static int pyra_send_control(struct usb_device *usb_dev, int value, |
39 | enum pyra_control_requests request) |
40 | { |
41 | struct roccat_common2_control control; |
42 | |
43 | if ((request == PYRA_CONTROL_REQUEST_PROFILE_SETTINGS || |
44 | request == PYRA_CONTROL_REQUEST_PROFILE_BUTTONS) && |
45 | (value < 0 || value > 4)) |
46 | return -EINVAL; |
47 | |
48 | control.command = ROCCAT_COMMON_COMMAND_CONTROL; |
49 | control.value = value; |
50 | control.request = request; |
51 | |
52 | return roccat_common2_send(usb_dev, report_id: ROCCAT_COMMON_COMMAND_CONTROL, |
53 | data: &control, size: sizeof(struct roccat_common2_control)); |
54 | } |
55 | |
56 | static int pyra_get_profile_settings(struct usb_device *usb_dev, |
57 | struct pyra_profile_settings *buf, int number) |
58 | { |
59 | int retval; |
60 | retval = pyra_send_control(usb_dev, value: number, |
61 | request: PYRA_CONTROL_REQUEST_PROFILE_SETTINGS); |
62 | if (retval) |
63 | return retval; |
64 | return roccat_common2_receive(usb_dev, report_id: PYRA_COMMAND_PROFILE_SETTINGS, |
65 | data: buf, size: PYRA_SIZE_PROFILE_SETTINGS); |
66 | } |
67 | |
68 | static int pyra_get_settings(struct usb_device *usb_dev, |
69 | struct pyra_settings *buf) |
70 | { |
71 | return roccat_common2_receive(usb_dev, report_id: PYRA_COMMAND_SETTINGS, |
72 | data: buf, size: PYRA_SIZE_SETTINGS); |
73 | } |
74 | |
75 | static int pyra_set_settings(struct usb_device *usb_dev, |
76 | struct pyra_settings const *settings) |
77 | { |
78 | return roccat_common2_send_with_status(usb_dev, |
79 | command: PYRA_COMMAND_SETTINGS, buf: settings, |
80 | size: PYRA_SIZE_SETTINGS); |
81 | } |
82 | |
83 | static ssize_t pyra_sysfs_read(struct file *fp, struct kobject *kobj, |
84 | char *buf, loff_t off, size_t count, |
85 | size_t real_size, uint command) |
86 | { |
87 | struct device *dev = kobj_to_dev(kobj)->parent->parent; |
88 | struct pyra_device *pyra = hid_get_drvdata(hdev: dev_get_drvdata(dev)); |
89 | struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); |
90 | int retval; |
91 | |
92 | if (off >= real_size) |
93 | return 0; |
94 | |
95 | if (off != 0 || count != real_size) |
96 | return -EINVAL; |
97 | |
98 | mutex_lock(&pyra->pyra_lock); |
99 | retval = roccat_common2_receive(usb_dev, report_id: command, data: buf, size: real_size); |
100 | mutex_unlock(lock: &pyra->pyra_lock); |
101 | |
102 | if (retval) |
103 | return retval; |
104 | |
105 | return real_size; |
106 | } |
107 | |
108 | static ssize_t pyra_sysfs_write(struct file *fp, struct kobject *kobj, |
109 | void const *buf, loff_t off, size_t count, |
110 | size_t real_size, uint command) |
111 | { |
112 | struct device *dev = kobj_to_dev(kobj)->parent->parent; |
113 | struct pyra_device *pyra = hid_get_drvdata(hdev: dev_get_drvdata(dev)); |
114 | struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); |
115 | int retval; |
116 | |
117 | if (off != 0 || count != real_size) |
118 | return -EINVAL; |
119 | |
120 | mutex_lock(&pyra->pyra_lock); |
121 | retval = roccat_common2_send_with_status(usb_dev, command, buf: (void *)buf, size: real_size); |
122 | mutex_unlock(lock: &pyra->pyra_lock); |
123 | |
124 | if (retval) |
125 | return retval; |
126 | |
127 | return real_size; |
128 | } |
129 | |
130 | #define PYRA_SYSFS_W(thingy, THINGY) \ |
131 | static ssize_t pyra_sysfs_write_ ## thingy(struct file *fp, \ |
132 | struct kobject *kobj, struct bin_attribute *attr, char *buf, \ |
133 | loff_t off, size_t count) \ |
134 | { \ |
135 | return pyra_sysfs_write(fp, kobj, buf, off, count, \ |
136 | PYRA_SIZE_ ## THINGY, PYRA_COMMAND_ ## THINGY); \ |
137 | } |
138 | |
139 | #define PYRA_SYSFS_R(thingy, THINGY) \ |
140 | static ssize_t pyra_sysfs_read_ ## thingy(struct file *fp, \ |
141 | struct kobject *kobj, struct bin_attribute *attr, char *buf, \ |
142 | loff_t off, size_t count) \ |
143 | { \ |
144 | return pyra_sysfs_read(fp, kobj, buf, off, count, \ |
145 | PYRA_SIZE_ ## THINGY, PYRA_COMMAND_ ## THINGY); \ |
146 | } |
147 | |
148 | #define PYRA_SYSFS_RW(thingy, THINGY) \ |
149 | PYRA_SYSFS_W(thingy, THINGY) \ |
150 | PYRA_SYSFS_R(thingy, THINGY) |
151 | |
152 | #define PYRA_BIN_ATTRIBUTE_RW(thingy, THINGY) \ |
153 | PYRA_SYSFS_RW(thingy, THINGY); \ |
154 | static struct bin_attribute bin_attr_##thingy = { \ |
155 | .attr = { .name = #thingy, .mode = 0660 }, \ |
156 | .size = PYRA_SIZE_ ## THINGY, \ |
157 | .read = pyra_sysfs_read_ ## thingy, \ |
158 | .write = pyra_sysfs_write_ ## thingy \ |
159 | } |
160 | |
161 | #define PYRA_BIN_ATTRIBUTE_R(thingy, THINGY) \ |
162 | PYRA_SYSFS_R(thingy, THINGY); \ |
163 | static struct bin_attribute bin_attr_##thingy = { \ |
164 | .attr = { .name = #thingy, .mode = 0440 }, \ |
165 | .size = PYRA_SIZE_ ## THINGY, \ |
166 | .read = pyra_sysfs_read_ ## thingy, \ |
167 | } |
168 | |
169 | #define PYRA_BIN_ATTRIBUTE_W(thingy, THINGY) \ |
170 | PYRA_SYSFS_W(thingy, THINGY); \ |
171 | static struct bin_attribute bin_attr_##thingy = { \ |
172 | .attr = { .name = #thingy, .mode = 0220 }, \ |
173 | .size = PYRA_SIZE_ ## THINGY, \ |
174 | .write = pyra_sysfs_write_ ## thingy \ |
175 | } |
176 | |
177 | PYRA_BIN_ATTRIBUTE_W(control, CONTROL); |
178 | PYRA_BIN_ATTRIBUTE_RW(info, INFO); |
179 | PYRA_BIN_ATTRIBUTE_RW(profile_settings, PROFILE_SETTINGS); |
180 | PYRA_BIN_ATTRIBUTE_RW(profile_buttons, PROFILE_BUTTONS); |
181 | |
182 | static ssize_t pyra_sysfs_read_profilex_settings(struct file *fp, |
183 | struct kobject *kobj, struct bin_attribute *attr, char *buf, |
184 | loff_t off, size_t count) |
185 | { |
186 | struct device *dev = kobj_to_dev(kobj)->parent->parent; |
187 | struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); |
188 | ssize_t retval; |
189 | |
190 | retval = pyra_send_control(usb_dev, value: *(uint *)(attr->private), |
191 | request: PYRA_CONTROL_REQUEST_PROFILE_SETTINGS); |
192 | if (retval) |
193 | return retval; |
194 | |
195 | return pyra_sysfs_read(fp, kobj, buf, off, count, |
196 | real_size: PYRA_SIZE_PROFILE_SETTINGS, |
197 | command: PYRA_COMMAND_PROFILE_SETTINGS); |
198 | } |
199 | |
200 | static ssize_t pyra_sysfs_read_profilex_buttons(struct file *fp, |
201 | struct kobject *kobj, struct bin_attribute *attr, char *buf, |
202 | loff_t off, size_t count) |
203 | { |
204 | struct device *dev = kobj_to_dev(kobj)->parent->parent; |
205 | struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); |
206 | ssize_t retval; |
207 | |
208 | retval = pyra_send_control(usb_dev, value: *(uint *)(attr->private), |
209 | request: PYRA_CONTROL_REQUEST_PROFILE_BUTTONS); |
210 | if (retval) |
211 | return retval; |
212 | |
213 | return pyra_sysfs_read(fp, kobj, buf, off, count, |
214 | real_size: PYRA_SIZE_PROFILE_BUTTONS, |
215 | command: PYRA_COMMAND_PROFILE_BUTTONS); |
216 | } |
217 | |
218 | #define PROFILE_ATTR(number) \ |
219 | static struct bin_attribute bin_attr_profile##number##_settings = { \ |
220 | .attr = { .name = "profile" #number "_settings", .mode = 0440 }, \ |
221 | .size = PYRA_SIZE_PROFILE_SETTINGS, \ |
222 | .read = pyra_sysfs_read_profilex_settings, \ |
223 | .private = &profile_numbers[number-1], \ |
224 | }; \ |
225 | static struct bin_attribute bin_attr_profile##number##_buttons = { \ |
226 | .attr = { .name = "profile" #number "_buttons", .mode = 0440 }, \ |
227 | .size = PYRA_SIZE_PROFILE_BUTTONS, \ |
228 | .read = pyra_sysfs_read_profilex_buttons, \ |
229 | .private = &profile_numbers[number-1], \ |
230 | }; |
231 | PROFILE_ATTR(1); |
232 | PROFILE_ATTR(2); |
233 | PROFILE_ATTR(3); |
234 | PROFILE_ATTR(4); |
235 | PROFILE_ATTR(5); |
236 | |
237 | static ssize_t pyra_sysfs_write_settings(struct file *fp, |
238 | struct kobject *kobj, struct bin_attribute *attr, char *buf, |
239 | loff_t off, size_t count) |
240 | { |
241 | struct device *dev = kobj_to_dev(kobj)->parent->parent; |
242 | struct pyra_device *pyra = hid_get_drvdata(hdev: dev_get_drvdata(dev)); |
243 | struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); |
244 | int retval = 0; |
245 | struct pyra_roccat_report roccat_report; |
246 | struct pyra_settings const *settings; |
247 | |
248 | if (off != 0 || count != PYRA_SIZE_SETTINGS) |
249 | return -EINVAL; |
250 | |
251 | settings = (struct pyra_settings const *)buf; |
252 | if (settings->startup_profile >= ARRAY_SIZE(pyra->profile_settings)) |
253 | return -EINVAL; |
254 | |
255 | mutex_lock(&pyra->pyra_lock); |
256 | |
257 | retval = pyra_set_settings(usb_dev, settings); |
258 | if (retval) { |
259 | mutex_unlock(lock: &pyra->pyra_lock); |
260 | return retval; |
261 | } |
262 | |
263 | profile_activated(pyra, new_profile: settings->startup_profile); |
264 | |
265 | roccat_report.type = PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2; |
266 | roccat_report.value = settings->startup_profile + 1; |
267 | roccat_report.key = 0; |
268 | roccat_report_event(minor: pyra->chrdev_minor, |
269 | data: (uint8_t const *)&roccat_report); |
270 | |
271 | mutex_unlock(lock: &pyra->pyra_lock); |
272 | return PYRA_SIZE_SETTINGS; |
273 | } |
274 | |
275 | PYRA_SYSFS_R(settings, SETTINGS); |
276 | static struct bin_attribute bin_attr_settings = |
277 | __BIN_ATTR(settings, (S_IWUSR | S_IRUGO), |
278 | pyra_sysfs_read_settings, pyra_sysfs_write_settings, |
279 | PYRA_SIZE_SETTINGS); |
280 | |
281 | static ssize_t pyra_sysfs_show_actual_cpi(struct device *dev, |
282 | struct device_attribute *attr, char *buf) |
283 | { |
284 | struct pyra_device *pyra = |
285 | hid_get_drvdata(hdev: dev_get_drvdata(dev: dev->parent->parent)); |
286 | return snprintf(buf, PAGE_SIZE, fmt: "%d\n" , pyra->actual_cpi); |
287 | } |
288 | static DEVICE_ATTR(actual_cpi, 0440, pyra_sysfs_show_actual_cpi, NULL); |
289 | |
290 | static ssize_t pyra_sysfs_show_actual_profile(struct device *dev, |
291 | struct device_attribute *attr, char *buf) |
292 | { |
293 | struct pyra_device *pyra = |
294 | hid_get_drvdata(hdev: dev_get_drvdata(dev: dev->parent->parent)); |
295 | struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); |
296 | struct pyra_settings settings; |
297 | |
298 | mutex_lock(&pyra->pyra_lock); |
299 | roccat_common2_receive(usb_dev, report_id: PYRA_COMMAND_SETTINGS, |
300 | data: &settings, size: PYRA_SIZE_SETTINGS); |
301 | mutex_unlock(lock: &pyra->pyra_lock); |
302 | |
303 | return snprintf(buf, PAGE_SIZE, fmt: "%d\n" , settings.startup_profile); |
304 | } |
305 | static DEVICE_ATTR(actual_profile, 0440, pyra_sysfs_show_actual_profile, NULL); |
306 | static DEVICE_ATTR(startup_profile, 0440, pyra_sysfs_show_actual_profile, NULL); |
307 | |
308 | static ssize_t pyra_sysfs_show_firmware_version(struct device *dev, |
309 | struct device_attribute *attr, char *buf) |
310 | { |
311 | struct pyra_device *pyra; |
312 | struct usb_device *usb_dev; |
313 | struct pyra_info info; |
314 | |
315 | dev = dev->parent->parent; |
316 | pyra = hid_get_drvdata(hdev: dev_get_drvdata(dev)); |
317 | usb_dev = interface_to_usbdev(to_usb_interface(dev)); |
318 | |
319 | mutex_lock(&pyra->pyra_lock); |
320 | roccat_common2_receive(usb_dev, report_id: PYRA_COMMAND_INFO, |
321 | data: &info, size: PYRA_SIZE_INFO); |
322 | mutex_unlock(lock: &pyra->pyra_lock); |
323 | |
324 | return snprintf(buf, PAGE_SIZE, fmt: "%d\n" , info.firmware_version); |
325 | } |
326 | static DEVICE_ATTR(firmware_version, 0440, pyra_sysfs_show_firmware_version, |
327 | NULL); |
328 | |
329 | static struct attribute *pyra_attrs[] = { |
330 | &dev_attr_actual_cpi.attr, |
331 | &dev_attr_actual_profile.attr, |
332 | &dev_attr_firmware_version.attr, |
333 | &dev_attr_startup_profile.attr, |
334 | NULL, |
335 | }; |
336 | |
337 | static struct bin_attribute *pyra_bin_attributes[] = { |
338 | &bin_attr_control, |
339 | &bin_attr_info, |
340 | &bin_attr_profile_settings, |
341 | &bin_attr_profile_buttons, |
342 | &bin_attr_settings, |
343 | &bin_attr_profile1_settings, |
344 | &bin_attr_profile2_settings, |
345 | &bin_attr_profile3_settings, |
346 | &bin_attr_profile4_settings, |
347 | &bin_attr_profile5_settings, |
348 | &bin_attr_profile1_buttons, |
349 | &bin_attr_profile2_buttons, |
350 | &bin_attr_profile3_buttons, |
351 | &bin_attr_profile4_buttons, |
352 | &bin_attr_profile5_buttons, |
353 | NULL, |
354 | }; |
355 | |
356 | static const struct attribute_group pyra_group = { |
357 | .attrs = pyra_attrs, |
358 | .bin_attrs = pyra_bin_attributes, |
359 | }; |
360 | |
361 | static const struct attribute_group *pyra_groups[] = { |
362 | &pyra_group, |
363 | NULL, |
364 | }; |
365 | |
366 | /* pyra_class is used for creating sysfs attributes via roccat char device */ |
367 | static const struct class pyra_class = { |
368 | .name = "pyra" , |
369 | .dev_groups = pyra_groups, |
370 | }; |
371 | |
372 | static int pyra_init_pyra_device_struct(struct usb_device *usb_dev, |
373 | struct pyra_device *pyra) |
374 | { |
375 | struct pyra_settings settings; |
376 | int retval, i; |
377 | |
378 | mutex_init(&pyra->pyra_lock); |
379 | |
380 | retval = pyra_get_settings(usb_dev, buf: &settings); |
381 | if (retval) |
382 | return retval; |
383 | |
384 | for (i = 0; i < 5; ++i) { |
385 | retval = pyra_get_profile_settings(usb_dev, |
386 | buf: &pyra->profile_settings[i], number: i); |
387 | if (retval) |
388 | return retval; |
389 | } |
390 | |
391 | profile_activated(pyra, new_profile: settings.startup_profile); |
392 | |
393 | return 0; |
394 | } |
395 | |
396 | static int pyra_init_specials(struct hid_device *hdev) |
397 | { |
398 | struct usb_interface *intf = to_usb_interface(hdev->dev.parent); |
399 | struct usb_device *usb_dev = interface_to_usbdev(intf); |
400 | struct pyra_device *pyra; |
401 | int retval; |
402 | |
403 | if (intf->cur_altsetting->desc.bInterfaceProtocol |
404 | == USB_INTERFACE_PROTOCOL_MOUSE) { |
405 | |
406 | pyra = kzalloc(size: sizeof(*pyra), GFP_KERNEL); |
407 | if (!pyra) { |
408 | hid_err(hdev, "can't alloc device descriptor\n" ); |
409 | return -ENOMEM; |
410 | } |
411 | hid_set_drvdata(hdev, data: pyra); |
412 | |
413 | retval = pyra_init_pyra_device_struct(usb_dev, pyra); |
414 | if (retval) { |
415 | hid_err(hdev, "couldn't init struct pyra_device\n" ); |
416 | goto exit_free; |
417 | } |
418 | |
419 | retval = roccat_connect(klass: &pyra_class, hid: hdev, |
420 | report_size: sizeof(struct pyra_roccat_report)); |
421 | if (retval < 0) { |
422 | hid_err(hdev, "couldn't init char dev\n" ); |
423 | } else { |
424 | pyra->chrdev_minor = retval; |
425 | pyra->roccat_claimed = 1; |
426 | } |
427 | } else { |
428 | hid_set_drvdata(hdev, NULL); |
429 | } |
430 | |
431 | return 0; |
432 | exit_free: |
433 | kfree(objp: pyra); |
434 | return retval; |
435 | } |
436 | |
437 | static void pyra_remove_specials(struct hid_device *hdev) |
438 | { |
439 | struct usb_interface *intf = to_usb_interface(hdev->dev.parent); |
440 | struct pyra_device *pyra; |
441 | |
442 | if (intf->cur_altsetting->desc.bInterfaceProtocol |
443 | == USB_INTERFACE_PROTOCOL_MOUSE) { |
444 | pyra = hid_get_drvdata(hdev); |
445 | if (pyra->roccat_claimed) |
446 | roccat_disconnect(minor: pyra->chrdev_minor); |
447 | kfree(objp: hid_get_drvdata(hdev)); |
448 | } |
449 | } |
450 | |
451 | static int pyra_probe(struct hid_device *hdev, const struct hid_device_id *id) |
452 | { |
453 | int retval; |
454 | |
455 | if (!hid_is_usb(hdev)) |
456 | return -EINVAL; |
457 | |
458 | retval = hid_parse(hdev); |
459 | if (retval) { |
460 | hid_err(hdev, "parse failed\n" ); |
461 | goto exit; |
462 | } |
463 | |
464 | retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT); |
465 | if (retval) { |
466 | hid_err(hdev, "hw start failed\n" ); |
467 | goto exit; |
468 | } |
469 | |
470 | retval = pyra_init_specials(hdev); |
471 | if (retval) { |
472 | hid_err(hdev, "couldn't install mouse\n" ); |
473 | goto exit_stop; |
474 | } |
475 | return 0; |
476 | |
477 | exit_stop: |
478 | hid_hw_stop(hdev); |
479 | exit: |
480 | return retval; |
481 | } |
482 | |
483 | static void pyra_remove(struct hid_device *hdev) |
484 | { |
485 | pyra_remove_specials(hdev); |
486 | hid_hw_stop(hdev); |
487 | } |
488 | |
489 | static void pyra_keep_values_up_to_date(struct pyra_device *pyra, |
490 | u8 const *data) |
491 | { |
492 | struct pyra_mouse_event_button const *button_event; |
493 | |
494 | switch (data[0]) { |
495 | case PYRA_MOUSE_REPORT_NUMBER_BUTTON: |
496 | button_event = (struct pyra_mouse_event_button const *)data; |
497 | switch (button_event->type) { |
498 | case PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2: |
499 | profile_activated(pyra, new_profile: button_event->data1 - 1); |
500 | break; |
501 | case PYRA_MOUSE_EVENT_BUTTON_TYPE_CPI: |
502 | pyra->actual_cpi = button_event->data1; |
503 | break; |
504 | } |
505 | break; |
506 | } |
507 | } |
508 | |
509 | static void pyra_report_to_chrdev(struct pyra_device const *pyra, |
510 | u8 const *data) |
511 | { |
512 | struct pyra_roccat_report roccat_report; |
513 | struct pyra_mouse_event_button const *button_event; |
514 | |
515 | if (data[0] != PYRA_MOUSE_REPORT_NUMBER_BUTTON) |
516 | return; |
517 | |
518 | button_event = (struct pyra_mouse_event_button const *)data; |
519 | |
520 | switch (button_event->type) { |
521 | case PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2: |
522 | case PYRA_MOUSE_EVENT_BUTTON_TYPE_CPI: |
523 | roccat_report.type = button_event->type; |
524 | roccat_report.value = button_event->data1; |
525 | roccat_report.key = 0; |
526 | roccat_report_event(minor: pyra->chrdev_minor, |
527 | data: (uint8_t const *)&roccat_report); |
528 | break; |
529 | case PYRA_MOUSE_EVENT_BUTTON_TYPE_MACRO: |
530 | case PYRA_MOUSE_EVENT_BUTTON_TYPE_SHORTCUT: |
531 | case PYRA_MOUSE_EVENT_BUTTON_TYPE_QUICKLAUNCH: |
532 | if (button_event->data2 == PYRA_MOUSE_EVENT_BUTTON_PRESS) { |
533 | roccat_report.type = button_event->type; |
534 | roccat_report.key = button_event->data1; |
535 | /* |
536 | * pyra reports profile numbers with range 1-5. |
537 | * Keeping this behaviour. |
538 | */ |
539 | roccat_report.value = pyra->actual_profile + 1; |
540 | roccat_report_event(minor: pyra->chrdev_minor, |
541 | data: (uint8_t const *)&roccat_report); |
542 | } |
543 | break; |
544 | } |
545 | } |
546 | |
547 | static int pyra_raw_event(struct hid_device *hdev, struct hid_report *report, |
548 | u8 *data, int size) |
549 | { |
550 | struct usb_interface *intf = to_usb_interface(hdev->dev.parent); |
551 | struct pyra_device *pyra = hid_get_drvdata(hdev); |
552 | |
553 | if (intf->cur_altsetting->desc.bInterfaceProtocol |
554 | != USB_INTERFACE_PROTOCOL_MOUSE) |
555 | return 0; |
556 | |
557 | if (pyra == NULL) |
558 | return 0; |
559 | |
560 | pyra_keep_values_up_to_date(pyra, data); |
561 | |
562 | if (pyra->roccat_claimed) |
563 | pyra_report_to_chrdev(pyra, data); |
564 | |
565 | return 0; |
566 | } |
567 | |
568 | static const struct hid_device_id pyra_devices[] = { |
569 | { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, |
570 | USB_DEVICE_ID_ROCCAT_PYRA_WIRED) }, |
571 | { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, |
572 | USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS) }, |
573 | { } |
574 | }; |
575 | |
576 | MODULE_DEVICE_TABLE(hid, pyra_devices); |
577 | |
578 | static struct hid_driver pyra_driver = { |
579 | .name = "pyra" , |
580 | .id_table = pyra_devices, |
581 | .probe = pyra_probe, |
582 | .remove = pyra_remove, |
583 | .raw_event = pyra_raw_event |
584 | }; |
585 | |
586 | static int __init pyra_init(void) |
587 | { |
588 | int retval; |
589 | |
590 | /* class name has to be same as driver name */ |
591 | retval = class_register(class: &pyra_class); |
592 | if (retval) |
593 | return retval; |
594 | |
595 | retval = hid_register_driver(&pyra_driver); |
596 | if (retval) |
597 | class_unregister(class: &pyra_class); |
598 | return retval; |
599 | } |
600 | |
601 | static void __exit pyra_exit(void) |
602 | { |
603 | hid_unregister_driver(&pyra_driver); |
604 | class_unregister(class: &pyra_class); |
605 | } |
606 | |
607 | module_init(pyra_init); |
608 | module_exit(pyra_exit); |
609 | |
610 | MODULE_AUTHOR("Stefan Achatz" ); |
611 | MODULE_DESCRIPTION("USB Roccat Pyra driver" ); |
612 | MODULE_LICENSE("GPL v2" ); |
613 | |