1 /* 2 * Roccat Pyra 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 Pyra is a mobile gamer mouse which comes in wired and wireless 16 * variant. Wireless variant is not tested. 17 * Userland tools can be found at http://sourceforge.net/projects/roccat 18 */ 19 20 #include <linux/device.h> 21 #include <linux/input.h> 22 #include <linux/hid.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-common.h" 28 #include "hid-roccat-pyra.h" 29 30 static uint profile_numbers[5] = {0, 1, 2, 3, 4}; 31 32 /* pyra_class is used for creating sysfs attributes via roccat char device */ 33 static struct class *pyra_class; 34 35 static void profile_activated(struct pyra_device *pyra, 36 unsigned int new_profile) 37 { 38 pyra->actual_profile = new_profile; 39 pyra->actual_cpi = pyra->profile_settings[pyra->actual_profile].y_cpi; 40 } 41 42 static int pyra_send_control(struct usb_device *usb_dev, int value, 43 enum pyra_control_requests request) 44 { 45 struct pyra_control control; 46 47 if ((request == PYRA_CONTROL_REQUEST_PROFILE_SETTINGS || 48 request == PYRA_CONTROL_REQUEST_PROFILE_BUTTONS) && 49 (value < 0 || value > 4)) 50 return -EINVAL; 51 52 control.command = PYRA_COMMAND_CONTROL; 53 control.value = value; 54 control.request = request; 55 56 return roccat_common_send(usb_dev, PYRA_USB_COMMAND_CONTROL, 57 &control, sizeof(struct pyra_control)); 58 } 59 60 static int pyra_receive_control_status(struct usb_device *usb_dev) 61 { 62 int retval; 63 struct pyra_control control; 64 65 do { 66 msleep(10); 67 retval = roccat_common_receive(usb_dev, PYRA_USB_COMMAND_CONTROL, 68 &control, sizeof(struct pyra_control)); 69 70 /* requested too early, try again */ 71 } while (retval == -EPROTO); 72 73 if (!retval && control.command == PYRA_COMMAND_CONTROL && 74 control.request == PYRA_CONTROL_REQUEST_STATUS && 75 control.value == 1) 76 return 0; 77 else { 78 hid_err(usb_dev, "receive control status: unknown response 0x%x 0x%x\n", 79 control.request, control.value); 80 return retval ? retval : -EINVAL; 81 } 82 } 83 84 static int pyra_get_profile_settings(struct usb_device *usb_dev, 85 struct pyra_profile_settings *buf, int number) 86 { 87 int retval; 88 retval = pyra_send_control(usb_dev, number, 89 PYRA_CONTROL_REQUEST_PROFILE_SETTINGS); 90 if (retval) 91 return retval; 92 return roccat_common_receive(usb_dev, PYRA_USB_COMMAND_PROFILE_SETTINGS, 93 buf, sizeof(struct pyra_profile_settings)); 94 } 95 96 static int pyra_get_profile_buttons(struct usb_device *usb_dev, 97 struct pyra_profile_buttons *buf, int number) 98 { 99 int retval; 100 retval = pyra_send_control(usb_dev, number, 101 PYRA_CONTROL_REQUEST_PROFILE_BUTTONS); 102 if (retval) 103 return retval; 104 return roccat_common_receive(usb_dev, PYRA_USB_COMMAND_PROFILE_BUTTONS, 105 buf, sizeof(struct pyra_profile_buttons)); 106 } 107 108 static int pyra_get_settings(struct usb_device *usb_dev, 109 struct pyra_settings *buf) 110 { 111 return roccat_common_receive(usb_dev, PYRA_USB_COMMAND_SETTINGS, 112 buf, sizeof(struct pyra_settings)); 113 } 114 115 static int pyra_get_info(struct usb_device *usb_dev, struct pyra_info *buf) 116 { 117 return roccat_common_receive(usb_dev, PYRA_USB_COMMAND_INFO, 118 buf, sizeof(struct pyra_info)); 119 } 120 121 static int pyra_send(struct usb_device *usb_dev, uint command, 122 void const *buf, uint size) 123 { 124 int retval; 125 retval = roccat_common_send(usb_dev, command, buf, size); 126 if (retval) 127 return retval; 128 return pyra_receive_control_status(usb_dev); 129 } 130 131 static int pyra_set_profile_settings(struct usb_device *usb_dev, 132 struct pyra_profile_settings const *settings) 133 { 134 return pyra_send(usb_dev, PYRA_USB_COMMAND_PROFILE_SETTINGS, settings, 135 sizeof(struct pyra_profile_settings)); 136 } 137 138 static int pyra_set_profile_buttons(struct usb_device *usb_dev, 139 struct pyra_profile_buttons const *buttons) 140 { 141 return pyra_send(usb_dev, PYRA_USB_COMMAND_PROFILE_BUTTONS, buttons, 142 sizeof(struct pyra_profile_buttons)); 143 } 144 145 static int pyra_set_settings(struct usb_device *usb_dev, 146 struct pyra_settings const *settings) 147 { 148 int retval; 149 retval = roccat_common_send(usb_dev, PYRA_USB_COMMAND_SETTINGS, settings, 150 sizeof(struct pyra_settings)); 151 if (retval) 152 return retval; 153 return pyra_receive_control_status(usb_dev); 154 } 155 156 static ssize_t pyra_sysfs_read_profilex_settings(struct file *fp, 157 struct kobject *kobj, struct bin_attribute *attr, char *buf, 158 loff_t off, size_t count) 159 { 160 struct device *dev = 161 container_of(kobj, struct device, kobj)->parent->parent; 162 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 163 164 if (off >= sizeof(struct pyra_profile_settings)) 165 return 0; 166 167 if (off + count > sizeof(struct pyra_profile_settings)) 168 count = sizeof(struct pyra_profile_settings) - off; 169 170 mutex_lock(&pyra->pyra_lock); 171 memcpy(buf, ((char const *)&pyra->profile_settings[*(uint *)(attr->private)]) + off, 172 count); 173 mutex_unlock(&pyra->pyra_lock); 174 175 return count; 176 } 177 178 static ssize_t pyra_sysfs_read_profilex_buttons(struct file *fp, 179 struct kobject *kobj, struct bin_attribute *attr, char *buf, 180 loff_t off, size_t count) 181 { 182 struct device *dev = 183 container_of(kobj, struct device, kobj)->parent->parent; 184 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 185 186 if (off >= sizeof(struct pyra_profile_buttons)) 187 return 0; 188 189 if (off + count > sizeof(struct pyra_profile_buttons)) 190 count = sizeof(struct pyra_profile_buttons) - off; 191 192 mutex_lock(&pyra->pyra_lock); 193 memcpy(buf, ((char const *)&pyra->profile_buttons[*(uint *)(attr->private)]) + off, 194 count); 195 mutex_unlock(&pyra->pyra_lock); 196 197 return count; 198 } 199 200 static ssize_t pyra_sysfs_write_profile_settings(struct file *fp, 201 struct kobject *kobj, struct bin_attribute *attr, char *buf, 202 loff_t off, size_t count) 203 { 204 struct device *dev = 205 container_of(kobj, struct device, kobj)->parent->parent; 206 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 207 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 208 int retval = 0; 209 int difference; 210 int profile_number; 211 struct pyra_profile_settings *profile_settings; 212 213 if (off != 0 || count != sizeof(struct pyra_profile_settings)) 214 return -EINVAL; 215 216 profile_number = ((struct pyra_profile_settings const *)buf)->number; 217 profile_settings = &pyra->profile_settings[profile_number]; 218 219 mutex_lock(&pyra->pyra_lock); 220 difference = memcmp(buf, profile_settings, 221 sizeof(struct pyra_profile_settings)); 222 if (difference) { 223 retval = pyra_set_profile_settings(usb_dev, 224 (struct pyra_profile_settings const *)buf); 225 if (!retval) 226 memcpy(profile_settings, buf, 227 sizeof(struct pyra_profile_settings)); 228 } 229 mutex_unlock(&pyra->pyra_lock); 230 231 if (retval) 232 return retval; 233 234 return sizeof(struct pyra_profile_settings); 235 } 236 237 static ssize_t pyra_sysfs_write_profile_buttons(struct file *fp, 238 struct kobject *kobj, struct bin_attribute *attr, char *buf, 239 loff_t off, size_t count) 240 { 241 struct device *dev = 242 container_of(kobj, struct device, kobj)->parent->parent; 243 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 244 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 245 int retval = 0; 246 int difference; 247 int profile_number; 248 struct pyra_profile_buttons *profile_buttons; 249 250 if (off != 0 || count != sizeof(struct pyra_profile_buttons)) 251 return -EINVAL; 252 253 profile_number = ((struct pyra_profile_buttons const *)buf)->number; 254 profile_buttons = &pyra->profile_buttons[profile_number]; 255 256 mutex_lock(&pyra->pyra_lock); 257 difference = memcmp(buf, profile_buttons, 258 sizeof(struct pyra_profile_buttons)); 259 if (difference) { 260 retval = pyra_set_profile_buttons(usb_dev, 261 (struct pyra_profile_buttons const *)buf); 262 if (!retval) 263 memcpy(profile_buttons, buf, 264 sizeof(struct pyra_profile_buttons)); 265 } 266 mutex_unlock(&pyra->pyra_lock); 267 268 if (retval) 269 return retval; 270 271 return sizeof(struct pyra_profile_buttons); 272 } 273 274 static ssize_t pyra_sysfs_read_settings(struct file *fp, 275 struct kobject *kobj, struct bin_attribute *attr, char *buf, 276 loff_t off, size_t count) 277 { 278 struct device *dev = 279 container_of(kobj, struct device, kobj)->parent->parent; 280 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 281 282 if (off >= sizeof(struct pyra_settings)) 283 return 0; 284 285 if (off + count > sizeof(struct pyra_settings)) 286 count = sizeof(struct pyra_settings) - off; 287 288 mutex_lock(&pyra->pyra_lock); 289 memcpy(buf, ((char const *)&pyra->settings) + off, count); 290 mutex_unlock(&pyra->pyra_lock); 291 292 return count; 293 } 294 295 static ssize_t pyra_sysfs_write_settings(struct file *fp, 296 struct kobject *kobj, struct bin_attribute *attr, char *buf, 297 loff_t off, size_t count) 298 { 299 struct device *dev = 300 container_of(kobj, struct device, kobj)->parent->parent; 301 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 302 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 303 int retval = 0; 304 int difference; 305 306 if (off != 0 || count != sizeof(struct pyra_settings)) 307 return -EINVAL; 308 309 mutex_lock(&pyra->pyra_lock); 310 difference = memcmp(buf, &pyra->settings, sizeof(struct pyra_settings)); 311 if (difference) { 312 retval = pyra_set_settings(usb_dev, 313 (struct pyra_settings const *)buf); 314 if (!retval) 315 memcpy(&pyra->settings, buf, 316 sizeof(struct pyra_settings)); 317 } 318 mutex_unlock(&pyra->pyra_lock); 319 320 if (retval) 321 return retval; 322 323 profile_activated(pyra, pyra->settings.startup_profile); 324 325 return sizeof(struct pyra_settings); 326 } 327 328 329 static ssize_t pyra_sysfs_show_actual_cpi(struct device *dev, 330 struct device_attribute *attr, char *buf) 331 { 332 struct pyra_device *pyra = 333 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 334 return snprintf(buf, PAGE_SIZE, "%d\n", pyra->actual_cpi); 335 } 336 337 static ssize_t pyra_sysfs_show_actual_profile(struct device *dev, 338 struct device_attribute *attr, char *buf) 339 { 340 struct pyra_device *pyra = 341 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 342 return snprintf(buf, PAGE_SIZE, "%d\n", pyra->actual_profile); 343 } 344 345 static ssize_t pyra_sysfs_show_firmware_version(struct device *dev, 346 struct device_attribute *attr, char *buf) 347 { 348 struct pyra_device *pyra = 349 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 350 return snprintf(buf, PAGE_SIZE, "%d\n", pyra->firmware_version); 351 } 352 353 static ssize_t pyra_sysfs_show_startup_profile(struct device *dev, 354 struct device_attribute *attr, char *buf) 355 { 356 struct pyra_device *pyra = 357 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 358 return snprintf(buf, PAGE_SIZE, "%d\n", pyra->settings.startup_profile); 359 } 360 361 static struct device_attribute pyra_attributes[] = { 362 __ATTR(actual_cpi, 0440, pyra_sysfs_show_actual_cpi, NULL), 363 __ATTR(actual_profile, 0440, pyra_sysfs_show_actual_profile, NULL), 364 __ATTR(firmware_version, 0440, 365 pyra_sysfs_show_firmware_version, NULL), 366 __ATTR(startup_profile, 0440, 367 pyra_sysfs_show_startup_profile, NULL), 368 __ATTR_NULL 369 }; 370 371 static struct bin_attribute pyra_bin_attributes[] = { 372 { 373 .attr = { .name = "profile_settings", .mode = 0220 }, 374 .size = sizeof(struct pyra_profile_settings), 375 .write = pyra_sysfs_write_profile_settings 376 }, 377 { 378 .attr = { .name = "profile1_settings", .mode = 0440 }, 379 .size = sizeof(struct pyra_profile_settings), 380 .read = pyra_sysfs_read_profilex_settings, 381 .private = &profile_numbers[0] 382 }, 383 { 384 .attr = { .name = "profile2_settings", .mode = 0440 }, 385 .size = sizeof(struct pyra_profile_settings), 386 .read = pyra_sysfs_read_profilex_settings, 387 .private = &profile_numbers[1] 388 }, 389 { 390 .attr = { .name = "profile3_settings", .mode = 0440 }, 391 .size = sizeof(struct pyra_profile_settings), 392 .read = pyra_sysfs_read_profilex_settings, 393 .private = &profile_numbers[2] 394 }, 395 { 396 .attr = { .name = "profile4_settings", .mode = 0440 }, 397 .size = sizeof(struct pyra_profile_settings), 398 .read = pyra_sysfs_read_profilex_settings, 399 .private = &profile_numbers[3] 400 }, 401 { 402 .attr = { .name = "profile5_settings", .mode = 0440 }, 403 .size = sizeof(struct pyra_profile_settings), 404 .read = pyra_sysfs_read_profilex_settings, 405 .private = &profile_numbers[4] 406 }, 407 { 408 .attr = { .name = "profile_buttons", .mode = 0220 }, 409 .size = sizeof(struct pyra_profile_buttons), 410 .write = pyra_sysfs_write_profile_buttons 411 }, 412 { 413 .attr = { .name = "profile1_buttons", .mode = 0440 }, 414 .size = sizeof(struct pyra_profile_buttons), 415 .read = pyra_sysfs_read_profilex_buttons, 416 .private = &profile_numbers[0] 417 }, 418 { 419 .attr = { .name = "profile2_buttons", .mode = 0440 }, 420 .size = sizeof(struct pyra_profile_buttons), 421 .read = pyra_sysfs_read_profilex_buttons, 422 .private = &profile_numbers[1] 423 }, 424 { 425 .attr = { .name = "profile3_buttons", .mode = 0440 }, 426 .size = sizeof(struct pyra_profile_buttons), 427 .read = pyra_sysfs_read_profilex_buttons, 428 .private = &profile_numbers[2] 429 }, 430 { 431 .attr = { .name = "profile4_buttons", .mode = 0440 }, 432 .size = sizeof(struct pyra_profile_buttons), 433 .read = pyra_sysfs_read_profilex_buttons, 434 .private = &profile_numbers[3] 435 }, 436 { 437 .attr = { .name = "profile5_buttons", .mode = 0440 }, 438 .size = sizeof(struct pyra_profile_buttons), 439 .read = pyra_sysfs_read_profilex_buttons, 440 .private = &profile_numbers[4] 441 }, 442 { 443 .attr = { .name = "settings", .mode = 0660 }, 444 .size = sizeof(struct pyra_settings), 445 .read = pyra_sysfs_read_settings, 446 .write = pyra_sysfs_write_settings 447 }, 448 __ATTR_NULL 449 }; 450 451 static int pyra_init_pyra_device_struct(struct usb_device *usb_dev, 452 struct pyra_device *pyra) 453 { 454 struct pyra_info info; 455 int retval, i; 456 457 mutex_init(&pyra->pyra_lock); 458 459 retval = pyra_get_info(usb_dev, &info); 460 if (retval) 461 return retval; 462 463 pyra->firmware_version = info.firmware_version; 464 465 retval = pyra_get_settings(usb_dev, &pyra->settings); 466 if (retval) 467 return retval; 468 469 for (i = 0; i < 5; ++i) { 470 retval = pyra_get_profile_settings(usb_dev, 471 &pyra->profile_settings[i], i); 472 if (retval) 473 return retval; 474 475 retval = pyra_get_profile_buttons(usb_dev, 476 &pyra->profile_buttons[i], i); 477 if (retval) 478 return retval; 479 } 480 481 profile_activated(pyra, pyra->settings.startup_profile); 482 483 return 0; 484 } 485 486 static int pyra_init_specials(struct hid_device *hdev) 487 { 488 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 489 struct usb_device *usb_dev = interface_to_usbdev(intf); 490 struct pyra_device *pyra; 491 int retval; 492 493 if (intf->cur_altsetting->desc.bInterfaceProtocol 494 == USB_INTERFACE_PROTOCOL_MOUSE) { 495 496 pyra = kzalloc(sizeof(*pyra), GFP_KERNEL); 497 if (!pyra) { 498 hid_err(hdev, "can't alloc device descriptor\n"); 499 return -ENOMEM; 500 } 501 hid_set_drvdata(hdev, pyra); 502 503 retval = pyra_init_pyra_device_struct(usb_dev, pyra); 504 if (retval) { 505 hid_err(hdev, "couldn't init struct pyra_device\n"); 506 goto exit_free; 507 } 508 509 retval = roccat_connect(pyra_class, hdev); 510 if (retval < 0) { 511 hid_err(hdev, "couldn't init char dev\n"); 512 } else { 513 pyra->chrdev_minor = retval; 514 pyra->roccat_claimed = 1; 515 } 516 } else { 517 hid_set_drvdata(hdev, NULL); 518 } 519 520 return 0; 521 exit_free: 522 kfree(pyra); 523 return retval; 524 } 525 526 static void pyra_remove_specials(struct hid_device *hdev) 527 { 528 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 529 struct pyra_device *pyra; 530 531 if (intf->cur_altsetting->desc.bInterfaceProtocol 532 == USB_INTERFACE_PROTOCOL_MOUSE) { 533 pyra = hid_get_drvdata(hdev); 534 if (pyra->roccat_claimed) 535 roccat_disconnect(pyra->chrdev_minor); 536 kfree(hid_get_drvdata(hdev)); 537 } 538 } 539 540 static int pyra_probe(struct hid_device *hdev, const struct hid_device_id *id) 541 { 542 int retval; 543 544 retval = hid_parse(hdev); 545 if (retval) { 546 hid_err(hdev, "parse failed\n"); 547 goto exit; 548 } 549 550 retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 551 if (retval) { 552 hid_err(hdev, "hw start failed\n"); 553 goto exit; 554 } 555 556 retval = pyra_init_specials(hdev); 557 if (retval) { 558 hid_err(hdev, "couldn't install mouse\n"); 559 goto exit_stop; 560 } 561 return 0; 562 563 exit_stop: 564 hid_hw_stop(hdev); 565 exit: 566 return retval; 567 } 568 569 static void pyra_remove(struct hid_device *hdev) 570 { 571 pyra_remove_specials(hdev); 572 hid_hw_stop(hdev); 573 } 574 575 static void pyra_keep_values_up_to_date(struct pyra_device *pyra, 576 u8 const *data) 577 { 578 struct pyra_mouse_event_button const *button_event; 579 580 switch (data[0]) { 581 case PYRA_MOUSE_REPORT_NUMBER_BUTTON: 582 button_event = (struct pyra_mouse_event_button const *)data; 583 switch (button_event->type) { 584 case PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2: 585 profile_activated(pyra, button_event->data1 - 1); 586 break; 587 case PYRA_MOUSE_EVENT_BUTTON_TYPE_CPI: 588 pyra->actual_cpi = button_event->data1; 589 break; 590 } 591 break; 592 } 593 } 594 595 static void pyra_report_to_chrdev(struct pyra_device const *pyra, 596 u8 const *data) 597 { 598 struct pyra_roccat_report roccat_report; 599 struct pyra_mouse_event_button const *button_event; 600 601 if (data[0] != PYRA_MOUSE_REPORT_NUMBER_BUTTON) 602 return; 603 604 button_event = (struct pyra_mouse_event_button const *)data; 605 606 switch (button_event->type) { 607 case PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2: 608 case PYRA_MOUSE_EVENT_BUTTON_TYPE_CPI: 609 roccat_report.type = button_event->type; 610 roccat_report.value = button_event->data1; 611 roccat_report.key = 0; 612 roccat_report_event(pyra->chrdev_minor, 613 (uint8_t const *)&roccat_report, 614 sizeof(struct pyra_roccat_report)); 615 break; 616 case PYRA_MOUSE_EVENT_BUTTON_TYPE_MACRO: 617 case PYRA_MOUSE_EVENT_BUTTON_TYPE_SHORTCUT: 618 case PYRA_MOUSE_EVENT_BUTTON_TYPE_QUICKLAUNCH: 619 if (button_event->data2 == PYRA_MOUSE_EVENT_BUTTON_PRESS) { 620 roccat_report.type = button_event->type; 621 roccat_report.key = button_event->data1; 622 /* 623 * pyra reports profile numbers with range 1-5. 624 * Keeping this behaviour. 625 */ 626 roccat_report.value = pyra->actual_profile + 1; 627 roccat_report_event(pyra->chrdev_minor, 628 (uint8_t const *)&roccat_report, 629 sizeof(struct pyra_roccat_report)); 630 } 631 break; 632 } 633 } 634 635 static int pyra_raw_event(struct hid_device *hdev, struct hid_report *report, 636 u8 *data, int size) 637 { 638 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 639 struct pyra_device *pyra = hid_get_drvdata(hdev); 640 641 if (intf->cur_altsetting->desc.bInterfaceProtocol 642 != USB_INTERFACE_PROTOCOL_MOUSE) 643 return 0; 644 645 pyra_keep_values_up_to_date(pyra, data); 646 647 if (pyra->roccat_claimed) 648 pyra_report_to_chrdev(pyra, data); 649 650 return 0; 651 } 652 653 static const struct hid_device_id pyra_devices[] = { 654 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, 655 USB_DEVICE_ID_ROCCAT_PYRA_WIRED) }, 656 /* TODO add USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS after testing */ 657 { } 658 }; 659 660 MODULE_DEVICE_TABLE(hid, pyra_devices); 661 662 static struct hid_driver pyra_driver = { 663 .name = "pyra", 664 .id_table = pyra_devices, 665 .probe = pyra_probe, 666 .remove = pyra_remove, 667 .raw_event = pyra_raw_event 668 }; 669 670 static int __init pyra_init(void) 671 { 672 int retval; 673 674 /* class name has to be same as driver name */ 675 pyra_class = class_create(THIS_MODULE, "pyra"); 676 if (IS_ERR(pyra_class)) 677 return PTR_ERR(pyra_class); 678 pyra_class->dev_attrs = pyra_attributes; 679 pyra_class->dev_bin_attrs = pyra_bin_attributes; 680 681 retval = hid_register_driver(&pyra_driver); 682 if (retval) 683 class_destroy(pyra_class); 684 return retval; 685 } 686 687 static void __exit pyra_exit(void) 688 { 689 class_destroy(pyra_class); 690 hid_unregister_driver(&pyra_driver); 691 } 692 693 module_init(pyra_init); 694 module_exit(pyra_exit); 695 696 MODULE_AUTHOR("Stefan Achatz"); 697 MODULE_DESCRIPTION("USB Roccat Pyra driver"); 698 MODULE_LICENSE("GPL v2"); 699