[mirror_ubuntu-artful-kernel.git] / drivers / hid / hid-roccat-common.c

/*
 * Roccat common functions for device specific drivers
 *
 * Copyright (c) 2011 Stefan Achatz <erazor_de@users.sourceforge.net>
 */

/*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 */

#include <linux/hid.h>
#include <linux/slab.h>
#include <linux/module.h>
#include "hid-roccat-common.h"

static inline uint16_t roccat_common2_feature_report(uint8_t report_id)
{
	return 0x300 | report_id;
}

int roccat_common2_receive(struct usb_device *usb_dev, uint report_id,
		void *data, uint size)
{
	char *buf;
	int len;

	buf = kmalloc(size, GFP_KERNEL);
	if (buf == NULL)
		return -ENOMEM;

	len = usb_control_msg(usb_dev, usb_rcvctrlpipe(usb_dev, 0),
			HID_REQ_GET_REPORT,
			USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_IN,
			roccat_common2_feature_report(report_id),
			0, buf, size, USB_CTRL_SET_TIMEOUT);

	memcpy(data, buf, size);
	kfree(buf);
	return ((len < 0) ? len : ((len != size) ? -EIO : 0));
}
EXPORT_SYMBOL_GPL(roccat_common2_receive);

int roccat_common2_send(struct usb_device *usb_dev, uint report_id,
		void const *data, uint size)
{
	char *buf;
	int len;

	buf = kmemdup(data, size, GFP_KERNEL);
	if (buf == NULL)
		return -ENOMEM;

	len = usb_control_msg(usb_dev, usb_sndctrlpipe(usb_dev, 0),
			HID_REQ_SET_REPORT,
			USB_TYPE_CLASS | USB_RECIP_INTERFACE | USB_DIR_OUT,
			roccat_common2_feature_report(report_id),
			0, buf, size, USB_CTRL_SET_TIMEOUT);

	kfree(buf);
	return ((len < 0) ? len : ((len != size) ? -EIO : 0));
}
EXPORT_SYMBOL_GPL(roccat_common2_send);

enum roccat_common2_control_states {
	ROCCAT_COMMON_CONTROL_STATUS_CRITICAL = 0,
	ROCCAT_COMMON_CONTROL_STATUS_OK = 1,
	ROCCAT_COMMON_CONTROL_STATUS_INVALID = 2,
	ROCCAT_COMMON_CONTROL_STATUS_BUSY = 3,
	ROCCAT_COMMON_CONTROL_STATUS_CRITICAL_NEW = 4,
};

static int roccat_common2_receive_control_status(struct usb_device *usb_dev)
{
	int retval;
	struct roccat_common2_control control;

	do {
		msleep(50);
		retval = roccat_common2_receive(usb_dev,
				ROCCAT_COMMON_COMMAND_CONTROL,
				&control, sizeof(struct roccat_common2_control));

		if (retval)
			return retval;

		switch (control.value) {
		case ROCCAT_COMMON_CONTROL_STATUS_OK:
			return 0;
		case ROCCAT_COMMON_CONTROL_STATUS_BUSY:
			msleep(500);
			continue;
		case ROCCAT_COMMON_CONTROL_STATUS_INVALID:
		case ROCCAT_COMMON_CONTROL_STATUS_CRITICAL:
		case ROCCAT_COMMON_CONTROL_STATUS_CRITICAL_NEW:
			return -EINVAL;
		default:
			dev_err(&usb_dev->dev,
					"roccat_common2_receive_control_status: "
					"unknown response value 0x%x\n",
					control.value);
			return -EINVAL;
		}

	} while (1);
}

int roccat_common2_send_with_status(struct usb_device *usb_dev,
		uint command, void const *buf, uint size)
{
	int retval;

	retval = roccat_common2_send(usb_dev, command, buf, size);
	if (retval)
		return retval;

	msleep(100);

	return roccat_common2_receive_control_status(usb_dev);
}
EXPORT_SYMBOL_GPL(roccat_common2_send_with_status);

int roccat_common2_device_init_struct(struct usb_device *usb_dev,
		struct roccat_common2_device *dev)
{
	mutex_init(&dev->lock);
	return 0;
}
EXPORT_SYMBOL_GPL(roccat_common2_device_init_struct);

ssize_t roccat_common2_sysfs_read(struct file *fp, struct kobject *kobj,
		char *buf, loff_t off, size_t count,
		size_t real_size, uint command)
{
	struct device *dev = kobj_to_dev(kobj)->parent->parent;
	struct roccat_common2_device *roccat_dev = hid_get_drvdata(dev_get_drvdata(dev));
	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
	int retval;

	if (off >= real_size)
		return 0;

	if (off != 0 || count != real_size)
		return -EINVAL;

	mutex_lock(&roccat_dev->lock);
	retval = roccat_common2_receive(usb_dev, command, buf, real_size);
	mutex_unlock(&roccat_dev->lock);

	return retval ? retval : real_size;
}
EXPORT_SYMBOL_GPL(roccat_common2_sysfs_read);

ssize_t roccat_common2_sysfs_write(struct file *fp, struct kobject *kobj,
		void const *buf, loff_t off, size_t count,
		size_t real_size, uint command)
{
	struct device *dev = kobj_to_dev(kobj)->parent->parent;
	struct roccat_common2_device *roccat_dev = hid_get_drvdata(dev_get_drvdata(dev));
	struct usb_device *usb_dev = interface_to_usbdev(to_usb_interface(dev));
	int retval;

	if (off != 0 || count != real_size)
		return -EINVAL;

	mutex_lock(&roccat_dev->lock);
	retval = roccat_common2_send_with_status(usb_dev, command, buf, real_size);
	mutex_unlock(&roccat_dev->lock);

	return retval ? retval : real_size;
}
EXPORT_SYMBOL_GPL(roccat_common2_sysfs_write);

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