static int koneplus_receive_control_status(struct usb_device *usb_dev)
{
	int retval;
	struct koneplus_control control;

	do {
		retval = roccat_common_receive(usb_dev, KONEPLUS_COMMAND_CONTROL,
				&control, sizeof(struct koneplus_control));

		
		if (retval)
			return retval;

		if (control.value == KONEPLUS_CONTROL_REQUEST_STATUS_OK)
			return 0;

		
		if (control.value == KONEPLUS_CONTROL_REQUEST_STATUS_WAIT) {
			msleep(500); 
			continue;
		}

		
		if (control.value == KONEPLUS_CONTROL_REQUEST_STATUS_OVERLOAD)
			return -EINVAL;

		hid_err(usb_dev, "koneplus_receive_control_status: "
				"unknown response value 0x%x\n", control.value);
		return -EINVAL;
	} while (1);
}
static int kovaplus_receive_control_status(struct usb_device *usb_dev)
{
	int retval;
	struct kovaplus_control control;

	do {
		retval = roccat_common_receive(usb_dev, KOVAPLUS_COMMAND_CONTROL,
				&control, sizeof(struct kovaplus_control));

		/* check if we get a completely wrong answer */
		if (retval)
			return retval;

		if (control.value == KOVAPLUS_CONTROL_REQUEST_STATUS_OK)
			return 0;

		/* indicates that hardware needs some more time to complete action */
		if (control.value == KOVAPLUS_CONTROL_REQUEST_STATUS_WAIT) {
			msleep(500); /* windows driver uses 1000 */
			continue;
		}

		/* seems to be critical - replug necessary */
		if (control.value == KOVAPLUS_CONTROL_REQUEST_STATUS_OVERLOAD)
			return -EINVAL;

		hid_err(usb_dev, "roccat_common_receive_control_status: "
				"unknown response value 0x%x\n", control.value);
		return -EINVAL;
	} while (1);
}
static ssize_t koneplus_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 =
			container_of(kobj, struct device, kobj)->parent->parent;
	struct koneplus_device *koneplus = 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(&koneplus->koneplus_lock);
	retval = roccat_common_receive(usb_dev, command, buf, real_size);
	mutex_unlock(&koneplus->koneplus_lock);

	if (retval)
		return retval;

	return real_size;
}
/* retval is 0-4 on success, < 0 on error */
static int kovaplus_get_actual_profile(struct usb_device *usb_dev)
{
	struct kovaplus_actual_profile buf;
	int retval;

	retval = roccat_common_receive(usb_dev, KOVAPLUS_COMMAND_ACTUAL_PROFILE,
			&buf, sizeof(struct kovaplus_actual_profile));

	return retval ? retval : buf.actual_profile;
}
static int pyra_get_profile_buttons(struct usb_device *usb_dev,
		struct pyra_profile_buttons *buf, int number)
{
	int retval;
	retval = pyra_send_control(usb_dev, number,
			PYRA_CONTROL_REQUEST_PROFILE_BUTTONS);
	if (retval)
		return retval;
	return roccat_common_receive(usb_dev, PYRA_COMMAND_PROFILE_BUTTONS,
			buf, sizeof(struct pyra_profile_buttons));
}
static int kovaplus_get_profile_buttons(struct usb_device *usb_dev,
		struct kovaplus_profile_buttons *buf, int number)
{
	int retval;

	retval = kovaplus_select_profile(usb_dev, number,
			KOVAPLUS_CONTROL_REQUEST_PROFILE_BUTTONS);
	if (retval)
		return retval;

	return roccat_common_receive(usb_dev, KOVAPLUS_COMMAND_PROFILE_BUTTONS,
			buf, sizeof(struct kovaplus_profile_buttons));
}
static int koneplus_get_profile_settings(struct usb_device *usb_dev,
		struct koneplus_profile_settings *buf, uint number)
{
	int retval;

	retval = koneplus_select_profile(usb_dev, number,
			KONEPLUS_CONTROL_REQUEST_PROFILE_SETTINGS);
	if (retval)
		return retval;

	return roccat_common_receive(usb_dev, KONEPLUS_COMMAND_PROFILE_SETTINGS,
			buf, sizeof(struct koneplus_profile_settings));
}
Exemple #8
0
/* retval is 1-5 on success, < 0 on error */
static int arvo_get_actual_profile(struct usb_device *usb_dev)
{
	struct arvo_actual_profile temp_buf;
	int retval;

	retval = roccat_common_receive(usb_dev, ARVO_COMMAND_ACTUAL_PROFILE,
			&temp_buf, sizeof(struct arvo_actual_profile));

	if (retval)
		return retval;

	return temp_buf.actual_profile;
}
Exemple #9
0
static ssize_t arvo_sysfs_show_key_mask(struct device *dev,
		struct device_attribute *attr, char *buf)
{
	struct arvo_device *arvo =
			hid_get_drvdata(dev_get_drvdata(dev->parent->parent));
	struct usb_device *usb_dev =
			interface_to_usbdev(to_usb_interface(dev->parent->parent));
	struct arvo_key_mask temp_buf;
	int retval;

	mutex_lock(&arvo->arvo_lock);
	retval = roccat_common_receive(usb_dev, ARVO_COMMAND_KEY_MASK,
			&temp_buf, sizeof(struct arvo_key_mask));
	mutex_unlock(&arvo->arvo_lock);
	if (retval)
		return retval;

	return snprintf(buf, PAGE_SIZE, "%d\n", temp_buf.key_mask);
}
static int pyra_receive_control_status(struct usb_device *usb_dev)
{
	int retval;
	struct pyra_control control;

	do {
		msleep(10);
		retval = roccat_common_receive(usb_dev, PYRA_COMMAND_CONTROL,
				&control, sizeof(struct pyra_control));

		/* requested too early, try again */
	} while (retval == -EPROTO);

	if (!retval && control.command == PYRA_COMMAND_CONTROL &&
			control.request == PYRA_CONTROL_REQUEST_STATUS &&
			control.value == 1)
		return 0;
	else {
		hid_err(usb_dev, "receive control status: unknown response 0x%x 0x%x\n",
			control.request, control.value);
		return retval ? retval : -EINVAL;
	}
}
static int pyra_get_info(struct usb_device *usb_dev, struct pyra_info *buf)
{
	return roccat_common_receive(usb_dev, PYRA_COMMAND_INFO,
			buf, sizeof(struct pyra_info));
}
static int pyra_get_settings(struct usb_device *usb_dev,
		struct pyra_settings *buf)
{
	return roccat_common_receive(usb_dev, PYRA_COMMAND_SETTINGS,
			buf, sizeof(struct pyra_settings));
}
static int isku_receive(struct usb_device *usb_dev, uint command,
		void *buf, uint size)
{
	return roccat_common_receive(usb_dev, command, buf, size);
}
static int kovaplus_get_info(struct usb_device *usb_dev,
		struct kovaplus_info *buf)
{
	return roccat_common_receive(usb_dev, KOVAPLUS_COMMAND_INFO,
			buf, sizeof(struct kovaplus_info));
}