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