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/usb.h> 24 #include <linux/module.h> 25 #include <linux/slab.h> 26 #include "hid-ids.h" 27 #include "hid-roccat.h" 28 #include "hid-roccat-pyra.h" 29 30 static void profile_activated(struct pyra_device *pyra, 31 unsigned int new_profile) 32 { 33 pyra->actual_profile = new_profile; 34 pyra->actual_cpi = pyra->profile_settings[pyra->actual_profile].y_cpi; 35 } 36 37 static int pyra_send_control(struct usb_device *usb_dev, int value, 38 enum pyra_control_requests request) 39 { 40 int len; 41 struct pyra_control control; 42 43 if ((request == PYRA_CONTROL_REQUEST_PROFILE_SETTINGS || 44 request == PYRA_CONTROL_REQUEST_PROFILE_BUTTONS) && 45 (value < 0 || value > 4)) 46 return -EINVAL; 47 48 control.command = PYRA_COMMAND_CONTROL; 49 control.value = value; 50 control.request = request; 51 52 len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0), 53 USB_REQ_SET_CONFIGURATION, 54 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT, 55 PYRA_USB_COMMAND_CONTROL, 0, (char *)&control, 56 sizeof(struct pyra_control), 57 USB_CTRL_SET_TIMEOUT); 58 59 if (len != sizeof(struct pyra_control)) 60 return len; 61 62 return 0; 63 } 64 65 static int pyra_receive_control_status(struct usb_device *usb_dev) 66 { 67 int len; 68 struct pyra_control control; 69 70 do { 71 msleep(10); 72 73 len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0), 74 USB_REQ_CLEAR_FEATURE, 75 USB_TYPE_CLASS | USB_RECIP_INTERFACE | 76 USB_DIR_IN, 77 PYRA_USB_COMMAND_CONTROL, 0, (char *)&control, 78 sizeof(struct pyra_control), 79 USB_CTRL_SET_TIMEOUT); 80 81 /* requested too early, try again */ 82 } while (len == -EPROTO); 83 84 if (len == sizeof(struct pyra_control) && 85 control.command == PYRA_COMMAND_CONTROL && 86 control.request == PYRA_CONTROL_REQUEST_STATUS && 87 control.value == 1) 88 return 0; 89 else { 90 hid_err(usb_dev, "receive control status: unknown response 0x%x 0x%x\n", 91 control.request, control.value); 92 return -EINVAL; 93 } 94 } 95 96 static int pyra_get_profile_settings(struct usb_device *usb_dev, 97 struct pyra_profile_settings *buf, int number) 98 { 99 int retval; 100 101 retval = pyra_send_control(usb_dev, number, 102 PYRA_CONTROL_REQUEST_PROFILE_SETTINGS); 103 104 if (retval) 105 return retval; 106 107 retval = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0), 108 USB_REQ_CLEAR_FEATURE, 109 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, 110 PYRA_USB_COMMAND_PROFILE_SETTINGS, 0, (char *)buf, 111 sizeof(struct pyra_profile_settings), 112 USB_CTRL_SET_TIMEOUT); 113 114 if (retval != sizeof(struct pyra_profile_settings)) 115 return retval; 116 117 return 0; 118 } 119 120 static int pyra_get_profile_buttons(struct usb_device *usb_dev, 121 struct pyra_profile_buttons *buf, int number) 122 { 123 int retval; 124 125 retval = pyra_send_control(usb_dev, number, 126 PYRA_CONTROL_REQUEST_PROFILE_BUTTONS); 127 128 if (retval) 129 return retval; 130 131 retval = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0), 132 USB_REQ_CLEAR_FEATURE, 133 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, 134 PYRA_USB_COMMAND_PROFILE_BUTTONS, 0, (char *)buf, 135 sizeof(struct pyra_profile_buttons), 136 USB_CTRL_SET_TIMEOUT); 137 138 if (retval != sizeof(struct pyra_profile_buttons)) 139 return retval; 140 141 return 0; 142 } 143 144 static int pyra_get_settings(struct usb_device *usb_dev, 145 struct pyra_settings *buf) 146 { 147 int len; 148 len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0), 149 USB_REQ_CLEAR_FEATURE, 150 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, 151 PYRA_USB_COMMAND_SETTINGS, 0, buf, 152 sizeof(struct pyra_settings), USB_CTRL_SET_TIMEOUT); 153 if (len != sizeof(struct pyra_settings)) 154 return -EIO; 155 return 0; 156 } 157 158 static int pyra_get_info(struct usb_device *usb_dev, struct pyra_info *buf) 159 { 160 int len; 161 len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0), 162 USB_REQ_CLEAR_FEATURE, 163 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN, 164 PYRA_USB_COMMAND_INFO, 0, buf, 165 sizeof(struct pyra_info), USB_CTRL_SET_TIMEOUT); 166 if (len != sizeof(struct pyra_info)) 167 return -EIO; 168 return 0; 169 } 170 171 static int pyra_set_profile_settings(struct usb_device *usb_dev, 172 struct pyra_profile_settings const *settings) 173 { 174 int len; 175 len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0), 176 USB_REQ_SET_CONFIGURATION, 177 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT, 178 PYRA_USB_COMMAND_PROFILE_SETTINGS, 0, (char *)settings, 179 sizeof(struct pyra_profile_settings), 180 USB_CTRL_SET_TIMEOUT); 181 if (len != sizeof(struct pyra_profile_settings)) 182 return -EIO; 183 if (pyra_receive_control_status(usb_dev)) 184 return -EIO; 185 return 0; 186 } 187 188 static int pyra_set_profile_buttons(struct usb_device *usb_dev, 189 struct pyra_profile_buttons const *buttons) 190 { 191 int len; 192 len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0), 193 USB_REQ_SET_CONFIGURATION, 194 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT, 195 PYRA_USB_COMMAND_PROFILE_BUTTONS, 0, (char *)buttons, 196 sizeof(struct pyra_profile_buttons), 197 USB_CTRL_SET_TIMEOUT); 198 if (len != sizeof(struct pyra_profile_buttons)) 199 return -EIO; 200 if (pyra_receive_control_status(usb_dev)) 201 return -EIO; 202 return 0; 203 } 204 205 static int pyra_set_settings(struct usb_device *usb_dev, 206 struct pyra_settings const *settings) 207 { 208 int len; 209 len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0), 210 USB_REQ_SET_CONFIGURATION, 211 USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT, 212 PYRA_USB_COMMAND_SETTINGS, 0, (char *)settings, 213 sizeof(struct pyra_settings), USB_CTRL_SET_TIMEOUT); 214 if (len != sizeof(struct pyra_settings)) 215 return -EIO; 216 if (pyra_receive_control_status(usb_dev)) 217 return -EIO; 218 return 0; 219 } 220 221 static ssize_t pyra_sysfs_read_profilex_settings(struct file *fp, 222 struct kobject *kobj, struct bin_attribute *attr, char *buf, 223 loff_t off, size_t count, int number) 224 { 225 struct device *dev = container_of(kobj, struct device, kobj); 226 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 227 228 if (off >= sizeof(struct pyra_profile_settings)) 229 return 0; 230 231 if (off + count > sizeof(struct pyra_profile_settings)) 232 count = sizeof(struct pyra_profile_settings) - off; 233 234 mutex_lock(&pyra->pyra_lock); 235 memcpy(buf, ((char const *)&pyra->profile_settings[number]) + off, 236 count); 237 mutex_unlock(&pyra->pyra_lock); 238 239 return count; 240 } 241 242 static ssize_t pyra_sysfs_read_profile1_settings(struct file *fp, 243 struct kobject *kobj, struct bin_attribute *attr, char *buf, 244 loff_t off, size_t count) 245 { 246 return pyra_sysfs_read_profilex_settings(fp, kobj, 247 attr, buf, off, count, 0); 248 } 249 250 static ssize_t pyra_sysfs_read_profile2_settings(struct file *fp, 251 struct kobject *kobj, struct bin_attribute *attr, char *buf, 252 loff_t off, size_t count) 253 { 254 return pyra_sysfs_read_profilex_settings(fp, kobj, 255 attr, buf, off, count, 1); 256 } 257 258 static ssize_t pyra_sysfs_read_profile3_settings(struct file *fp, 259 struct kobject *kobj, struct bin_attribute *attr, char *buf, 260 loff_t off, size_t count) 261 { 262 return pyra_sysfs_read_profilex_settings(fp, kobj, 263 attr, buf, off, count, 2); 264 } 265 266 static ssize_t pyra_sysfs_read_profile4_settings(struct file *fp, 267 struct kobject *kobj, struct bin_attribute *attr, char *buf, 268 loff_t off, size_t count) 269 { 270 return pyra_sysfs_read_profilex_settings(fp, kobj, 271 attr, buf, off, count, 3); 272 } 273 274 static ssize_t pyra_sysfs_read_profile5_settings(struct file *fp, 275 struct kobject *kobj, struct bin_attribute *attr, char *buf, 276 loff_t off, size_t count) 277 { 278 return pyra_sysfs_read_profilex_settings(fp, kobj, 279 attr, buf, off, count, 4); 280 } 281 282 static ssize_t pyra_sysfs_read_profilex_buttons(struct file *fp, 283 struct kobject *kobj, struct bin_attribute *attr, char *buf, 284 loff_t off, size_t count, int number) 285 { 286 struct device *dev = container_of(kobj, struct device, kobj); 287 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 288 289 if (off >= sizeof(struct pyra_profile_buttons)) 290 return 0; 291 292 if (off + count > sizeof(struct pyra_profile_buttons)) 293 count = sizeof(struct pyra_profile_buttons) - off; 294 295 mutex_lock(&pyra->pyra_lock); 296 memcpy(buf, ((char const *)&pyra->profile_buttons[number]) + off, 297 count); 298 mutex_unlock(&pyra->pyra_lock); 299 300 return count; 301 } 302 303 static ssize_t pyra_sysfs_read_profile1_buttons(struct file *fp, 304 struct kobject *kobj, struct bin_attribute *attr, char *buf, 305 loff_t off, size_t count) 306 { 307 return pyra_sysfs_read_profilex_buttons(fp, kobj, 308 attr, buf, off, count, 0); 309 } 310 311 static ssize_t pyra_sysfs_read_profile2_buttons(struct file *fp, 312 struct kobject *kobj, struct bin_attribute *attr, char *buf, 313 loff_t off, size_t count) 314 { 315 return pyra_sysfs_read_profilex_buttons(fp, kobj, 316 attr, buf, off, count, 1); 317 } 318 319 static ssize_t pyra_sysfs_read_profile3_buttons(struct file *fp, 320 struct kobject *kobj, struct bin_attribute *attr, char *buf, 321 loff_t off, size_t count) 322 { 323 return pyra_sysfs_read_profilex_buttons(fp, kobj, 324 attr, buf, off, count, 2); 325 } 326 327 static ssize_t pyra_sysfs_read_profile4_buttons(struct file *fp, 328 struct kobject *kobj, struct bin_attribute *attr, char *buf, 329 loff_t off, size_t count) 330 { 331 return pyra_sysfs_read_profilex_buttons(fp, kobj, 332 attr, buf, off, count, 3); 333 } 334 335 static ssize_t pyra_sysfs_read_profile5_buttons(struct file *fp, 336 struct kobject *kobj, struct bin_attribute *attr, char *buf, 337 loff_t off, size_t count) 338 { 339 return pyra_sysfs_read_profilex_buttons(fp, kobj, 340 attr, buf, off, count, 4); 341 } 342 343 static ssize_t pyra_sysfs_write_profile_settings(struct file *fp, 344 struct kobject *kobj, struct bin_attribute *attr, char *buf, 345 loff_t off, size_t count) 346 { 347 struct device *dev = container_of(kobj, struct device, kobj); 348 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 349 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 350 int retval = 0; 351 int difference; 352 int profile_number; 353 struct pyra_profile_settings *profile_settings; 354 355 if (off != 0 || count != sizeof(struct pyra_profile_settings)) 356 return -EINVAL; 357 358 profile_number = ((struct pyra_profile_settings const *)buf)->number; 359 profile_settings = &pyra->profile_settings[profile_number]; 360 361 mutex_lock(&pyra->pyra_lock); 362 difference = memcmp(buf, profile_settings, 363 sizeof(struct pyra_profile_settings)); 364 if (difference) { 365 retval = pyra_set_profile_settings(usb_dev, 366 (struct pyra_profile_settings const *)buf); 367 if (!retval) 368 memcpy(profile_settings, buf, 369 sizeof(struct pyra_profile_settings)); 370 } 371 mutex_unlock(&pyra->pyra_lock); 372 373 if (retval) 374 return retval; 375 376 return sizeof(struct pyra_profile_settings); 377 } 378 379 static ssize_t pyra_sysfs_write_profile_buttons(struct file *fp, 380 struct kobject *kobj, struct bin_attribute *attr, char *buf, 381 loff_t off, size_t count) 382 { 383 struct device *dev = container_of(kobj, struct device, kobj); 384 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 385 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 386 int retval = 0; 387 int difference; 388 int profile_number; 389 struct pyra_profile_buttons *profile_buttons; 390 391 if (off != 0 || count != sizeof(struct pyra_profile_buttons)) 392 return -EINVAL; 393 394 profile_number = ((struct pyra_profile_buttons const *)buf)->number; 395 profile_buttons = &pyra->profile_buttons[profile_number]; 396 397 mutex_lock(&pyra->pyra_lock); 398 difference = memcmp(buf, profile_buttons, 399 sizeof(struct pyra_profile_buttons)); 400 if (difference) { 401 retval = pyra_set_profile_buttons(usb_dev, 402 (struct pyra_profile_buttons const *)buf); 403 if (!retval) 404 memcpy(profile_buttons, buf, 405 sizeof(struct pyra_profile_buttons)); 406 } 407 mutex_unlock(&pyra->pyra_lock); 408 409 if (retval) 410 return retval; 411 412 return sizeof(struct pyra_profile_buttons); 413 } 414 415 static ssize_t pyra_sysfs_read_settings(struct file *fp, 416 struct kobject *kobj, struct bin_attribute *attr, char *buf, 417 loff_t off, size_t count) 418 { 419 struct device *dev = container_of(kobj, struct device, kobj); 420 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 421 422 if (off >= sizeof(struct pyra_settings)) 423 return 0; 424 425 if (off + count > sizeof(struct pyra_settings)) 426 count = sizeof(struct pyra_settings) - off; 427 428 mutex_lock(&pyra->pyra_lock); 429 memcpy(buf, ((char const *)&pyra->settings) + off, count); 430 mutex_unlock(&pyra->pyra_lock); 431 432 return count; 433 } 434 435 static ssize_t pyra_sysfs_write_settings(struct file *fp, 436 struct kobject *kobj, struct bin_attribute *attr, char *buf, 437 loff_t off, size_t count) 438 { 439 struct device *dev = container_of(kobj, struct device, kobj); 440 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 441 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 442 int retval = 0; 443 int difference; 444 445 if (off != 0 || count != sizeof(struct pyra_settings)) 446 return -EINVAL; 447 448 mutex_lock(&pyra->pyra_lock); 449 difference = memcmp(buf, &pyra->settings, sizeof(struct pyra_settings)); 450 if (difference) { 451 retval = pyra_set_settings(usb_dev, 452 (struct pyra_settings const *)buf); 453 if (!retval) 454 memcpy(&pyra->settings, buf, 455 sizeof(struct pyra_settings)); 456 } 457 mutex_unlock(&pyra->pyra_lock); 458 459 if (retval) 460 return retval; 461 462 profile_activated(pyra, pyra->settings.startup_profile); 463 464 return sizeof(struct pyra_settings); 465 } 466 467 468 static ssize_t pyra_sysfs_show_actual_cpi(struct device *dev, 469 struct device_attribute *attr, char *buf) 470 { 471 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 472 return snprintf(buf, PAGE_SIZE, "%d\n", pyra->actual_cpi); 473 } 474 475 static ssize_t pyra_sysfs_show_actual_profile(struct device *dev, 476 struct device_attribute *attr, char *buf) 477 { 478 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 479 return snprintf(buf, PAGE_SIZE, "%d\n", pyra->actual_profile); 480 } 481 482 static ssize_t pyra_sysfs_show_firmware_version(struct device *dev, 483 struct device_attribute *attr, char *buf) 484 { 485 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 486 return snprintf(buf, PAGE_SIZE, "%d\n", pyra->firmware_version); 487 } 488 489 static ssize_t pyra_sysfs_show_startup_profile(struct device *dev, 490 struct device_attribute *attr, char *buf) 491 { 492 struct pyra_device *pyra = hid_get_drvdata(dev_get_drvdata(dev)); 493 return snprintf(buf, PAGE_SIZE, "%d\n", pyra->settings.startup_profile); 494 } 495 496 static DEVICE_ATTR(actual_cpi, 0440, pyra_sysfs_show_actual_cpi, NULL); 497 498 static DEVICE_ATTR(actual_profile, 0440, pyra_sysfs_show_actual_profile, NULL); 499 500 static DEVICE_ATTR(firmware_version, 0440, 501 pyra_sysfs_show_firmware_version, NULL); 502 503 static DEVICE_ATTR(startup_profile, 0440, 504 pyra_sysfs_show_startup_profile, NULL); 505 506 static struct attribute *pyra_attributes[] = { 507 &dev_attr_actual_cpi.attr, 508 &dev_attr_actual_profile.attr, 509 &dev_attr_firmware_version.attr, 510 &dev_attr_startup_profile.attr, 511 NULL 512 }; 513 514 static struct attribute_group pyra_attribute_group = { 515 .attrs = pyra_attributes 516 }; 517 518 static struct bin_attribute pyra_profile_settings_attr = { 519 .attr = { .name = "profile_settings", .mode = 0220 }, 520 .size = sizeof(struct pyra_profile_settings), 521 .write = pyra_sysfs_write_profile_settings 522 }; 523 524 static struct bin_attribute pyra_profile1_settings_attr = { 525 .attr = { .name = "profile1_settings", .mode = 0440 }, 526 .size = sizeof(struct pyra_profile_settings), 527 .read = pyra_sysfs_read_profile1_settings 528 }; 529 530 static struct bin_attribute pyra_profile2_settings_attr = { 531 .attr = { .name = "profile2_settings", .mode = 0440 }, 532 .size = sizeof(struct pyra_profile_settings), 533 .read = pyra_sysfs_read_profile2_settings 534 }; 535 536 static struct bin_attribute pyra_profile3_settings_attr = { 537 .attr = { .name = "profile3_settings", .mode = 0440 }, 538 .size = sizeof(struct pyra_profile_settings), 539 .read = pyra_sysfs_read_profile3_settings 540 }; 541 542 static struct bin_attribute pyra_profile4_settings_attr = { 543 .attr = { .name = "profile4_settings", .mode = 0440 }, 544 .size = sizeof(struct pyra_profile_settings), 545 .read = pyra_sysfs_read_profile4_settings 546 }; 547 548 static struct bin_attribute pyra_profile5_settings_attr = { 549 .attr = { .name = "profile5_settings", .mode = 0440 }, 550 .size = sizeof(struct pyra_profile_settings), 551 .read = pyra_sysfs_read_profile5_settings 552 }; 553 554 static struct bin_attribute pyra_profile_buttons_attr = { 555 .attr = { .name = "profile_buttons", .mode = 0220 }, 556 .size = sizeof(struct pyra_profile_buttons), 557 .write = pyra_sysfs_write_profile_buttons 558 }; 559 560 static struct bin_attribute pyra_profile1_buttons_attr = { 561 .attr = { .name = "profile1_buttons", .mode = 0440 }, 562 .size = sizeof(struct pyra_profile_buttons), 563 .read = pyra_sysfs_read_profile1_buttons 564 }; 565 566 static struct bin_attribute pyra_profile2_buttons_attr = { 567 .attr = { .name = "profile2_buttons", .mode = 0440 }, 568 .size = sizeof(struct pyra_profile_buttons), 569 .read = pyra_sysfs_read_profile2_buttons 570 }; 571 572 static struct bin_attribute pyra_profile3_buttons_attr = { 573 .attr = { .name = "profile3_buttons", .mode = 0440 }, 574 .size = sizeof(struct pyra_profile_buttons), 575 .read = pyra_sysfs_read_profile3_buttons 576 }; 577 578 static struct bin_attribute pyra_profile4_buttons_attr = { 579 .attr = { .name = "profile4_buttons", .mode = 0440 }, 580 .size = sizeof(struct pyra_profile_buttons), 581 .read = pyra_sysfs_read_profile4_buttons 582 }; 583 584 static struct bin_attribute pyra_profile5_buttons_attr = { 585 .attr = { .name = "profile5_buttons", .mode = 0440 }, 586 .size = sizeof(struct pyra_profile_buttons), 587 .read = pyra_sysfs_read_profile5_buttons 588 }; 589 590 static struct bin_attribute pyra_settings_attr = { 591 .attr = { .name = "settings", .mode = 0660 }, 592 .size = sizeof(struct pyra_settings), 593 .read = pyra_sysfs_read_settings, 594 .write = pyra_sysfs_write_settings 595 }; 596 597 static int pyra_create_sysfs_attributes(struct usb_interface *intf) 598 { 599 int retval; 600 601 retval = sysfs_create_group(&intf->dev.kobj, &pyra_attribute_group); 602 if (retval) 603 goto exit_1; 604 605 retval = sysfs_create_bin_file(&intf->dev.kobj, 606 &pyra_profile_settings_attr); 607 if (retval) 608 goto exit_2; 609 610 retval = sysfs_create_bin_file(&intf->dev.kobj, 611 &pyra_profile1_settings_attr); 612 if (retval) 613 goto exit_3; 614 615 retval = sysfs_create_bin_file(&intf->dev.kobj, 616 &pyra_profile2_settings_attr); 617 if (retval) 618 goto exit_4; 619 620 retval = sysfs_create_bin_file(&intf->dev.kobj, 621 &pyra_profile3_settings_attr); 622 if (retval) 623 goto exit_5; 624 625 retval = sysfs_create_bin_file(&intf->dev.kobj, 626 &pyra_profile4_settings_attr); 627 if (retval) 628 goto exit_6; 629 630 retval = sysfs_create_bin_file(&intf->dev.kobj, 631 &pyra_profile5_settings_attr); 632 if (retval) 633 goto exit_7; 634 635 retval = sysfs_create_bin_file(&intf->dev.kobj, 636 &pyra_profile_buttons_attr); 637 if (retval) 638 goto exit_8; 639 640 retval = sysfs_create_bin_file(&intf->dev.kobj, 641 &pyra_profile1_buttons_attr); 642 if (retval) 643 goto exit_9; 644 645 retval = sysfs_create_bin_file(&intf->dev.kobj, 646 &pyra_profile2_buttons_attr); 647 if (retval) 648 goto exit_10; 649 650 retval = sysfs_create_bin_file(&intf->dev.kobj, 651 &pyra_profile3_buttons_attr); 652 if (retval) 653 goto exit_11; 654 655 retval = sysfs_create_bin_file(&intf->dev.kobj, 656 &pyra_profile4_buttons_attr); 657 if (retval) 658 goto exit_12; 659 660 retval = sysfs_create_bin_file(&intf->dev.kobj, 661 &pyra_profile5_buttons_attr); 662 if (retval) 663 goto exit_13; 664 665 retval = sysfs_create_bin_file(&intf->dev.kobj, 666 &pyra_settings_attr); 667 if (retval) 668 goto exit_14; 669 670 return 0; 671 672 exit_14: 673 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile5_buttons_attr); 674 exit_13: 675 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile4_buttons_attr); 676 exit_12: 677 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile3_buttons_attr); 678 exit_11: 679 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile2_buttons_attr); 680 exit_10: 681 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile1_buttons_attr); 682 exit_9: 683 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile_buttons_attr); 684 exit_8: 685 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile5_settings_attr); 686 exit_7: 687 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile4_settings_attr); 688 exit_6: 689 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile3_settings_attr); 690 exit_5: 691 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile2_settings_attr); 692 exit_4: 693 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile1_settings_attr); 694 exit_3: 695 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile_settings_attr); 696 exit_2: 697 sysfs_remove_group(&intf->dev.kobj, &pyra_attribute_group); 698 exit_1: 699 return retval; 700 } 701 702 static void pyra_remove_sysfs_attributes(struct usb_interface *intf) 703 { 704 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_settings_attr); 705 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile5_buttons_attr); 706 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile4_buttons_attr); 707 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile3_buttons_attr); 708 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile2_buttons_attr); 709 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile1_buttons_attr); 710 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile_buttons_attr); 711 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile5_settings_attr); 712 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile4_settings_attr); 713 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile3_settings_attr); 714 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile2_settings_attr); 715 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile1_settings_attr); 716 sysfs_remove_bin_file(&intf->dev.kobj, &pyra_profile_settings_attr); 717 sysfs_remove_group(&intf->dev.kobj, &pyra_attribute_group); 718 } 719 720 static int pyra_init_pyra_device_struct(struct usb_device *usb_dev, 721 struct pyra_device *pyra) 722 { 723 struct pyra_info *info; 724 int retval, i; 725 726 mutex_init(&pyra->pyra_lock); 727 728 info = kmalloc(sizeof(struct pyra_info), GFP_KERNEL); 729 if (!info) 730 return -ENOMEM; 731 retval = pyra_get_info(usb_dev, info); 732 if (retval) { 733 kfree(info); 734 return retval; 735 } 736 pyra->firmware_version = info->firmware_version; 737 kfree(info); 738 739 retval = pyra_get_settings(usb_dev, &pyra->settings); 740 if (retval) 741 return retval; 742 743 for (i = 0; i < 5; ++i) { 744 retval = pyra_get_profile_settings(usb_dev, 745 &pyra->profile_settings[i], i); 746 if (retval) 747 return retval; 748 749 retval = pyra_get_profile_buttons(usb_dev, 750 &pyra->profile_buttons[i], i); 751 if (retval) 752 return retval; 753 } 754 755 profile_activated(pyra, pyra->settings.startup_profile); 756 757 return 0; 758 } 759 760 static int pyra_init_specials(struct hid_device *hdev) 761 { 762 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 763 struct usb_device *usb_dev = interface_to_usbdev(intf); 764 struct pyra_device *pyra; 765 int retval; 766 767 if (intf->cur_altsetting->desc.bInterfaceProtocol 768 == USB_INTERFACE_PROTOCOL_MOUSE) { 769 770 pyra = kzalloc(sizeof(*pyra), GFP_KERNEL); 771 if (!pyra) { 772 hid_err(hdev, "can't alloc device descriptor\n"); 773 return -ENOMEM; 774 } 775 hid_set_drvdata(hdev, pyra); 776 777 retval = pyra_init_pyra_device_struct(usb_dev, pyra); 778 if (retval) { 779 hid_err(hdev, "couldn't init struct pyra_device\n"); 780 goto exit_free; 781 } 782 783 retval = roccat_connect(hdev); 784 if (retval < 0) { 785 hid_err(hdev, "couldn't init char dev\n"); 786 } else { 787 pyra->chrdev_minor = retval; 788 pyra->roccat_claimed = 1; 789 } 790 791 retval = pyra_create_sysfs_attributes(intf); 792 if (retval) { 793 hid_err(hdev, "cannot create sysfs files\n"); 794 goto exit_free; 795 } 796 } else { 797 hid_set_drvdata(hdev, NULL); 798 } 799 800 return 0; 801 exit_free: 802 kfree(pyra); 803 return retval; 804 } 805 806 static void pyra_remove_specials(struct hid_device *hdev) 807 { 808 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 809 struct pyra_device *pyra; 810 811 if (intf->cur_altsetting->desc.bInterfaceProtocol 812 == USB_INTERFACE_PROTOCOL_MOUSE) { 813 pyra_remove_sysfs_attributes(intf); 814 pyra = hid_get_drvdata(hdev); 815 if (pyra->roccat_claimed) 816 roccat_disconnect(pyra->chrdev_minor); 817 kfree(hid_get_drvdata(hdev)); 818 } 819 } 820 821 static int pyra_probe(struct hid_device *hdev, const struct hid_device_id *id) 822 { 823 int retval; 824 825 retval = hid_parse(hdev); 826 if (retval) { 827 hid_err(hdev, "parse failed\n"); 828 goto exit; 829 } 830 831 retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 832 if (retval) { 833 hid_err(hdev, "hw start failed\n"); 834 goto exit; 835 } 836 837 retval = pyra_init_specials(hdev); 838 if (retval) { 839 hid_err(hdev, "couldn't install mouse\n"); 840 goto exit_stop; 841 } 842 return 0; 843 844 exit_stop: 845 hid_hw_stop(hdev); 846 exit: 847 return retval; 848 } 849 850 static void pyra_remove(struct hid_device *hdev) 851 { 852 pyra_remove_specials(hdev); 853 hid_hw_stop(hdev); 854 } 855 856 static void pyra_keep_values_up_to_date(struct pyra_device *pyra, 857 u8 const *data) 858 { 859 struct pyra_mouse_event_button const *button_event; 860 861 switch (data[0]) { 862 case PYRA_MOUSE_REPORT_NUMBER_BUTTON: 863 button_event = (struct pyra_mouse_event_button const *)data; 864 switch (button_event->type) { 865 case PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2: 866 profile_activated(pyra, button_event->data1 - 1); 867 break; 868 case PYRA_MOUSE_EVENT_BUTTON_TYPE_CPI: 869 pyra->actual_cpi = button_event->data1; 870 break; 871 } 872 break; 873 } 874 } 875 876 static void pyra_report_to_chrdev(struct pyra_device const *pyra, 877 u8 const *data) 878 { 879 struct pyra_roccat_report roccat_report; 880 struct pyra_mouse_event_button const *button_event; 881 882 if (data[0] != PYRA_MOUSE_REPORT_NUMBER_BUTTON) 883 return; 884 885 button_event = (struct pyra_mouse_event_button const *)data; 886 887 switch (button_event->type) { 888 case PYRA_MOUSE_EVENT_BUTTON_TYPE_PROFILE_2: 889 case PYRA_MOUSE_EVENT_BUTTON_TYPE_CPI: 890 roccat_report.type = button_event->type; 891 roccat_report.value = button_event->data1; 892 roccat_report.key = 0; 893 roccat_report_event(pyra->chrdev_minor, 894 (uint8_t const *)&roccat_report, 895 sizeof(struct pyra_roccat_report)); 896 break; 897 case PYRA_MOUSE_EVENT_BUTTON_TYPE_MACRO: 898 case PYRA_MOUSE_EVENT_BUTTON_TYPE_SHORTCUT: 899 case PYRA_MOUSE_EVENT_BUTTON_TYPE_QUICKLAUNCH: 900 if (button_event->data2 == PYRA_MOUSE_EVENT_BUTTON_PRESS) { 901 roccat_report.type = button_event->type; 902 roccat_report.key = button_event->data1; 903 /* 904 * pyra reports profile numbers with range 1-5. 905 * Keeping this behaviour. 906 */ 907 roccat_report.value = pyra->actual_profile + 1; 908 roccat_report_event(pyra->chrdev_minor, 909 (uint8_t const *)&roccat_report, 910 sizeof(struct pyra_roccat_report)); 911 } 912 break; 913 } 914 } 915 916 static int pyra_raw_event(struct hid_device *hdev, struct hid_report *report, 917 u8 *data, int size) 918 { 919 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 920 struct pyra_device *pyra = hid_get_drvdata(hdev); 921 922 if (intf->cur_altsetting->desc.bInterfaceProtocol 923 != USB_INTERFACE_PROTOCOL_MOUSE) 924 return 0; 925 926 pyra_keep_values_up_to_date(pyra, data); 927 928 if (pyra->roccat_claimed) 929 pyra_report_to_chrdev(pyra, data); 930 931 return 0; 932 } 933 934 static const struct hid_device_id pyra_devices[] = { 935 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, 936 USB_DEVICE_ID_ROCCAT_PYRA_WIRED) }, 937 /* TODO add USB_DEVICE_ID_ROCCAT_PYRA_WIRELESS after testing */ 938 { } 939 }; 940 941 MODULE_DEVICE_TABLE(hid, pyra_devices); 942 943 static struct hid_driver pyra_driver = { 944 .name = "pyra", 945 .id_table = pyra_devices, 946 .probe = pyra_probe, 947 .remove = pyra_remove, 948 .raw_event = pyra_raw_event 949 }; 950 951 static int __init pyra_init(void) 952 { 953 return hid_register_driver(&pyra_driver); 954 } 955 956 static void __exit pyra_exit(void) 957 { 958 hid_unregister_driver(&pyra_driver); 959 } 960 961 module_init(pyra_init); 962 module_exit(pyra_exit); 963 964 MODULE_AUTHOR("Stefan Achatz"); 965 MODULE_DESCRIPTION("USB Roccat Pyra driver"); 966 MODULE_LICENSE("GPL v2"); 967