drivers/hid/hid-roccat-arvo.c

   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");