1 /* 2 * Roccat Kova[+] driver for Linux 3 * 4 * Copyright (c) 2011 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 Kova[+] is a bigger version of the Pyra with two more side buttons. 16 */ 17 18 #include <linux/device.h> 19 #include <linux/input.h> 20 #include <linux/hid.h> 21 #include <linux/module.h> 22 #include <linux/slab.h> 23 #include <linux/hid-roccat.h> 24 #include "hid-ids.h" 25 #include "hid-roccat-common.h" 26 #include "hid-roccat-kovaplus.h" 27 28 static uint profile_numbers[5] = {0, 1, 2, 3, 4}; 29 30 static struct class *kovaplus_class; 31 32 static uint kovaplus_convert_event_cpi(uint value) 33 { 34 return (value == 7 ? 4 : (value == 4 ? 3 : value)); 35 } 36 37 static void kovaplus_profile_activated(struct kovaplus_device *kovaplus, 38 uint new_profile_index) 39 { 40 kovaplus->actual_profile = new_profile_index; 41 kovaplus->actual_cpi = kovaplus->profile_settings[new_profile_index].cpi_startup_level; 42 kovaplus->actual_x_sensitivity = kovaplus->profile_settings[new_profile_index].sensitivity_x; 43 kovaplus->actual_y_sensitivity = kovaplus->profile_settings[new_profile_index].sensitivity_y; 44 } 45 46 static int kovaplus_send_control(struct usb_device *usb_dev, uint value, 47 enum kovaplus_control_requests request) 48 { 49 int retval; 50 struct roccat_common2_control control; 51 52 if ((request == KOVAPLUS_CONTROL_REQUEST_PROFILE_SETTINGS || 53 request == KOVAPLUS_CONTROL_REQUEST_PROFILE_BUTTONS) && 54 value > 4) 55 return -EINVAL; 56 57 control.command = ROCCAT_COMMON_COMMAND_CONTROL; 58 control.value = value; 59 control.request = request; 60 61 retval = roccat_common2_send(usb_dev, ROCCAT_COMMON_COMMAND_CONTROL, 62 &control, sizeof(struct roccat_common2_control)); 63 64 return retval; 65 } 66 67 static int kovaplus_select_profile(struct usb_device *usb_dev, uint number, 68 enum kovaplus_control_requests request) 69 { 70 return kovaplus_send_control(usb_dev, number, request); 71 } 72 73 static int kovaplus_get_profile_settings(struct usb_device *usb_dev, 74 struct kovaplus_profile_settings *buf, uint number) 75 { 76 int retval; 77 78 retval = kovaplus_select_profile(usb_dev, number, 79 KOVAPLUS_CONTROL_REQUEST_PROFILE_SETTINGS); 80 if (retval) 81 return retval; 82 83 return roccat_common2_receive(usb_dev, KOVAPLUS_COMMAND_PROFILE_SETTINGS, 84 buf, KOVAPLUS_SIZE_PROFILE_SETTINGS); 85 } 86 87 static int kovaplus_get_profile_buttons(struct usb_device *usb_dev, 88 struct kovaplus_profile_buttons *buf, int number) 89 { 90 int retval; 91 92 retval = kovaplus_select_profile(usb_dev, number, 93 KOVAPLUS_CONTROL_REQUEST_PROFILE_BUTTONS); 94 if (retval) 95 return retval; 96 97 return roccat_common2_receive(usb_dev, KOVAPLUS_COMMAND_PROFILE_BUTTONS, 98 buf, KOVAPLUS_SIZE_PROFILE_BUTTONS); 99 } 100 101 /* retval is 0-4 on success, < 0 on error */ 102 static int kovaplus_get_actual_profile(struct usb_device *usb_dev) 103 { 104 struct kovaplus_actual_profile buf; 105 int retval; 106 107 retval = roccat_common2_receive(usb_dev, KOVAPLUS_COMMAND_ACTUAL_PROFILE, 108 &buf, sizeof(struct kovaplus_actual_profile)); 109 110 return retval ? retval : buf.actual_profile; 111 } 112 113 static int kovaplus_set_actual_profile(struct usb_device *usb_dev, 114 int new_profile) 115 { 116 struct kovaplus_actual_profile buf; 117 118 buf.command = KOVAPLUS_COMMAND_ACTUAL_PROFILE; 119 buf.size = sizeof(struct kovaplus_actual_profile); 120 buf.actual_profile = new_profile; 121 122 return roccat_common2_send_with_status(usb_dev, 123 KOVAPLUS_COMMAND_ACTUAL_PROFILE, 124 &buf, sizeof(struct kovaplus_actual_profile)); 125 } 126 127 static ssize_t kovaplus_sysfs_read(struct file *fp, struct kobject *kobj, 128 char *buf, loff_t off, size_t count, 129 size_t real_size, uint command) 130 { 131 struct device *dev = 132 container_of(kobj, struct device, kobj)->parent->parent; 133 struct kovaplus_device *kovaplus = hid_get_drvdata(dev_get_drvdata(dev)); 134 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 135 int retval; 136 137 if (off >= real_size) 138 return 0; 139 140 if (off != 0 || count != real_size) 141 return -EINVAL; 142 143 mutex_lock(&kovaplus->kovaplus_lock); 144 retval = roccat_common2_receive(usb_dev, command, buf, real_size); 145 mutex_unlock(&kovaplus->kovaplus_lock); 146 147 if (retval) 148 return retval; 149 150 return real_size; 151 } 152 153 static ssize_t kovaplus_sysfs_write(struct file *fp, struct kobject *kobj, 154 void const *buf, loff_t off, size_t count, 155 size_t real_size, uint command) 156 { 157 struct device *dev = 158 container_of(kobj, struct device, kobj)->parent->parent; 159 struct kovaplus_device *kovaplus = hid_get_drvdata(dev_get_drvdata(dev)); 160 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 161 int retval; 162 163 if (off != 0 || count != real_size) 164 return -EINVAL; 165 166 mutex_lock(&kovaplus->kovaplus_lock); 167 retval = roccat_common2_send_with_status(usb_dev, command, 168 buf, real_size); 169 mutex_unlock(&kovaplus->kovaplus_lock); 170 171 if (retval) 172 return retval; 173 174 return real_size; 175 } 176 177 #define KOVAPLUS_SYSFS_W(thingy, THINGY) \ 178 static ssize_t kovaplus_sysfs_write_ ## thingy(struct file *fp, \ 179 struct kobject *kobj, struct bin_attribute *attr, char *buf, \ 180 loff_t off, size_t count) \ 181 { \ 182 return kovaplus_sysfs_write(fp, kobj, buf, off, count, \ 183 KOVAPLUS_SIZE_ ## THINGY, KOVAPLUS_COMMAND_ ## THINGY); \ 184 } 185 186 #define KOVAPLUS_SYSFS_R(thingy, THINGY) \ 187 static ssize_t kovaplus_sysfs_read_ ## thingy(struct file *fp, \ 188 struct kobject *kobj, struct bin_attribute *attr, char *buf, \ 189 loff_t off, size_t count) \ 190 { \ 191 return kovaplus_sysfs_read(fp, kobj, buf, off, count, \ 192 KOVAPLUS_SIZE_ ## THINGY, KOVAPLUS_COMMAND_ ## THINGY); \ 193 } 194 195 #define KOVAPLUS_SYSFS_RW(thingy, THINGY) \ 196 KOVAPLUS_SYSFS_W(thingy, THINGY) \ 197 KOVAPLUS_SYSFS_R(thingy, THINGY) 198 199 #define KOVAPLUS_BIN_ATTRIBUTE_RW(thingy, THINGY) \ 200 { \ 201 .attr = { .name = #thingy, .mode = 0660 }, \ 202 .size = KOVAPLUS_SIZE_ ## THINGY, \ 203 .read = kovaplus_sysfs_read_ ## thingy, \ 204 .write = kovaplus_sysfs_write_ ## thingy \ 205 } 206 207 #define KOVAPLUS_BIN_ATTRIBUTE_R(thingy, THINGY) \ 208 { \ 209 .attr = { .name = #thingy, .mode = 0440 }, \ 210 .size = KOVAPLUS_SIZE_ ## THINGY, \ 211 .read = kovaplus_sysfs_read_ ## thingy, \ 212 } 213 214 #define KOVAPLUS_BIN_ATTRIBUTE_W(thingy, THINGY) \ 215 { \ 216 .attr = { .name = #thingy, .mode = 0220 }, \ 217 .size = KOVAPLUS_SIZE_ ## THINGY, \ 218 .write = kovaplus_sysfs_write_ ## thingy \ 219 } 220 221 KOVAPLUS_SYSFS_W(control, CONTROL) 222 KOVAPLUS_SYSFS_RW(info, INFO) 223 KOVAPLUS_SYSFS_RW(profile_settings, PROFILE_SETTINGS) 224 KOVAPLUS_SYSFS_RW(profile_buttons, PROFILE_BUTTONS) 225 226 static ssize_t kovaplus_sysfs_read_profilex_settings(struct file *fp, 227 struct kobject *kobj, struct bin_attribute *attr, char *buf, 228 loff_t off, size_t count) 229 { 230 struct device *dev = 231 container_of(kobj, struct device, kobj)->parent->parent; 232 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 233 ssize_t retval; 234 235 retval = kovaplus_select_profile(usb_dev, *(uint *)(attr->private), 236 KOVAPLUS_CONTROL_REQUEST_PROFILE_SETTINGS); 237 if (retval) 238 return retval; 239 240 return kovaplus_sysfs_read(fp, kobj, buf, off, count, 241 KOVAPLUS_SIZE_PROFILE_SETTINGS, 242 KOVAPLUS_COMMAND_PROFILE_SETTINGS); 243 } 244 245 static ssize_t kovaplus_sysfs_read_profilex_buttons(struct file *fp, 246 struct kobject *kobj, struct bin_attribute *attr, char *buf, 247 loff_t off, size_t count) 248 { 249 struct device *dev = 250 container_of(kobj, struct device, kobj)->parent->parent; 251 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 252 ssize_t retval; 253 254 retval = kovaplus_select_profile(usb_dev, *(uint *)(attr->private), 255 KOVAPLUS_CONTROL_REQUEST_PROFILE_BUTTONS); 256 if (retval) 257 return retval; 258 259 return kovaplus_sysfs_read(fp, kobj, buf, off, count, 260 KOVAPLUS_SIZE_PROFILE_BUTTONS, 261 KOVAPLUS_COMMAND_PROFILE_BUTTONS); 262 } 263 264 static ssize_t kovaplus_sysfs_show_actual_profile(struct device *dev, 265 struct device_attribute *attr, char *buf) 266 { 267 struct kovaplus_device *kovaplus = 268 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 269 return snprintf(buf, PAGE_SIZE, "%d\n", kovaplus->actual_profile); 270 } 271 272 static ssize_t kovaplus_sysfs_set_actual_profile(struct device *dev, 273 struct device_attribute *attr, char const *buf, size_t size) 274 { 275 struct kovaplus_device *kovaplus; 276 struct usb_device *usb_dev; 277 unsigned long profile; 278 int retval; 279 struct kovaplus_roccat_report roccat_report; 280 281 dev = dev->parent->parent; 282 kovaplus = hid_get_drvdata(dev_get_drvdata(dev)); 283 usb_dev = interface_to_usbdev(to_usb_interface(dev)); 284 285 retval = strict_strtoul(buf, 10, &profile); 286 if (retval) 287 return retval; 288 289 if (profile >= 5) 290 return -EINVAL; 291 292 mutex_lock(&kovaplus->kovaplus_lock); 293 retval = kovaplus_set_actual_profile(usb_dev, profile); 294 if (retval) { 295 mutex_unlock(&kovaplus->kovaplus_lock); 296 return retval; 297 } 298 299 kovaplus_profile_activated(kovaplus, profile); 300 301 roccat_report.type = KOVAPLUS_MOUSE_REPORT_BUTTON_TYPE_PROFILE_1; 302 roccat_report.profile = profile + 1; 303 roccat_report.button = 0; 304 roccat_report.data1 = profile + 1; 305 roccat_report.data2 = 0; 306 roccat_report_event(kovaplus->chrdev_minor, 307 (uint8_t const *)&roccat_report); 308 309 mutex_unlock(&kovaplus->kovaplus_lock); 310 311 return size; 312 } 313 314 static ssize_t kovaplus_sysfs_show_actual_cpi(struct device *dev, 315 struct device_attribute *attr, char *buf) 316 { 317 struct kovaplus_device *kovaplus = 318 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 319 return snprintf(buf, PAGE_SIZE, "%d\n", kovaplus->actual_cpi); 320 } 321 322 static ssize_t kovaplus_sysfs_show_actual_sensitivity_x(struct device *dev, 323 struct device_attribute *attr, char *buf) 324 { 325 struct kovaplus_device *kovaplus = 326 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 327 return snprintf(buf, PAGE_SIZE, "%d\n", kovaplus->actual_x_sensitivity); 328 } 329 330 static ssize_t kovaplus_sysfs_show_actual_sensitivity_y(struct device *dev, 331 struct device_attribute *attr, char *buf) 332 { 333 struct kovaplus_device *kovaplus = 334 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 335 return snprintf(buf, PAGE_SIZE, "%d\n", kovaplus->actual_y_sensitivity); 336 } 337 338 static ssize_t kovaplus_sysfs_show_firmware_version(struct device *dev, 339 struct device_attribute *attr, char *buf) 340 { 341 struct kovaplus_device *kovaplus; 342 struct usb_device *usb_dev; 343 struct kovaplus_info info; 344 345 dev = dev->parent->parent; 346 kovaplus = hid_get_drvdata(dev_get_drvdata(dev)); 347 usb_dev = interface_to_usbdev(to_usb_interface(dev)); 348 349 mutex_lock(&kovaplus->kovaplus_lock); 350 roccat_common2_receive(usb_dev, KOVAPLUS_COMMAND_INFO, 351 &info, KOVAPLUS_SIZE_INFO); 352 mutex_unlock(&kovaplus->kovaplus_lock); 353 354 return snprintf(buf, PAGE_SIZE, "%d\n", info.firmware_version); 355 } 356 357 static struct device_attribute kovaplus_attributes[] = { 358 __ATTR(actual_cpi, 0440, 359 kovaplus_sysfs_show_actual_cpi, NULL), 360 __ATTR(firmware_version, 0440, 361 kovaplus_sysfs_show_firmware_version, NULL), 362 __ATTR(actual_profile, 0660, 363 kovaplus_sysfs_show_actual_profile, 364 kovaplus_sysfs_set_actual_profile), 365 __ATTR(actual_sensitivity_x, 0440, 366 kovaplus_sysfs_show_actual_sensitivity_x, NULL), 367 __ATTR(actual_sensitivity_y, 0440, 368 kovaplus_sysfs_show_actual_sensitivity_y, NULL), 369 __ATTR_NULL 370 }; 371 372 static struct bin_attribute kovaplus_bin_attributes[] = { 373 KOVAPLUS_BIN_ATTRIBUTE_W(control, CONTROL), 374 KOVAPLUS_BIN_ATTRIBUTE_RW(info, INFO), 375 KOVAPLUS_BIN_ATTRIBUTE_RW(profile_settings, PROFILE_SETTINGS), 376 KOVAPLUS_BIN_ATTRIBUTE_RW(profile_buttons, PROFILE_BUTTONS), 377 { 378 .attr = { .name = "profile1_settings", .mode = 0440 }, 379 .size = KOVAPLUS_SIZE_PROFILE_SETTINGS, 380 .read = kovaplus_sysfs_read_profilex_settings, 381 .private = &profile_numbers[0] 382 }, 383 { 384 .attr = { .name = "profile2_settings", .mode = 0440 }, 385 .size = KOVAPLUS_SIZE_PROFILE_SETTINGS, 386 .read = kovaplus_sysfs_read_profilex_settings, 387 .private = &profile_numbers[1] 388 }, 389 { 390 .attr = { .name = "profile3_settings", .mode = 0440 }, 391 .size = KOVAPLUS_SIZE_PROFILE_SETTINGS, 392 .read = kovaplus_sysfs_read_profilex_settings, 393 .private = &profile_numbers[2] 394 }, 395 { 396 .attr = { .name = "profile4_settings", .mode = 0440 }, 397 .size = KOVAPLUS_SIZE_PROFILE_SETTINGS, 398 .read = kovaplus_sysfs_read_profilex_settings, 399 .private = &profile_numbers[3] 400 }, 401 { 402 .attr = { .name = "profile5_settings", .mode = 0440 }, 403 .size = KOVAPLUS_SIZE_PROFILE_SETTINGS, 404 .read = kovaplus_sysfs_read_profilex_settings, 405 .private = &profile_numbers[4] 406 }, 407 { 408 .attr = { .name = "profile1_buttons", .mode = 0440 }, 409 .size = KOVAPLUS_SIZE_PROFILE_BUTTONS, 410 .read = kovaplus_sysfs_read_profilex_buttons, 411 .private = &profile_numbers[0] 412 }, 413 { 414 .attr = { .name = "profile2_buttons", .mode = 0440 }, 415 .size = KOVAPLUS_SIZE_PROFILE_BUTTONS, 416 .read = kovaplus_sysfs_read_profilex_buttons, 417 .private = &profile_numbers[1] 418 }, 419 { 420 .attr = { .name = "profile3_buttons", .mode = 0440 }, 421 .size = KOVAPLUS_SIZE_PROFILE_BUTTONS, 422 .read = kovaplus_sysfs_read_profilex_buttons, 423 .private = &profile_numbers[2] 424 }, 425 { 426 .attr = { .name = "profile4_buttons", .mode = 0440 }, 427 .size = KOVAPLUS_SIZE_PROFILE_BUTTONS, 428 .read = kovaplus_sysfs_read_profilex_buttons, 429 .private = &profile_numbers[3] 430 }, 431 { 432 .attr = { .name = "profile5_buttons", .mode = 0440 }, 433 .size = KOVAPLUS_SIZE_PROFILE_BUTTONS, 434 .read = kovaplus_sysfs_read_profilex_buttons, 435 .private = &profile_numbers[4] 436 }, 437 __ATTR_NULL 438 }; 439 440 static int kovaplus_init_kovaplus_device_struct(struct usb_device *usb_dev, 441 struct kovaplus_device *kovaplus) 442 { 443 int retval, i; 444 static uint wait = 70; /* device will freeze with just 60 */ 445 446 mutex_init(&kovaplus->kovaplus_lock); 447 448 for (i = 0; i < 5; ++i) { 449 msleep(wait); 450 retval = kovaplus_get_profile_settings(usb_dev, 451 &kovaplus->profile_settings[i], i); 452 if (retval) 453 return retval; 454 455 msleep(wait); 456 retval = kovaplus_get_profile_buttons(usb_dev, 457 &kovaplus->profile_buttons[i], i); 458 if (retval) 459 return retval; 460 } 461 462 msleep(wait); 463 retval = kovaplus_get_actual_profile(usb_dev); 464 if (retval < 0) 465 return retval; 466 kovaplus_profile_activated(kovaplus, retval); 467 468 return 0; 469 } 470 471 static int kovaplus_init_specials(struct hid_device *hdev) 472 { 473 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 474 struct usb_device *usb_dev = interface_to_usbdev(intf); 475 struct kovaplus_device *kovaplus; 476 int retval; 477 478 if (intf->cur_altsetting->desc.bInterfaceProtocol 479 == USB_INTERFACE_PROTOCOL_MOUSE) { 480 481 kovaplus = kzalloc(sizeof(*kovaplus), GFP_KERNEL); 482 if (!kovaplus) { 483 hid_err(hdev, "can't alloc device descriptor\n"); 484 return -ENOMEM; 485 } 486 hid_set_drvdata(hdev, kovaplus); 487 488 retval = kovaplus_init_kovaplus_device_struct(usb_dev, kovaplus); 489 if (retval) { 490 hid_err(hdev, "couldn't init struct kovaplus_device\n"); 491 goto exit_free; 492 } 493 494 retval = roccat_connect(kovaplus_class, hdev, 495 sizeof(struct kovaplus_roccat_report)); 496 if (retval < 0) { 497 hid_err(hdev, "couldn't init char dev\n"); 498 } else { 499 kovaplus->chrdev_minor = retval; 500 kovaplus->roccat_claimed = 1; 501 } 502 503 } else { 504 hid_set_drvdata(hdev, NULL); 505 } 506 507 return 0; 508 exit_free: 509 kfree(kovaplus); 510 return retval; 511 } 512 513 static void kovaplus_remove_specials(struct hid_device *hdev) 514 { 515 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 516 struct kovaplus_device *kovaplus; 517 518 if (intf->cur_altsetting->desc.bInterfaceProtocol 519 == USB_INTERFACE_PROTOCOL_MOUSE) { 520 kovaplus = hid_get_drvdata(hdev); 521 if (kovaplus->roccat_claimed) 522 roccat_disconnect(kovaplus->chrdev_minor); 523 kfree(kovaplus); 524 } 525 } 526 527 static int kovaplus_probe(struct hid_device *hdev, 528 const struct hid_device_id *id) 529 { 530 int retval; 531 532 retval = hid_parse(hdev); 533 if (retval) { 534 hid_err(hdev, "parse failed\n"); 535 goto exit; 536 } 537 538 retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 539 if (retval) { 540 hid_err(hdev, "hw start failed\n"); 541 goto exit; 542 } 543 544 retval = kovaplus_init_specials(hdev); 545 if (retval) { 546 hid_err(hdev, "couldn't install mouse\n"); 547 goto exit_stop; 548 } 549 550 return 0; 551 552 exit_stop: 553 hid_hw_stop(hdev); 554 exit: 555 return retval; 556 } 557 558 static void kovaplus_remove(struct hid_device *hdev) 559 { 560 kovaplus_remove_specials(hdev); 561 hid_hw_stop(hdev); 562 } 563 564 static void kovaplus_keep_values_up_to_date(struct kovaplus_device *kovaplus, 565 u8 const *data) 566 { 567 struct kovaplus_mouse_report_button const *button_report; 568 569 if (data[0] != KOVAPLUS_MOUSE_REPORT_NUMBER_BUTTON) 570 return; 571 572 button_report = (struct kovaplus_mouse_report_button const *)data; 573 574 switch (button_report->type) { 575 case KOVAPLUS_MOUSE_REPORT_BUTTON_TYPE_PROFILE_1: 576 kovaplus_profile_activated(kovaplus, button_report->data1 - 1); 577 break; 578 case KOVAPLUS_MOUSE_REPORT_BUTTON_TYPE_CPI: 579 kovaplus->actual_cpi = kovaplus_convert_event_cpi(button_report->data1); 580 case KOVAPLUS_MOUSE_REPORT_BUTTON_TYPE_SENSITIVITY: 581 kovaplus->actual_x_sensitivity = button_report->data1; 582 kovaplus->actual_y_sensitivity = button_report->data2; 583 } 584 } 585 586 static void kovaplus_report_to_chrdev(struct kovaplus_device const *kovaplus, 587 u8 const *data) 588 { 589 struct kovaplus_roccat_report roccat_report; 590 struct kovaplus_mouse_report_button const *button_report; 591 592 if (data[0] != KOVAPLUS_MOUSE_REPORT_NUMBER_BUTTON) 593 return; 594 595 button_report = (struct kovaplus_mouse_report_button const *)data; 596 597 if (button_report->type == KOVAPLUS_MOUSE_REPORT_BUTTON_TYPE_PROFILE_2) 598 return; 599 600 roccat_report.type = button_report->type; 601 roccat_report.profile = kovaplus->actual_profile + 1; 602 603 if (roccat_report.type == KOVAPLUS_MOUSE_REPORT_BUTTON_TYPE_MACRO || 604 roccat_report.type == KOVAPLUS_MOUSE_REPORT_BUTTON_TYPE_SHORTCUT || 605 roccat_report.type == KOVAPLUS_MOUSE_REPORT_BUTTON_TYPE_QUICKLAUNCH || 606 roccat_report.type == KOVAPLUS_MOUSE_REPORT_BUTTON_TYPE_TIMER) 607 roccat_report.button = button_report->data1; 608 else 609 roccat_report.button = 0; 610 611 if (roccat_report.type == KOVAPLUS_MOUSE_REPORT_BUTTON_TYPE_CPI) 612 roccat_report.data1 = kovaplus_convert_event_cpi(button_report->data1); 613 else 614 roccat_report.data1 = button_report->data1; 615 616 roccat_report.data2 = button_report->data2; 617 618 roccat_report_event(kovaplus->chrdev_minor, 619 (uint8_t const *)&roccat_report); 620 } 621 622 static int kovaplus_raw_event(struct hid_device *hdev, 623 struct hid_report *report, u8 *data, int size) 624 { 625 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 626 struct kovaplus_device *kovaplus = hid_get_drvdata(hdev); 627 628 if (intf->cur_altsetting->desc.bInterfaceProtocol 629 != USB_INTERFACE_PROTOCOL_MOUSE) 630 return 0; 631 632 if (kovaplus == NULL) 633 return 0; 634 635 kovaplus_keep_values_up_to_date(kovaplus, data); 636 637 if (kovaplus->roccat_claimed) 638 kovaplus_report_to_chrdev(kovaplus, data); 639 640 return 0; 641 } 642 643 static const struct hid_device_id kovaplus_devices[] = { 644 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_KOVAPLUS) }, 645 { } 646 }; 647 648 MODULE_DEVICE_TABLE(hid, kovaplus_devices); 649 650 static struct hid_driver kovaplus_driver = { 651 .name = "kovaplus", 652 .id_table = kovaplus_devices, 653 .probe = kovaplus_probe, 654 .remove = kovaplus_remove, 655 .raw_event = kovaplus_raw_event 656 }; 657 658 static int __init kovaplus_init(void) 659 { 660 int retval; 661 662 kovaplus_class = class_create(THIS_MODULE, "kovaplus"); 663 if (IS_ERR(kovaplus_class)) 664 return PTR_ERR(kovaplus_class); 665 kovaplus_class->dev_attrs = kovaplus_attributes; 666 kovaplus_class->dev_bin_attrs = kovaplus_bin_attributes; 667 668 retval = hid_register_driver(&kovaplus_driver); 669 if (retval) 670 class_destroy(kovaplus_class); 671 return retval; 672 } 673 674 static void __exit kovaplus_exit(void) 675 { 676 hid_unregister_driver(&kovaplus_driver); 677 class_destroy(kovaplus_class); 678 } 679 680 module_init(kovaplus_init); 681 module_exit(kovaplus_exit); 682 683 MODULE_AUTHOR("Stefan Achatz"); 684 MODULE_DESCRIPTION("USB Roccat Kova[+] driver"); 685 MODULE_LICENSE("GPL v2"); 686