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