[deliverable/linux.git] / drivers / hid / hid-lgff.c

/*
 * Force feedback support for hid-compliant for some of the devices from
 * Logitech, namely:
 * - WingMan Cordless RumblePad
 * - WingMan Force 3D
 *
 *  Copyright (c) 2002-2004 Johann Deneux
 *  Copyright (c) 2006 Anssi Hannula <anssi.hannula@gmail.com>
 */

/*
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
 *
 * Should you need to contact me, the author, you can do so by
 * e-mail - mail your message to <johann.deneux@it.uu.se>
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/input.h>
#include <linux/usb.h>
#include <linux/hid.h>

#include "usbhid/usbhid.h"
#include "hid-lg.h"

struct dev_type {
	u16 idVendor;
	u16 idProduct;
	const signed short *ff;
};

static const signed short ff_rumble[] = {
	FF_RUMBLE,
	-1
};

static const signed short ff_joystick[] = {
	FF_CONSTANT,
	-1
};

static const signed short ff_joystick_ac[] = {
	FF_CONSTANT,
	FF_AUTOCENTER,
	-1
};

static const signed short ff_wheel[] = {
	FF_CONSTANT,
	FF_AUTOCENTER,
	-1
};

static const struct dev_type devices[] = {
	{ 0x046d, 0xc211, ff_rumble },
	{ 0x046d, 0xc219, ff_rumble },
	{ 0x046d, 0xc283, ff_joystick },
	{ 0x046d, 0xc286, ff_joystick_ac },
	{ 0x046d, 0xc287, ff_joystick_ac },
	{ 0x046d, 0xc293, ff_joystick },
	{ 0x046d, 0xc294, ff_wheel },
	{ 0x046d, 0xc295, ff_joystick },
	{ 0x046d, 0xca03, ff_wheel },
};

static int hid_lgff_play(struct input_dev *dev, void *data, struct ff_effect *effect)
{
	struct hid_device *hid = input_get_drvdata(dev);
	struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
	struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
	int x, y;
	unsigned int left, right;

#define CLAMP(x) if (x < 0) x = 0; if (x > 0xff) x = 0xff

	switch (effect->type) {
	case FF_CONSTANT:
		x = effect->u.ramp.start_level + 0x7f;	/* 0x7f is center */
		y = effect->u.ramp.end_level + 0x7f;
		CLAMP(x);
		CLAMP(y);
		report->field[0]->value[0] = 0x51;
		report->field[0]->value[1] = 0x08;
		report->field[0]->value[2] = x;
		report->field[0]->value[3] = y;
		dbg_hid("(x, y)=(%04x, %04x)\n", x, y);
		usbhid_submit_report(hid, report, USB_DIR_OUT);
		break;

	case FF_RUMBLE:
		right = effect->u.rumble.strong_magnitude;
		left = effect->u.rumble.weak_magnitude;
		right = right * 0xff / 0xffff;
		left = left * 0xff / 0xffff;
		CLAMP(left);
		CLAMP(right);
		report->field[0]->value[0] = 0x42;
		report->field[0]->value[1] = 0x00;
		report->field[0]->value[2] = left;
		report->field[0]->value[3] = right;
		dbg_hid("(left, right)=(%04x, %04x)\n", left, right);
		usbhid_submit_report(hid, report, USB_DIR_OUT);
		break;
	}
	return 0;
}

static void hid_lgff_set_autocenter(struct input_dev *dev, u16 magnitude)
{
	struct hid_device *hid = input_get_drvdata(dev);
	struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
	struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
	__s32 *value = report->field[0]->value;
	magnitude = (magnitude >> 12) & 0xf;
	*value++ = 0xfe;
	*value++ = 0x0d;
	*value++ = magnitude;   /* clockwise strength */
	*value++ = magnitude;   /* counter-clockwise strength */
	*value++ = 0x80;
	*value++ = 0x00;
	*value = 0x00;
	usbhid_submit_report(hid, report, USB_DIR_OUT);
}

int lgff_init(struct hid_device* hid)
{
	struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
	struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
	struct input_dev *dev = hidinput->input;
	struct hid_report *report;
	struct hid_field *field;
	const signed short *ff_bits = ff_joystick;
	int error;
	int i;

	/* Find the report to use */
	if (list_empty(report_list)) {
		hid_err(hid, "No output report found\n");
		return -1;
	}

	/* Check that the report looks ok */
	report = list_entry(report_list->next, struct hid_report, list);
	field = report->field[0];
	if (!field) {
		hid_err(hid, "NULL field\n");
		return -1;
	}

	for (i = 0; i < ARRAY_SIZE(devices); i++) {
		if (dev->id.vendor == devices[i].idVendor &&
		    dev->id.product == devices[i].idProduct) {
			ff_bits = devices[i].ff;
			break;
		}
	}

	for (i = 0; ff_bits[i] >= 0; i++)
		set_bit(ff_bits[i], dev->ffbit);

	error = input_ff_create_memless(dev, NULL, hid_lgff_play);
	if (error)
		return error;

	if ( test_bit(FF_AUTOCENTER, dev->ffbit) )
		dev->ff->set_autocenter = hid_lgff_set_autocenter;

	pr_info("Force feedback for Logitech force feedback devices by Johann Deneux <johann.deneux@it.uu.se>\n");

	return 0;
}
Commit	Line	Data
1da177e4	1	/*
1da177e4 LT	2	* Force feedback support for hid-compliant for some of the devices from
	3	* Logitech, namely:
	4	* - WingMan Cordless RumblePad
	5	* - WingMan Force 3D
	6	*
	7	* Copyright (c) 2002-2004 Johann Deneux
dc76c912	8	* Copyright (c) 2006 Anssi Hannula <anssi.hannula@gmail.com>
1da177e4 LT	9	*/
	10
	11	/*
	12	* This program is free software; you can redistribute it and/or modify
	13	* it under the terms of the GNU General Public License as published by
	14	* the Free Software Foundation; either version 2 of the License, or
	15	* (at your option) any later version.
	16	*
	17	* This program is distributed in the hope that it will be useful,
	18	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	19	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	20	* GNU General Public License for more details.
	21	*
	22	* You should have received a copy of the GNU General Public License
	23	* along with this program; if not, write to the Free Software
	24	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	25	*
	26	* Should you need to contact me, the author, you can do so by
	27	* e-mail - mail your message to <johann.deneux@it.uu.se>
	28	*/
	29
4291ee30 JP	30	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
4291ee30 JP	31
1da177e4	32	#include <linux/input.h>
1da177e4	33	#include <linux/usb.h>
dde5845a	34	#include <linux/hid.h>
606bd0a8 JS	35
	36	#include "usbhid/usbhid.h"
	37	#include "hid-lg.h"
1da177e4	38
f9f852df	39	struct dev_type {
1da177e4 LT	40	u16 idVendor;
1da177e4 LT	41	u16 idProduct;
dc76c912	42	const signed short *ff;
1da177e4 LT	43	};
1da177e4 LT	44
dc76c912	45	static const signed short ff_rumble[] = {
1da177e4 LT	46	FF_RUMBLE,
	47	-1
	48	};
	49
dc76c912	50	static const signed short ff_joystick[] = {
1da177e4 LT	51	FF_CONSTANT,
	52	-1
	53	};
	54
f0bca459 SB	55	static const signed short ff_joystick_ac[] = {
	56	FF_CONSTANT,
	57	FF_AUTOCENTER,
	58	-1
	59	};
	60
2bea94db SB	61	static const signed short ff_wheel[] = {
	62	FF_CONSTANT,
	63	FF_AUTOCENTER,
	64	-1
	65	};
	66
f9f852df	67	static const struct dev_type devices[] = {
dc76c912 AH	68	{ 0x046d, 0xc211, ff_rumble },
	69	{ 0x046d, 0xc219, ff_rumble },
	70	{ 0x046d, 0xc283, ff_joystick },
f0bca459	71	{ 0x046d, 0xc286, ff_joystick_ac },
74f292ca	72	{ 0x046d, 0xc287, ff_joystick_ac },
fd30ea8c	73	{ 0x046d, 0xc293, ff_joystick },
92e0d896	74	{ 0x046d, 0xc294, ff_wheel },
130b1ab3	75	{ 0x046d, 0xc295, ff_joystick },
2bea94db	76	{ 0x046d, 0xca03, ff_wheel },
1da177e4 LT	77	};
1da177e4 LT	78
dc76c912 AH	79	static int hid_lgff_play(struct input_dev dev, void data, struct ff_effect *effect)
dc76c912 AH	80	{
e0712985	81	struct hid_device *hid = input_get_drvdata(dev);
dc76c912 AH	82	struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
	83	struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
	84	int x, y;
	85	unsigned int left, right;
	86
	87	#define CLAMP(x) if (x < 0) x = 0; if (x > 0xff) x = 0xff
	88
	89	switch (effect->type) {
	90	case FF_CONSTANT:
	91	x = effect->u.ramp.start_level + 0x7f; /* 0x7f is center */
	92	y = effect->u.ramp.end_level + 0x7f;
	93	CLAMP(x);
	94	CLAMP(y);
	95	report->field[0]->value[0] = 0x51;
	96	report->field[0]->value[1] = 0x08;
	97	report->field[0]->value[2] = x;
	98	report->field[0]->value[3] = y;
58037eb9	99	dbg_hid("(x, y)=(%04x, %04x)\n", x, y);
4916b3a5	100	usbhid_submit_report(hid, report, USB_DIR_OUT);
dc76c912 AH	101	break;
	102
	103	case FF_RUMBLE:
	104	right = effect->u.rumble.strong_magnitude;
	105	left = effect->u.rumble.weak_magnitude;
	106	right = right * 0xff / 0xffff;
	107	left = left * 0xff / 0xffff;
	108	CLAMP(left);
	109	CLAMP(right);
	110	report->field[0]->value[0] = 0x42;
	111	report->field[0]->value[1] = 0x00;
	112	report->field[0]->value[2] = left;
	113	report->field[0]->value[3] = right;
58037eb9	114	dbg_hid("(left, right)=(%04x, %04x)\n", left, right);
4916b3a5	115	usbhid_submit_report(hid, report, USB_DIR_OUT);
dc76c912 AH	116	break;
	117	}
	118	return 0;
	119	}
	120
2bea94db SB	121	static void hid_lgff_set_autocenter(struct input_dev *dev, u16 magnitude)
	122	{
	123	struct hid_device *hid = input_get_drvdata(dev);
	124	struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
	125	struct hid_report *report = list_entry(report_list->next, struct hid_report, list);
	126	__s32 *value = report->field[0]->value;
	127	magnitude = (magnitude >> 12) & 0xf;
	128	*value++ = 0xfe;
	129	*value++ = 0x0d;
	130	value++ = magnitude; / clockwise strength */
	131	value++ = magnitude; / counter-clockwise strength */
	132	*value++ = 0x80;
	133	*value++ = 0x00;
	134	*value = 0x00;
	135	usbhid_submit_report(hid, report, USB_DIR_OUT);
	136	}
	137
606bd0a8	138	int lgff_init(struct hid_device* hid)
1da177e4	139	{
dc76c912 AH	140	struct hid_input *hidinput = list_entry(hid->inputs.next, struct hid_input, list);
	141	struct list_head *report_list = &hid->report_enum[HID_OUTPUT_REPORT].report_list;
	142	struct input_dev *dev = hidinput->input;
	143	struct hid_report *report;
	144	struct hid_field *field;
00a8691c	145	const signed short *ff_bits = ff_joystick;
dc76c912	146	int error;
00a8691c	147	int i;
1da177e4 LT	148
1da177e4 LT	149	/* Find the report to use */
dc76c912	150	if (list_empty(report_list)) {
4291ee30	151	hid_err(hid, "No output report found\n");
1da177e4 LT	152	return -1;
1da177e4 LT	153	}
dc76c912	154
1da177e4	155	/* Check that the report looks ok */
dc76c912	156	report = list_entry(report_list->next, struct hid_report, list);
1da177e4 LT	157	field = report->field[0];
1da177e4 LT	158	if (!field) {
4291ee30	159	hid_err(hid, "NULL field\n");
1da177e4 LT	160	return -1;
	161	}
	162
dc76c912 AH	163	for (i = 0; i < ARRAY_SIZE(devices); i++) {
	164	if (dev->id.vendor == devices[i].idVendor &&
	165	dev->id.product == devices[i].idProduct) {
00a8691c	166	ff_bits = devices[i].ff;
dc76c912	167	break;
1da177e4	168	}
1da177e4	169	}
1da177e4	170
00a8691c DT	171	for (i = 0; ff_bits[i] >= 0; i++)
	172	set_bit(ff_bits[i], dev->ffbit);
	173
dc76c912 AH	174	error = input_ff_create_memless(dev, NULL, hid_lgff_play);
	175	if (error)
	176	return error;
1da177e4	177
2bea94db SB	178	if ( test_bit(FF_AUTOCENTER, dev->ffbit) )
	179	dev->ff->set_autocenter = hid_lgff_set_autocenter;
	180
4291ee30	181	pr_info("Force feedback for Logitech force feedback devices by Johann Deneux <johann.deneux@it.uu.se>\n");
1da177e4	182
1da177e4 LT	183	return 0;
1da177e4 LT	184	}