1 /* 2 * Roccat Arvo 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 Arvo is a gamer keyboard with 5 macro keys that can be configured in 16 * 5 profiles. 17 */ 18 19 #include <linux/device.h> 20 #include <linux/input.h> 21 #include <linux/hid.h> 22 #include <linux/module.h> 23 #include <linux/slab.h> 24 #include <linux/hid-roccat.h> 25 #include "hid-ids.h" 26 #include "hid-roccat-common.h" 27 #include "hid-roccat-arvo.h" 28 29 static struct class *arvo_class; 30 31 static ssize_t arvo_sysfs_show_mode_key(struct device *dev, 32 struct device_attribute *attr, char *buf) 33 { 34 struct arvo_device *arvo = 35 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 36 struct usb_device *usb_dev = 37 interface_to_usbdev(to_usb_interface(dev->parent->parent)); 38 struct arvo_mode_key temp_buf; 39 int retval; 40 41 mutex_lock(&arvo->arvo_lock); 42 retval = roccat_common2_receive(usb_dev, ARVO_COMMAND_MODE_KEY, 43 &temp_buf, sizeof(struct arvo_mode_key)); 44 mutex_unlock(&arvo->arvo_lock); 45 if (retval) 46 return retval; 47 48 return snprintf(buf, PAGE_SIZE, "%d\n", temp_buf.state); 49 } 50 51 static ssize_t arvo_sysfs_set_mode_key(struct device *dev, 52 struct device_attribute *attr, char const *buf, size_t size) 53 { 54 struct arvo_device *arvo = 55 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 56 struct usb_device *usb_dev = 57 interface_to_usbdev(to_usb_interface(dev->parent->parent)); 58 struct arvo_mode_key temp_buf; 59 unsigned long state; 60 int retval; 61 62 retval = kstrtoul(buf, 10, &state); 63 if (retval) 64 return retval; 65 66 temp_buf.command = ARVO_COMMAND_MODE_KEY; 67 temp_buf.state = state; 68 69 mutex_lock(&arvo->arvo_lock); 70 retval = roccat_common2_send(usb_dev, ARVO_COMMAND_MODE_KEY, 71 &temp_buf, sizeof(struct arvo_mode_key)); 72 mutex_unlock(&arvo->arvo_lock); 73 if (retval) 74 return retval; 75 76 return size; 77 } 78 static DEVICE_ATTR(mode_key, 0660, 79 arvo_sysfs_show_mode_key, arvo_sysfs_set_mode_key); 80 81 static ssize_t arvo_sysfs_show_key_mask(struct device *dev, 82 struct device_attribute *attr, char *buf) 83 { 84 struct arvo_device *arvo = 85 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 86 struct usb_device *usb_dev = 87 interface_to_usbdev(to_usb_interface(dev->parent->parent)); 88 struct arvo_key_mask temp_buf; 89 int retval; 90 91 mutex_lock(&arvo->arvo_lock); 92 retval = roccat_common2_receive(usb_dev, ARVO_COMMAND_KEY_MASK, 93 &temp_buf, sizeof(struct arvo_key_mask)); 94 mutex_unlock(&arvo->arvo_lock); 95 if (retval) 96 return retval; 97 98 return snprintf(buf, PAGE_SIZE, "%d\n", temp_buf.key_mask); 99 } 100 101 static ssize_t arvo_sysfs_set_key_mask(struct device *dev, 102 struct device_attribute *attr, char const *buf, size_t size) 103 { 104 struct arvo_device *arvo = 105 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 106 struct usb_device *usb_dev = 107 interface_to_usbdev(to_usb_interface(dev->parent->parent)); 108 struct arvo_key_mask temp_buf; 109 unsigned long key_mask; 110 int retval; 111 112 retval = kstrtoul(buf, 10, &key_mask); 113 if (retval) 114 return retval; 115 116 temp_buf.command = ARVO_COMMAND_KEY_MASK; 117 temp_buf.key_mask = key_mask; 118 119 mutex_lock(&arvo->arvo_lock); 120 retval = roccat_common2_send(usb_dev, ARVO_COMMAND_KEY_MASK, 121 &temp_buf, sizeof(struct arvo_key_mask)); 122 mutex_unlock(&arvo->arvo_lock); 123 if (retval) 124 return retval; 125 126 return size; 127 } 128 static DEVICE_ATTR(key_mask, 0660, 129 arvo_sysfs_show_key_mask, arvo_sysfs_set_key_mask); 130 131 /* retval is 1-5 on success, < 0 on error */ 132 static int arvo_get_actual_profile(struct usb_device *usb_dev) 133 { 134 struct arvo_actual_profile temp_buf; 135 int retval; 136 137 retval = roccat_common2_receive(usb_dev, ARVO_COMMAND_ACTUAL_PROFILE, 138 &temp_buf, sizeof(struct arvo_actual_profile)); 139 140 if (retval) 141 return retval; 142 143 return temp_buf.actual_profile; 144 } 145 146 static ssize_t arvo_sysfs_show_actual_profile(struct device *dev, 147 struct device_attribute *attr, char *buf) 148 { 149 struct arvo_device *arvo = 150 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 151 152 return snprintf(buf, PAGE_SIZE, "%d\n", arvo->actual_profile); 153 } 154 155 static ssize_t arvo_sysfs_set_actual_profile(struct device *dev, 156 struct device_attribute *attr, char const *buf, size_t size) 157 { 158 struct arvo_device *arvo = 159 hid_get_drvdata(dev_get_drvdata(dev->parent->parent)); 160 struct usb_device *usb_dev = 161 interface_to_usbdev(to_usb_interface(dev->parent->parent)); 162 struct arvo_actual_profile temp_buf; 163 unsigned long profile; 164 int retval; 165 166 retval = kstrtoul(buf, 10, &profile); 167 if (retval) 168 return retval; 169 170 if (profile < 1 || profile > 5) 171 return -EINVAL; 172 173 temp_buf.command = ARVO_COMMAND_ACTUAL_PROFILE; 174 temp_buf.actual_profile = profile; 175 176 mutex_lock(&arvo->arvo_lock); 177 retval = roccat_common2_send(usb_dev, ARVO_COMMAND_ACTUAL_PROFILE, 178 &temp_buf, sizeof(struct arvo_actual_profile)); 179 if (!retval) { 180 arvo->actual_profile = profile; 181 retval = size; 182 } 183 mutex_unlock(&arvo->arvo_lock); 184 return retval; 185 } 186 static DEVICE_ATTR(actual_profile, 0660, 187 arvo_sysfs_show_actual_profile, 188 arvo_sysfs_set_actual_profile); 189 190 static ssize_t arvo_sysfs_write(struct file *fp, 191 struct kobject *kobj, void const *buf, 192 loff_t off, size_t count, size_t real_size, uint command) 193 { 194 struct device *dev = 195 container_of(kobj, struct device, kobj)->parent->parent; 196 struct arvo_device *arvo = hid_get_drvdata(dev_get_drvdata(dev)); 197 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 198 int retval; 199 200 if (off != 0 || count != real_size) 201 return -EINVAL; 202 203 mutex_lock(&arvo->arvo_lock); 204 retval = roccat_common2_send(usb_dev, command, buf, real_size); 205 mutex_unlock(&arvo->arvo_lock); 206 207 return (retval ? retval : real_size); 208 } 209 210 static ssize_t arvo_sysfs_read(struct file *fp, 211 struct kobject *kobj, void *buf, loff_t off, 212 size_t count, size_t real_size, uint command) 213 { 214 struct device *dev = 215 container_of(kobj, struct device, kobj)->parent->parent; 216 struct arvo_device *arvo = hid_get_drvdata(dev_get_drvdata(dev)); 217 struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev)); 218 int retval; 219 220 if (off >= real_size) 221 return 0; 222 223 if (off != 0 || count != real_size) 224 return -EINVAL; 225 226 mutex_lock(&arvo->arvo_lock); 227 retval = roccat_common2_receive(usb_dev, command, buf, real_size); 228 mutex_unlock(&arvo->arvo_lock); 229 230 return (retval ? retval : real_size); 231 } 232 233 static ssize_t arvo_sysfs_write_button(struct file *fp, 234 struct kobject *kobj, struct bin_attribute *attr, char *buf, 235 loff_t off, size_t count) 236 { 237 return arvo_sysfs_write(fp, kobj, buf, off, count, 238 sizeof(struct arvo_button), ARVO_COMMAND_BUTTON); 239 } 240 static BIN_ATTR(button, 0220, NULL, arvo_sysfs_write_button, 241 sizeof(struct arvo_button)); 242 243 static ssize_t arvo_sysfs_read_info(struct file *fp, 244 struct kobject *kobj, struct bin_attribute *attr, char *buf, 245 loff_t off, size_t count) 246 { 247 return arvo_sysfs_read(fp, kobj, buf, off, count, 248 sizeof(struct arvo_info), ARVO_COMMAND_INFO); 249 } 250 static BIN_ATTR(info, 0440, arvo_sysfs_read_info, NULL, 251 sizeof(struct arvo_info)); 252 253 static struct attribute *arvo_attrs[] = { 254 &dev_attr_mode_key.attr, 255 &dev_attr_key_mask.attr, 256 &dev_attr_actual_profile.attr, 257 NULL, 258 }; 259 260 static struct bin_attribute *arvo_bin_attributes[] = { 261 &bin_attr_button, 262 &bin_attr_info, 263 NULL, 264 }; 265 266 static const struct attribute_group arvo_group = { 267 .attrs = arvo_attrs, 268 .bin_attrs = arvo_bin_attributes, 269 }; 270 271 static const struct attribute_group *arvo_groups[] = { 272 &arvo_group, 273 NULL, 274 }; 275 276 static int arvo_init_arvo_device_struct(struct usb_device *usb_dev, 277 struct arvo_device *arvo) 278 { 279 int retval; 280 281 mutex_init(&arvo->arvo_lock); 282 283 retval = arvo_get_actual_profile(usb_dev); 284 if (retval < 0) 285 return retval; 286 arvo->actual_profile = retval; 287 288 return 0; 289 } 290 291 static int arvo_init_specials(struct hid_device *hdev) 292 { 293 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 294 struct usb_device *usb_dev = interface_to_usbdev(intf); 295 struct arvo_device *arvo; 296 int retval; 297 298 if (intf->cur_altsetting->desc.bInterfaceProtocol 299 == USB_INTERFACE_PROTOCOL_KEYBOARD) { 300 hid_set_drvdata(hdev, NULL); 301 return 0; 302 } 303 304 arvo = kzalloc(sizeof(*arvo), GFP_KERNEL); 305 if (!arvo) { 306 hid_err(hdev, "can't alloc device descriptor\n"); 307 return -ENOMEM; 308 } 309 hid_set_drvdata(hdev, arvo); 310 311 retval = arvo_init_arvo_device_struct(usb_dev, arvo); 312 if (retval) { 313 hid_err(hdev, "couldn't init struct arvo_device\n"); 314 goto exit_free; 315 } 316 317 retval = roccat_connect(arvo_class, hdev, 318 sizeof(struct arvo_roccat_report)); 319 if (retval < 0) { 320 hid_err(hdev, "couldn't init char dev\n"); 321 } else { 322 arvo->chrdev_minor = retval; 323 arvo->roccat_claimed = 1; 324 } 325 326 return 0; 327 exit_free: 328 kfree(arvo); 329 return retval; 330 } 331 332 static void arvo_remove_specials(struct hid_device *hdev) 333 { 334 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 335 struct arvo_device *arvo; 336 337 if (intf->cur_altsetting->desc.bInterfaceProtocol 338 == USB_INTERFACE_PROTOCOL_KEYBOARD) 339 return; 340 341 arvo = hid_get_drvdata(hdev); 342 if (arvo->roccat_claimed) 343 roccat_disconnect(arvo->chrdev_minor); 344 kfree(arvo); 345 } 346 347 static int arvo_probe(struct hid_device *hdev, 348 const struct hid_device_id *id) 349 { 350 int retval; 351 352 retval = hid_parse(hdev); 353 if (retval) { 354 hid_err(hdev, "parse failed\n"); 355 goto exit; 356 } 357 358 retval = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 359 if (retval) { 360 hid_err(hdev, "hw start failed\n"); 361 goto exit; 362 } 363 364 retval = arvo_init_specials(hdev); 365 if (retval) { 366 hid_err(hdev, "couldn't install keyboard\n"); 367 goto exit_stop; 368 } 369 370 return 0; 371 372 exit_stop: 373 hid_hw_stop(hdev); 374 exit: 375 return retval; 376 } 377 378 static void arvo_remove(struct hid_device *hdev) 379 { 380 arvo_remove_specials(hdev); 381 hid_hw_stop(hdev); 382 } 383 384 static void arvo_report_to_chrdev(struct arvo_device const *arvo, 385 u8 const *data) 386 { 387 struct arvo_special_report const *special_report; 388 struct arvo_roccat_report roccat_report; 389 390 special_report = (struct arvo_special_report const *)data; 391 392 roccat_report.profile = arvo->actual_profile; 393 roccat_report.button = special_report->event & 394 ARVO_SPECIAL_REPORT_EVENT_MASK_BUTTON; 395 if ((special_report->event & ARVO_SPECIAL_REPORT_EVENT_MASK_ACTION) == 396 ARVO_SPECIAL_REPORT_EVENT_ACTION_PRESS) 397 roccat_report.action = ARVO_ROCCAT_REPORT_ACTION_PRESS; 398 else 399 roccat_report.action = ARVO_ROCCAT_REPORT_ACTION_RELEASE; 400 401 roccat_report_event(arvo->chrdev_minor, 402 (uint8_t const *)&roccat_report); 403 } 404 405 static int arvo_raw_event(struct hid_device *hdev, 406 struct hid_report *report, u8 *data, int size) 407 { 408 struct arvo_device *arvo = hid_get_drvdata(hdev); 409 410 if (size != 3) 411 return 0; 412 413 if (arvo && arvo->roccat_claimed) 414 arvo_report_to_chrdev(arvo, data); 415 416 return 0; 417 } 418 419 static const struct hid_device_id arvo_devices[] = { 420 { HID_USB_DEVICE(USB_VENDOR_ID_ROCCAT, USB_DEVICE_ID_ROCCAT_ARVO) }, 421 { } 422 }; 423 424 MODULE_DEVICE_TABLE(hid, arvo_devices); 425 426 static struct hid_driver arvo_driver = { 427 .name = "arvo", 428 .id_table = arvo_devices, 429 .probe = arvo_probe, 430 .remove = arvo_remove, 431 .raw_event = arvo_raw_event 432 }; 433 434 static int __init arvo_init(void) 435 { 436 int retval; 437 438 arvo_class = class_create(THIS_MODULE, "arvo"); 439 if (IS_ERR(arvo_class)) 440 return PTR_ERR(arvo_class); 441 arvo_class->dev_groups = arvo_groups; 442 443 retval = hid_register_driver(&arvo_driver); 444 if (retval) 445 class_destroy(arvo_class); 446 return retval; 447 } 448 449 static void __exit arvo_exit(void) 450 { 451 hid_unregister_driver(&arvo_driver); 452 class_destroy(arvo_class); 453 } 454 455 module_init(arvo_init); 456 module_exit(arvo_exit); 457 458 MODULE_AUTHOR("Stefan Achatz"); 459 MODULE_DESCRIPTION("USB Roccat Arvo driver"); 460 MODULE_LICENSE("GPL v2"); 461