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

/*
 *  HID driver for some logitech "special" devices
 *
 *  Copyright (c) 1999 Andreas Gal
 *  Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
 *  Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
 *  Copyright (c) 2006-2007 Jiri Kosina
 *  Copyright (c) 2008 Jiri Slaby
 *  Copyright (c) 2010 Hendrik Iben
 */

/*
 * 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/device.h>
#include <linux/hid.h>
#include <linux/module.h>
#include <linux/random.h>
#include <linux/sched.h>
#include <linux/wait.h>

#include "hid-ids.h"
#include "hid-lg.h"

#define LG_RDESC		0x001
#define LG_BAD_RELATIVE_KEYS	0x002
#define LG_DUPLICATE_USAGES	0x004
#define LG_EXPANDED_KEYMAP	0x010
#define LG_IGNORE_DOUBLED_WHEEL	0x020
#define LG_WIRELESS		0x040
#define LG_INVERT_HWHEEL	0x080
#define LG_NOGET		0x100
#define LG_FF			0x200
#define LG_FF2			0x400
#define LG_RDESC_REL_ABS	0x800
#define LG_FF3			0x1000
#define LG_FF4			0x2000

/* Size of the original descriptor of the Driving Force Pro wheel */
#define DFP_RDESC_ORIG_SIZE	97

/* Fixed report descriptor for Logitech Driving Force Pro wheel controller
 *
 * The original descriptor hides the separate throttle and brake axes in
 * a custom vendor usage page, providing only a combined value as
 * GenericDesktop.Y.
 * This descriptor removes the combined Y axis and instead reports
 * separate throttle (Y) and brake (RZ).
 */
static __u8 dfp_rdesc_fixed[] = {
0x05, 0x01,         /*  Usage Page (Desktop),                   */
0x09, 0x04,         /*  Usage (Joystik),                        */
0xA1, 0x01,         /*  Collection (Application),               */
0xA1, 0x02,         /*      Collection (Logical),               */
0x95, 0x01,         /*          Report Count (1),               */
0x75, 0x0E,         /*          Report Size (14),               */
0x14,               /*          Logical Minimum (0),            */
0x26, 0xFF, 0x3F,   /*          Logical Maximum (16383),        */
0x34,               /*          Physical Minimum (0),           */
0x46, 0xFF, 0x3F,   /*          Physical Maximum (16383),       */
0x09, 0x30,         /*          Usage (X),                      */
0x81, 0x02,         /*          Input (Variable),               */
0x95, 0x0E,         /*          Report Count (14),              */
0x75, 0x01,         /*          Report Size (1),                */
0x25, 0x01,         /*          Logical Maximum (1),            */
0x45, 0x01,         /*          Physical Maximum (1),           */
0x05, 0x09,         /*          Usage Page (Button),            */
0x19, 0x01,         /*          Usage Minimum (01h),            */
0x29, 0x0E,         /*          Usage Maximum (0Eh),            */
0x81, 0x02,         /*          Input (Variable),               */
0x05, 0x01,         /*          Usage Page (Desktop),           */
0x95, 0x01,         /*          Report Count (1),               */
0x75, 0x04,         /*          Report Size (4),                */
0x25, 0x07,         /*          Logical Maximum (7),            */
0x46, 0x3B, 0x01,   /*          Physical Maximum (315),         */
0x65, 0x14,         /*          Unit (Degrees),                 */
0x09, 0x39,         /*          Usage (Hat Switch),             */
0x81, 0x42,         /*          Input (Variable, Nullstate),    */
0x65, 0x00,         /*          Unit,                           */
0x26, 0xFF, 0x00,   /*          Logical Maximum (255),          */
0x46, 0xFF, 0x00,   /*          Physical Maximum (255),         */
0x75, 0x08,         /*          Report Size (8),                */
0x81, 0x01,         /*          Input (Constant),               */
0x09, 0x31,         /*          Usage (Y),                      */
0x81, 0x02,         /*          Input (Variable),               */
0x09, 0x35,         /*          Usage (Rz),                     */
0x81, 0x02,         /*          Input (Variable),               */
0x81, 0x01,         /*          Input (Constant),               */
0xC0,               /*      End Collection,                     */
0xA1, 0x02,         /*      Collection (Logical),               */
0x09, 0x02,         /*          Usage (02h),                    */
0x95, 0x07,         /*          Report Count (7),               */
0x91, 0x02,         /*          Output (Variable),              */
0xC0,               /*      End Collection,                     */
0xC0                /*  End Collection                          */
};


/*
 * Certain Logitech keyboards send in report #3 keys which are far
 * above the logical maximum described in descriptor. This extends
 * the original value of 0x28c of logical maximum to 0x104d
 */
static __u8 *lg_report_fixup(struct hid_device *hdev, __u8 *rdesc,
		unsigned int *rsize)
{
	struct lg_drv_data *drv_data = (struct lg_drv_data *)hid_get_drvdata(hdev);

	if ((drv_data->quirks & LG_RDESC) && *rsize >= 90 && rdesc[83] == 0x26 &&
			rdesc[84] == 0x8c && rdesc[85] == 0x02) {
		hid_info(hdev,
			 "fixing up Logitech keyboard report descriptor\n");
		rdesc[84] = rdesc[89] = 0x4d;
		rdesc[85] = rdesc[90] = 0x10;
	}
	if ((drv_data->quirks & LG_RDESC_REL_ABS) && *rsize >= 50 &&
			rdesc[32] == 0x81 && rdesc[33] == 0x06 &&
			rdesc[49] == 0x81 && rdesc[50] == 0x06) {
		hid_info(hdev,
			 "fixing up rel/abs in Logitech report descriptor\n");
		rdesc[33] = rdesc[50] = 0x02;
	}
	if ((drv_data->quirks & LG_FF4) && *rsize >= 101 &&
			rdesc[41] == 0x95 && rdesc[42] == 0x0B &&
			rdesc[47] == 0x05 && rdesc[48] == 0x09) {
		hid_info(hdev, "fixing up Logitech Speed Force Wireless button descriptor\n");
		rdesc[41] = 0x05;
		rdesc[42] = 0x09;
		rdesc[47] = 0x95;
		rdesc[48] = 0x0B;
	}

	switch (hdev->product) {
	case USB_DEVICE_ID_LOGITECH_DFP_WHEEL:
		if (*rsize == DFP_RDESC_ORIG_SIZE) {
			hid_info(hdev,
				"fixing up Logitech Driving Force Pro report descriptor\n");
			rdesc = dfp_rdesc_fixed;
			*rsize = sizeof(dfp_rdesc_fixed);
		}
		break;
	}

	return rdesc;
}

#define lg_map_key_clear(c)	hid_map_usage_clear(hi, usage, bit, max, \
		EV_KEY, (c))

static int lg_ultrax_remote_mapping(struct hid_input *hi,
		struct hid_usage *usage, unsigned long **bit, int *max)
{
	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
		return 0;

	set_bit(EV_REP, hi->input->evbit);
	switch (usage->hid & HID_USAGE) {
	/* Reported on Logitech Ultra X Media Remote */
	case 0x004: lg_map_key_clear(KEY_AGAIN);	break;
	case 0x00d: lg_map_key_clear(KEY_HOME);		break;
	case 0x024: lg_map_key_clear(KEY_SHUFFLE);	break;
	case 0x025: lg_map_key_clear(KEY_TV);		break;
	case 0x026: lg_map_key_clear(KEY_MENU);		break;
	case 0x031: lg_map_key_clear(KEY_AUDIO);	break;
	case 0x032: lg_map_key_clear(KEY_TEXT);		break;
	case 0x033: lg_map_key_clear(KEY_LAST);		break;
	case 0x047: lg_map_key_clear(KEY_MP3);		break;
	case 0x048: lg_map_key_clear(KEY_DVD);		break;
	case 0x049: lg_map_key_clear(KEY_MEDIA);	break;
	case 0x04a: lg_map_key_clear(KEY_VIDEO);	break;
	case 0x04b: lg_map_key_clear(KEY_ANGLE);	break;
	case 0x04c: lg_map_key_clear(KEY_LANGUAGE);	break;
	case 0x04d: lg_map_key_clear(KEY_SUBTITLE);	break;
	case 0x051: lg_map_key_clear(KEY_RED);		break;
	case 0x052: lg_map_key_clear(KEY_CLOSE);	break;

	default:
		return 0;
	}
	return 1;
}

static int lg_dinovo_mapping(struct hid_input *hi, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
		return 0;

	switch (usage->hid & HID_USAGE) {

	case 0x00d: lg_map_key_clear(KEY_MEDIA);	break;
	default:
		return 0;

	}
	return 1;
}

static int lg_wireless_mapping(struct hid_input *hi, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
		return 0;

	switch (usage->hid & HID_USAGE) {
	case 0x1001: lg_map_key_clear(KEY_MESSENGER);		break;
	case 0x1003: lg_map_key_clear(KEY_SOUND);		break;
	case 0x1004: lg_map_key_clear(KEY_VIDEO);		break;
	case 0x1005: lg_map_key_clear(KEY_AUDIO);		break;
	case 0x100a: lg_map_key_clear(KEY_DOCUMENTS);		break;
	/* The following two entries are Playlist 1 and 2 on the MX3200 */
	case 0x100f: lg_map_key_clear(KEY_FN_1);		break;
	case 0x1010: lg_map_key_clear(KEY_FN_2);		break;
	case 0x1011: lg_map_key_clear(KEY_PREVIOUSSONG);	break;
	case 0x1012: lg_map_key_clear(KEY_NEXTSONG);		break;
	case 0x1013: lg_map_key_clear(KEY_CAMERA);		break;
	case 0x1014: lg_map_key_clear(KEY_MESSENGER);		break;
	case 0x1015: lg_map_key_clear(KEY_RECORD);		break;
	case 0x1016: lg_map_key_clear(KEY_PLAYER);		break;
	case 0x1017: lg_map_key_clear(KEY_EJECTCD);		break;
	case 0x1018: lg_map_key_clear(KEY_MEDIA);		break;
	case 0x1019: lg_map_key_clear(KEY_PROG1);		break;
	case 0x101a: lg_map_key_clear(KEY_PROG2);		break;
	case 0x101b: lg_map_key_clear(KEY_PROG3);		break;
	case 0x101c: lg_map_key_clear(KEY_CYCLEWINDOWS);	break;
	case 0x101f: lg_map_key_clear(KEY_ZOOMIN);		break;
	case 0x1020: lg_map_key_clear(KEY_ZOOMOUT);		break;
	case 0x1021: lg_map_key_clear(KEY_ZOOMRESET);		break;
	case 0x1023: lg_map_key_clear(KEY_CLOSE);		break;
	case 0x1027: lg_map_key_clear(KEY_MENU);		break;
	/* this one is marked as 'Rotate' */
	case 0x1028: lg_map_key_clear(KEY_ANGLE);		break;
	case 0x1029: lg_map_key_clear(KEY_SHUFFLE);		break;
	case 0x102a: lg_map_key_clear(KEY_BACK);		break;
	case 0x102b: lg_map_key_clear(KEY_CYCLEWINDOWS);	break;
	case 0x102d: lg_map_key_clear(KEY_WWW);			break;
	/* The following two are 'Start/answer call' and 'End/reject call'
	   on the MX3200 */
	case 0x1031: lg_map_key_clear(KEY_OK);			break;
	case 0x1032: lg_map_key_clear(KEY_CANCEL);		break;
	case 0x1041: lg_map_key_clear(KEY_BATTERY);		break;
	case 0x1042: lg_map_key_clear(KEY_WORDPROCESSOR);	break;
	case 0x1043: lg_map_key_clear(KEY_SPREADSHEET);		break;
	case 0x1044: lg_map_key_clear(KEY_PRESENTATION);	break;
	case 0x1045: lg_map_key_clear(KEY_UNDO);		break;
	case 0x1046: lg_map_key_clear(KEY_REDO);		break;
	case 0x1047: lg_map_key_clear(KEY_PRINT);		break;
	case 0x1048: lg_map_key_clear(KEY_SAVE);		break;
	case 0x1049: lg_map_key_clear(KEY_PROG1);		break;
	case 0x104a: lg_map_key_clear(KEY_PROG2);		break;
	case 0x104b: lg_map_key_clear(KEY_PROG3);		break;
	case 0x104c: lg_map_key_clear(KEY_PROG4);		break;

	default:
		return 0;
	}
	return 1;
}

static int lg_input_mapping(struct hid_device *hdev, struct hid_input *hi,
		struct hid_field *field, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	/* extended mapping for certain Logitech hardware (Logitech cordless
	   desktop LX500) */
	static const u8 e_keymap[] = {
		  0,216,  0,213,175,156,  0,  0,  0,  0,
		144,  0,  0,  0,  0,  0,  0,  0,  0,212,
		174,167,152,161,112,  0,  0,  0,154,  0,
		  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
		  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
		  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
		  0,  0,  0,  0,  0,183,184,185,186,187,
		188,189,190,191,192,193,194,  0,  0,  0
	};
	struct lg_drv_data *drv_data = (struct lg_drv_data *)hid_get_drvdata(hdev);
	unsigned int hid = usage->hid;

	if (hdev->product == USB_DEVICE_ID_LOGITECH_RECEIVER &&
			lg_ultrax_remote_mapping(hi, usage, bit, max))
		return 1;

	if (hdev->product == USB_DEVICE_ID_DINOVO_MINI &&
			lg_dinovo_mapping(hi, usage, bit, max))
		return 1;

	if ((drv_data->quirks & LG_WIRELESS) && lg_wireless_mapping(hi, usage, bit, max))
		return 1;

	if ((hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
		return 0;

	hid &= HID_USAGE;

	/* Special handling for Logitech Cordless Desktop */
	if (field->application == HID_GD_MOUSE) {
		if ((drv_data->quirks & LG_IGNORE_DOUBLED_WHEEL) &&
				(hid == 7 || hid == 8))
			return -1;
	} else {
		if ((drv_data->quirks & LG_EXPANDED_KEYMAP) &&
				hid < ARRAY_SIZE(e_keymap) &&
				e_keymap[hid] != 0) {
			hid_map_usage(hi, usage, bit, max, EV_KEY,
					e_keymap[hid]);
			return 1;
		}
	}

	return 0;
}

static int lg_input_mapped(struct hid_device *hdev, struct hid_input *hi,
		struct hid_field *field, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	struct lg_drv_data *drv_data = (struct lg_drv_data *)hid_get_drvdata(hdev);

	if ((drv_data->quirks & LG_BAD_RELATIVE_KEYS) && usage->type == EV_KEY &&
			(field->flags & HID_MAIN_ITEM_RELATIVE))
		field->flags &= ~HID_MAIN_ITEM_RELATIVE;

	if ((drv_data->quirks & LG_DUPLICATE_USAGES) && (usage->type == EV_KEY ||
			 usage->type == EV_REL || usage->type == EV_ABS))
		clear_bit(usage->code, *bit);

	return 0;
}

static int lg_event(struct hid_device *hdev, struct hid_field *field,
		struct hid_usage *usage, __s32 value)
{
	struct lg_drv_data *drv_data = (struct lg_drv_data *)hid_get_drvdata(hdev);

	if ((drv_data->quirks & LG_INVERT_HWHEEL) && usage->code == REL_HWHEEL) {
		input_event(field->hidinput->input, usage->type, usage->code,
				-value);
		return 1;
	}

	return 0;
}

static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
	unsigned int connect_mask = HID_CONNECT_DEFAULT;
	struct lg_drv_data *drv_data;
	int ret;

	drv_data = kzalloc(sizeof(struct lg_drv_data), GFP_KERNEL);
	if (!drv_data) {
		hid_err(hdev, "Insufficient memory, cannot allocate driver data\n");
		return -ENOMEM;
	}
	drv_data->quirks = id->driver_data;
	
	hid_set_drvdata(hdev, (void *)drv_data);

	if (drv_data->quirks & LG_NOGET)
		hdev->quirks |= HID_QUIRK_NOGET;

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

	if (drv_data->quirks & (LG_FF | LG_FF2 | LG_FF3 | LG_FF4))
		connect_mask &= ~HID_CONNECT_FF;

	ret = hid_hw_start(hdev, connect_mask);
	if (ret) {
		hid_err(hdev, "hw start failed\n");
		goto err_free;
	}

	/* Setup wireless link with Logitech Wii wheel */
	if(hdev->product == USB_DEVICE_ID_LOGITECH_WII_WHEEL) {
		unsigned char buf[] = { 0x00, 0xAF,  0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };

		ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);

		if (ret >= 0) {
			/* insert a little delay of 10 jiffies ~ 40ms */
			wait_queue_head_t wait;
			init_waitqueue_head (&wait);
			wait_event_interruptible_timeout(wait, 0, 10);

			/* Select random Address */
			buf[1] = 0xB2;
			get_random_bytes(&buf[2], 2);

			ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
		}
	}

	if (drv_data->quirks & LG_FF)
		lgff_init(hdev);
	if (drv_data->quirks & LG_FF2)
		lg2ff_init(hdev);
	if (drv_data->quirks & LG_FF3)
		lg3ff_init(hdev);
	if (drv_data->quirks & LG_FF4)
		lg4ff_init(hdev);

	return 0;
err_free:
	kfree(drv_data);
	return ret;
}

static void lg_remove(struct hid_device *hdev)
{
	struct lg_drv_data *drv_data = (struct lg_drv_data *)hid_get_drvdata(hdev);
	if (drv_data->quirks & LG_FF4)
		lg4ff_deinit(hdev);

	hid_hw_stop(hdev);
	kfree(drv_data);
}

static const struct hid_device_id lg_devices[] = {
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER),
		.driver_data = LG_RDESC | LG_WIRELESS },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER),
		.driver_data = LG_RDESC | LG_WIRELESS },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2),
		.driver_data = LG_RDESC | LG_WIRELESS },

	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER),
		.driver_data = LG_BAD_RELATIVE_KEYS },

	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP),
		.driver_data = LG_DUPLICATE_USAGES },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE),
		.driver_data = LG_DUPLICATE_USAGES },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI),
		.driver_data = LG_DUPLICATE_USAGES },

	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD),
		.driver_data = LG_IGNORE_DOUBLED_WHEEL | LG_EXPANDED_KEYMAP },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500),
		.driver_data = LG_IGNORE_DOUBLED_WHEEL | LG_EXPANDED_KEYMAP },

	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D),
		.driver_data = LG_NOGET },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL),
		.driver_data = LG_NOGET | LG_FF4 },

	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD),
		.driver_data = LG_FF2 },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD),
		.driver_data = LG_FF },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2),
		.driver_data = LG_FF },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D),
		.driver_data = LG_FF },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO),
		.driver_data = LG_FF },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL),
		.driver_data = LG_FF4 },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2),
		.driver_data = LG_FF4 },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL),
		.driver_data = LG_FF4 },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL),
		.driver_data = LG_FF4 },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL),
		.driver_data = LG_FF4 },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL),
		.driver_data = LG_NOGET | LG_FF4 },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL),
		.driver_data = LG_FF4 },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG ),
		.driver_data = LG_FF },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2),
		.driver_data = LG_FF2 },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940),
		.driver_data = LG_FF3 },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR),
		.driver_data = LG_RDESC_REL_ABS },
	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER),
		.driver_data = LG_RDESC_REL_ABS },
	{ }
};

MODULE_DEVICE_TABLE(hid, lg_devices);

static struct hid_driver lg_driver = {
	.name = "logitech",
	.id_table = lg_devices,
	.report_fixup = lg_report_fixup,
	.input_mapping = lg_input_mapping,
	.input_mapped = lg_input_mapped,
	.event = lg_event,
	.probe = lg_probe,
	.remove = lg_remove,
};

static int __init lg_init(void)
{
	return hid_register_driver(&lg_driver);
}

static void __exit lg_exit(void)
{
	hid_unregister_driver(&lg_driver);
}

module_init(lg_init);
module_exit(lg_exit);
MODULE_LICENSE("GPL");
Commit	Line	Data
5f22a799 JS	1	/*
	2	* HID driver for some logitech "special" devices
	3	*
	4	* Copyright (c) 1999 Andreas Gal
	5	* Copyright (c) 2000-2005 Vojtech Pavlik <vojtech@suse.cz>
	6	* Copyright (c) 2005 Michael Haboustak <mike-@cinci.rr.com> for Concept2, Inc
	7	* Copyright (c) 2006-2007 Jiri Kosina
5f22a799	8	* Copyright (c) 2008 Jiri Slaby
2c6118e4	9	* Copyright (c) 2010 Hendrik Iben
5f22a799 JS	10	*/
	11
	12	/*
	13	* This program is free software; you can redistribute it and/or modify it
	14	* under the terms of the GNU General Public License as published by the Free
	15	* Software Foundation; either version 2 of the License, or (at your option)
	16	* any later version.
	17	*/
	18
	19	#include <linux/device.h>
	20	#include <linux/hid.h>
	21	#include <linux/module.h>
32c88cbc SW	22	#include <linux/random.h>
	23	#include <linux/sched.h>
	24	#include <linux/wait.h>
5f22a799 JS	25
5f22a799 JS	26	#include "hid-ids.h"
606bd0a8	27	#include "hid-lg.h"
5f22a799 JS	28
	29	#define LG_RDESC 0x001
	30	#define LG_BAD_RELATIVE_KEYS 0x002
	31	#define LG_DUPLICATE_USAGES 0x004
5f22a799 JS	32	#define LG_EXPANDED_KEYMAP 0x010
	33	#define LG_IGNORE_DOUBLED_WHEEL 0x020
	34	#define LG_WIRELESS 0x040
	35	#define LG_INVERT_HWHEEL 0x080
	36	#define LG_NOGET 0x100
606bd0a8 JS	37	#define LG_FF 0x200
606bd0a8 JS	38	#define LG_FF2 0x400
24985cf6	39	#define LG_RDESC_REL_ABS 0x800
74f292ca	40	#define LG_FF3 0x1000
32c88cbc	41	#define LG_FF4 0x2000
5f22a799	42
dc0a4f0c MB	43	/* Size of the original descriptor of the Driving Force Pro wheel */
	44	#define DFP_RDESC_ORIG_SIZE 97
	45
	46	/* Fixed report descriptor for Logitech Driving Force Pro wheel controller
	47	*
	48	* The original descriptor hides the separate throttle and brake axes in
	49	* a custom vendor usage page, providing only a combined value as
	50	* GenericDesktop.Y.
	51	* This descriptor removes the combined Y axis and instead reports
	52	* separate throttle (Y) and brake (RZ).
	53	*/
	54	static __u8 dfp_rdesc_fixed[] = {
	55	0x05, 0x01, /* Usage Page (Desktop), */
	56	0x09, 0x04, /* Usage (Joystik), */
	57	0xA1, 0x01, /* Collection (Application), */
	58	0xA1, 0x02, /* Collection (Logical), */
	59	0x95, 0x01, /* Report Count (1), */
	60	0x75, 0x0E, /* Report Size (14), */
	61	0x14, /* Logical Minimum (0), */
	62	0x26, 0xFF, 0x3F, /* Logical Maximum (16383), */
	63	0x34, /* Physical Minimum (0), */
	64	0x46, 0xFF, 0x3F, /* Physical Maximum (16383), */
	65	0x09, 0x30, /* Usage (X), */
	66	0x81, 0x02, /* Input (Variable), */
	67	0x95, 0x0E, /* Report Count (14), */
	68	0x75, 0x01, /* Report Size (1), */
	69	0x25, 0x01, /* Logical Maximum (1), */
	70	0x45, 0x01, /* Physical Maximum (1), */
	71	0x05, 0x09, /* Usage Page (Button), */
	72	0x19, 0x01, /* Usage Minimum (01h), */
	73	0x29, 0x0E, /* Usage Maximum (0Eh), */
	74	0x81, 0x02, /* Input (Variable), */
	75	0x05, 0x01, /* Usage Page (Desktop), */
	76	0x95, 0x01, /* Report Count (1), */
	77	0x75, 0x04, /* Report Size (4), */
	78	0x25, 0x07, /* Logical Maximum (7), */
	79	0x46, 0x3B, 0x01, /* Physical Maximum (315), */
	80	0x65, 0x14, /* Unit (Degrees), */
	81	0x09, 0x39, /* Usage (Hat Switch), */
	82	0x81, 0x42, /* Input (Variable, Nullstate), */
	83	0x65, 0x00, /* Unit, */
	84	0x26, 0xFF, 0x00, /* Logical Maximum (255), */
	85	0x46, 0xFF, 0x00, /* Physical Maximum (255), */
	86	0x75, 0x08, /* Report Size (8), */
	87	0x81, 0x01, /* Input (Constant), */
	88	0x09, 0x31, /* Usage (Y), */
	89	0x81, 0x02, /* Input (Variable), */
	90	0x09, 0x35, /* Usage (Rz), */
	91	0x81, 0x02, /* Input (Variable), */
	92	0x81, 0x01, /* Input (Constant), */
	93	0xC0, /* End Collection, */
	94	0xA1, 0x02, /* Collection (Logical), */
	95	0x09, 0x02, /* Usage (02h), */
	96	0x95, 0x07, /* Report Count (7), */
	97	0x91, 0x02, /* Output (Variable), */
	98	0xC0, /* End Collection, */
	99	0xC0 /* End Collection */
	100	};
	101
	102
5f22a799 JS	103	/*
	104	* Certain Logitech keyboards send in report #3 keys which are far
	105	* above the logical maximum described in descriptor. This extends
	106	* the original value of 0x28c of logical maximum to 0x104d
	107	*/
73e4008d NK	108	static __u8 lg_report_fixup(struct hid_device hdev, __u8 *rdesc,
73e4008d NK	109	unsigned int *rsize)
5f22a799	110	{
8577dbf9	111	struct lg_drv_data drv_data = (struct lg_drv_data )hid_get_drvdata(hdev);
5f22a799	112
8577dbf9	113	if ((drv_data->quirks & LG_RDESC) && *rsize >= 90 && rdesc[83] == 0x26 &&
5f22a799	114	rdesc[84] == 0x8c && rdesc[85] == 0x02) {
4291ee30 JP	115	hid_info(hdev,
4291ee30 JP	116	"fixing up Logitech keyboard report descriptor\n");
5f22a799 JS	117	rdesc[84] = rdesc[89] = 0x4d;
	118	rdesc[85] = rdesc[90] = 0x10;
	119	}
8577dbf9	120	if ((drv_data->quirks & LG_RDESC_REL_ABS) && *rsize >= 50 &&
24985cf6 JK	121	rdesc[32] == 0x81 && rdesc[33] == 0x06 &&
24985cf6 JK	122	rdesc[49] == 0x81 && rdesc[50] == 0x06) {
4291ee30 JP	123	hid_info(hdev,
4291ee30 JP	124	"fixing up rel/abs in Logitech report descriptor\n");
24985cf6 JK	125	rdesc[33] = rdesc[50] = 0x02;
24985cf6 JK	126	}
8577dbf9	127	if ((drv_data->quirks & LG_FF4) && *rsize >= 101 &&
32c88cbc SW	128	rdesc[41] == 0x95 && rdesc[42] == 0x0B &&
32c88cbc SW	129	rdesc[47] == 0x05 && rdesc[48] == 0x09) {
4291ee30	130	hid_info(hdev, "fixing up Logitech Speed Force Wireless button descriptor\n");
32c88cbc SW	131	rdesc[41] = 0x05;
	132	rdesc[42] = 0x09;
	133	rdesc[47] = 0x95;
	134	rdesc[48] = 0x0B;
	135	}
dc0a4f0c MB	136
	137	switch (hdev->product) {
	138	case USB_DEVICE_ID_LOGITECH_DFP_WHEEL:
	139	if (*rsize == DFP_RDESC_ORIG_SIZE) {
	140	hid_info(hdev,
	141	"fixing up Logitech Driving Force Pro report descriptor\n");
	142	rdesc = dfp_rdesc_fixed;
	143	*rsize = sizeof(dfp_rdesc_fixed);
	144	}
	145	break;
	146	}
	147
73e4008d	148	return rdesc;
5f22a799 JS	149	}
	150
	151	#define lg_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, \
	152	EV_KEY, (c))
	153
	154	static int lg_ultrax_remote_mapping(struct hid_input *hi,
	155	struct hid_usage usage, unsigned long bit, int max)
	156	{
	157	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
	158	return 0;
	159
	160	set_bit(EV_REP, hi->input->evbit);
	161	switch (usage->hid & HID_USAGE) {
	162	/* Reported on Logitech Ultra X Media Remote */
	163	case 0x004: lg_map_key_clear(KEY_AGAIN); break;
	164	case 0x00d: lg_map_key_clear(KEY_HOME); break;
	165	case 0x024: lg_map_key_clear(KEY_SHUFFLE); break;
	166	case 0x025: lg_map_key_clear(KEY_TV); break;
	167	case 0x026: lg_map_key_clear(KEY_MENU); break;
	168	case 0x031: lg_map_key_clear(KEY_AUDIO); break;
	169	case 0x032: lg_map_key_clear(KEY_TEXT); break;
	170	case 0x033: lg_map_key_clear(KEY_LAST); break;
	171	case 0x047: lg_map_key_clear(KEY_MP3); break;
	172	case 0x048: lg_map_key_clear(KEY_DVD); break;
	173	case 0x049: lg_map_key_clear(KEY_MEDIA); break;
	174	case 0x04a: lg_map_key_clear(KEY_VIDEO); break;
	175	case 0x04b: lg_map_key_clear(KEY_ANGLE); break;
	176	case 0x04c: lg_map_key_clear(KEY_LANGUAGE); break;
	177	case 0x04d: lg_map_key_clear(KEY_SUBTITLE); break;
	178	case 0x051: lg_map_key_clear(KEY_RED); break;
	179	case 0x052: lg_map_key_clear(KEY_CLOSE); break;
	180
	181	default:
	182	return 0;
	183	}
	184	return 1;
	185	}
	186
66d61bec JK	187	static int lg_dinovo_mapping(struct hid_input hi, struct hid_usage usage,
	188	unsigned long *bit, int max)
	189	{
	190	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
	191	return 0;
	192
	193	switch (usage->hid & HID_USAGE) {
	194
	195	case 0x00d: lg_map_key_clear(KEY_MEDIA); break;
	196	default:
	197	return 0;
	198
	199	}
	200	return 1;
	201	}
	202
5f22a799 JS	203	static int lg_wireless_mapping(struct hid_input hi, struct hid_usage usage,
	204	unsigned long *bit, int max)
	205	{
	206	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
	207	return 0;
	208
	209	switch (usage->hid & HID_USAGE) {
	210	case 0x1001: lg_map_key_clear(KEY_MESSENGER); break;
	211	case 0x1003: lg_map_key_clear(KEY_SOUND); break;
	212	case 0x1004: lg_map_key_clear(KEY_VIDEO); break;
	213	case 0x1005: lg_map_key_clear(KEY_AUDIO); break;
	214	case 0x100a: lg_map_key_clear(KEY_DOCUMENTS); break;
18392212 LC	215	/* The following two entries are Playlist 1 and 2 on the MX3200 */
	216	case 0x100f: lg_map_key_clear(KEY_FN_1); break;
	217	case 0x1010: lg_map_key_clear(KEY_FN_2); break;
5f22a799 JS	218	case 0x1011: lg_map_key_clear(KEY_PREVIOUSSONG); break;
	219	case 0x1012: lg_map_key_clear(KEY_NEXTSONG); break;
	220	case 0x1013: lg_map_key_clear(KEY_CAMERA); break;
	221	case 0x1014: lg_map_key_clear(KEY_MESSENGER); break;
	222	case 0x1015: lg_map_key_clear(KEY_RECORD); break;
	223	case 0x1016: lg_map_key_clear(KEY_PLAYER); break;
	224	case 0x1017: lg_map_key_clear(KEY_EJECTCD); break;
	225	case 0x1018: lg_map_key_clear(KEY_MEDIA); break;
	226	case 0x1019: lg_map_key_clear(KEY_PROG1); break;
	227	case 0x101a: lg_map_key_clear(KEY_PROG2); break;
	228	case 0x101b: lg_map_key_clear(KEY_PROG3); break;
18392212	229	case 0x101c: lg_map_key_clear(KEY_CYCLEWINDOWS); break;
5f22a799 JS	230	case 0x101f: lg_map_key_clear(KEY_ZOOMIN); break;
	231	case 0x1020: lg_map_key_clear(KEY_ZOOMOUT); break;
	232	case 0x1021: lg_map_key_clear(KEY_ZOOMRESET); break;
	233	case 0x1023: lg_map_key_clear(KEY_CLOSE); break;
	234	case 0x1027: lg_map_key_clear(KEY_MENU); break;
	235	/* this one is marked as 'Rotate' */
	236	case 0x1028: lg_map_key_clear(KEY_ANGLE); break;
	237	case 0x1029: lg_map_key_clear(KEY_SHUFFLE); break;
	238	case 0x102a: lg_map_key_clear(KEY_BACK); break;
	239	case 0x102b: lg_map_key_clear(KEY_CYCLEWINDOWS); break;
18392212 LC	240	case 0x102d: lg_map_key_clear(KEY_WWW); break;
	241	/* The following two are 'Start/answer call' and 'End/reject call'
	242	on the MX3200 */
	243	case 0x1031: lg_map_key_clear(KEY_OK); break;
	244	case 0x1032: lg_map_key_clear(KEY_CANCEL); break;
5f22a799 JS	245	case 0x1041: lg_map_key_clear(KEY_BATTERY); break;
	246	case 0x1042: lg_map_key_clear(KEY_WORDPROCESSOR); break;
	247	case 0x1043: lg_map_key_clear(KEY_SPREADSHEET); break;
	248	case 0x1044: lg_map_key_clear(KEY_PRESENTATION); break;
	249	case 0x1045: lg_map_key_clear(KEY_UNDO); break;
	250	case 0x1046: lg_map_key_clear(KEY_REDO); break;
	251	case 0x1047: lg_map_key_clear(KEY_PRINT); break;
	252	case 0x1048: lg_map_key_clear(KEY_SAVE); break;
	253	case 0x1049: lg_map_key_clear(KEY_PROG1); break;
	254	case 0x104a: lg_map_key_clear(KEY_PROG2); break;
	255	case 0x104b: lg_map_key_clear(KEY_PROG3); break;
	256	case 0x104c: lg_map_key_clear(KEY_PROG4); break;
	257
	258	default:
	259	return 0;
	260	}
	261	return 1;
	262	}
	263
	264	static int lg_input_mapping(struct hid_device hdev, struct hid_input hi,
	265	struct hid_field field, struct hid_usage usage,
	266	unsigned long *bit, int max)
	267	{
	268	/* extended mapping for certain Logitech hardware (Logitech cordless
	269	desktop LX500) */
	270	static const u8 e_keymap[] = {
	271	0,216, 0,213,175,156, 0, 0, 0, 0,
	272	144, 0, 0, 0, 0, 0, 0, 0, 0,212,
	273	174,167,152,161,112, 0, 0, 0,154, 0,
	274	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	275	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	276	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	277	0, 0, 0, 0, 0,183,184,185,186,187,
	278	188,189,190,191,192,193,194, 0, 0, 0
	279	};
8577dbf9	280	struct lg_drv_data drv_data = (struct lg_drv_data )hid_get_drvdata(hdev);
5f22a799 JS	281	unsigned int hid = usage->hid;
	282
	283	if (hdev->product == USB_DEVICE_ID_LOGITECH_RECEIVER &&
	284	lg_ultrax_remote_mapping(hi, usage, bit, max))
	285	return 1;
	286
66d61bec JK	287	if (hdev->product == USB_DEVICE_ID_DINOVO_MINI &&
	288	lg_dinovo_mapping(hi, usage, bit, max))
	289	return 1;
	290
8577dbf9	291	if ((drv_data->quirks & LG_WIRELESS) && lg_wireless_mapping(hi, usage, bit, max))
5f22a799 JS	292	return 1;
	293
	294	if ((hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
	295	return 0;
	296
	297	hid &= HID_USAGE;
	298
	299	/* Special handling for Logitech Cordless Desktop */
	300	if (field->application == HID_GD_MOUSE) {
8577dbf9	301	if ((drv_data->quirks & LG_IGNORE_DOUBLED_WHEEL) &&
5f22a799 JS	302	(hid == 7 \|\| hid == 8))
	303	return -1;
	304	} else {
8577dbf9	305	if ((drv_data->quirks & LG_EXPANDED_KEYMAP) &&
5f22a799 JS	306	hid < ARRAY_SIZE(e_keymap) &&
	307	e_keymap[hid] != 0) {
	308	hid_map_usage(hi, usage, bit, max, EV_KEY,
	309	e_keymap[hid]);
	310	return 1;
	311	}
	312	}
	313
	314	return 0;
	315	}
	316
	317	static int lg_input_mapped(struct hid_device hdev, struct hid_input hi,
	318	struct hid_field field, struct hid_usage usage,
	319	unsigned long *bit, int max)
	320	{
8577dbf9	321	struct lg_drv_data drv_data = (struct lg_drv_data )hid_get_drvdata(hdev);
5f22a799	322
8577dbf9	323	if ((drv_data->quirks & LG_BAD_RELATIVE_KEYS) && usage->type == EV_KEY &&
5f22a799 JS	324	(field->flags & HID_MAIN_ITEM_RELATIVE))
	325	field->flags &= ~HID_MAIN_ITEM_RELATIVE;
	326
8577dbf9	327	if ((drv_data->quirks & LG_DUPLICATE_USAGES) && (usage->type == EV_KEY \|\|
5f22a799 JS	328	usage->type == EV_REL \|\| usage->type == EV_ABS))
	329	clear_bit(usage->code, *bit);
	330
	331	return 0;
	332	}
	333
	334	static int lg_event(struct hid_device hdev, struct hid_field field,
	335	struct hid_usage *usage, __s32 value)
	336	{
8577dbf9	337	struct lg_drv_data drv_data = (struct lg_drv_data )hid_get_drvdata(hdev);
5f22a799	338
8577dbf9	339	if ((drv_data->quirks & LG_INVERT_HWHEEL) && usage->code == REL_HWHEEL) {
5f22a799 JS	340	input_event(field->hidinput->input, usage->type, usage->code,
	341	-value);
	342	return 1;
	343	}
	344
	345	return 0;
	346	}
	347
	348	static int lg_probe(struct hid_device hdev, const struct hid_device_id id)
	349	{
606bd0a8	350	unsigned int connect_mask = HID_CONNECT_DEFAULT;
8577dbf9	351	struct lg_drv_data *drv_data;
5f22a799 JS	352	int ret;
5f22a799 JS	353
8577dbf9 MM	354	drv_data = kzalloc(sizeof(struct lg_drv_data), GFP_KERNEL);
	355	if (!drv_data) {
	356	hid_err(hdev, "Insufficient memory, cannot allocate driver data\n");
	357	return -ENOMEM;
	358	}
	359	drv_data->quirks = id->driver_data;
	360
	361	hid_set_drvdata(hdev, (void *)drv_data);
5f22a799	362
8577dbf9	363	if (drv_data->quirks & LG_NOGET)
5f22a799 JS	364	hdev->quirks \|= HID_QUIRK_NOGET;
	365
	366	ret = hid_parse(hdev);
	367	if (ret) {
4291ee30	368	hid_err(hdev, "parse failed\n");
5f22a799 JS	369	goto err_free;
	370	}
	371
8577dbf9	372	if (drv_data->quirks & (LG_FF \| LG_FF2 \| LG_FF3 \| LG_FF4))
606bd0a8 JS	373	connect_mask &= ~HID_CONNECT_FF;
	374
	375	ret = hid_hw_start(hdev, connect_mask);
5f22a799	376	if (ret) {
4291ee30	377	hid_err(hdev, "hw start failed\n");
5f22a799 JS	378	goto err_free;
	379	}
	380
7362cd22 MM	381	/* Setup wireless link with Logitech Wii wheel */
7362cd22 MM	382	if(hdev->product == USB_DEVICE_ID_LOGITECH_WII_WHEEL) {
32c88cbc SW	383	unsigned char buf[] = { 0x00, 0xAF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
	384
	385	ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
	386
	387	if (ret >= 0) {
	388	/* insert a little delay of 10 jiffies ~ 40ms */
	389	wait_queue_head_t wait;
	390	init_waitqueue_head (&wait);
	391	wait_event_interruptible_timeout(wait, 0, 10);
	392
	393	/* Select random Address */
	394	buf[1] = 0xB2;
	395	get_random_bytes(&buf[2], 2);
	396
	397	ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
	398	}
	399	}
	400
8577dbf9	401	if (drv_data->quirks & LG_FF)
606bd0a8	402	lgff_init(hdev);
8577dbf9	403	if (drv_data->quirks & LG_FF2)
606bd0a8	404	lg2ff_init(hdev);
8577dbf9	405	if (drv_data->quirks & LG_FF3)
74f292ca	406	lg3ff_init(hdev);
8577dbf9	407	if (drv_data->quirks & LG_FF4)
32c88cbc	408	lg4ff_init(hdev);
606bd0a8	409
5f22a799 JS	410	return 0;
5f22a799 JS	411	err_free:
8577dbf9	412	kfree(drv_data);
5f22a799 JS	413	return ret;
	414	}
	415
30bb75d7 MM	416	static void lg_remove(struct hid_device *hdev)
30bb75d7 MM	417	{
8577dbf9 MM	418	struct lg_drv_data drv_data = (struct lg_drv_data )hid_get_drvdata(hdev);
8577dbf9 MM	419	if (drv_data->quirks & LG_FF4)
30bb75d7 MM	420	lg4ff_deinit(hdev);
	421
	422	hid_hw_stop(hdev);
8577dbf9	423	kfree(drv_data);
30bb75d7 MM	424	}
30bb75d7 MM	425
5f22a799 JS	426	static const struct hid_device_id lg_devices[] = {
	427	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER),
	428	.driver_data = LG_RDESC \| LG_WIRELESS },
	429	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER),
	430	.driver_data = LG_RDESC \| LG_WIRELESS },
	431	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2),
	432	.driver_data = LG_RDESC \| LG_WIRELESS },
	433
	434	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER),
	435	.driver_data = LG_BAD_RELATIVE_KEYS },
	436
	437	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP),
	438	.driver_data = LG_DUPLICATE_USAGES },
	439	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE),
	440	.driver_data = LG_DUPLICATE_USAGES },
	441	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI),
	442	.driver_data = LG_DUPLICATE_USAGES },
	443
5f22a799 JS	444	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD),
	445	.driver_data = LG_IGNORE_DOUBLED_WHEEL \| LG_EXPANDED_KEYMAP },
	446	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500),
	447	.driver_data = LG_IGNORE_DOUBLED_WHEEL \| LG_EXPANDED_KEYMAP },
	448
5f22a799 JS	449	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D),
	450	.driver_data = LG_NOGET },
	451	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL),
7362cd22	452	.driver_data = LG_NOGET \| LG_FF4 },
606bd0a8	453
2c6118e4 HI	454	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD),
2c6118e4 HI	455	.driver_data = LG_FF2 },
606bd0a8 JS	456	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD),
	457	.driver_data = LG_FF },
	458	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2),
	459	.driver_data = LG_FF },
	460	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D),
	461	.driver_data = LG_FF },
	462	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO),
	463	.driver_data = LG_FF },
	464	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL),
7362cd22	465	.driver_data = LG_FF4 },
606bd0a8	466	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2),
7362cd22	467	.driver_data = LG_FF4 },
243b706d	468	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL),
7362cd22 MM	469	.driver_data = LG_FF4 },
	470	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL),
	471	.driver_data = LG_FF4 },
fdc6807f	472	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL),
7362cd22	473	.driver_data = LG_FF4 },
5623a24a	474	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL),
7362cd22	475	.driver_data = LG_NOGET \| LG_FF4 },
32c88cbc SW	476	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL),
32c88cbc SW	477	.driver_data = LG_FF4 },
fd30ea8c JK	478	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG ),
fd30ea8c JK	479	.driver_data = LG_FF },
606bd0a8 JS	480	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2),
606bd0a8 JS	481	.driver_data = LG_FF2 },
74f292ca GS	482	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940),
74f292ca GS	483	.driver_data = LG_FF3 },
24985cf6 JK	484	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR),
	485	.driver_data = LG_RDESC_REL_ABS },
	486	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER),
	487	.driver_data = LG_RDESC_REL_ABS },
5f22a799 JS	488	{ }
5f22a799 JS	489	};
24985cf6	490
5f22a799 JS	491	MODULE_DEVICE_TABLE(hid, lg_devices);
	492
	493	static struct hid_driver lg_driver = {
	494	.name = "logitech",
	495	.id_table = lg_devices,
	496	.report_fixup = lg_report_fixup,
	497	.input_mapping = lg_input_mapping,
	498	.input_mapped = lg_input_mapped,
	499	.event = lg_event,
	500	.probe = lg_probe,
30bb75d7	501	.remove = lg_remove,
5f22a799 JS	502	};
5f22a799 JS	503
a24f423b	504	static int __init lg_init(void)
5f22a799 JS	505	{
	506	return hid_register_driver(&lg_driver);
	507	}
	508
a24f423b	509	static void __exit lg_exit(void)
5f22a799 JS	510	{
	511	hid_unregister_driver(&lg_driver);
	512	}
	513
	514	module_init(lg_init);
	515	module_exit(lg_exit);
	516	MODULE_LICENSE("GPL");