[linux-2.6-block.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 = 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 = 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 = 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 = 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;
	}
	if (drv_data->quirks & LG_FF4) {
		return lg4ff_adjust_input_event(hdev, field, usage, value, drv_data);
	}

	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 = 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	{
25751553	111	struct lg_drv_data *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	};
25751553	280	struct lg_drv_data *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	{
25751553	321	struct lg_drv_data *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	{
25751553	337	struct lg_drv_data *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	}
2b24a960 MM	344	if (drv_data->quirks & LG_FF4) {
	345	return lg4ff_adjust_input_event(hdev, field, usage, value, drv_data);
	346	}
5f22a799 JS	347
	348	return 0;
	349	}
	350
	351	static int lg_probe(struct hid_device hdev, const struct hid_device_id id)
	352	{
606bd0a8	353	unsigned int connect_mask = HID_CONNECT_DEFAULT;
8577dbf9	354	struct lg_drv_data *drv_data;
5f22a799 JS	355	int ret;
5f22a799 JS	356
8577dbf9 MM	357	drv_data = kzalloc(sizeof(struct lg_drv_data), GFP_KERNEL);
	358	if (!drv_data) {
	359	hid_err(hdev, "Insufficient memory, cannot allocate driver data\n");
	360	return -ENOMEM;
	361	}
	362	drv_data->quirks = id->driver_data;
a80fe5d6	363
8577dbf9	364	hid_set_drvdata(hdev, (void *)drv_data);
5f22a799	365
8577dbf9	366	if (drv_data->quirks & LG_NOGET)
5f22a799 JS	367	hdev->quirks \|= HID_QUIRK_NOGET;
	368
	369	ret = hid_parse(hdev);
	370	if (ret) {
4291ee30	371	hid_err(hdev, "parse failed\n");
5f22a799 JS	372	goto err_free;
	373	}
	374
8577dbf9	375	if (drv_data->quirks & (LG_FF \| LG_FF2 \| LG_FF3 \| LG_FF4))
606bd0a8 JS	376	connect_mask &= ~HID_CONNECT_FF;
	377
	378	ret = hid_hw_start(hdev, connect_mask);
5f22a799	379	if (ret) {
4291ee30	380	hid_err(hdev, "hw start failed\n");
5f22a799 JS	381	goto err_free;
	382	}
	383
7362cd22	384	/* Setup wireless link with Logitech Wii wheel */
a80fe5d6	385	if (hdev->product == USB_DEVICE_ID_LOGITECH_WII_WHEEL) {
32c88cbc SW	386	unsigned char buf[] = { 0x00, 0xAF, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
	387
	388	ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
	389
	390	if (ret >= 0) {
	391	/* insert a little delay of 10 jiffies ~ 40ms */
	392	wait_queue_head_t wait;
	393	init_waitqueue_head (&wait);
	394	wait_event_interruptible_timeout(wait, 0, 10);
	395
	396	/* Select random Address */
	397	buf[1] = 0xB2;
	398	get_random_bytes(&buf[2], 2);
	399
	400	ret = hdev->hid_output_raw_report(hdev, buf, sizeof(buf), HID_FEATURE_REPORT);
	401	}
	402	}
	403
8577dbf9	404	if (drv_data->quirks & LG_FF)
606bd0a8	405	lgff_init(hdev);
8577dbf9	406	if (drv_data->quirks & LG_FF2)
606bd0a8	407	lg2ff_init(hdev);
8577dbf9	408	if (drv_data->quirks & LG_FF3)
74f292ca	409	lg3ff_init(hdev);
8577dbf9	410	if (drv_data->quirks & LG_FF4)
32c88cbc	411	lg4ff_init(hdev);
606bd0a8	412
5f22a799 JS	413	return 0;
5f22a799 JS	414	err_free:
8577dbf9	415	kfree(drv_data);
5f22a799 JS	416	return ret;
	417	}
	418
30bb75d7 MM	419	static void lg_remove(struct hid_device *hdev)
30bb75d7 MM	420	{
25751553	421	struct lg_drv_data *drv_data = hid_get_drvdata(hdev);
8577dbf9	422	if (drv_data->quirks & LG_FF4)
30bb75d7 MM	423	lg4ff_deinit(hdev);
	424
	425	hid_hw_stop(hdev);
8577dbf9	426	kfree(drv_data);
30bb75d7 MM	427	}
30bb75d7 MM	428
5f22a799 JS	429	static const struct hid_device_id lg_devices[] = {
	430	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_MX3000_RECEIVER),
	431	.driver_data = LG_RDESC \| LG_WIRELESS },
	432	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER),
	433	.driver_data = LG_RDESC \| LG_WIRELESS },
	434	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_S510_RECEIVER_2),
	435	.driver_data = LG_RDESC \| LG_WIRELESS },
	436
	437	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RECEIVER),
	438	.driver_data = LG_BAD_RELATIVE_KEYS },
	439
	440	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_DESKTOP),
	441	.driver_data = LG_DUPLICATE_USAGES },
	442	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_EDGE),
	443	.driver_data = LG_DUPLICATE_USAGES },
	444	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_DINOVO_MINI),
	445	.driver_data = LG_DUPLICATE_USAGES },
	446
5f22a799 JS	447	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_ELITE_KBD),
	448	.driver_data = LG_IGNORE_DOUBLED_WHEEL \| LG_EXPANDED_KEYMAP },
	449	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_CORDLESS_DESKTOP_LX500),
	450	.driver_data = LG_IGNORE_DOUBLED_WHEEL \| LG_EXPANDED_KEYMAP },
	451
5f22a799 JS	452	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_EXTREME_3D),
	453	.driver_data = LG_NOGET },
	454	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WHEEL),
7362cd22	455	.driver_data = LG_NOGET \| LG_FF4 },
606bd0a8	456
2c6118e4 HI	457	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD_CORD),
2c6118e4 HI	458	.driver_data = LG_FF2 },
606bd0a8 JS	459	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD),
	460	.driver_data = LG_FF },
	461	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2_2),
	462	.driver_data = LG_FF },
	463	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_F3D),
	464	.driver_data = LG_FF },
	465	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FORCE3D_PRO),
	466	.driver_data = LG_FF },
	467	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL),
7362cd22	468	.driver_data = LG_FF4 },
606bd0a8	469	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOMO_WHEEL2),
7362cd22	470	.driver_data = LG_FF4 },
243b706d	471	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G25_WHEEL),
7362cd22 MM	472	.driver_data = LG_FF4 },
	473	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFGT_WHEEL),
	474	.driver_data = LG_FF4 },
fdc6807f	475	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_G27_WHEEL),
7362cd22	476	.driver_data = LG_FF4 },
5623a24a	477	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_DFP_WHEEL),
7362cd22	478	.driver_data = LG_NOGET \| LG_FF4 },
32c88cbc SW	479	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WII_WHEEL),
32c88cbc SW	480	.driver_data = LG_FF4 },
a80fe5d6	481	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_WINGMAN_FFG),
fd30ea8c	482	.driver_data = LG_FF },
606bd0a8 JS	483	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_RUMBLEPAD2),
606bd0a8 JS	484	.driver_data = LG_FF2 },
74f292ca GS	485	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_FLIGHT_SYSTEM_G940),
74f292ca GS	486	.driver_data = LG_FF3 },
24985cf6 JK	487	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACENAVIGATOR),
	488	.driver_data = LG_RDESC_REL_ABS },
	489	{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_SPACETRAVELLER),
	490	.driver_data = LG_RDESC_REL_ABS },
5f22a799 JS	491	{ }
5f22a799 JS	492	};
24985cf6	493
5f22a799 JS	494	MODULE_DEVICE_TABLE(hid, lg_devices);
	495
	496	static struct hid_driver lg_driver = {
	497	.name = "logitech",
	498	.id_table = lg_devices,
	499	.report_fixup = lg_report_fixup,
	500	.input_mapping = lg_input_mapping,
	501	.input_mapped = lg_input_mapped,
	502	.event = lg_event,
	503	.probe = lg_probe,
30bb75d7	504	.remove = lg_remove,
5f22a799 JS	505	};
5f22a799 JS	506
a24f423b	507	static int __init lg_init(void)
5f22a799 JS	508	{
	509	return hid_register_driver(&lg_driver);
	510	}
	511
a24f423b	512	static void __exit lg_exit(void)
5f22a799 JS	513	{
	514	hid_unregister_driver(&lg_driver);
	515	}
	516
	517	module_init(lg_init);
	518	module_exit(lg_exit);
	519	MODULE_LICENSE("GPL");