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