drivers/hid/hid-roccat-common.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Roccat common functions for device specific drivers
   4  *
   5  * Copyright (c) 2011 Stefan Achatz <erazor_de@users.sourceforge.net>
   6  */
   7
   8 /*
   9  */
  10
  11 #include <linux/hid.h>
  12 #include <linux/slab.h>
  13 #include <linux/module.h>
  14 #include "hid-roccat-common.h"
  15
  16 static inline uint16_t roccat_common2_feature_report(uint8_t report_id)
  17 {
  18         return 0x300 | report_id;
  19 }
  20
  21 int roccat_common2_receive(struct usb_device *usb_dev, uint report_id,
  22                 void *data, uint size)
  23 {
  24         char *buf;
  25         int len;
  26
  27         buf = kmalloc(size, GFP_KERNEL);
  28         if (buf == NULL)
  29                 return -ENOMEM;
  30
  31         len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
  32                         HID_REQ_GET_REPORT,
  33                         USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
  34                         roccat_common2_feature_report(report_id),
  35                         0, buf, size, USB_CTRL_SET_TIMEOUT);
  36
  37         memcpy(data, buf, size);
  38         kfree(buf);
  39         return ((len < 0) ? len : ((len != size) ? -EIO : 0));
  40 }
  41 EXPORT_SYMBOL_GPL(roccat_common2_receive);
  42
  43 int roccat_common2_send(struct usb_device *usb_dev, uint report_id,
  44                 void const *data, uint size)
  45 {
  46         char *buf;
  47         int len;
  48
  49         buf = kmemdup(data, size, GFP_KERNEL);
  50         if (buf == NULL)
  51                 return -ENOMEM;
  52
  53         len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
  54                         HID_REQ_SET_REPORT,
  55                         USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
  56                         roccat_common2_feature_report(report_id),
  57                         0, buf, size, USB_CTRL_SET_TIMEOUT);
  58
  59         kfree(buf);
  60         return ((len < 0) ? len : ((len != size) ? -EIO : 0));
  61 }
  62 EXPORT_SYMBOL_GPL(roccat_common2_send);
  63
  64 enum roccat_common2_control_states {
  65         ROCCAT_COMMON_CONTROL_STATUS_CRITICAL = 0,
  66         ROCCAT_COMMON_CONTROL_STATUS_OK = 1,
  67         ROCCAT_COMMON_CONTROL_STATUS_INVALID = 2,
  68         ROCCAT_COMMON_CONTROL_STATUS_BUSY = 3,
  69         ROCCAT_COMMON_CONTROL_STATUS_CRITICAL_NEW = 4,
  70 };
  71
  72 static int roccat_common2_receive_control_status(struct usb_device *usb_dev)
  73 {
  74         int retval;
  75         struct roccat_common2_control control;
  76
  77         do {
  78                 msleep(50);
  79                 retval = roccat_common2_receive(usb_dev,
  80                                 ROCCAT_COMMON_COMMAND_CONTROL,
  81                                 &control, sizeof(struct roccat_common2_control));
  82
  83                 if (retval)
  84                         return retval;
  85
  86                 switch (control.value) {
  87                 case ROCCAT_COMMON_CONTROL_STATUS_OK:
  88                         return 0;
  89                 case ROCCAT_COMMON_CONTROL_STATUS_BUSY:
  90                         msleep(500);
  91                         continue;
  92                 case ROCCAT_COMMON_CONTROL_STATUS_INVALID:
  93                 case ROCCAT_COMMON_CONTROL_STATUS_CRITICAL:
  94                 case ROCCAT_COMMON_CONTROL_STATUS_CRITICAL_NEW:
  95                         return -EINVAL;
  96                 default:
  97                         dev_err(&usb_dev->dev,
  98                                         "roccat_common2_receive_control_status: "
  99                                         "unknown response value 0x%x\n",
 100                                         control.value);
 101                         return -EINVAL;
 102                 }
 103
 104         } while (1);
 105 }
 106
 107 int roccat_common2_send_with_status(struct usb_device *usb_dev,
 108                 uint command, void const *buf, uint size)
 109 {
 110         int retval;
 111
 112         retval = roccat_common2_send(usb_dev, command, buf, size);
 113         if (retval)
 114                 return retval;
 115
 116         msleep(100);
 117
 118         return roccat_common2_receive_control_status(usb_dev);
 119 }
 120 EXPORT_SYMBOL_GPL(roccat_common2_send_with_status);
 121
 122 int roccat_common2_device_init_struct(struct usb_device *usb_dev,
 123                 struct roccat_common2_device *dev)
 124 {
 125         mutex_init(&dev->lock);
 126         return 0;
 127 }
 128 EXPORT_SYMBOL_GPL(roccat_common2_device_init_struct);
 129
 130 ssize_t roccat_common2_sysfs_read(struct file *fp, struct kobject *kobj,
 131                 char *buf, loff_t off, size_t count,
 132                 size_t real_size, uint command)
 133 {
 134         struct device *dev = kobj_to_dev(kobj)->parent->parent;
 135         struct roccat_common2_device *roccat_dev = hid_get_drvdata(dev_get_drvdata(dev));
 136         struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 137         int retval;
 138
 139         if (off >= real_size)
 140                 return 0;
 141
 142         if (off != 0 || count != real_size)
 143                 return -EINVAL;
 144
 145         mutex_lock(&roccat_dev->lock);
 146         retval = roccat_common2_receive(usb_dev, command, buf, real_size);
 147         mutex_unlock(&roccat_dev->lock);
 148
 149         return retval ? retval : real_size;
 150 }
 151 EXPORT_SYMBOL_GPL(roccat_common2_sysfs_read);
 152
 153 ssize_t roccat_common2_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 = kobj_to_dev(kobj)->parent->parent;
 158         struct roccat_common2_device *roccat_dev = hid_get_drvdata(dev_get_drvdata(dev));
 159         struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
 160         int retval;
 161
 162         if (off != 0 || count != real_size)
 163                 return -EINVAL;
 164
 165         mutex_lock(&roccat_dev->lock);
 166         retval = roccat_common2_send_with_status(usb_dev, command, buf, real_size);
 167         mutex_unlock(&roccat_dev->lock);
 168
 169         return retval ? retval : real_size;
 170 }
 171 EXPORT_SYMBOL_GPL(roccat_common2_sysfs_write);
 172
 173 MODULE_AUTHOR("Stefan Achatz");
 174 MODULE_DESCRIPTION("USB Roccat common driver");
 175 MODULE_LICENSE("GPL v2");