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