[GitHub/LineageOS/android_kernel_samsung_universal7580.git] / drivers / hid / hid-pl.c

/*
 *  Force feedback support for PantherLord/GreenAsia based devices
 *
 *  The devices are distributed under various names and the same USB device ID
 *  can be used in both adapters and actual game controllers.
 *
 *  0810:0001 "Twin USB Joystick"
 *   - tested with PantherLord USB/PS2 2in1 Adapter
 *   - contains two reports, one for each port (HID_QUIRK_MULTI_INPUT)
 *
 *  0e8f:0003 "GreenAsia Inc.    USB Joystick     "
 *   - tested with König Gaming gamepad
 *
 *  0e8f:0003 "GASIA USB Gamepad"
 *   - another version of the König gamepad
 *
 *  Copyright (c) 2007, 2009 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
 */


/* #define DEBUG */

#define debug(format, arg...) pr_debug("hid-plff: " format "\n" , ## arg)

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

#include "hid-ids.h"

#ifdef CONFIG_PANTHERLORD_FF
#include "usbhid/usbhid.h"

struct plff_device {
	struct hid_report *report;
	s32 *strong;
	s32 *weak;
};

static int hid_plff_play(struct input_dev *dev, void *data,
			 struct ff_effect *effect)
{
	struct hid_device *hid = input_get_drvdata(dev);
	struct plff_device *plff = data;
	int left, right;

	left = effect->u.rumble.strong_magnitude;
	right = effect->u.rumble.weak_magnitude;
	debug("called with 0x%04x 0x%04x", left, right);

	left = left * 0x7f / 0xffff;
	right = right * 0x7f / 0xffff;

	*plff->strong = left;
	*plff->weak = right;
	debug("running with 0x%02x 0x%02x", left, right);
	usbhid_submit_report(hid, plff->report, USB_DIR_OUT);

	return 0;
}

static int plff_init(struct hid_device *hid)
{
	struct plff_device *plff;
	struct hid_report *report;
	struct hid_input *hidinput;
	struct list_head *report_list =
			&hid->report_enum[HID_OUTPUT_REPORT].report_list;
	struct list_head *report_ptr = report_list;
	struct input_dev *dev;
	int error;
	s32 *strong;
	s32 *weak;

	/* The device contains one output report per physical device, all
	   containing 1 field, which contains 4 ff00.0002 usages and 4 16bit
	   absolute values.

	   The input reports also contain a field which contains
	   8 ff00.0001 usages and 8 boolean values. Their meaning is
	   currently unknown.
	   
	   A version of the 0e8f:0003 exists that has all the values in
	   separate fields and misses the extra input field, thus resembling
	   Zeroplus (hid-zpff) devices.
	*/

	if (list_empty(report_list)) {
		hid_err(hid, "no output reports found\n");
		return -ENODEV;
	}

	list_for_each_entry(hidinput, &hid->inputs, list) {

		report_ptr = report_ptr->next;

		if (report_ptr == report_list) {
			hid_err(hid, "required output report is missing\n");
			return -ENODEV;
		}

		report = list_entry(report_ptr, struct hid_report, list);
		if (report->maxfield < 1) {
			hid_err(hid, "no fields in the report\n");
			return -ENODEV;
		}

		if (report->field[0]->report_count >= 4) {
			report->field[0]->value[0] = 0x00;
			report->field[0]->value[1] = 0x00;
			strong = &report->field[0]->value[2];
			weak = &report->field[0]->value[3];
			debug("detected single-field device");
		} else if (report->maxfield >= 4 && report->field[0]->maxusage == 1 &&
				report->field[0]->usage[0].hid == (HID_UP_LED | 0x43)) {
			report->field[0]->value[0] = 0x00;
			report->field[1]->value[0] = 0x00;
			strong = &report->field[2]->value[0];
			weak = &report->field[3]->value[0];
			debug("detected 4-field device");
		} else {
			hid_err(hid, "not enough fields or values\n");
			return -ENODEV;
		}

		plff = kzalloc(sizeof(struct plff_device), GFP_KERNEL);
		if (!plff)
			return -ENOMEM;

		dev = hidinput->input;

		set_bit(FF_RUMBLE, dev->ffbit);

		error = input_ff_create_memless(dev, plff, hid_plff_play);
		if (error) {
			kfree(plff);
			return error;
		}

		plff->report = report;
		plff->strong = strong;
		plff->weak = weak;

		*strong = 0x00;
		*weak = 0x00;
		usbhid_submit_report(hid, plff->report, USB_DIR_OUT);
	}

	hid_info(hid, "Force feedback for PantherLord/GreenAsia devices by Anssi Hannula <anssi.hannula@gmail.com>\n");

	return 0;
}
#else
static inline int plff_init(struct hid_device *hid)
{
	return 0;
}
#endif

static int pl_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
	int ret;

	if (id->driver_data)
		hdev->quirks |= HID_QUIRK_MULTI_INPUT;

	ret = hid_parse(hdev);
	if (ret) {
		hid_err(hdev, "parse failed\n");
		goto err;
	}

	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
	if (ret) {
		hid_err(hdev, "hw start failed\n");
		goto err;
	}

	plff_init(hdev);

	return 0;
err:
	return ret;
}

static const struct hid_device_id pl_devices[] = {
	{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR),
		.driver_data = 1 }, /* Twin USB Joystick */
	{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR),
		.driver_data = 1 }, /* Twin USB Joystick */
	{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003), },
	{ }
};
MODULE_DEVICE_TABLE(hid, pl_devices);

static struct hid_driver pl_driver = {
	.name = "pantherlord",
	.id_table = pl_devices,
	.probe = pl_probe,
};

static int __init pl_init(void)
{
	return hid_register_driver(&pl_driver);
}

static void __exit pl_exit(void)
{
	hid_unregister_driver(&pl_driver);
}

module_init(pl_init);
module_exit(pl_exit);
MODULE_LICENSE("GPL");
Commit	Line	Data
20eb1279	1	/*
5edc41ee AH	2	* Force feedback support for PantherLord/GreenAsia based devices
	3	*
	4	* The devices are distributed under various names and the same USB device ID
	5	* can be used in both adapters and actual game controllers.
	6	*
	7	* 0810:0001 "Twin USB Joystick"
	8	* - tested with PantherLord USB/PS2 2in1 Adapter
	9	* - contains two reports, one for each port (HID_QUIRK_MULTI_INPUT)
	10	*
	11	* 0e8f:0003 "GreenAsia Inc. USB Joystick "
d36b6910	12	* - tested with König Gaming gamepad
20eb1279	13	*
27a9c179	14	* 0e8f:0003 "GASIA USB Gamepad"
d36b6910	15	* - another version of the König gamepad
27a9c179 AH	16	*
27a9c179 AH	17	* Copyright (c) 2007, 2009 Anssi Hannula <anssi.hannula@gmail.com>
20eb1279 AH	18	*/
	19
	20	/*
	21	* This program is free software; you can redistribute it and/or modify
	22	* it under the terms of the GNU General Public License as published by
	23	* the Free Software Foundation; either version 2 of the License, or
	24	* (at your option) any later version.
	25	*
	26	* This program is distributed in the hope that it will be useful,
	27	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	28	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	29	* GNU General Public License for more details.
	30	*
	31	* You should have received a copy of the GNU General Public License
	32	* along with this program; if not, write to the Free Software
	33	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	34	*/
	35
	36
	37	/* #define DEBUG */
	38
	39	#define debug(format, arg...) pr_debug("hid-plff: " format "\n" , ## arg)
	40
	41	#include <linux/input.h>
5a0e3ad6	42	#include <linux/slab.h>
8f86a2c3	43	#include <linux/module.h>
20eb1279 AH	44	#include <linux/usb.h>
20eb1279 AH	45	#include <linux/hid.h>
5f022298 JS	46
	47	#include "hid-ids.h"
	48
	49	#ifdef CONFIG_PANTHERLORD_FF
	50	#include "usbhid/usbhid.h"
20eb1279 AH	51
	52	struct plff_device {
	53	struct hid_report *report;
27a9c179 AH	54	s32 *strong;
27a9c179 AH	55	s32 *weak;
20eb1279 AH	56	};
	57
	58	static int hid_plff_play(struct input_dev dev, void data,
	59	struct ff_effect *effect)
	60	{
e0712985	61	struct hid_device *hid = input_get_drvdata(dev);
20eb1279 AH	62	struct plff_device *plff = data;
	63	int left, right;
	64
	65	left = effect->u.rumble.strong_magnitude;
	66	right = effect->u.rumble.weak_magnitude;
	67	debug("called with 0x%04x 0x%04x", left, right);
	68
	69	left = left * 0x7f / 0xffff;
	70	right = right * 0x7f / 0xffff;
	71
27a9c179 AH	72	*plff->strong = left;
27a9c179 AH	73	*plff->weak = right;
20eb1279 AH	74	debug("running with 0x%02x 0x%02x", left, right);
	75	usbhid_submit_report(hid, plff->report, USB_DIR_OUT);
	76
	77	return 0;
	78	}
	79
5f022298	80	static int plff_init(struct hid_device *hid)
20eb1279 AH	81	{
	82	struct plff_device *plff;
	83	struct hid_report *report;
	84	struct hid_input *hidinput;
	85	struct list_head *report_list =
	86	&hid->report_enum[HID_OUTPUT_REPORT].report_list;
	87	struct list_head *report_ptr = report_list;
	88	struct input_dev *dev;
	89	int error;
27a9c179 AH	90	s32 *strong;
27a9c179 AH	91	s32 *weak;
20eb1279	92
5edc41ee AH	93	/* The device contains one output report per physical device, all
	94	containing 1 field, which contains 4 ff00.0002 usages and 4 16bit
	95	absolute values.
20eb1279	96
5edc41ee	97	The input reports also contain a field which contains
20eb1279	98	8 ff00.0001 usages and 8 boolean values. Their meaning is
27a9c179 AH	99	currently unknown.
	100
	101	A version of the 0e8f:0003 exists that has all the values in
	102	separate fields and misses the extra input field, thus resembling
	103	Zeroplus (hid-zpff) devices.
	104	*/
20eb1279 AH	105
20eb1279 AH	106	if (list_empty(report_list)) {
4291ee30	107	hid_err(hid, "no output reports found\n");
20eb1279 AH	108	return -ENODEV;
	109	}
	110
	111	list_for_each_entry(hidinput, &hid->inputs, list) {
	112
	113	report_ptr = report_ptr->next;
	114
	115	if (report_ptr == report_list) {
4291ee30	116	hid_err(hid, "required output report is missing\n");
20eb1279 AH	117	return -ENODEV;
	118	}
	119
	120	report = list_entry(report_ptr, struct hid_report, list);
	121	if (report->maxfield < 1) {
4291ee30	122	hid_err(hid, "no fields in the report\n");
20eb1279 AH	123	return -ENODEV;
	124	}
	125
27a9c179 AH	126	if (report->field[0]->report_count >= 4) {
	127	report->field[0]->value[0] = 0x00;
	128	report->field[0]->value[1] = 0x00;
	129	strong = &report->field[0]->value[2];
	130	weak = &report->field[0]->value[3];
	131	debug("detected single-field device");
	132	} else if (report->maxfield >= 4 && report->field[0]->maxusage == 1 &&
	133	report->field[0]->usage[0].hid == (HID_UP_LED \| 0x43)) {
	134	report->field[0]->value[0] = 0x00;
	135	report->field[1]->value[0] = 0x00;
	136	strong = &report->field[2]->value[0];
	137	weak = &report->field[3]->value[0];
	138	debug("detected 4-field device");
	139	} else {
4291ee30	140	hid_err(hid, "not enough fields or values\n");
20eb1279 AH	141	return -ENODEV;
	142	}
	143
	144	plff = kzalloc(sizeof(struct plff_device), GFP_KERNEL);
	145	if (!plff)
	146	return -ENOMEM;
	147
	148	dev = hidinput->input;
	149
	150	set_bit(FF_RUMBLE, dev->ffbit);
	151
	152	error = input_ff_create_memless(dev, plff, hid_plff_play);
	153	if (error) {
	154	kfree(plff);
	155	return error;
	156	}
	157
	158	plff->report = report;
27a9c179 AH	159	plff->strong = strong;
	160	plff->weak = weak;
	161
	162	*strong = 0x00;
	163	*weak = 0x00;
20eb1279 AH	164	usbhid_submit_report(hid, plff->report, USB_DIR_OUT);
	165	}
	166
4291ee30	167	hid_info(hid, "Force feedback for PantherLord/GreenAsia devices by Anssi Hannula <anssi.hannula@gmail.com>\n");
20eb1279 AH	168
	169	return 0;
	170	}
5f022298 JS	171	#else
	172	static inline int plff_init(struct hid_device *hid)
	173	{
	174	return 0;
	175	}
	176	#endif
	177
	178	static int pl_probe(struct hid_device hdev, const struct hid_device_id id)
	179	{
	180	int ret;
	181
	182	if (id->driver_data)
	183	hdev->quirks \|= HID_QUIRK_MULTI_INPUT;
	184
	185	ret = hid_parse(hdev);
	186	if (ret) {
4291ee30	187	hid_err(hdev, "parse failed\n");
5f022298 JS	188	goto err;
	189	}
	190
	191	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT & ~HID_CONNECT_FF);
	192	if (ret) {
4291ee30	193	hid_err(hdev, "hw start failed\n");
5f022298 JS	194	goto err;
	195	}
	196
	197	plff_init(hdev);
	198
	199	return 0;
	200	err:
	201	return ret;
	202	}
	203
	204	static const struct hid_device_id pl_devices[] = {
	205	{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PSX_ADAPTOR),
	206	.driver_data = 1 }, /* Twin USB Joystick */
578f3a35 JK	207	{ HID_USB_DEVICE(USB_VENDOR_ID_GAMERON, USB_DEVICE_ID_GAMERON_DUAL_PCS_ADAPTOR),
578f3a35 JK	208	.driver_data = 1 }, /* Twin USB Joystick */
27a9c179	209	{ HID_USB_DEVICE(USB_VENDOR_ID_GREENASIA, 0x0003), },
5f022298 JS	210	{ }
	211	};
	212	MODULE_DEVICE_TABLE(hid, pl_devices);
	213
	214	static struct hid_driver pl_driver = {
	215	.name = "pantherlord",
	216	.id_table = pl_devices,
	217	.probe = pl_probe,
	218	};
	219
a24f423b	220	static int __init pl_init(void)
5f022298 JS	221	{
	222	return hid_register_driver(&pl_driver);
	223	}
	224
a24f423b	225	static void __exit pl_exit(void)
5f022298 JS	226	{
	227	hid_unregister_driver(&pl_driver);
	228	}
	229
	230	module_init(pl_init);
	231	module_exit(pl_exit);
	232	MODULE_LICENSE("GPL");