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 an updated/improved version of the Kone with more memory 16 * and functionality and without the non-standard behaviours the Kone had. 17 */ 18 19 #include <linux/device.h> 20 #include <linux/input.h> 21 #include <linux/hid.h> 22 #include <linux/usb.h> 23 #include <linux/module.h> 24 #include <linux/slab.h> 25 #include "hid-ids.h" 26 #include "hid-roccat.h" 27 #include "hid-roccat-koneplus.h" 28 29 static uint profile_numbers[5] = {0, 1, 2, 3, 4}; 30 31 static struct class *koneplus_class; 32 33 static void koneplus_profile_activated(struct koneplus_device *koneplus, 34 uint new_profile) 35 { 36 koneplus->actual_profile = new_profile; 37 } 38 39 static int koneplus_send_control(struct usb_device *usb_dev, uint value, 40 enum koneplus_control_requests request) 41 { 42 int len; 43 struct koneplus_control *control; 44 45 if ((request == KONEPLUS_CONTROL_REQUEST_PROFILE_SETTINGS || 46 request == KONEPLUS_CONTROL_REQUEST_PROFILE_BUTTONS) && 47 value > 4) 48 return -EINVAL; 49 50 control = kmalloc(sizeof(struct koneplus_control), GFP_KERNEL); 51 if (!control) 52 return -ENOMEM; 53 54 control->command = KONEPLUS_COMMAND_CONTROL; 55 control->value = value; 56 control->request = request; 57 58 len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0), 59 USB_REQ_SET_CONFIGURATION, 60 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT, 61 KONEPLUS_USB_COMMAND_CONTROL, 0, control, 62 sizeof(struct koneplus_control), 63 USB_CTRL_SET_TIMEOUT); 64 65 kfree(control); 66 67 if (len != sizeof(struct koneplus_control)) 68 return len; 69 70 return 0; 71 } 72 73 static int koneplus_receive(struct usb_device *usb_dev, uint usb_command, 74 void *buf, uint size) { 75 int len; 76 77 len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0), 78 USB_REQ_CLEAR_FEATURE, 79 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, 80 usb_command, 0, buf, size, USB_CTRL_SET_TIMEOUT); 81 82 return (len != size) ? -EIO : 0; 83 } 84 85 static int koneplus_receive_control_status(struct usb_device *usb_dev) 86 { 87 int retval; 88 struct koneplus_control *control; 89 90 control = kmalloc(sizeof(struct koneplus_control), GFP_KERNEL); 91 if (!control) 92 return -ENOMEM; 93 94 do { 95 retval = koneplus_receive(usb_dev, KONEPLUS_USB_COMMAND_CONTROL, 96 control, sizeof(struct koneplus_control)); 97 98 /* check if we get a completely wrong answer */ 99 if (retval) 100 goto out; 101 102 if (control->value == KONEPLUS_CONTROL_REQUEST_STATUS_OK) { 103 retval = 0; 104 goto out; 105 } 106 107 /* indicates that hardware needs some more time to complete action */ 108 if (control->value == KONEPLUS_CONTROL_REQUEST_STATUS_WAIT) { 109 msleep(500); /* windows driver uses 1000 */ 110 continue; 111 } 112 113 /* seems to be critical - replug necessary */ 114 if (control->value == KONEPLUS_CONTROL_REQUEST_STATUS_OVERLOAD) { 115 retval = -EINVAL; 116 goto out; 117 } 118 119 dev_err(&usb_dev->dev, "koneplus_receive_control_status: " 120 "unknown response value 0x%x\n", control->value); 121 retval = -EINVAL; 122 goto out; 123 124 } while (1); 125 out: 126 kfree(control); 127 return retval; 128 } 129 130 static int koneplus_send(struct usb_device *usb_dev, uint command, 131 void *buf, uint size) { 132 int len; 133 134 len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0), 135 USB_REQ_SET_CONFIGURATION, 136 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT, 137 command, 0, buf, size, USB_CTRL_SET_TIMEOUT); 138 139 if (len != size) 140 return -EIO; 141 142 if (koneplus_receive_control_status(usb_dev)) 143 return -EIO; 144 145 return 0; 146 } 147 148 static int koneplus_select_profile(struct usb_device *usb_dev, uint number, 149 enum koneplus_control_requests request) 150 { 151 int retval; 152 153 retval = koneplus_send_control(usb_dev, number, request); 154 if (retval) 155 return retval; 156 157 /* allow time to settle things - windows driver uses 500 */ 158 msleep(100); 159 160 retval = koneplus_receive_control_status(usb_dev); 161 if (retval) 162 return retval; 163 164 return 0; 165 } 166 167 static int koneplus_get_info(struct usb_device *usb_dev, 168 struct koneplus_info *buf) 169 { 170 return koneplus_receive(usb_dev, KONEPLUS_USB_COMMAND_INFO, 171 buf, sizeof(struct koneplus_info)); 172 } 173 174 static int koneplus_get_profile_settings(struct usb_device *usb_dev, 175 struct koneplus_profile_settings *buf, uint number) 176 { 177 int retval; 178 179 retval = koneplus_select_profile(usb_dev, number, 180 KONEPLUS_CONTROL_REQUEST_PROFILE_SETTINGS); 181 if (retval) 182 return retval; 183 184 return koneplus_receive(usb_dev, KONEPLUS_USB_COMMAND_PROFILE_SETTINGS, 185 buf, sizeof(struct koneplus_profile_settings)); 186 } 187 188 static int koneplus_set_profile_settings(struct usb_device *usb_dev, 189 struct koneplus_profile_settings const *settings) 190 { 191 return koneplus_send(usb_dev, KONEPLUS_USB_COMMAND_PROFILE_SETTINGS, 192 (void *)settings, sizeof(struct koneplus_profile_settings)); 193 } 194 195 static int koneplus_get_profile_buttons(struct usb_device *usb_dev, 196 struct koneplus_profile_buttons *buf, int number) 197 { 198 int retval; 199 200 retval = koneplus_select_profile(usb_dev, number, 201 KONEPLUS_CONTROL_REQUEST_PROFILE_BUTTONS); 202 if (retval) 203 return retval; 204 205 return koneplus_receive(usb_dev, KONEPLUS_USB_COMMAND_PROFILE_BUTTONS, 206 buf, sizeof(struct koneplus_profile_buttons)); 207 } 208 209 static int koneplus_set_profile_buttons(struct usb_device *usb_dev, 210 struct koneplus_profile_buttons const *buttons) 211 { 212 return koneplus_send(usb_dev, KONEPLUS_USB_COMMAND_PROFILE_BUTTONS, 213 (void *)buttons, sizeof(struct koneplus_profile_buttons)); 214 } 215 216 /* retval is 0-4 on success, < 0 on error */ 217 static int koneplus_get_startup_profile(struct usb_device *usb_dev) 218 { 219 struct koneplus_startup_profile *buf; 220 int retval; 221 222 buf = kmalloc(sizeof(struct koneplus_startup_profile), GFP_KERNEL); 223 224 retval = koneplus_receive(usb_dev, KONEPLUS_USB_COMMAND_STARTUP_PROFILE, 225 buf, sizeof(struct koneplus_startup_profile)); 226 227 if (retval) 228 goto out; 229 230 retval = buf->startup_profile; 231 out: 232 kfree(buf); 233 return retval; 234 } 235 236 static int koneplus_set_startup_profile(struct usb_device *usb_dev, 237 int startup_profile) 238 { 239 struct koneplus_startup_profile buf; 240 241 buf.command = KONEPLUS_COMMAND_STARTUP_PROFILE; 242 buf.size = sizeof(struct koneplus_startup_profile); 243 buf.startup_profile = startup_profile; 244 245 return koneplus_send(usb_dev, KONEPLUS_USB_COMMAND_STARTUP_PROFILE, 246 (char *)&buf, sizeof(struct koneplus_profile_buttons)); 247 } 248 249 static ssize_t koneplus_sysfs_read(struct file *fp, struct kobject *kobj, 250 char *buf, loff_t off, size_t count, 251 size_t real_size, uint command) 252 { 253 struct device *dev = 254 container_of(kobj, struct device, kobj)->parent->parent; 255 struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev)); 256 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 257 int retval; 258 259 if (off != 0 || count != real_size) 260 return -EINVAL; 261 262 mutex_lock(&koneplus->koneplus_lock); 263 retval = koneplus_receive(usb_dev, command, buf, real_size); 264 mutex_unlock(&koneplus->koneplus_lock); 265 266 if (retval) 267 return retval; 268 269 return real_size; 270 } 271 272 static ssize_t koneplus_sysfs_write(struct file *fp, struct kobject *kobj, 273 void const *buf, loff_t off, size_t count, 274 size_t real_size, uint command) 275 { 276 struct device *dev = 277 container_of(kobj, struct device, kobj)->parent->parent; 278 struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev)); 279 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 280 int retval; 281 282 if (off != 0 || count != real_size) 283 return -EINVAL; 284 285 mutex_lock(&koneplus->koneplus_lock); 286 retval = koneplus_send(usb_dev, command, (void *)buf, real_size); 287 mutex_unlock(&koneplus->koneplus_lock); 288 289 if (retval) 290 return retval; 291 292 return real_size; 293 } 294 295 static ssize_t koneplus_sysfs_write_macro(struct file *fp, 296 struct kobject *kobj, struct bin_attribute *attr, char *buf, 297 loff_t off, size_t count) 298 { 299 return koneplus_sysfs_write(fp, kobj, buf, off, count, 300 sizeof(struct koneplus_macro), KONEPLUS_USB_COMMAND_MACRO); 301 } 302 303 static ssize_t koneplus_sysfs_read_sensor(struct file *fp, 304 struct kobject *kobj, struct bin_attribute *attr, char *buf, 305 loff_t off, size_t count) 306 { 307 return koneplus_sysfs_read(fp, kobj, buf, off, count, 308 sizeof(struct koneplus_sensor), KONEPLUS_USB_COMMAND_SENSOR); 309 } 310 311 static ssize_t koneplus_sysfs_write_sensor(struct file *fp, 312 struct kobject *kobj, struct bin_attribute *attr, char *buf, 313 loff_t off, size_t count) 314 { 315 return koneplus_sysfs_write(fp, kobj, buf, off, count, 316 sizeof(struct koneplus_sensor), KONEPLUS_USB_COMMAND_SENSOR); 317 } 318 319 static ssize_t koneplus_sysfs_write_tcu(struct file *fp, 320 struct kobject *kobj, struct bin_attribute *attr, char *buf, 321 loff_t off, size_t count) 322 { 323 return koneplus_sysfs_write(fp, kobj, buf, off, count, 324 sizeof(struct koneplus_tcu), KONEPLUS_USB_COMMAND_TCU); 325 } 326 327 static ssize_t koneplus_sysfs_read_tcu_image(struct file *fp, 328 struct kobject *kobj, struct bin_attribute *attr, char *buf, 329 loff_t off, size_t count) 330 { 331 return koneplus_sysfs_read(fp, kobj, buf, off, count, 332 sizeof(struct koneplus_tcu_image), KONEPLUS_USB_COMMAND_TCU); 333 } 334 335 static ssize_t koneplus_sysfs_read_profilex_settings(struct file *fp, 336 struct kobject *kobj, struct bin_attribute *attr, char *buf, 337 loff_t off, size_t count) 338 { 339 struct device *dev = 340 container_of(kobj, struct device, kobj)->parent->parent; 341 struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev)); 342 343 if (off >= sizeof(struct koneplus_profile_settings)) 344 return 0; 345 346 if (off + count > sizeof(struct koneplus_profile_settings)) 347 count = sizeof(struct koneplus_profile_settings) - off; 348 349 mutex_lock(&koneplus->koneplus_lock); 350 memcpy(buf, ((void const *)&koneplus->profile_settings[*(uint *)(attr->private)]) + off, 351 count); 352 mutex_unlock(&koneplus->koneplus_lock); 353 354 return count; 355 } 356 357 static ssize_t koneplus_sysfs_write_profile_settings(struct file *fp, 358 struct kobject *kobj, struct bin_attribute *attr, char *buf, 359 loff_t off, size_t count) 360 { 361 struct device *dev = 362 container_of(kobj, struct device, kobj)->parent->parent; 363 struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev)); 364 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 365 int retval = 0; 366 int difference; 367 int profile_number; 368 struct koneplus_profile_settings *profile_settings; 369 370 if (off != 0 || count != sizeof(struct koneplus_profile_settings)) 371 return -EINVAL; 372 373 profile_number = ((struct koneplus_profile_settings const *)buf)->number; 374 profile_settings = &koneplus->profile_settings[profile_number]; 375 376 mutex_lock(&koneplus->koneplus_lock); 377 difference = memcmp(buf, profile_settings, 378 sizeof(struct koneplus_profile_settings)); 379 if (difference) { 380 retval = koneplus_set_profile_settings(usb_dev, 381 (struct koneplus_profile_settings const *)buf); 382 if (!retval) 383 memcpy(profile_settings, buf, 384 sizeof(struct koneplus_profile_settings)); 385 } 386 mutex_unlock(&koneplus->koneplus_lock); 387 388 if (retval) 389 return retval; 390 391 return sizeof(struct koneplus_profile_settings); 392 } 393 394 static ssize_t koneplus_sysfs_read_profilex_buttons(struct file *fp, 395 struct kobject *kobj, struct bin_attribute *attr, char *buf, 396 loff_t off, size_t count) 397 { 398 struct device *dev = 399 container_of(kobj, struct device, kobj)->parent->parent; 400 struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev)); 401 402 if (off >= sizeof(struct koneplus_profile_buttons)) 403 return 0; 404 405 if (off + count > sizeof(struct koneplus_profile_buttons)) 406 count = sizeof(struct koneplus_profile_buttons) - off; 407 408 mutex_lock(&koneplus->koneplus_lock); 409 memcpy(buf, ((void const *)&koneplus->profile_buttons[*(uint *)(attr->private)]) + off, 410 count); 411 mutex_unlock(&koneplus->koneplus_lock); 412 413 return count; 414 } 415 416 static ssize_t koneplus_sysfs_write_profile_buttons(struct file *fp, 417 struct kobject *kobj, struct bin_attribute *attr, char *buf, 418 loff_t off, size_t count) 419 { 420 struct device *dev = 421 container_of(kobj, struct device, kobj)->parent->parent; 422 struct koneplus_device *koneplus = hid_get_drvdata(dev_get_drvdata(dev)); 423 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 424 int retval = 0; 425 int difference; 426 uint profile_number; 427 struct koneplus_profile_buttons *profile_buttons; 428 429 if (off != 0 || count != sizeof(struct koneplus_profile_buttons)) 430 return -EINVAL; 431 432 profile_number = ((struct koneplus_profile_buttons const *)buf)->number; 433 profile_buttons = &koneplus->profile_buttons[profile_number]; 434 435 mutex_lock(&koneplus->koneplus_lock); 436 difference = memcmp(buf, profile_buttons, 437 sizeof(struct koneplus_profile_buttons)); 438 if (difference) { 439 retval = koneplus_set_profile_buttons(usb_dev, 440 (struct koneplus_profile_buttons const *)buf); 441 if (!retval) 442 memcpy(profile_buttons, buf, 443 sizeof(struct koneplus_profile_buttons)); 444 } 445 mutex_unlock(&koneplus->koneplus_lock); 446 447 if (retval) 448 return retval; 449 450 return sizeof(struct koneplus_profile_buttons); 451 } 452 453 static ssize_t koneplus_sysfs_show_startup_profile(struct device *dev, 454 struct device_attribute *attr, char *buf) 455 { 456 struct koneplus_device *koneplus = 457 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 458 return snprintf(buf, PAGE_SIZE, "%d\n", koneplus->startup_profile); 459 } 460 461 static ssize_t koneplus_sysfs_set_startup_profile(struct device *dev, 462 struct device_attribute *attr, char const *buf, size_t size) 463 { 464 struct koneplus_device *koneplus; 465 struct usb_device *usb_dev; 466 unsigned long profile; 467 int retval; 468 469 dev = dev->parent->parent; 470 koneplus = hid_get_drvdata(dev_get_drvdata(dev)); 471 usb_dev = interface_to_usbdev(to_usb_interface(dev)); 472 473 retval = strict_strtoul(buf, 10, &profile); 474 if (retval) 475 return retval; 476 477 mutex_lock(&koneplus->koneplus_lock); 478 retval = koneplus_set_startup_profile(usb_dev, profile); 479 mutex_unlock(&koneplus->koneplus_lock); 480 if (retval) 481 return retval; 482 483 return size; 484 } 485 486 static ssize_t koneplus_sysfs_show_actual_profile(struct device *dev, 487 struct device_attribute *attr, char *buf) 488 { 489 struct koneplus_device *koneplus = 490 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 491 return snprintf(buf, PAGE_SIZE, "%d\n", koneplus->actual_profile); 492 } 493 494 static ssize_t koneplus_sysfs_show_firmware_version(struct device *dev, 495 struct device_attribute *attr, char *buf) 496 { 497 struct koneplus_device *koneplus = 498 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 499 return snprintf(buf, PAGE_SIZE, "%d\n", koneplus->info.firmware_version); 500 } 501 502 static struct device_attribute koneplus_attributes[] = { 503 __ATTR(startup_profile, 0660, 504 koneplus_sysfs_show_startup_profile, 505 koneplus_sysfs_set_startup_profile), 506 __ATTR(actual_profile, 0440, 507 koneplus_sysfs_show_actual_profile, NULL), 508 __ATTR(firmware_version, 0440, 509 koneplus_sysfs_show_firmware_version, NULL), 510 __ATTR_NULL 511 }; 512 513 static struct bin_attribute koneplus_bin_attributes[] = { 514 { 515 .attr = { .name = "sensor", .mode = 0220 }, 516 .size = sizeof(struct koneplus_sensor), 517 .read = koneplus_sysfs_read_sensor, 518 .write = koneplus_sysfs_write_sensor 519 }, 520 { 521 .attr = { .name = "tcu", .mode = 0220 }, 522 .size = sizeof(struct koneplus_tcu), 523 .write = koneplus_sysfs_write_tcu 524 }, 525 { 526 .attr = { .name = "tcu_image", .mode = 0440 }, 527 .size = sizeof(struct koneplus_tcu_image), 528 .read = koneplus_sysfs_read_tcu_image 529 }, 530 { 531 .attr = { .name = "profile_settings", .mode = 0220 }, 532 .size = sizeof(struct koneplus_profile_settings), 533 .write = koneplus_sysfs_write_profile_settings 534 }, 535 { 536 .attr = { .name = "profile1_settings", .mode = 0440 }, 537 .size = sizeof(struct koneplus_profile_settings), 538 .read = koneplus_sysfs_read_profilex_settings, 539 .private = &profile_numbers[0] 540 }, 541 { 542 .attr = { .name = "profile2_settings", .mode = 0440 }, 543 .size = sizeof(struct koneplus_profile_settings), 544 .read = koneplus_sysfs_read_profilex_settings, 545 .private = &profile_numbers[1] 546 }, 547 { 548 .attr = { .name = "profile3_settings", .mode = 0440 }, 549 .size = sizeof(struct koneplus_profile_settings), 550 .read = koneplus_sysfs_read_profilex_settings, 551 .private = &profile_numbers[2] 552 }, 553 { 554 .attr = { .name = "profile4_settings", .mode = 0440 }, 555 .size = sizeof(struct koneplus_profile_settings), 556 .read = koneplus_sysfs_read_profilex_settings, 557 .private = &profile_numbers[3] 558 }, 559 { 560 .attr = { .name = "profile5_settings", .mode = 0440 }, 561 .size = sizeof(struct koneplus_profile_settings), 562 .read = koneplus_sysfs_read_profilex_settings, 563 .private = &profile_numbers[4] 564 }, 565 { 566 .attr = { .name = "profile_buttons", .mode = 0220 }, 567 .size = sizeof(struct koneplus_profile_buttons), 568 .write = koneplus_sysfs_write_profile_buttons 569 }, 570 { 571 .attr = { .name = "profile1_buttons", .mode = 0440 }, 572 .size = sizeof(struct koneplus_profile_buttons), 573 .read = koneplus_sysfs_read_profilex_buttons, 574 .private = &profile_numbers[0] 575 }, 576 { 577 .attr = { .name = "profile2_buttons", .mode = 0440 }, 578 .size = sizeof(struct koneplus_profile_buttons), 579 .read = koneplus_sysfs_read_profilex_buttons, 580 .private = &profile_numbers[1] 581 }, 582 { 583 .attr = { .name = "profile3_buttons", .mode = 0440 }, 584 .size = sizeof(struct koneplus_profile_buttons), 585 .read = koneplus_sysfs_read_profilex_buttons, 586 .private = &profile_numbers[2] 587 }, 588 { 589 .attr = { .name = "profile4_buttons", .mode = 0440 }, 590 .size = sizeof(struct koneplus_profile_buttons), 591 .read = koneplus_sysfs_read_profilex_buttons, 592 .private = &profile_numbers[3] 593 }, 594 { 595 .attr = { .name = "profile5_buttons", .mode = 0440 }, 596 .size = sizeof(struct koneplus_profile_buttons), 597 .read = koneplus_sysfs_read_profilex_buttons, 598 .private = &profile_numbers[4] 599 }, 600 { 601 .attr = { .name = "macro", .mode = 0220 }, 602 .size = sizeof(struct koneplus_macro), 603 .write = koneplus_sysfs_write_macro 604 }, 605 __ATTR_NULL 606 }; 607 608 static int koneplus_init_koneplus_device_struct(struct usb_device *usb_dev, 609 struct koneplus_device *koneplus) 610 { 611 int retval, i; 612 static uint wait = 70; /* device will freeze with just 60 */ 613 614 mutex_init(&koneplus->koneplus_lock); 615 616 koneplus->startup_profile = koneplus_get_startup_profile(usb_dev); 617 618 msleep(wait); 619 retval = koneplus_get_info(usb_dev, &koneplus->info); 620 if (retval) 621 return retval; 622 623 for (i = 0; i < 5; ++i) { 624 msleep(wait); 625 retval = koneplus_get_profile_settings(usb_dev, 626 &koneplus->profile_settings[i], i); 627 if (retval) 628 return retval; 629 630 msleep(wait); 631 retval = koneplus_get_profile_buttons(usb_dev, 632 &koneplus->profile_buttons[i], i); 633 if (retval) 634 return retval; 635 } 636 637 koneplus_profile_activated(koneplus, koneplus->startup_profile); 638 639 return 0; 640 } 641 642 static int koneplus_init_specials(struct hid_device *hdev) 643 { 644 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 645 struct usb_device *usb_dev = interface_to_usbdev(intf); 646 struct koneplus_device *koneplus; 647 int retval; 648 649 if (intf->cur_altsetting->desc.bInterfaceProtocol 650 == USB_INTERFACE_PROTOCOL_MOUSE) { 651 652 koneplus = kzalloc(sizeof(*koneplus), GFP_KERNEL); 653 if (!koneplus) { 654 dev_err(&hdev->dev, "can't alloc device descriptor\n"); 655 return -ENOMEM; 656 } 657 hid_set_drvdata(hdev, koneplus); 658 659 retval = koneplus_init_koneplus_device_struct(usb_dev, koneplus); 660 if (retval) { 661 dev_err(&hdev->dev, 662 "couldn't init struct koneplus_device\n"); 663 goto exit_free; 664 } 665 666 retval = roccat_connect(koneplus_class, hdev); 667 if (retval < 0) { 668 dev_err(&hdev->dev, "couldn't init char dev\n"); 669 } else { 670 koneplus->chrdev_minor = retval; 671 koneplus->roccat_claimed = 1; 672 } 673 } else { 674 hid_set_drvdata(hdev, NULL); 675 } 676 677 return 0; 678 exit_free: 679 kfree(koneplus); 680 return retval; 681 } 682 683 static void koneplus_remove_specials(struct hid_device *hdev) 684 { 685 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 686 struct koneplus_device *koneplus; 687 688 if (intf->cur_altsetting->desc.bInterfaceProtocol 689 == USB_INTERFACE_PROTOCOL_MOUSE) { 690 koneplus = hid_get_drvdata(hdev); 691 if (koneplus->roccat_claimed) 692 roccat_disconnect(koneplus->chrdev_minor); 693 kfree(koneplus); 694 } 695 } 696 697 static int koneplus_probe(struct hid_device *hdev, 698 const struct hid_device_id *id) 699 { 700 int retval; 701 702 retval = hid_parse(hdev); 703 if (retval) { 704 dev_err(&hdev->dev, "parse failed\n"); 705 goto exit; 706 } 707 708 retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 709 if (retval) { 710 dev_err(&hdev->dev, "hw start failed\n"); 711 goto exit; 712 } 713 714 retval = koneplus_init_specials(hdev); 715 if (retval) { 716 dev_err(&hdev->dev, "couldn't install mouse\n"); 717 goto exit_stop; 718 } 719 720 return 0; 721 722 exit_stop: 723 hid_hw_stop(hdev); 724 exit: 725 return retval; 726 } 727 728 static void koneplus_remove(struct hid_device *hdev) 729 { 730 koneplus_remove_specials(hdev); 731 hid_hw_stop(hdev); 732 } 733 734 static void koneplus_keep_values_up_to_date(struct koneplus_device *koneplus, 735 u8 const *data) 736 { 737 struct koneplus_mouse_report_button const *button_report; 738 739 switch (data[0]) { 740 case KONEPLUS_MOUSE_REPORT_NUMBER_BUTTON: 741 button_report = (struct koneplus_mouse_report_button const *)data; 742 switch (button_report->type) { 743 case KONEPLUS_MOUSE_REPORT_BUTTON_TYPE_PROFILE: 744 koneplus_profile_activated(koneplus, button_report->data1 - 1); 745 break; 746 } 747 break; 748 } 749 } 750 751 static void koneplus_report_to_chrdev(struct koneplus_device const *koneplus, 752 u8 const *data) 753 { 754 struct koneplus_roccat_report roccat_report; 755 struct koneplus_mouse_report_button const *button_report; 756 757 if (data[0] != KONEPLUS_MOUSE_REPORT_NUMBER_BUTTON) 758 return; 759 760 button_report = (struct koneplus_mouse_report_button const *)data; 761 762 if ((button_report->type == KONEPLUS_MOUSE_REPORT_BUTTON_TYPE_QUICKLAUNCH || 763 button_report->type == KONEPLUS_MOUSE_REPORT_BUTTON_TYPE_TIMER) && 764 button_report->data2 != KONEPLUS_MOUSE_REPORT_BUTTON_ACTION_PRESS) 765 return; 766 767 roccat_report.type = button_report->type; 768 roccat_report.data1 = button_report->data1; 769 roccat_report.data2 = button_report->data2; 770 roccat_report.profile = koneplus->actual_profile + 1; 771 roccat_report_event(koneplus->chrdev_minor, 772 (uint8_t const *)&roccat_report, 773 sizeof(struct koneplus_roccat_report)); 774 } 775 776 static int koneplus_raw_event(struct hid_device *hdev, 777 struct hid_report *report, u8 *data, int size) 778 { 779 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 780 struct koneplus_device *koneplus = hid_get_drvdata(hdev); 781 782 if (intf->cur_altsetting->desc.bInterfaceProtocol 783 != USB_INTERFACE_PROTOCOL_MOUSE) 784 return 0; 785 786 koneplus_keep_values_up_to_date(koneplus, data); 787 788 if (koneplus->roccat_claimed) 789 koneplus_report_to_chrdev(koneplus, data); 790 791 return 0; 792 } 793 794 static const struct hid_device_id koneplus_devices[] = { 795 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KONEPLUS) }, 796 { } 797 }; 798 799 MODULE_DEVICE_TABLE(hid, koneplus_devices); 800 801 static struct hid_driver koneplus_driver = { 802 .name = "koneplus", 803 .id_table = koneplus_devices, 804 .probe = koneplus_probe, 805 .remove = koneplus_remove, 806 .raw_event = koneplus_raw_event 807 }; 808 809 static int __init koneplus_init(void) 810 { 811 int retval; 812 813 /* class name has to be same as driver name */ 814 koneplus_class = class_create(THIS_MODULE, "koneplus"); 815 if (IS_ERR(koneplus_class)) 816 return PTR_ERR(koneplus_class); 817 koneplus_class->dev_attrs = koneplus_attributes; 818 koneplus_class->dev_bin_attrs = koneplus_bin_attributes; 819 820 retval = hid_register_driver(&koneplus_driver); 821 if (retval) 822 class_destroy(koneplus_class); 823 return retval; 824 } 825 826 static void __exit koneplus_exit(void) 827 { 828 class_destroy(koneplus_class); 829 hid_unregister_driver(&koneplus_driver); 830 } 831 832 module_init(koneplus_init); 833 module_exit(koneplus_exit); 834 835 MODULE_AUTHOR("Stefan Achatz"); 836 MODULE_DESCRIPTION("USB Roccat Kone[+] driver"); 837 MODULE_LICENSE("GPL v2"); 838