2 * Roccat Kone driver for Linux
4 * Copyright (c) 2010 Stefan Achatz <erazor_de@users.sourceforge.net>
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)
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.
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?
25 * TODO is it possible to overwrite group for sysfs attributes via udev?
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>
35 #include "hid-roccat-common.h"
36 #include "hid-roccat-kone.h"
38 static uint profile_numbers[5] = {0, 1, 2, 3, 4};
40 static int kone_receive(struct usb_device *usb_dev, uint usb_command,
41 void *data, uint size)
46 buf = kmalloc(size, GFP_KERNEL);
50 len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
52 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
53 usb_command, 0, buf, size, USB_CTRL_SET_TIMEOUT);
55 memcpy(data, buf, size);
57 return ((len < 0) ? len : ((len != size) ? -EIO : 0));
60 static int kone_send(struct usb_device *usb_dev, uint usb_command,
61 void const *data, uint size)
66 buf = kmalloc(size, GFP_KERNEL);
70 memcpy(buf, data, size);
72 len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
74 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
75 usb_command, 0, buf, size, USB_CTRL_SET_TIMEOUT);
78 return ((len < 0) ? len : ((len != size) ? -EIO : 0));
81 /* kone_class is used for creating sysfs attributes via roccat char device */
82 static struct class *kone_class;
84 static void kone_set_settings_checksum(struct kone_settings *settings)
86 uint16_t checksum = 0;
87 unsigned char *address = (unsigned char *)settings;
90 for (i = 0; i < sizeof(struct kone_settings) - 2; ++i, ++address)
92 settings->checksum = cpu_to_le16(checksum);
96 * Checks success after writing data to mouse
97 * On success returns 0
98 * On failure returns errno
100 static int kone_check_write(struct usb_device *usb_dev)
107 * Mouse needs 50 msecs until it says ok, but there are
108 * 30 more msecs needed for next write to work.
112 retval = kone_receive(usb_dev,
113 kone_command_confirm_write, &data, 1);
118 * value of 3 seems to mean something like
119 * "not finished yet, but it looks good"
120 * So check again after a moment.
124 if (data == 1) /* everything alright */
128 hid_err(usb_dev, "got retval %d when checking write\n", data);
133 * Reads settings from mouse and stores it in @buf
134 * On success returns 0
135 * On failure returns errno
137 static int kone_get_settings(struct usb_device *usb_dev,
138 struct kone_settings *buf)
140 return kone_receive(usb_dev, kone_command_settings, buf,
141 sizeof(struct kone_settings));
145 * Writes settings from @buf to mouse
146 * On success returns 0
147 * On failure returns errno
149 static int kone_set_settings(struct usb_device *usb_dev,
150 struct kone_settings const *settings)
153 retval = kone_send(usb_dev, kone_command_settings,
154 settings, sizeof(struct kone_settings));
157 return kone_check_write(usb_dev);
161 * Reads profile data from mouse and stores it in @buf
162 * @number: profile number to read
163 * On success returns 0
164 * On failure returns errno
166 static int kone_get_profile(struct usb_device *usb_dev,
167 struct kone_profile *buf, int number)
171 if (number < 1 || number > 5)
174 len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
175 USB_REQ_CLEAR_FEATURE,
176 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
177 kone_command_profile, number, buf,
178 sizeof(struct kone_profile), USB_CTRL_SET_TIMEOUT);
180 if (len != sizeof(struct kone_profile))
187 * Writes profile data to mouse.
188 * @number: profile number to write
189 * On success returns 0
190 * On failure returns errno
192 static int kone_set_profile(struct usb_device *usb_dev,
193 struct kone_profile const *profile, int number)
197 if (number < 1 || number > 5)
200 len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
201 USB_REQ_SET_CONFIGURATION,
202 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
203 kone_command_profile, number, (void *)profile,
204 sizeof(struct kone_profile),
205 USB_CTRL_SET_TIMEOUT);
207 if (len != sizeof(struct kone_profile))
210 if (kone_check_write(usb_dev))
217 * Reads value of "fast-clip-weight" and stores it in @result
218 * On success returns 0
219 * On failure returns errno
221 static int kone_get_weight(struct usb_device *usb_dev, int *result)
226 retval = kone_receive(usb_dev, kone_command_weight, &data, 1);
236 * Reads firmware_version of mouse and stores it in @result
237 * On success returns 0
238 * On failure returns errno
240 static int kone_get_firmware_version(struct usb_device *usb_dev, int *result)
245 retval = kone_receive(usb_dev, kone_command_firmware_version,
250 *result = le16_to_cpu(data);
254 static ssize_t kone_sysfs_read_settings(struct file *fp, struct kobject *kobj,
255 struct bin_attribute *attr, char *buf,
256 loff_t off, size_t count) {
258 container_of(kobj, struct device, kobj)->parent->parent;
259 struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
261 if (off >= sizeof(struct kone_settings))
264 if (off + count > sizeof(struct kone_settings))
265 count = sizeof(struct kone_settings) - off;
267 mutex_lock(&kone->kone_lock);
268 memcpy(buf, ((char const *)&kone->settings) + off, count);
269 mutex_unlock(&kone->kone_lock);
275 * Writing settings automatically activates startup_profile.
276 * This function keeps values in kone_device up to date and assumes that in
277 * case of error the old data is still valid
279 static ssize_t kone_sysfs_write_settings(struct file *fp, struct kobject *kobj,
280 struct bin_attribute *attr, char *buf,
281 loff_t off, size_t count) {
283 container_of(kobj, struct device, kobj)->parent->parent;
284 struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
285 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
286 int retval = 0, difference;
288 /* I need to get my data in one piece */
289 if (off != 0 || count != sizeof(struct kone_settings))
292 mutex_lock(&kone->kone_lock);
293 difference = memcmp(buf, &kone->settings, sizeof(struct kone_settings));
295 retval = kone_set_settings(usb_dev,
296 (struct kone_settings const *)buf);
298 memcpy(&kone->settings, buf,
299 sizeof(struct kone_settings));
301 mutex_unlock(&kone->kone_lock);
307 * If we get here, treat settings as okay and update actual values
308 * according to startup_profile
310 kone->actual_profile = kone->settings.startup_profile;
311 kone->actual_dpi = kone->profiles[kone->actual_profile - 1].startup_dpi;
313 return sizeof(struct kone_settings);
316 static ssize_t kone_sysfs_read_profilex(struct file *fp,
317 struct kobject *kobj, struct bin_attribute *attr,
318 char *buf, loff_t off, size_t count) {
320 container_of(kobj, struct device, kobj)->parent->parent;
321 struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
323 if (off >= sizeof(struct kone_profile))
326 if (off + count > sizeof(struct kone_profile))
327 count = sizeof(struct kone_profile) - off;
329 mutex_lock(&kone->kone_lock);
330 memcpy(buf, ((char const *)&kone->profiles[*(uint *)(attr->private)]) + off, count);
331 mutex_unlock(&kone->kone_lock);
336 /* Writes data only if different to stored data */
337 static ssize_t kone_sysfs_write_profilex(struct file *fp,
338 struct kobject *kobj, struct bin_attribute *attr,
339 char *buf, loff_t off, size_t count) {
341 container_of(kobj, struct device, kobj)->parent->parent;
342 struct kone_device *kone = hid_get_drvdata(dev_get_drvdata(dev));
343 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
344 struct kone_profile *profile;
345 int retval = 0, difference;
347 /* I need to get my data in one piece */
348 if (off != 0 || count != sizeof(struct kone_profile))
351 profile = &kone->profiles[*(uint *)(attr->private)];
353 mutex_lock(&kone->kone_lock);
354 difference = memcmp(buf, profile, sizeof(struct kone_profile));
356 retval = kone_set_profile(usb_dev,
357 (struct kone_profile const *)buf,
358 *(uint *)(attr->private) + 1);
360 memcpy(profile, buf, sizeof(struct kone_profile));
362 mutex_unlock(&kone->kone_lock);
367 return sizeof(struct kone_profile);
370 static ssize_t kone_sysfs_show_actual_profile(struct device *dev,
371 struct device_attribute *attr, char *buf)
373 struct kone_device *kone =
374 hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
375 return snprintf(buf, PAGE_SIZE, "%d\n", kone->actual_profile);
378 static ssize_t kone_sysfs_show_actual_dpi(struct device *dev,
379 struct device_attribute *attr, char *buf)
381 struct kone_device *kone =
382 hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
383 return snprintf(buf, PAGE_SIZE, "%d\n", kone->actual_dpi);
386 /* weight is read each time, since we don't get informed when it's changed */
387 static ssize_t kone_sysfs_show_weight(struct device *dev,
388 struct device_attribute *attr, char *buf)
390 struct kone_device *kone;
391 struct usb_device *usb_dev;
395 dev = dev->parent->parent;
396 kone = hid_get_drvdata(dev_get_drvdata(dev));
397 usb_dev = interface_to_usbdev(to_usb_interface(dev));
399 mutex_lock(&kone->kone_lock);
400 retval = kone_get_weight(usb_dev, &weight);
401 mutex_unlock(&kone->kone_lock);
405 return snprintf(buf, PAGE_SIZE, "%d\n", weight);
408 static ssize_t kone_sysfs_show_firmware_version(struct device *dev,
409 struct device_attribute *attr, char *buf)
411 struct kone_device *kone =
412 hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
413 return snprintf(buf, PAGE_SIZE, "%d\n", kone->firmware_version);
416 static ssize_t kone_sysfs_show_tcu(struct device *dev,
417 struct device_attribute *attr, char *buf)
419 struct kone_device *kone =
420 hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
421 return snprintf(buf, PAGE_SIZE, "%d\n", kone->settings.tcu);
424 static int kone_tcu_command(struct usb_device *usb_dev, int number)
428 return kone_send(usb_dev, kone_command_calibrate, &value, 1);
432 * Calibrating the tcu is the only action that changes settings data inside the
433 * mouse, so this data needs to be reread
435 static ssize_t kone_sysfs_set_tcu(struct device *dev,
436 struct device_attribute *attr, char const *buf, size_t size)
438 struct kone_device *kone;
439 struct usb_device *usb_dev;
443 dev = dev->parent->parent;
444 kone = hid_get_drvdata(dev_get_drvdata(dev));
445 usb_dev = interface_to_usbdev(to_usb_interface(dev));
447 retval = strict_strtoul(buf, 10, &state);
451 if (state != 0 && state != 1)
454 mutex_lock(&kone->kone_lock);
456 if (state == 1) { /* state activate */
457 retval = kone_tcu_command(usb_dev, 1);
460 retval = kone_tcu_command(usb_dev, 2);
463 ssleep(5); /* tcu needs this time for calibration */
464 retval = kone_tcu_command(usb_dev, 3);
467 retval = kone_tcu_command(usb_dev, 0);
470 retval = kone_tcu_command(usb_dev, 4);
474 * Kone needs this time to settle things.
475 * Reading settings too early will result in invalid data.
476 * Roccat's driver waits 1 sec, maybe this time could be
482 /* calibration changes values in settings, so reread */
483 retval = kone_get_settings(usb_dev, &kone->settings);
485 goto exit_no_settings;
487 /* only write settings back if activation state is different */
488 if (kone->settings.tcu != state) {
489 kone->settings.tcu = state;
490 kone_set_settings_checksum(&kone->settings);
492 retval = kone_set_settings(usb_dev, &kone->settings);
494 hid_err(usb_dev, "couldn't set tcu state\n");
496 * try to reread valid settings into buffer overwriting
499 retval = kone_get_settings(usb_dev, &kone->settings);
501 goto exit_no_settings;
508 hid_err(usb_dev, "couldn't read settings\n");
510 mutex_unlock(&kone->kone_lock);
514 static ssize_t kone_sysfs_show_startup_profile(struct device *dev,
515 struct device_attribute *attr, char *buf)
517 struct kone_device *kone =
518 hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
519 return snprintf(buf, PAGE_SIZE, "%d\n", kone->settings.startup_profile);
522 static ssize_t kone_sysfs_set_startup_profile(struct device *dev,
523 struct device_attribute *attr, char const *buf, size_t size)
525 struct kone_device *kone;
526 struct usb_device *usb_dev;
528 unsigned long new_startup_profile;
530 dev = dev->parent->parent;
531 kone = hid_get_drvdata(dev_get_drvdata(dev));
532 usb_dev = interface_to_usbdev(to_usb_interface(dev));
534 retval = strict_strtoul(buf, 10, &new_startup_profile);
538 if (new_startup_profile < 1 || new_startup_profile > 5)
541 mutex_lock(&kone->kone_lock);
543 kone->settings.startup_profile = new_startup_profile;
544 kone_set_settings_checksum(&kone->settings);
546 retval = kone_set_settings(usb_dev, &kone->settings);
548 mutex_unlock(&kone->kone_lock);
553 /* changing the startup profile immediately activates this profile */
554 kone->actual_profile = new_startup_profile;
555 kone->actual_dpi = kone->profiles[kone->actual_profile - 1].startup_dpi;
560 static struct device_attribute kone_attributes[] = {
562 * Read actual dpi settings.
563 * Returns raw value for further processing. Refer to enum
564 * kone_polling_rates to get real value.
566 __ATTR(actual_dpi, 0440, kone_sysfs_show_actual_dpi, NULL),
567 __ATTR(actual_profile, 0440, kone_sysfs_show_actual_profile, NULL),
570 * The mouse can be equipped with one of four supplied weights from 5
571 * to 20 grams which are recognized and its value can be read out.
572 * This returns the raw value reported by the mouse for easy evaluation
573 * by software. Refer to enum kone_weights to get corresponding real
576 __ATTR(weight, 0440, kone_sysfs_show_weight, NULL),
579 * Prints firmware version stored in mouse as integer.
580 * The raw value reported by the mouse is returned for easy evaluation,
581 * to get the real version number the decimal point has to be shifted 2
582 * positions to the left. E.g. a value of 138 means 1.38.
584 __ATTR(firmware_version, 0440,
585 kone_sysfs_show_firmware_version, NULL),
588 * Prints state of Tracking Control Unit as number where 0 = off and
589 * 1 = on. Writing 0 deactivates tcu and writing 1 calibrates and
592 __ATTR(tcu, 0660, kone_sysfs_show_tcu, kone_sysfs_set_tcu),
594 /* Prints and takes the number of the profile the mouse starts with */
595 __ATTR(startup_profile, 0660,
596 kone_sysfs_show_startup_profile,
597 kone_sysfs_set_startup_profile),
601 static struct bin_attribute kone_bin_attributes[] = {
603 .attr = { .name = "settings", .mode = 0660 },
604 .size = sizeof(struct kone_settings),
605 .read = kone_sysfs_read_settings,
606 .write = kone_sysfs_write_settings
609 .attr = { .name = "profile1", .mode = 0660 },
610 .size = sizeof(struct kone_profile),
611 .read = kone_sysfs_read_profilex,
612 .write = kone_sysfs_write_profilex,
613 .private = &profile_numbers[0]
616 .attr = { .name = "profile2", .mode = 0660 },
617 .size = sizeof(struct kone_profile),
618 .read = kone_sysfs_read_profilex,
619 .write = kone_sysfs_write_profilex,
620 .private = &profile_numbers[1]
623 .attr = { .name = "profile3", .mode = 0660 },
624 .size = sizeof(struct kone_profile),
625 .read = kone_sysfs_read_profilex,
626 .write = kone_sysfs_write_profilex,
627 .private = &profile_numbers[2]
630 .attr = { .name = "profile4", .mode = 0660 },
631 .size = sizeof(struct kone_profile),
632 .read = kone_sysfs_read_profilex,
633 .write = kone_sysfs_write_profilex,
634 .private = &profile_numbers[3]
637 .attr = { .name = "profile5", .mode = 0660 },
638 .size = sizeof(struct kone_profile),
639 .read = kone_sysfs_read_profilex,
640 .write = kone_sysfs_write_profilex,
641 .private = &profile_numbers[4]
646 static int kone_init_kone_device_struct(struct usb_device *usb_dev,
647 struct kone_device *kone)
652 mutex_init(&kone->kone_lock);
654 for (i = 0; i < 5; ++i) {
655 retval = kone_get_profile(usb_dev, &kone->profiles[i], i + 1);
660 retval = kone_get_settings(usb_dev, &kone->settings);
664 retval = kone_get_firmware_version(usb_dev, &kone->firmware_version);
668 kone->actual_profile = kone->settings.startup_profile;
669 kone->actual_dpi = kone->profiles[kone->actual_profile].startup_dpi;
675 * Since IGNORE_MOUSE quirk moved to hid-apple, there is no way to bind only to
676 * mousepart if usb_hid is compiled into the kernel and kone is compiled as
678 * Secial behaviour is bound only to mousepart since only mouseevents contain
679 * additional notifications.
681 static int kone_init_specials(struct hid_device *hdev)
683 struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
684 struct usb_device *usb_dev = interface_to_usbdev(intf);
685 struct kone_device *kone;
688 if (intf->cur_altsetting->desc.bInterfaceProtocol
689 == USB_INTERFACE_PROTOCOL_MOUSE) {
691 kone = kzalloc(sizeof(*kone), GFP_KERNEL);
693 hid_err(hdev, "can't alloc device descriptor\n");
696 hid_set_drvdata(hdev, kone);
698 retval = kone_init_kone_device_struct(usb_dev, kone);
700 hid_err(hdev, "couldn't init struct kone_device\n");
704 retval = roccat_connect(kone_class, hdev,
705 sizeof(struct kone_roccat_report));
707 hid_err(hdev, "couldn't init char dev\n");
708 /* be tolerant about not getting chrdev */
710 kone->roccat_claimed = 1;
711 kone->chrdev_minor = retval;
714 hid_set_drvdata(hdev, NULL);
723 static void kone_remove_specials(struct hid_device *hdev)
725 struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
726 struct kone_device *kone;
728 if (intf->cur_altsetting->desc.bInterfaceProtocol
729 == USB_INTERFACE_PROTOCOL_MOUSE) {
730 kone = hid_get_drvdata(hdev);
731 if (kone->roccat_claimed)
732 roccat_disconnect(kone->chrdev_minor);
733 kfree(hid_get_drvdata(hdev));
737 static int kone_probe(struct hid_device *hdev, const struct hid_device_id *id)
741 retval = hid_parse(hdev);
743 hid_err(hdev, "parse failed\n");
747 retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
749 hid_err(hdev, "hw start failed\n");
753 retval = kone_init_specials(hdev);
755 hid_err(hdev, "couldn't install mouse\n");
767 static void kone_remove(struct hid_device *hdev)
769 kone_remove_specials(hdev);
773 /* handle special events and keep actual profile and dpi values up to date */
774 static void kone_keep_values_up_to_date(struct kone_device *kone,
775 struct kone_mouse_event const *event)
777 switch (event->event) {
778 case kone_mouse_event_switch_profile:
779 case kone_mouse_event_osd_profile:
780 kone->actual_profile = event->value;
781 kone->actual_dpi = kone->profiles[kone->actual_profile - 1].
784 case kone_mouse_event_switch_dpi:
785 case kone_mouse_event_osd_dpi:
786 kone->actual_dpi = event->value;
791 static void kone_report_to_chrdev(struct kone_device const *kone,
792 struct kone_mouse_event const *event)
794 struct kone_roccat_report roccat_report;
796 switch (event->event) {
797 case kone_mouse_event_switch_profile:
798 case kone_mouse_event_switch_dpi:
799 case kone_mouse_event_osd_profile:
800 case kone_mouse_event_osd_dpi:
801 roccat_report.event = event->event;
802 roccat_report.value = event->value;
803 roccat_report.key = 0;
804 roccat_report_event(kone->chrdev_minor,
805 (uint8_t *)&roccat_report);
807 case kone_mouse_event_call_overlong_macro:
808 if (event->value == kone_keystroke_action_press) {
809 roccat_report.event = kone_mouse_event_call_overlong_macro;
810 roccat_report.value = kone->actual_profile;
811 roccat_report.key = event->macro_key;
812 roccat_report_event(kone->chrdev_minor,
813 (uint8_t *)&roccat_report);
821 * Is called for keyboard- and mousepart.
822 * Only mousepart gets informations about special events in its extended event
825 static int kone_raw_event(struct hid_device *hdev, struct hid_report *report,
828 struct kone_device *kone = hid_get_drvdata(hdev);
829 struct kone_mouse_event *event = (struct kone_mouse_event *)data;
831 /* keyboard events are always processed by default handler */
832 if (size != sizeof(struct kone_mouse_event))
839 * Firmware 1.38 introduced new behaviour for tilt and special buttons.
840 * Pressed button is reported in each movement event.
841 * Workaround sends only one event per press.
843 if (memcmp(&kone->last_mouse_event.tilt, &event->tilt, 5))
844 memcpy(&kone->last_mouse_event, event,
845 sizeof(struct kone_mouse_event));
847 memset(&event->tilt, 0, 5);
849 kone_keep_values_up_to_date(kone, event);
851 if (kone->roccat_claimed)
852 kone_report_to_chrdev(kone, event);
854 return 0; /* always do further processing */
857 static const struct hid_device_id kone_devices[] = {
858 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONE) },
862 MODULE_DEVICE_TABLE(hid, kone_devices);
864 static struct hid_driver kone_driver = {
866 .id_table = kone_devices,
868 .remove = kone_remove,
869 .raw_event = kone_raw_event
872 static int __init kone_init(void)
876 /* class name has to be same as driver name */
877 kone_class = class_create(THIS_MODULE, "kone");
878 if (IS_ERR(kone_class))
879 return PTR_ERR(kone_class);
880 kone_class->dev_attrs = kone_attributes;
881 kone_class->dev_bin_attrs = kone_bin_attributes;
883 retval = hid_register_driver(&kone_driver);
885 class_destroy(kone_class);
889 static void __exit kone_exit(void)
891 hid_unregister_driver(&kone_driver);
892 class_destroy(kone_class);
895 module_init(kone_init);
896 module_exit(kone_exit);
898 MODULE_AUTHOR("Stefan Achatz");
899 MODULE_DESCRIPTION("USB Roccat Kone driver");
900 MODULE_LICENSE("GPL v2");