[linux-2.6-block.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_OVERLOAD = 0,
	ROCCAT_COMMON_CONTROL_STATUS_OK = 1,
	ROCCAT_COMMON_CONTROL_STATUS_INVALID = 2,
	ROCCAT_COMMON_CONTROL_STATUS_WAIT = 3,
};

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_WAIT:
			msleep(500);
			continue;
		case ROCCAT_COMMON_CONTROL_STATUS_INVALID:

		case ROCCAT_COMMON_CONTROL_STATUS_OVERLOAD:
			/* seems to be critical - replug necessary */
			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);

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 {
4728f2dc SA	68	ROCCAT_COMMON_CONTROL_STATUS_OVERLOAD = 0,
	69	ROCCAT_COMMON_CONTROL_STATUS_OK = 1,
	70	ROCCAT_COMMON_CONTROL_STATUS_INVALID = 2,
	71	ROCCAT_COMMON_CONTROL_STATUS_WAIT = 3,
	72	};
	73
7392d73b	74	static int roccat_common2_receive_control_status(struct usb_device *usb_dev)
4728f2dc SA	75	{
4728f2dc SA	76	int retval;
7392d73b	77	struct roccat_common2_control control;
4728f2dc SA	78
	79	do {
	80	msleep(50);
7392d73b	81	retval = roccat_common2_receive(usb_dev,
4728f2dc	82	ROCCAT_COMMON_COMMAND_CONTROL,
7392d73b	83	&control, sizeof(struct roccat_common2_control));
4728f2dc SA	84
	85	if (retval)
	86	return retval;
	87
	88	switch (control.value) {
	89	case ROCCAT_COMMON_CONTROL_STATUS_OK:
	90	return 0;
	91	case ROCCAT_COMMON_CONTROL_STATUS_WAIT:
	92	msleep(500);
	93	continue;
	94	case ROCCAT_COMMON_CONTROL_STATUS_INVALID:
	95
	96	case ROCCAT_COMMON_CONTROL_STATUS_OVERLOAD:
	97	/* seems to be critical - replug necessary */
	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
5772f636 SA	125	MODULE_AUTHOR("Stefan Achatz");
	126	MODULE_DESCRIPTION("USB Roccat common driver");
	127	MODULE_LICENSE("GPL v2");