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