This source file includes following definitions.
- kone_profile_activated
- kone_profile_report
- kone_receive
- kone_send
- kone_set_settings_checksum
- kone_check_write
- kone_get_settings
- kone_set_settings
- kone_get_profile
- kone_set_profile
- kone_get_weight
- kone_get_firmware_version
- kone_sysfs_read_settings
- kone_sysfs_write_settings
- kone_sysfs_read_profilex
- kone_sysfs_write_profilex
- kone_sysfs_show_actual_profile
- kone_sysfs_show_actual_dpi
- kone_sysfs_show_weight
- kone_sysfs_show_firmware_version
- kone_sysfs_show_tcu
- kone_tcu_command
- kone_sysfs_set_tcu
- kone_sysfs_show_startup_profile
- kone_sysfs_set_startup_profile
- kone_init_kone_device_struct
- kone_init_specials
- kone_remove_specials
- kone_probe
- kone_remove
- kone_keep_values_up_to_date
- kone_report_to_chrdev
- kone_raw_event
- kone_init
- kone_exit
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25 #include <linux/device.h>
26 #include <linux/input.h>
27 #include <linux/hid.h>
28 #include <linux/module.h>
29 #include <linux/slab.h>
30 #include <linux/hid-roccat.h>
31 #include "hid-ids.h"
32 #include "hid-roccat-common.h"
33 #include "hid-roccat-kone.h"
34
35 static uint profile_numbers[5] = {0, 1, 2, 3, 4};
36
37 static void kone_profile_activated(struct kone_device *kone, uint new_profile)
38 {
39 kone->actual_profile = new_profile;
40 kone->actual_dpi = kone->profiles[new_profile - 1].startup_dpi;
41 }
42
43 static void kone_profile_report(struct kone_device *kone, uint new_profile)
44 {
45 struct kone_roccat_report roccat_report;
46
47 roccat_report.event = kone_mouse_event_switch_profile;
48 roccat_report.value = new_profile;
49 roccat_report.key = 0;
50 roccat_report_event(kone->chrdev_minor, (uint8_t *)&roccat_report);
51 }
52
53 static int kone_receive(struct usb_device *usb_dev, uint usb_command,
54 void *data, uint size)
55 {
56 char *buf;
57 int len;
58
59 buf = kmalloc(size, GFP_KERNEL);
60 if (buf == NULL)
61 return -ENOMEM;
62
63 len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
64 HID_REQ_GET_REPORT,
65 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
66 usb_command, 0, buf, size, USB_CTRL_SET_TIMEOUT);
67
68 memcpy(data, buf, size);
69 kfree(buf);
70 return ((len < 0) ? len : ((len != size) ? -EIO : 0));
71 }
72
73 static int kone_send(struct usb_device *usb_dev, uint usb_command,
74 void const *data, uint size)
75 {
76 char *buf;
77 int len;
78
79 buf = kmemdup(data, size, GFP_KERNEL);
80 if (buf == NULL)
81 return -ENOMEM;
82
83 len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
84 HID_REQ_SET_REPORT,
85 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
86 usb_command, 0, buf, size, USB_CTRL_SET_TIMEOUT);
87
88 kfree(buf);
89 return ((len < 0) ? len : ((len != size) ? -EIO : 0));
90 }
91
92
93 static struct class *kone_class;
94
95 static void kone_set_settings_checksum(struct kone_settings *settings)
96 {
97 uint16_t checksum = 0;
98 unsigned char *address = (unsigned char *)settings;
99 int i;
100
101 for (i = 0; i < sizeof(struct kone_settings) - 2; ++i, ++address)
102 checksum += *address;
103 settings->checksum = cpu_to_le16(checksum);
104 }
105
106
107
108
109
110
111 static int kone_check_write(struct usb_device *usb_dev)
112 {
113 int retval;
114 uint8_t data;
115
116 do {
117
118
119
120
121 msleep(80);
122
123 retval = kone_receive(usb_dev,
124 kone_command_confirm_write, &data, 1);
125 if (retval)
126 return retval;
127
128
129
130
131
132
133 } while (data == 3);
134
135 if (data == 1)
136 return 0;
137
138
139 dev_err(&usb_dev->dev, "got retval %d when checking write\n", data);
140 return -EIO;
141 }
142
143
144
145
146
147
148 static int kone_get_settings(struct usb_device *usb_dev,
149 struct kone_settings *buf)
150 {
151 return kone_receive(usb_dev, kone_command_settings, buf,
152 sizeof(struct kone_settings));
153 }
154
155
156
157
158
159
160 static int kone_set_settings(struct usb_device *usb_dev,
161 struct kone_settings const *settings)
162 {
163 int retval;
164
165 retval = kone_send(usb_dev, kone_command_settings,
166 settings, sizeof(struct kone_settings));
167 if (retval)
168 return retval;
169 return kone_check_write(usb_dev);
170 }
171
172
173
174
175
176
177
178 static int kone_get_profile(struct usb_device *usb_dev,
179 struct kone_profile *buf, int number)
180 {
181 int len;
182
183 if (number < 1 || number > 5)
184 return -EINVAL;
185
186 len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
187 USB_REQ_CLEAR_FEATURE,
188 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
189 kone_command_profile, number, buf,
190 sizeof(struct kone_profile), USB_CTRL_SET_TIMEOUT);
191
192 if (len != sizeof(struct kone_profile))
193 return -EIO;
194
195 return 0;
196 }
197
198
199
200
201
202
203
204 static int kone_set_profile(struct usb_device *usb_dev,
205 struct kone_profile const *profile, int number)
206 {
207 int len;
208
209 if (number < 1 || number > 5)
210 return -EINVAL;
211
212 len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
213 USB_REQ_SET_CONFIGURATION,
214 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
215 kone_command_profile, number, (void *)profile,
216 sizeof(struct kone_profile),
217 USB_CTRL_SET_TIMEOUT);
218
219 if (len != sizeof(struct kone_profile))
220 return len;
221
222 if (kone_check_write(usb_dev))
223 return -EIO;
224
225 return 0;
226 }
227
228
229
230
231
232
233 static int kone_get_weight(struct usb_device *usb_dev, int *result)
234 {
235 int retval;
236 uint8_t data;
237
238 retval = kone_receive(usb_dev, kone_command_weight, &data, 1);
239
240 if (retval)
241 return retval;
242
243 *result = (int)data;
244 return 0;
245 }
246
247
248
249
250
251
252 static int kone_get_firmware_version(struct usb_device *usb_dev, int *result)
253 {
254 int retval;
255 uint16_t data;
256
257 retval = kone_receive(usb_dev, kone_command_firmware_version,
258 &data, 2);
259 if (retval)
260 return retval;
261
262 *result = le16_to_cpu(data);
263 return 0;
264 }
265
266 static ssize_t kone_sysfs_read_settings(struct file *fp, struct kobject *kobj,
267 struct bin_attribute *attr, char *buf,
268 loff_t off, size_t count) {
269 struct device *dev = kobj_to_dev(kobj)->parent->parent;
270 struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
271
272 if (off >= sizeof(struct kone_settings))
273 return 0;
274
275 if (off + count > sizeof(struct kone_settings))
276 count = sizeof(struct kone_settings) - off;
277
278 mutex_lock(&kone->kone_lock);
279 memcpy(buf, ((char const *)&kone->settings) + off, count);
280 mutex_unlock(&kone->kone_lock);
281
282 return count;
283 }
284
285
286
287
288
289
290 static ssize_t kone_sysfs_write_settings(struct file *fp, struct kobject *kobj,
291 struct bin_attribute *attr, char *buf,
292 loff_t off, size_t count) {
293 struct device *dev = kobj_to_dev(kobj)->parent->parent;
294 struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
295 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
296 int retval = 0, difference, old_profile;
297
298
299 if (off != 0 || count != sizeof(struct kone_settings))
300 return -EINVAL;
301
302 mutex_lock(&kone->kone_lock);
303 difference = memcmp(buf, &kone->settings, sizeof(struct kone_settings));
304 if (difference) {
305 retval = kone_set_settings(usb_dev,
306 (struct kone_settings const *)buf);
307 if (retval) {
308 mutex_unlock(&kone->kone_lock);
309 return retval;
310 }
311
312 old_profile = kone->settings.startup_profile;
313 memcpy(&kone->settings, buf, sizeof(struct kone_settings));
314
315 kone_profile_activated(kone, kone->settings.startup_profile);
316
317 if (kone->settings.startup_profile != old_profile)
318 kone_profile_report(kone, kone->settings.startup_profile);
319 }
320 mutex_unlock(&kone->kone_lock);
321
322 return sizeof(struct kone_settings);
323 }
324 static BIN_ATTR(settings, 0660, kone_sysfs_read_settings,
325 kone_sysfs_write_settings, sizeof(struct kone_settings));
326
327 static ssize_t kone_sysfs_read_profilex(struct file *fp,
328 struct kobject *kobj, struct bin_attribute *attr,
329 char *buf, loff_t off, size_t count) {
330 struct device *dev = kobj_to_dev(kobj)->parent->parent;
331 struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
332
333 if (off >= sizeof(struct kone_profile))
334 return 0;
335
336 if (off + count > sizeof(struct kone_profile))
337 count = sizeof(struct kone_profile) - off;
338
339 mutex_lock(&kone->kone_lock);
340 memcpy(buf, ((char const *)&kone->profiles[*(uint *)(attr->private)]) + off, count);
341 mutex_unlock(&kone->kone_lock);
342
343 return count;
344 }
345
346
347 static ssize_t kone_sysfs_write_profilex(struct file *fp,
348 struct kobject *kobj, struct bin_attribute *attr,
349 char *buf, loff_t off, size_t count) {
350 struct device *dev = kobj_to_dev(kobj)->parent->parent;
351 struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
352 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
353 struct kone_profile *profile;
354 int retval = 0, difference;
355
356
357 if (off != 0 || count != sizeof(struct kone_profile))
358 return -EINVAL;
359
360 profile = &kone->profiles[*(uint *)(attr->private)];
361
362 mutex_lock(&kone->kone_lock);
363 difference = memcmp(buf, profile, sizeof(struct kone_profile));
364 if (difference) {
365 retval = kone_set_profile(usb_dev,
366 (struct kone_profile const *)buf,
367 *(uint *)(attr->private) + 1);
368 if (!retval)
369 memcpy(profile, buf, sizeof(struct kone_profile));
370 }
371 mutex_unlock(&kone->kone_lock);
372
373 if (retval)
374 return retval;
375
376 return sizeof(struct kone_profile);
377 }
378 #define PROFILE_ATTR(number) \
379 static struct bin_attribute bin_attr_profile##number = { \
380 .attr = { .name = "profile" #number, .mode = 0660 }, \
381 .size = sizeof(struct kone_profile), \
382 .read = kone_sysfs_read_profilex, \
383 .write = kone_sysfs_write_profilex, \
384 .private = &profile_numbers[number-1], \
385 }
386 PROFILE_ATTR(1);
387 PROFILE_ATTR(2);
388 PROFILE_ATTR(3);
389 PROFILE_ATTR(4);
390 PROFILE_ATTR(5);
391
392 static ssize_t kone_sysfs_show_actual_profile(struct device *dev,
393 struct device_attribute *attr, char *buf)
394 {
395 struct kone_device *kone =
396 hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
397 return snprintf(buf, PAGE_SIZE, "%d\n", kone->actual_profile);
398 }
399 static DEVICE_ATTR(actual_profile, 0440, kone_sysfs_show_actual_profile, NULL);
400
401 static ssize_t kone_sysfs_show_actual_dpi(struct device *dev,
402 struct device_attribute *attr, char *buf)
403 {
404 struct kone_device *kone =
405 hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
406 return snprintf(buf, PAGE_SIZE, "%d\n", kone->actual_dpi);
407 }
408 static DEVICE_ATTR(actual_dpi, 0440, kone_sysfs_show_actual_dpi, NULL);
409
410
411 static ssize_t kone_sysfs_show_weight(struct device *dev,
412 struct device_attribute *attr, char *buf)
413 {
414 struct kone_device *kone;
415 struct usb_device *usb_dev;
416 int weight = 0;
417 int retval;
418
419 dev = dev->parent->parent;
420 kone = hid_get_drvdata(dev_get_drvdata(dev));
421 usb_dev = interface_to_usbdev(to_usb_interface(dev));
422
423 mutex_lock(&kone->kone_lock);
424 retval = kone_get_weight(usb_dev, &weight);
425 mutex_unlock(&kone->kone_lock);
426
427 if (retval)
428 return retval;
429 return snprintf(buf, PAGE_SIZE, "%d\n", weight);
430 }
431 static DEVICE_ATTR(weight, 0440, kone_sysfs_show_weight, NULL);
432
433 static ssize_t kone_sysfs_show_firmware_version(struct device *dev,
434 struct device_attribute *attr, char *buf)
435 {
436 struct kone_device *kone =
437 hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
438 return snprintf(buf, PAGE_SIZE, "%d\n", kone->firmware_version);
439 }
440 static DEVICE_ATTR(firmware_version, 0440, kone_sysfs_show_firmware_version,
441 NULL);
442
443 static ssize_t kone_sysfs_show_tcu(struct device *dev,
444 struct device_attribute *attr, char *buf)
445 {
446 struct kone_device *kone =
447 hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
448 return snprintf(buf, PAGE_SIZE, "%d\n", kone->settings.tcu);
449 }
450
451 static int kone_tcu_command(struct usb_device *usb_dev, int number)
452 {
453 unsigned char value;
454
455 value = number;
456 return kone_send(usb_dev, kone_command_calibrate, &value, 1);
457 }
458
459
460
461
462
463 static ssize_t kone_sysfs_set_tcu(struct device *dev,
464 struct device_attribute *attr, char const *buf, size_t size)
465 {
466 struct kone_device *kone;
467 struct usb_device *usb_dev;
468 int retval;
469 unsigned long state;
470
471 dev = dev->parent->parent;
472 kone = hid_get_drvdata(dev_get_drvdata(dev));
473 usb_dev = interface_to_usbdev(to_usb_interface(dev));
474
475 retval = kstrtoul(buf, 10, &state);
476 if (retval)
477 return retval;
478
479 if (state != 0 && state != 1)
480 return -EINVAL;
481
482 mutex_lock(&kone->kone_lock);
483
484 if (state == 1) {
485 retval = kone_tcu_command(usb_dev, 1);
486 if (retval)
487 goto exit_unlock;
488 retval = kone_tcu_command(usb_dev, 2);
489 if (retval)
490 goto exit_unlock;
491 ssleep(5);
492 retval = kone_tcu_command(usb_dev, 3);
493 if (retval)
494 goto exit_unlock;
495 retval = kone_tcu_command(usb_dev, 0);
496 if (retval)
497 goto exit_unlock;
498 retval = kone_tcu_command(usb_dev, 4);
499 if (retval)
500 goto exit_unlock;
501
502
503
504
505
506
507 ssleep(1);
508 }
509
510
511 retval = kone_get_settings(usb_dev, &kone->settings);
512 if (retval)
513 goto exit_no_settings;
514
515
516 if (kone->settings.tcu != state) {
517 kone->settings.tcu = state;
518 kone_set_settings_checksum(&kone->settings);
519
520 retval = kone_set_settings(usb_dev, &kone->settings);
521 if (retval) {
522 dev_err(&usb_dev->dev, "couldn't set tcu state\n");
523
524
525
526
527 retval = kone_get_settings(usb_dev, &kone->settings);
528 if (retval)
529 goto exit_no_settings;
530 goto exit_unlock;
531 }
532
533 kone_profile_activated(kone, kone->settings.startup_profile);
534 }
535
536 retval = size;
537 exit_no_settings:
538 dev_err(&usb_dev->dev, "couldn't read settings\n");
539 exit_unlock:
540 mutex_unlock(&kone->kone_lock);
541 return retval;
542 }
543 static DEVICE_ATTR(tcu, 0660, kone_sysfs_show_tcu, kone_sysfs_set_tcu);
544
545 static ssize_t kone_sysfs_show_startup_profile(struct device *dev,
546 struct device_attribute *attr, char *buf)
547 {
548 struct kone_device *kone =
549 hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
550 return snprintf(buf, PAGE_SIZE, "%d\n", kone->settings.startup_profile);
551 }
552
553 static ssize_t kone_sysfs_set_startup_profile(struct device *dev,
554 struct device_attribute *attr, char const *buf, size_t size)
555 {
556 struct kone_device *kone;
557 struct usb_device *usb_dev;
558 int retval;
559 unsigned long new_startup_profile;
560
561 dev = dev->parent->parent;
562 kone = hid_get_drvdata(dev_get_drvdata(dev));
563 usb_dev = interface_to_usbdev(to_usb_interface(dev));
564
565 retval = kstrtoul(buf, 10, &new_startup_profile);
566 if (retval)
567 return retval;
568
569 if (new_startup_profile < 1 || new_startup_profile > 5)
570 return -EINVAL;
571
572 mutex_lock(&kone->kone_lock);
573
574 kone->settings.startup_profile = new_startup_profile;
575 kone_set_settings_checksum(&kone->settings);
576
577 retval = kone_set_settings(usb_dev, &kone->settings);
578 if (retval) {
579 mutex_unlock(&kone->kone_lock);
580 return retval;
581 }
582
583
584 kone_profile_activated(kone, new_startup_profile);
585 kone_profile_report(kone, new_startup_profile);
586
587 mutex_unlock(&kone->kone_lock);
588 return size;
589 }
590 static DEVICE_ATTR(startup_profile, 0660, kone_sysfs_show_startup_profile,
591 kone_sysfs_set_startup_profile);
592
593 static struct attribute *kone_attrs[] = {
594
595
596
597
598
599 &dev_attr_actual_dpi.attr,
600 &dev_attr_actual_profile.attr,
601
602
603
604
605
606
607
608
609 &dev_attr_weight.attr,
610
611
612
613
614
615
616
617 &dev_attr_firmware_version.attr,
618
619
620
621
622
623
624 &dev_attr_tcu.attr,
625
626
627 &dev_attr_startup_profile.attr,
628 NULL,
629 };
630
631 static struct bin_attribute *kone_bin_attributes[] = {
632 &bin_attr_settings,
633 &bin_attr_profile1,
634 &bin_attr_profile2,
635 &bin_attr_profile3,
636 &bin_attr_profile4,
637 &bin_attr_profile5,
638 NULL,
639 };
640
641 static const struct attribute_group kone_group = {
642 .attrs = kone_attrs,
643 .bin_attrs = kone_bin_attributes,
644 };
645
646 static const struct attribute_group *kone_groups[] = {
647 &kone_group,
648 NULL,
649 };
650
651 static int kone_init_kone_device_struct(struct usb_device *usb_dev,
652 struct kone_device *kone)
653 {
654 uint i;
655 int retval;
656
657 mutex_init(&kone->kone_lock);
658
659 for (i = 0; i < 5; ++i) {
660 retval = kone_get_profile(usb_dev, &kone->profiles[i], i + 1);
661 if (retval)
662 return retval;
663 }
664
665 retval = kone_get_settings(usb_dev, &kone->settings);
666 if (retval)
667 return retval;
668
669 retval = kone_get_firmware_version(usb_dev, &kone->firmware_version);
670 if (retval)
671 return retval;
672
673 kone_profile_activated(kone, kone->settings.startup_profile);
674
675 return 0;
676 }
677
678
679
680
681
682
683
684
685 static int kone_init_specials(struct hid_device *hdev)
686 {
687 struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
688 struct usb_device *usb_dev = interface_to_usbdev(intf);
689 struct kone_device *kone;
690 int retval;
691
692 if (intf->cur_altsetting->desc.bInterfaceProtocol
693 == USB_INTERFACE_PROTOCOL_MOUSE) {
694
695 kone = kzalloc(sizeof(*kone), GFP_KERNEL);
696 if (!kone)
697 return -ENOMEM;
698 hid_set_drvdata(hdev, kone);
699
700 retval = kone_init_kone_device_struct(usb_dev, kone);
701 if (retval) {
702 hid_err(hdev, "couldn't init struct kone_device\n");
703 goto exit_free;
704 }
705
706 retval = roccat_connect(kone_class, hdev,
707 sizeof(struct kone_roccat_report));
708 if (retval < 0) {
709 hid_err(hdev, "couldn't init char dev\n");
710
711 } else {
712 kone->roccat_claimed = 1;
713 kone->chrdev_minor = retval;
714 }
715 } else {
716 hid_set_drvdata(hdev, NULL);
717 }
718
719 return 0;
720 exit_free:
721 kfree(kone);
722 return retval;
723 }
724
725 static void kone_remove_specials(struct hid_device *hdev)
726 {
727 struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
728 struct kone_device *kone;
729
730 if (intf->cur_altsetting->desc.bInterfaceProtocol
731 == USB_INTERFACE_PROTOCOL_MOUSE) {
732 kone = hid_get_drvdata(hdev);
733 if (kone->roccat_claimed)
734 roccat_disconnect(kone->chrdev_minor);
735 kfree(hid_get_drvdata(hdev));
736 }
737 }
738
739 static int kone_probe(struct hid_device *hdev, const struct hid_device_id *id)
740 {
741 int retval;
742
743 retval = hid_parse(hdev);
744 if (retval) {
745 hid_err(hdev, "parse failed\n");
746 goto exit;
747 }
748
749 retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
750 if (retval) {
751 hid_err(hdev, "hw start failed\n");
752 goto exit;
753 }
754
755 retval = kone_init_specials(hdev);
756 if (retval) {
757 hid_err(hdev, "couldn't install mouse\n");
758 goto exit_stop;
759 }
760
761 return 0;
762
763 exit_stop:
764 hid_hw_stop(hdev);
765 exit:
766 return retval;
767 }
768
769 static void kone_remove(struct hid_device *hdev)
770 {
771 kone_remove_specials(hdev);
772 hid_hw_stop(hdev);
773 }
774
775
776 static void kone_keep_values_up_to_date(struct kone_device *kone,
777 struct kone_mouse_event const *event)
778 {
779 switch (event->event) {
780 case kone_mouse_event_switch_profile:
781 kone->actual_dpi = kone->profiles[event->value - 1].
782 startup_dpi;
783
784 case kone_mouse_event_osd_profile:
785 kone->actual_profile = event->value;
786 break;
787 case kone_mouse_event_switch_dpi:
788 case kone_mouse_event_osd_dpi:
789 kone->actual_dpi = event->value;
790 break;
791 }
792 }
793
794 static void kone_report_to_chrdev(struct kone_device const *kone,
795 struct kone_mouse_event const *event)
796 {
797 struct kone_roccat_report roccat_report;
798
799 switch (event->event) {
800 case kone_mouse_event_switch_profile:
801 case kone_mouse_event_switch_dpi:
802 case kone_mouse_event_osd_profile:
803 case kone_mouse_event_osd_dpi:
804 roccat_report.event = event->event;
805 roccat_report.value = event->value;
806 roccat_report.key = 0;
807 roccat_report_event(kone->chrdev_minor,
808 (uint8_t *)&roccat_report);
809 break;
810 case kone_mouse_event_call_overlong_macro:
811 case kone_mouse_event_multimedia:
812 if (event->value == kone_keystroke_action_press) {
813 roccat_report.event = event->event;
814 roccat_report.value = kone->actual_profile;
815 roccat_report.key = event->macro_key;
816 roccat_report_event(kone->chrdev_minor,
817 (uint8_t *)&roccat_report);
818 }
819 break;
820 }
821
822 }
823
824
825
826
827
828
829 static int kone_raw_event(struct hid_device *hdev, struct hid_report *report,
830 u8 *data, int size)
831 {
832 struct kone_device *kone = hid_get_drvdata(hdev);
833 struct kone_mouse_event *event = (struct kone_mouse_event *)data;
834
835
836 if (size != sizeof(struct kone_mouse_event))
837 return 0;
838
839 if (kone == NULL)
840 return 0;
841
842
843
844
845
846
847 if (memcmp(&kone->last_mouse_event.tilt, &event->tilt, 5))
848 memcpy(&kone->last_mouse_event, event,
849 sizeof(struct kone_mouse_event));
850 else
851 memset(&event->tilt, 0, 5);
852
853 kone_keep_values_up_to_date(kone, event);
854
855 if (kone->roccat_claimed)
856 kone_report_to_chrdev(kone, event);
857
858 return 0;
859 }
860
861 static const struct hid_device_id kone_devices[] = {
862 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },
863 { }
864 };
865
866 MODULE_DEVICE_TABLE(hid, kone_devices);
867
868 static struct hid_driver kone_driver = {
869 .name = "kone",
870 .id_table = kone_devices,
871 .probe = kone_probe,
872 .remove = kone_remove,
873 .raw_event = kone_raw_event
874 };
875
876 static int __init kone_init(void)
877 {
878 int retval;
879
880
881 kone_class = class_create(THIS_MODULE, "kone");
882 if (IS_ERR(kone_class))
883 return PTR_ERR(kone_class);
884 kone_class->dev_groups = kone_groups;
885
886 retval = hid_register_driver(&kone_driver);
887 if (retval)
888 class_destroy(kone_class);
889 return retval;
890 }
891
892 static void __exit kone_exit(void)
893 {
894 hid_unregister_driver(&kone_driver);
895 class_destroy(kone_class);
896 }
897
898 module_init(kone_init);
899 module_exit(kone_exit);
900
901 MODULE_AUTHOR("Stefan Achatz");
902 MODULE_DESCRIPTION("USB Roccat Kone driver");
903 MODULE_LICENSE("GPL v2");