[mirror_ubuntu-hirsute-kernel.git] / drivers / hid / hid-microsoft.c

/*
 *  HID driver for some microsoft "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
 */

/*
 * 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/input.h>
#include <linux/hid.h>
#include <linux/module.h>

#include "hid-ids.h"

#define MS_HIDINPUT		BIT(0)
#define MS_ERGONOMY		BIT(1)
#define MS_PRESENTER		BIT(2)
#define MS_RDESC		BIT(3)
#define MS_NOGET		BIT(4)
#define MS_DUPLICATE_USAGES	BIT(5)
#define MS_SURFACE_DIAL		BIT(6)

struct ms_data {
	unsigned long quirks;
};

static __u8 *ms_report_fixup(struct hid_device *hdev, __u8 *rdesc,
		unsigned int *rsize)
{
	struct ms_data *ms = hid_get_drvdata(hdev);
	unsigned long quirks = ms->quirks;

	/*
	 * Microsoft Wireless Desktop Receiver (Model 1028) has
	 * 'Usage Min/Max' where it ought to have 'Physical Min/Max'
	 */
	if ((quirks & MS_RDESC) && *rsize == 571 && rdesc[557] == 0x19 &&
			rdesc[559] == 0x29) {
		hid_info(hdev, "fixing up Microsoft Wireless Receiver Model 1028 report descriptor\n");
		rdesc[557] = 0x35;
		rdesc[559] = 0x45;
	}
	return rdesc;
}

#define ms_map_key_clear(c)	hid_map_usage_clear(hi, usage, bit, max, \
					EV_KEY, (c))
static int ms_ergonomy_kb_quirk(struct hid_input *hi, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	struct input_dev *input = hi->input;

	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) {
		switch (usage->hid & HID_USAGE) {
		/*
		 * Microsoft uses these 2 reserved usage ids for 2 keys on
		 * the MS office kb labelled "Office Home" and "Task Pane".
		 */
		case 0x29d:
			ms_map_key_clear(KEY_PROG1);
			return 1;
		case 0x29e:
			ms_map_key_clear(KEY_PROG2);
			return 1;
		}
		return 0;
	}

	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
		return 0;

	switch (usage->hid & HID_USAGE) {
	case 0xfd06: ms_map_key_clear(KEY_CHAT);	break;
	case 0xfd07: ms_map_key_clear(KEY_PHONE);	break;
	case 0xff00:
		/* Special keypad keys */
		ms_map_key_clear(KEY_KPEQUAL);
		set_bit(KEY_KPLEFTPAREN, input->keybit);
		set_bit(KEY_KPRIGHTPAREN, input->keybit);
		break;
	case 0xff01:
		/* Scroll wheel */
		hid_map_usage_clear(hi, usage, bit, max, EV_REL, REL_WHEEL);
		break;
	case 0xff02:
		/*
		 * This byte contains a copy of the modifier keys byte of a
		 * standard hid keyboard report, as send by interface 0
		 * (this usage is found on interface 1).
		 *
		 * This byte only gets send when another key in the same report
		 * changes state, and as such is useless, ignore it.
		 */
		return -1;
	case 0xff05:
		set_bit(EV_REP, input->evbit);
		ms_map_key_clear(KEY_F13);
		set_bit(KEY_F14, input->keybit);
		set_bit(KEY_F15, input->keybit);
		set_bit(KEY_F16, input->keybit);
		set_bit(KEY_F17, input->keybit);
		set_bit(KEY_F18, input->keybit);
		break;
	default:
		return 0;
	}
	return 1;
}

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

	set_bit(EV_REP, hi->input->evbit);
	switch (usage->hid & HID_USAGE) {
	case 0xfd08: ms_map_key_clear(KEY_FORWARD);	break;
	case 0xfd09: ms_map_key_clear(KEY_BACK);	break;
	case 0xfd0b: ms_map_key_clear(KEY_PLAYPAUSE);	break;
	case 0xfd0e: ms_map_key_clear(KEY_CLOSE);	break;
	case 0xfd0f: ms_map_key_clear(KEY_PLAY);	break;
	default:
		return 0;
	}
	return 1;
}

static int ms_surface_dial_quirk(struct hid_input *hi, struct hid_field *field,
		struct hid_usage *usage, unsigned long **bit, int *max)
{
	switch (usage->hid & HID_USAGE_PAGE) {
	case 0xff070000:
		/* fall-through */
	case HID_UP_DIGITIZER:
		/* ignore those axis */
		return -1;
	case HID_UP_GENDESK:
		switch (usage->hid) {
		case HID_GD_X:
			/* fall-through */
		case HID_GD_Y:
			/* fall-through */
		case HID_GD_RFKILL_BTN:
			/* ignore those axis */
			return -1;
		}
	}

	return 0;
}

static int ms_input_mapping(struct hid_device *hdev, struct hid_input *hi,
		struct hid_field *field, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	struct ms_data *ms = hid_get_drvdata(hdev);
	unsigned long quirks = ms->quirks;

	if (quirks & MS_ERGONOMY) {
		int ret = ms_ergonomy_kb_quirk(hi, usage, bit, max);
		if (ret)
			return ret;
	}

	if ((quirks & MS_PRESENTER) &&
			ms_presenter_8k_quirk(hi, usage, bit, max))
		return 1;

	if (quirks & MS_SURFACE_DIAL) {
		int ret = ms_surface_dial_quirk(hi, field, usage, bit, max);

		if (ret)
			return ret;
	}

	return 0;
}

static int ms_input_mapped(struct hid_device *hdev, struct hid_input *hi,
		struct hid_field *field, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	struct ms_data *ms = hid_get_drvdata(hdev);
	unsigned long quirks = ms->quirks;

	if (quirks & MS_DUPLICATE_USAGES)
		clear_bit(usage->code, *bit);

	return 0;
}

static int ms_event(struct hid_device *hdev, struct hid_field *field,
		struct hid_usage *usage, __s32 value)
{
	struct ms_data *ms = hid_get_drvdata(hdev);
	unsigned long quirks = ms->quirks;
	struct input_dev *input;

	if (!(hdev->claimed & HID_CLAIMED_INPUT) || !field->hidinput ||
			!usage->type)
		return 0;

	input = field->hidinput->input;

	/* Handling MS keyboards special buttons */
	if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff00)) {
		/* Special keypad keys */
		input_report_key(input, KEY_KPEQUAL, value & 0x01);
		input_report_key(input, KEY_KPLEFTPAREN, value & 0x02);
		input_report_key(input, KEY_KPRIGHTPAREN, value & 0x04);
		return 1;
	}

	if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff01)) {
		/* Scroll wheel */
		int step = ((value & 0x60) >> 5) + 1;

		switch (value & 0x1f) {
		case 0x01:
			input_report_rel(input, REL_WHEEL, step);
			break;
		case 0x1f:
			input_report_rel(input, REL_WHEEL, -step);
			break;
		}
		return 1;
	}

	if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR | 0xff05)) {
		static unsigned int last_key = 0;
		unsigned int key = 0;
		switch (value) {
		case 0x01: key = KEY_F14; break;
		case 0x02: key = KEY_F15; break;
		case 0x04: key = KEY_F16; break;
		case 0x08: key = KEY_F17; break;
		case 0x10: key = KEY_F18; break;
		}
		if (key) {
			input_event(input, usage->type, key, 1);
			last_key = key;
		} else
			input_event(input, usage->type, last_key, 0);

		return 1;
	}

	return 0;
}

static int ms_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
	unsigned long quirks = id->driver_data;
	struct ms_data *ms;
	int ret;

	ms = devm_kzalloc(&hdev->dev, sizeof(*ms), GFP_KERNEL);
	if (ms == NULL)
		return -ENOMEM;

	ms->quirks = quirks;

	hid_set_drvdata(hdev, ms);

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

	if (quirks & MS_SURFACE_DIAL)
		hdev->quirks |= HID_QUIRK_INPUT_PER_APP;

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

	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT | ((quirks & MS_HIDINPUT) ?
				HID_CONNECT_HIDINPUT_FORCE : 0));
	if (ret) {
		hid_err(hdev, "hw start failed\n");
		goto err_free;
	}

	return 0;
err_free:
	return ret;
}

static const struct hid_device_id ms_devices[] = {
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV),
		.driver_data = MS_HIDINPUT },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_OFFICE_KB),
		.driver_data = MS_ERGONOMY },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K),
		.driver_data = MS_ERGONOMY },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K_JP),
		.driver_data = MS_ERGONOMY },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE7K),
		.driver_data = MS_ERGONOMY },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K),
		.driver_data = MS_ERGONOMY | MS_RDESC },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB),
		.driver_data = MS_PRESENTER },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K),
		.driver_data = MS_ERGONOMY },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_7K),
		.driver_data = MS_ERGONOMY },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_600),
		.driver_data = MS_ERGONOMY },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3KV1),
		.driver_data = MS_ERGONOMY },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0),
		.driver_data = MS_NOGET },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500),
		.driver_data = MS_DUPLICATE_USAGES },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER),
		.driver_data = MS_HIDINPUT },
	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_KEYBOARD),
		.driver_data = MS_ERGONOMY},

	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT),
		.driver_data = MS_PRESENTER },
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, 0x091B),
		.driver_data = MS_SURFACE_DIAL },
	{ }
};
MODULE_DEVICE_TABLE(hid, ms_devices);

static struct hid_driver ms_driver = {
	.name = "microsoft",
	.id_table = ms_devices,
	.report_fixup = ms_report_fixup,
	.input_mapping = ms_input_mapping,
	.input_mapped = ms_input_mapped,
	.event = ms_event,
	.probe = ms_probe,
};
module_hid_driver(ms_driver);

MODULE_LICENSE("GPL");
Commit	Line	Data
78a849a6 JS	1	/*
	2	* HID driver for some microsoft "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
78a849a6 JS	8	* Copyright (c) 2008 Jiri Slaby
	9	*/
	10
	11	/*
	12	* This program is free software; you can redistribute it and/or modify it
	13	* under the terms of the GNU General Public License as published by the Free
	14	* Software Foundation; either version 2 of the License, or (at your option)
	15	* any later version.
	16	*/
	17
	18	#include <linux/device.h>
	19	#include <linux/input.h>
	20	#include <linux/hid.h>
	21	#include <linux/module.h>
	22
	23	#include "hid-ids.h"
	24
30576c5f BT	25	#define MS_HIDINPUT BIT(0)
	26	#define MS_ERGONOMY BIT(1)
	27	#define MS_PRESENTER BIT(2)
	28	#define MS_RDESC BIT(3)
	29	#define MS_NOGET BIT(4)
	30	#define MS_DUPLICATE_USAGES BIT(5)
	31	#define MS_SURFACE_DIAL BIT(6)
78a849a6	32
f2d3b625 AS	33	struct ms_data {
	34	unsigned long quirks;
	35	};
	36
73e4008d NK	37	static __u8 ms_report_fixup(struct hid_device hdev, __u8 *rdesc,
73e4008d NK	38	unsigned int *rsize)
78a849a6	39	{
f2d3b625 AS	40	struct ms_data *ms = hid_get_drvdata(hdev);
f2d3b625 AS	41	unsigned long quirks = ms->quirks;
78a849a6	42
3ccc60f9 JS	43	/*
	44	* Microsoft Wireless Desktop Receiver (Model 1028) has
	45	* 'Usage Min/Max' where it ought to have 'Physical Min/Max'
	46	*/
73e4008d	47	if ((quirks & MS_RDESC) && *rsize == 571 && rdesc[557] == 0x19 &&
78a849a6	48	rdesc[559] == 0x29) {
4291ee30	49	hid_info(hdev, "fixing up Microsoft Wireless Receiver Model 1028 report descriptor\n");
0fb21de0 JK	50	rdesc[557] = 0x35;
0fb21de0 JK	51	rdesc[559] = 0x45;
78a849a6	52	}
73e4008d	53	return rdesc;
78a849a6 JS	54	}
	55
	56	#define ms_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, max, \
	57	EV_KEY, (c))
	58	static int ms_ergonomy_kb_quirk(struct hid_input hi, struct hid_usage usage,
	59	unsigned long *bit, int max)
	60	{
	61	struct input_dev *input = hi->input;
	62
34e75dca HG	63	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) {
	64	switch (usage->hid & HID_USAGE) {
	65	/*
	66	* Microsoft uses these 2 reserved usage ids for 2 keys on
	67	* the MS office kb labelled "Office Home" and "Task Pane".
	68	*/
	69	case 0x29d:
	70	ms_map_key_clear(KEY_PROG1);
	71	return 1;
	72	case 0x29e:
	73	ms_map_key_clear(KEY_PROG2);
	74	return 1;
	75	}
	76	return 0;
	77	}
	78
aac59f6a HG	79	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
	80	return 0;
	81
78a849a6 JS	82	switch (usage->hid & HID_USAGE) {
	83	case 0xfd06: ms_map_key_clear(KEY_CHAT); break;
	84	case 0xfd07: ms_map_key_clear(KEY_PHONE); break;
3faed1af HG	85	case 0xff00:
	86	/* Special keypad keys */
	87	ms_map_key_clear(KEY_KPEQUAL);
	88	set_bit(KEY_KPLEFTPAREN, input->keybit);
	89	set_bit(KEY_KPRIGHTPAREN, input->keybit);
	90	break;
	91	case 0xff01:
	92	/* Scroll wheel */
	93	hid_map_usage_clear(hi, usage, bit, max, EV_REL, REL_WHEEL);
	94	break;
	95	case 0xff02:
	96	/*
	97	* This byte contains a copy of the modifier keys byte of a
	98	* standard hid keyboard report, as send by interface 0
	99	* (this usage is found on interface 1).
	100	*
	101	* This byte only gets send when another key in the same report
	102	* changes state, and as such is useless, ignore it.
	103	*/
	104	return -1;
78a849a6 JS	105	case 0xff05:
	106	set_bit(EV_REP, input->evbit);
	107	ms_map_key_clear(KEY_F13);
	108	set_bit(KEY_F14, input->keybit);
	109	set_bit(KEY_F15, input->keybit);
	110	set_bit(KEY_F16, input->keybit);
	111	set_bit(KEY_F17, input->keybit);
	112	set_bit(KEY_F18, input->keybit);
b2b98ea8	113	break;
78a849a6 JS	114	default:
	115	return 0;
	116	}
	117	return 1;
	118	}
	119
	120	static int ms_presenter_8k_quirk(struct hid_input hi, struct hid_usage usage,
	121	unsigned long *bit, int max)
	122	{
aac59f6a HG	123	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
	124	return 0;
	125
78a849a6 JS	126	set_bit(EV_REP, hi->input->evbit);
	127	switch (usage->hid & HID_USAGE) {
	128	case 0xfd08: ms_map_key_clear(KEY_FORWARD); break;
	129	case 0xfd09: ms_map_key_clear(KEY_BACK); break;
	130	case 0xfd0b: ms_map_key_clear(KEY_PLAYPAUSE); break;
	131	case 0xfd0e: ms_map_key_clear(KEY_CLOSE); break;
	132	case 0xfd0f: ms_map_key_clear(KEY_PLAY); break;
	133	default:
	134	return 0;
	135	}
	136	return 1;
	137	}
	138
30576c5f BT	139	static int ms_surface_dial_quirk(struct hid_input hi, struct hid_field field,
	140	struct hid_usage usage, unsigned long bit, int max)
	141	{
	142	switch (usage->hid & HID_USAGE_PAGE) {
	143	case 0xff070000:
	144	/* fall-through */
	145	case HID_UP_DIGITIZER:
	146	/* ignore those axis */
	147	return -1;
	148	case HID_UP_GENDESK:
	149	switch (usage->hid) {
	150	case HID_GD_X:
	151	/* fall-through */
	152	case HID_GD_Y:
	153	/* fall-through */
	154	case HID_GD_RFKILL_BTN:
	155	/* ignore those axis */
	156	return -1;
	157	}
	158	}
	159
	160	return 0;
	161	}
	162
78a849a6 JS	163	static int ms_input_mapping(struct hid_device hdev, struct hid_input hi,
	164	struct hid_field field, struct hid_usage usage,
	165	unsigned long *bit, int max)
	166	{
f2d3b625 AS	167	struct ms_data *ms = hid_get_drvdata(hdev);
f2d3b625 AS	168	unsigned long quirks = ms->quirks;
78a849a6	169
78a849a6 JS	170	if (quirks & MS_ERGONOMY) {
	171	int ret = ms_ergonomy_kb_quirk(hi, usage, bit, max);
	172	if (ret)
	173	return ret;
	174	}
	175
	176	if ((quirks & MS_PRESENTER) &&
	177	ms_presenter_8k_quirk(hi, usage, bit, max))
	178	return 1;
	179
30576c5f BT	180	if (quirks & MS_SURFACE_DIAL) {
	181	int ret = ms_surface_dial_quirk(hi, field, usage, bit, max);
	182
	183	if (ret)
	184	return ret;
	185	}
	186
78a849a6 JS	187	return 0;
	188	}
	189
23c10bec AS	190	static int ms_input_mapped(struct hid_device hdev, struct hid_input hi,
	191	struct hid_field field, struct hid_usage usage,
	192	unsigned long *bit, int max)
	193	{
f2d3b625 AS	194	struct ms_data *ms = hid_get_drvdata(hdev);
f2d3b625 AS	195	unsigned long quirks = ms->quirks;
23c10bec AS	196
	197	if (quirks & MS_DUPLICATE_USAGES)
	198	clear_bit(usage->code, *bit);
	199
	200	return 0;
	201	}
	202
78a849a6 JS	203	static int ms_event(struct hid_device hdev, struct hid_field field,
	204	struct hid_usage *usage, __s32 value)
	205	{
f2d3b625 AS	206	struct ms_data *ms = hid_get_drvdata(hdev);
f2d3b625 AS	207	unsigned long quirks = ms->quirks;
3faed1af	208	struct input_dev *input;
78a849a6 JS	209
	210	if (!(hdev->claimed & HID_CLAIMED_INPUT) \|\| !field->hidinput \|\|
	211	!usage->type)
	212	return 0;
	213
3faed1af HG	214	input = field->hidinput->input;
3faed1af HG	215
78a849a6	216	/* Handling MS keyboards special buttons */
3faed1af HG	217	if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR \| 0xff00)) {
	218	/* Special keypad keys */
	219	input_report_key(input, KEY_KPEQUAL, value & 0x01);
	220	input_report_key(input, KEY_KPLEFTPAREN, value & 0x02);
	221	input_report_key(input, KEY_KPRIGHTPAREN, value & 0x04);
	222	return 1;
	223	}
	224
	225	if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR \| 0xff01)) {
	226	/* Scroll wheel */
	227	int step = ((value & 0x60) >> 5) + 1;
	228
	229	switch (value & 0x1f) {
	230	case 0x01:
	231	input_report_rel(input, REL_WHEEL, step);
	232	break;
	233	case 0x1f:
	234	input_report_rel(input, REL_WHEEL, -step);
	235	break;
	236	}
	237	return 1;
	238	}
	239
78a849a6	240	if (quirks & MS_ERGONOMY && usage->hid == (HID_UP_MSVENDOR \| 0xff05)) {
78a849a6 JS	241	static unsigned int last_key = 0;
	242	unsigned int key = 0;
	243	switch (value) {
	244	case 0x01: key = KEY_F14; break;
	245	case 0x02: key = KEY_F15; break;
	246	case 0x04: key = KEY_F16; break;
	247	case 0x08: key = KEY_F17; break;
	248	case 0x10: key = KEY_F18; break;
	249	}
	250	if (key) {
	251	input_event(input, usage->type, key, 1);
	252	last_key = key;
	253	} else
	254	input_event(input, usage->type, last_key, 0);
	255
	256	return 1;
	257	}
	258
	259	return 0;
	260	}
	261
	262	static int ms_probe(struct hid_device hdev, const struct hid_device_id id)
	263	{
	264	unsigned long quirks = id->driver_data;
f2d3b625	265	struct ms_data *ms;
78a849a6 JS	266	int ret;
78a849a6 JS	267
f2d3b625 AS	268	ms = devm_kzalloc(&hdev->dev, sizeof(*ms), GFP_KERNEL);
	269	if (ms == NULL)
	270	return -ENOMEM;
	271
	272	ms->quirks = quirks;
	273
	274	hid_set_drvdata(hdev, ms);
78a849a6	275
78a849a6 JS	276	if (quirks & MS_NOGET)
	277	hdev->quirks \|= HID_QUIRK_NOGET;
	278
30576c5f BT	279	if (quirks & MS_SURFACE_DIAL)
	280	hdev->quirks \|= HID_QUIRK_INPUT_PER_APP;
	281
78a849a6 JS	282	ret = hid_parse(hdev);
78a849a6 JS	283	if (ret) {
4291ee30	284	hid_err(hdev, "parse failed\n");
78a849a6 JS	285	goto err_free;
	286	}
	287
93c10132 JS	288	ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT \| ((quirks & MS_HIDINPUT) ?
93c10132 JS	289	HID_CONNECT_HIDINPUT_FORCE : 0));
78a849a6	290	if (ret) {
4291ee30	291	hid_err(hdev, "hw start failed\n");
78a849a6 JS	292	goto err_free;
	293	}
	294
	295	return 0;
	296	err_free:
	297	return ret;
	298	}
	299
	300	static const struct hid_device_id ms_devices[] = {
	301	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_SIDEWINDER_GV),
	302	.driver_data = MS_HIDINPUT },
3faed1af HG	303	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_OFFICE_KB),
3faed1af HG	304	.driver_data = MS_ERGONOMY },
78a849a6 JS	305	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K),
78a849a6 JS	306	.driver_data = MS_ERGONOMY },
89759e20 AJ	307	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE4K_JP),
89759e20 AJ	308	.driver_data = MS_ERGONOMY },
ef567cf9 JS	309	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_NE7K),
ef567cf9 JS	310	.driver_data = MS_ERGONOMY },
78a849a6 JS	311	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_LK6K),
	312	.driver_data = MS_ERGONOMY \| MS_RDESC },
	313	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_USB),
	314	.driver_data = MS_PRESENTER },
f3b83d71	315	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K),
52dc085a	316	.driver_data = MS_ERGONOMY },
c847a89a ALH	317	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_7K),
	318	.driver_data = MS_ERGONOMY },
	319	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_600),
	320	.driver_data = MS_ERGONOMY },
	321	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3KV1),
	322	.driver_data = MS_ERGONOMY },
78a849a6 JS	323	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0),
78a849a6 JS	324	.driver_data = MS_NOGET },
23c10bec AS	325	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500),
23c10bec AS	326	.driver_data = MS_DUPLICATE_USAGES },
18eec2cd RR	327	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER),
18eec2cd RR	328	.driver_data = MS_HIDINPUT },
f9a82c20 SB	329	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_KEYBOARD),
f9a82c20 SB	330	.driver_data = MS_ERGONOMY},
78a849a6 JS	331
	332	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PRESENTER_8K_BT),
	333	.driver_data = MS_PRESENTER },
30576c5f BT	334	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_MICROSOFT, 0x091B),
30576c5f BT	335	.driver_data = MS_SURFACE_DIAL },
78a849a6 JS	336	{ }
	337	};
	338	MODULE_DEVICE_TABLE(hid, ms_devices);
	339
	340	static struct hid_driver ms_driver = {
	341	.name = "microsoft",
	342	.id_table = ms_devices,
	343	.report_fixup = ms_report_fixup,
	344	.input_mapping = ms_input_mapping,
23c10bec	345	.input_mapped = ms_input_mapped,
78a849a6 JS	346	.event = ms_event,
	347	.probe = ms_probe,
	348	};
f425458e	349	module_hid_driver(ms_driver);
78a849a6	350
78a849a6	351	MODULE_LICENSE("GPL");