[deliverable/linux.git] / drivers / hid / hid-input-quirks.c

/*
 *  HID-input usage mapping quirks
 *
 *  This is used to handle HID-input mappings for devices violating
 *  HUT 1.12 specification.
 *
 * Copyright (c) 2007-2008 Jiri Kosina
 */

/*
 * 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
 */

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

#define map_abs(c)      do { usage->code = c; usage->type = EV_ABS; *bit = input->absbit; *max = ABS_MAX; } while (0)
#define map_rel(c)      do { usage->code = c; usage->type = EV_REL; *bit = input->relbit; *max = REL_MAX; } while (0)
#define map_key(c)      do { usage->code = c; usage->type = EV_KEY; *bit = input->keybit; *max = KEY_MAX; } while (0)
#define map_led(c)      do { usage->code = c; usage->type = EV_LED; *bit = input->ledbit; *max = LED_MAX; } while (0)

#define map_abs_clear(c)        do { map_abs(c); clear_bit(c, *bit); } while (0)
#define map_key_clear(c)        do { map_key(c); clear_bit(c, *bit); } while (0)

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

	switch (usage->hid & HID_USAGE) {
		case 0x03a: map_key_clear(KEY_SOUND);		break;
		case 0x03b: map_key_clear(KEY_CAMERA);		break;
		case 0x03c: map_key_clear(KEY_DOCUMENTS);	break;
		default:
			return 0;
	}
	return 1;
}

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

	switch (usage->hid & HID_USAGE) {
		case 0x301: map_key_clear(KEY_PROG1);		break;
		case 0x302: map_key_clear(KEY_PROG2);		break;
		case 0x303: map_key_clear(KEY_PROG3);		break;
		default:
			return 0;
	}
	return 1;
}

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

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

		default:
			return 0;
	}
	return 1;
}

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

	set_bit(EV_REP, input->evbit);
	switch(usage->hid & HID_USAGE) {
		/* Reported on Gyration MCE Remote */
		case 0x00d: map_key_clear(KEY_HOME);		break;
		case 0x024: map_key_clear(KEY_DVD);		break;
		case 0x025: map_key_clear(KEY_PVR);		break;
		case 0x046: map_key_clear(KEY_MEDIA);		break;
		case 0x047: map_key_clear(KEY_MP3);		break;
		case 0x049: map_key_clear(KEY_CAMERA);		break;
		case 0x04a: map_key_clear(KEY_VIDEO);		break;

		default:
			return 0;
	}
	return 1;
}

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

	set_bit(EV_REP, input->evbit);
	switch (usage->hid & HID_USAGE) {
		case 0xff01: map_key_clear(BTN_1);		break;
		case 0xff02: map_key_clear(BTN_2);		break;
		case 0xff03: map_key_clear(BTN_3);		break;
		case 0xff04: map_key_clear(BTN_4);		break;
		case 0xff05: map_key_clear(BTN_5);		break;
		case 0xff06: map_key_clear(BTN_6);		break;
		case 0xff07: map_key_clear(BTN_7);		break;
		case 0xff08: map_key_clear(BTN_8);		break;
		case 0xff09: map_key_clear(BTN_9);		break;
		case 0xff0a: map_key_clear(BTN_A);		break;
		case 0xff0b: map_key_clear(BTN_B);		break;
		default:
			return 0;
	}
	return 1;
}

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

	switch(usage->hid & HID_USAGE) {
		case 0xfd06: map_key_clear(KEY_CHAT);		break;
		case 0xfd07: map_key_clear(KEY_PHONE);		break;
		case 0xff05:
			set_bit(EV_REP, input->evbit);
			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);
		default:
			return 0;
	}
	return 1;
}

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

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

static int quirk_petalynx_remote(struct hid_usage *usage, struct input_dev *input,
			      unsigned long **bit, int *max)
{
	if (((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR) &&
			((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER))
		return 0;

	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_LOGIVENDOR)
		switch(usage->hid & HID_USAGE) {
			case 0x05a: map_key_clear(KEY_TEXT);		break;
			case 0x05b: map_key_clear(KEY_RED);		break;
			case 0x05c: map_key_clear(KEY_GREEN);		break;
			case 0x05d: map_key_clear(KEY_YELLOW);		break;
			case 0x05e: map_key_clear(KEY_BLUE);		break;
			default:
				return 0;
		}

	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER)
		switch(usage->hid & HID_USAGE) {
			case 0x0f6: map_key_clear(KEY_NEXT);            break;
			case 0x0fa: map_key_clear(KEY_BACK);            break;
			default:
				return 0;
		}
	return 1;
}

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

	switch (usage->hid & HID_USAGE) {
		case 0x1001: map_key_clear(KEY_MESSENGER);	break;
		case 0x1003: map_key_clear(KEY_SOUND);		break;
		case 0x1004: map_key_clear(KEY_VIDEO);		break;
		case 0x1005: map_key_clear(KEY_AUDIO);		break;
		case 0x100a: map_key_clear(KEY_DOCUMENTS);	break;
		case 0x1011: map_key_clear(KEY_PREVIOUSSONG);	break;
		case 0x1012: map_key_clear(KEY_NEXTSONG);	break;
		case 0x1013: map_key_clear(KEY_CAMERA);		break;
		case 0x1014: map_key_clear(KEY_MESSENGER);	break;
		case 0x1015: map_key_clear(KEY_RECORD);		break;
		case 0x1016: map_key_clear(KEY_PLAYER);		break;
		case 0x1017: map_key_clear(KEY_EJECTCD);	break;
		case 0x1018: map_key_clear(KEY_MEDIA);		break;
		case 0x1019: map_key_clear(KEY_PROG1);		break;
		case 0x101a: map_key_clear(KEY_PROG2);		break;
		case 0x101b: map_key_clear(KEY_PROG3);		break;
		case 0x101f: map_key_clear(KEY_ZOOMIN);		break;
		case 0x1020: map_key_clear(KEY_ZOOMOUT);	break;
		case 0x1021: map_key_clear(KEY_ZOOMRESET);	break;
		case 0x1023: map_key_clear(KEY_CLOSE);		break;
		case 0x1027: map_key_clear(KEY_MENU);		break;
		/* this one is marked as 'Rotate' */
		case 0x1028: map_key_clear(KEY_ANGLE);		break;
		case 0x1029: map_key_clear(KEY_SHUFFLE);	break;
		case 0x102a: map_key_clear(KEY_BACK);		break;
		case 0x102b: map_key_clear(KEY_CYCLEWINDOWS);	break;
		case 0x1041: map_key_clear(KEY_BATTERY);	break;
		case 0x1042: map_key_clear(KEY_WORDPROCESSOR);	break;
		case 0x1043: map_key_clear(KEY_SPREADSHEET);	break;
		case 0x1044: map_key_clear(KEY_PRESENTATION);	break;
		case 0x1045: map_key_clear(KEY_UNDO);		break;
		case 0x1046: map_key_clear(KEY_REDO);		break;
		case 0x1047: map_key_clear(KEY_PRINT);		break;
		case 0x1048: map_key_clear(KEY_SAVE);		break;
		case 0x1049: map_key_clear(KEY_PROG1);		break;
		case 0x104a: map_key_clear(KEY_PROG2);		break;
		case 0x104b: map_key_clear(KEY_PROG3);		break;
		case 0x104c: map_key_clear(KEY_PROG4);		break;

		default:
			return 0;
	}
	return 1;
}

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

	switch (usage->hid & HID_USAGE) {
		case 0x156: map_key_clear(KEY_WORDPROCESSOR);	break;
		case 0x157: map_key_clear(KEY_SPREADSHEET);	break;
		case 0x158: map_key_clear(KEY_PRESENTATION);	break;
		case 0x15c: map_key_clear(KEY_STOP);		break;

		default:
			return 0;
	}
	return 1;
}

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

	switch (usage->hid & HID_USAGE) {
		case 0x230: map_key(BTN_MOUSE);			break;
		case 0x231: map_rel(REL_WHEEL);			break;
		/* 
		 * this keyboard has a scrollwheel implemented in
		 * totally broken way. We map this usage temporarily
		 * to HWHEEL and handle it in the event quirk handler
		 */
		case 0x232: map_rel(REL_HWHEEL);		break;

		default:
			return 0;
	}
	return 1;
}

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

	switch (usage->hid & HID_USAGE) {
		case 0x2003: map_key_clear(KEY_ZOOMIN);		break;
		case 0x2103: map_key_clear(KEY_ZOOMOUT);	break;
		default:
			return 0;
	}
	return 1;
}

#define VENDOR_ID_BELKIN			0x1020
#define DEVICE_ID_BELKIN_WIRELESS_KEYBOARD	0x0006

#define VENDOR_ID_CHERRY			0x046a
#define DEVICE_ID_CHERRY_CYMOTION		0x0023

#define VENDOR_ID_CHICONY			0x04f2
#define DEVICE_ID_CHICONY_TACTICAL_PAD		0x0418

#define VENDOR_ID_EZKEY				0x0518
#define DEVICE_ID_BTC_8193			0x0002

#define VENDOR_ID_GYRATION			0x0c16
#define DEVICE_ID_GYRATION_REMOTE		0x0002

#define VENDOR_ID_LOGITECH			0x046d
#define DEVICE_ID_LOGITECH_RECEIVER		0xc101
#define DEVICE_ID_S510_RECEIVER			0xc50c
#define DEVICE_ID_S510_RECEIVER_2		0xc517
#define DEVICE_ID_MX3000_RECEIVER		0xc513

#define VENDOR_ID_MICROSOFT			0x045e
#define DEVICE_ID_MS4K				0x00db
#define DEVICE_ID_MS6K				0x00f9
#define DEVICE_IS_MS_PRESENTER_8K_BT		0x0701
#define DEVICE_ID_MS_PRESENTER_8K_USB		0x0713

#define VENDOR_ID_MONTEREY			0x0566
#define DEVICE_ID_GENIUS_KB29E			0x3004

#define VENDOR_ID_PETALYNX			0x18b1
#define DEVICE_ID_PETALYNX_MAXTER_REMOTE	0x0037

#define VENDOR_ID_SUNPLUS			0x04fc
#define DEVICE_ID_SUNPLUS_WDESKTOP		0x05d8

static const struct hid_input_blacklist {
	__u16 idVendor;
	__u16 idProduct;
	int (*quirk)(struct hid_usage *, struct input_dev *, unsigned long **, int *);
} hid_input_blacklist[] = {
	{ VENDOR_ID_BELKIN, DEVICE_ID_BELKIN_WIRELESS_KEYBOARD, quirk_belkin_wkbd },

	{ VENDOR_ID_CHERRY, DEVICE_ID_CHERRY_CYMOTION, quirk_cherry_cymotion },

	{ VENDOR_ID_CHICONY, DEVICE_ID_CHICONY_TACTICAL_PAD, quirk_chicony_tactical_pad },

	{ VENDOR_ID_EZKEY, DEVICE_ID_BTC_8193, quirk_btc_8193 },

	{ VENDOR_ID_GYRATION, DEVICE_ID_GYRATION_REMOTE, quirk_gyration_remote },

	{ VENDOR_ID_LOGITECH, DEVICE_ID_LOGITECH_RECEIVER, quirk_logitech_ultrax_remote },
	{ VENDOR_ID_LOGITECH, DEVICE_ID_S510_RECEIVER, quirk_logitech_wireless },
	{ VENDOR_ID_LOGITECH, DEVICE_ID_S510_RECEIVER_2, quirk_logitech_wireless },
	{ VENDOR_ID_LOGITECH, DEVICE_ID_MX3000_RECEIVER, quirk_logitech_wireless },

	{ VENDOR_ID_MICROSOFT, DEVICE_ID_MS4K, quirk_microsoft_ergonomy_kb },
	{ VENDOR_ID_MICROSOFT, DEVICE_ID_MS6K, quirk_microsoft_ergonomy_kb },
	{ VENDOR_ID_MICROSOFT, DEVICE_IS_MS_PRESENTER_8K_BT, quirk_microsoft_presenter_8k },
	{ VENDOR_ID_MICROSOFT, DEVICE_ID_MS_PRESENTER_8K_USB, quirk_microsoft_presenter_8k },

	{ VENDOR_ID_MONTEREY, DEVICE_ID_GENIUS_KB29E, quirk_cherry_genius_29e },

	{ VENDOR_ID_PETALYNX, DEVICE_ID_PETALYNX_MAXTER_REMOTE, quirk_petalynx_remote },

	{ VENDOR_ID_SUNPLUS, DEVICE_ID_SUNPLUS_WDESKTOP, quirk_sunplus_wdesktop },

	{ 0, 0, NULL }
};

int hidinput_mapping_quirks(struct hid_usage *usage, 
				   struct input_dev *input, 
				   unsigned long **bit, int *max)
{
	struct hid_device *device = input_get_drvdata(input);
	int i = 0;
	
	while (hid_input_blacklist[i].quirk) {
		if (hid_input_blacklist[i].idVendor == device->vendor &&
				hid_input_blacklist[i].idProduct == device->product)
			return hid_input_blacklist[i].quirk(usage, input, bit, max);
		i++;
	}
	return 0;
}

int hidinput_event_quirks(struct hid_device *hid, struct hid_field *field, struct hid_usage *usage, __s32 value)
{
	struct input_dev *input;

	input = field->hidinput->input;

	if (((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_5) && (usage->hid == 0x00090005))
		|| ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_7) && (usage->hid == 0x00090007))) {
		if (value) hid->quirks |=  HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
		else       hid->quirks &= ~HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
		return 1;
	}

	if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_B8) &&
			(usage->type == EV_REL) &&
			(usage->code == REL_WHEEL)) {
		hid->delayed_value = value;
		return 1;
	}

	if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_B8) &&
			(usage->hid == 0x000100b8)) {
		input_event(input, EV_REL, value ? REL_HWHEEL : REL_WHEEL, hid->delayed_value);
		return 1;
	}

	if ((hid->quirks & HID_QUIRK_INVERT_HWHEEL) && (usage->code == REL_HWHEEL)) {
		input_event(input, usage->type, usage->code, -value);
		return 1;
	}

	if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_ON) && (usage->code == REL_WHEEL)) {
		input_event(input, usage->type, REL_HWHEEL, value);
		return 1;
	}

	if ((hid->quirks & HID_QUIRK_APPLE_HAS_FN) && hidinput_apple_event(hid, input, usage, value))
		return 1;

	/* Handling MS keyboards special buttons */
	if (hid->quirks & HID_QUIRK_MICROSOFT_KEYS && 
			usage->hid == (HID_UP_MSVENDOR | 0xff05)) {
		int key = 0;
		static int last_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;
			default: break;
		}
		if (key) {
			input_event(input, usage->type, key, 1);
			last_key = key;
		} else {
			input_event(input, usage->type, last_key, 0);
		}
	}

	/* handle the temporary quirky mapping to HWHEEL */
	if (hid->quirks & HID_QUIRK_HWHEEL_WHEEL_INVERT &&
			usage->type == EV_REL && usage->code == REL_HWHEEL) {
		input_event(input, usage->type, REL_WHEEL, -value);
		return 1;
	}

	/* Gyration MCE remote "Sleep" key */
	if (hid->vendor == VENDOR_ID_GYRATION &&
	    hid->product == DEVICE_ID_GYRATION_REMOTE &&
	    (usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK &&
	    (usage->hid & 0xff) == 0x82) {
		input_event(input, usage->type, usage->code, 1);
		input_sync(input);
		input_event(input, usage->type, usage->code, 0);
		input_sync(input);
		return 1;
	}
	return 0;
}
Commit	Line	Data
10bd065f JK	1	/*
	2	* HID-input usage mapping quirks
	3	*
	4	* This is used to handle HID-input mappings for devices violating
	5	* HUT 1.12 specification.
	6	*
85c985f4	7	* Copyright (c) 2007-2008 Jiri Kosina
10bd065f JK	8	*/
	9
	10	/*
	11	* This program is free software; you can redistribute it and/or modify it
	12	* under the terms of the GNU General Public License as published by the Free
	13	* Software Foundation; either version 2 of the License
	14	*/
	15
	16	#include <linux/input.h>
	17	#include <linux/hid.h>
	18
70d215c4 FW	19	#define map_abs(c) do { usage->code = c; usage->type = EV_ABS; bit = input->absbit; max = ABS_MAX; } while (0)
	20	#define map_rel(c) do { usage->code = c; usage->type = EV_REL; bit = input->relbit; max = REL_MAX; } while (0)
	21	#define map_key(c) do { usage->code = c; usage->type = EV_KEY; bit = input->keybit; max = KEY_MAX; } while (0)
	22	#define map_led(c) do { usage->code = c; usage->type = EV_LED; bit = input->ledbit; max = LED_MAX; } while (0)
10bd065f	23
70d215c4 FW	24	#define map_abs_clear(c) do { map_abs(c); clear_bit(c, *bit); } while (0)
70d215c4 FW	25	#define map_key_clear(c) do { map_key(c); clear_bit(c, *bit); } while (0)
10bd065f JK	26
10bd065f JK	27	static int quirk_belkin_wkbd(struct hid_usage usage, struct input_dev input,
70d215c4	28	unsigned long *bit, int max)
10bd065f JK	29	{
	30	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
	31	return 0;
	32
	33	switch (usage->hid & HID_USAGE) {
	34	case 0x03a: map_key_clear(KEY_SOUND); break;
	35	case 0x03b: map_key_clear(KEY_CAMERA); break;
	36	case 0x03c: map_key_clear(KEY_DOCUMENTS); break;
	37	default:
	38	return 0;
	39	}
	40	return 1;
	41	}
	42
	43	static int quirk_cherry_cymotion(struct hid_usage usage, struct input_dev input,
70d215c4	44	unsigned long *bit, int max)
10bd065f JK	45	{
	46	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
	47	return 0;
	48
	49	switch (usage->hid & HID_USAGE) {
	50	case 0x301: map_key_clear(KEY_PROG1); break;
	51	case 0x302: map_key_clear(KEY_PROG2); break;
	52	case 0x303: map_key_clear(KEY_PROG3); break;
	53	default:
	54	return 0;
	55	}
	56	return 1;
	57	}
	58
	59	static int quirk_logitech_ultrax_remote(struct hid_usage usage, struct input_dev input,
70d215c4	60	unsigned long *bit, int max)
10bd065f JK	61	{
	62	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
	63	return 0;
	64
	65	set_bit(EV_REP, input->evbit);
	66	switch(usage->hid & HID_USAGE) {
	67	/* Reported on Logitech Ultra X Media Remote */
	68	case 0x004: map_key_clear(KEY_AGAIN); break;
	69	case 0x00d: map_key_clear(KEY_HOME); break;
	70	case 0x024: map_key_clear(KEY_SHUFFLE); break;
	71	case 0x025: map_key_clear(KEY_TV); break;
	72	case 0x026: map_key_clear(KEY_MENU); break;
	73	case 0x031: map_key_clear(KEY_AUDIO); break;
	74	case 0x032: map_key_clear(KEY_TEXT); break;
	75	case 0x033: map_key_clear(KEY_LAST); break;
	76	case 0x047: map_key_clear(KEY_MP3); break;
	77	case 0x048: map_key_clear(KEY_DVD); break;
	78	case 0x049: map_key_clear(KEY_MEDIA); break;
	79	case 0x04a: map_key_clear(KEY_VIDEO); break;
	80	case 0x04b: map_key_clear(KEY_ANGLE); break;
	81	case 0x04c: map_key_clear(KEY_LANGUAGE); break;
	82	case 0x04d: map_key_clear(KEY_SUBTITLE); break;
	83	case 0x051: map_key_clear(KEY_RED); break;
	84	case 0x052: map_key_clear(KEY_CLOSE); break;
	85
	86	default:
	87	return 0;
	88	}
	89	return 1;
	90	}
	91
a7f32697 DW	92	static int quirk_gyration_remote(struct hid_usage usage, struct input_dev input,
	93	unsigned long *bit, int max)
	94	{
	95	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR)
	96	return 0;
	97
	98	set_bit(EV_REP, input->evbit);
	99	switch(usage->hid & HID_USAGE) {
	100	/* Reported on Gyration MCE Remote */
	101	case 0x00d: map_key_clear(KEY_HOME); break;
	102	case 0x024: map_key_clear(KEY_DVD); break;
	103	case 0x025: map_key_clear(KEY_PVR); break;
	104	case 0x046: map_key_clear(KEY_MEDIA); break;
	105	case 0x047: map_key_clear(KEY_MP3); break;
	106	case 0x049: map_key_clear(KEY_CAMERA); break;
	107	case 0x04a: map_key_clear(KEY_VIDEO); break;
	108
	109	default:
	110	return 0;
	111	}
	112	return 1;
	113	}
	114
10bd065f	115	static int quirk_chicony_tactical_pad(struct hid_usage usage, struct input_dev input,
70d215c4	116	unsigned long *bit, int max)
10bd065f JK	117	{
	118	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
	119	return 0;
	120
	121	set_bit(EV_REP, input->evbit);
	122	switch (usage->hid & HID_USAGE) {
	123	case 0xff01: map_key_clear(BTN_1); break;
	124	case 0xff02: map_key_clear(BTN_2); break;
	125	case 0xff03: map_key_clear(BTN_3); break;
	126	case 0xff04: map_key_clear(BTN_4); break;
	127	case 0xff05: map_key_clear(BTN_5); break;
	128	case 0xff06: map_key_clear(BTN_6); break;
	129	case 0xff07: map_key_clear(BTN_7); break;
	130	case 0xff08: map_key_clear(BTN_8); break;
	131	case 0xff09: map_key_clear(BTN_9); break;
	132	case 0xff0a: map_key_clear(BTN_A); break;
	133	case 0xff0b: map_key_clear(BTN_B); break;
	134	default:
	135	return 0;
	136	}
	137	return 1;
	138	}
	139
	140	static int quirk_microsoft_ergonomy_kb(struct hid_usage usage, struct input_dev input,
70d215c4	141	unsigned long *bit, int max)
10bd065f JK	142	{
	143	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
	144	return 0;
	145
	146	switch(usage->hid & HID_USAGE) {
	147	case 0xfd06: map_key_clear(KEY_CHAT); break;
	148	case 0xfd07: map_key_clear(KEY_PHONE); break;
	149	case 0xff05:
	150	set_bit(EV_REP, input->evbit);
	151	map_key_clear(KEY_F13);
	152	set_bit(KEY_F14, input->keybit);
	153	set_bit(KEY_F15, input->keybit);
	154	set_bit(KEY_F16, input->keybit);
	155	set_bit(KEY_F17, input->keybit);
	156	set_bit(KEY_F18, input->keybit);
	157	default:
	158	return 0;
	159	}
	160	return 1;
	161	}
	162
	163	static int quirk_microsoft_presenter_8k(struct hid_usage usage, struct input_dev input,
70d215c4	164	unsigned long *bit, int max)
10bd065f JK	165	{
	166	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_MSVENDOR)
	167	return 0;
	168
	169	set_bit(EV_REP, input->evbit);
	170	switch(usage->hid & HID_USAGE) {
d7d32c81 JK	171	case 0xfd08: map_key_clear(KEY_FORWARD); break;
	172	case 0xfd09: map_key_clear(KEY_BACK); break;
	173	case 0xfd0b: map_key_clear(KEY_PLAYPAUSE); break;
	174	case 0xfd0e: map_key_clear(KEY_CLOSE); break;
	175	case 0xfd0f: map_key_clear(KEY_PLAY); break;
10bd065f JK	176	default:
	177	return 0;
	178	}
	179	return 1;
	180	}
	181
	182	static int quirk_petalynx_remote(struct hid_usage usage, struct input_dev input,
70d215c4	183	unsigned long *bit, int max)
10bd065f JK	184	{
	185	if (((usage->hid & HID_USAGE_PAGE) != HID_UP_LOGIVENDOR) &&
	186	((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER))
	187	return 0;
	188
	189	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_LOGIVENDOR)
	190	switch(usage->hid & HID_USAGE) {
	191	case 0x05a: map_key_clear(KEY_TEXT); break;
	192	case 0x05b: map_key_clear(KEY_RED); break;
	193	case 0x05c: map_key_clear(KEY_GREEN); break;
	194	case 0x05d: map_key_clear(KEY_YELLOW); break;
	195	case 0x05e: map_key_clear(KEY_BLUE); break;
	196	default:
	197	return 0;
	198	}
	199
	200	if ((usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER)
	201	switch(usage->hid & HID_USAGE) {
	202	case 0x0f6: map_key_clear(KEY_NEXT); break;
	203	case 0x0fa: map_key_clear(KEY_BACK); break;
	204	default:
	205	return 0;
	206	}
	207	return 1;
	208	}
	209
	210	static int quirk_logitech_wireless(struct hid_usage usage, struct input_dev input,
70d215c4	211	unsigned long *bit, int max)
10bd065f JK	212	{
	213	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
	214	return 0;
	215
	216	switch (usage->hid & HID_USAGE) {
	217	case 0x1001: map_key_clear(KEY_MESSENGER); break;
	218	case 0x1003: map_key_clear(KEY_SOUND); break;
	219	case 0x1004: map_key_clear(KEY_VIDEO); break;
	220	case 0x1005: map_key_clear(KEY_AUDIO); break;
	221	case 0x100a: map_key_clear(KEY_DOCUMENTS); break;
	222	case 0x1011: map_key_clear(KEY_PREVIOUSSONG); break;
	223	case 0x1012: map_key_clear(KEY_NEXTSONG); break;
	224	case 0x1013: map_key_clear(KEY_CAMERA); break;
	225	case 0x1014: map_key_clear(KEY_MESSENGER); break;
	226	case 0x1015: map_key_clear(KEY_RECORD); break;
	227	case 0x1016: map_key_clear(KEY_PLAYER); break;
	228	case 0x1017: map_key_clear(KEY_EJECTCD); break;
	229	case 0x1018: map_key_clear(KEY_MEDIA); break;
	230	case 0x1019: map_key_clear(KEY_PROG1); break;
	231	case 0x101a: map_key_clear(KEY_PROG2); break;
	232	case 0x101b: map_key_clear(KEY_PROG3); break;
	233	case 0x101f: map_key_clear(KEY_ZOOMIN); break;
	234	case 0x1020: map_key_clear(KEY_ZOOMOUT); break;
	235	case 0x1021: map_key_clear(KEY_ZOOMRESET); break;
	236	case 0x1023: map_key_clear(KEY_CLOSE); break;
	237	case 0x1027: map_key_clear(KEY_MENU); break;
	238	/* this one is marked as 'Rotate' */
	239	case 0x1028: map_key_clear(KEY_ANGLE); break;
	240	case 0x1029: map_key_clear(KEY_SHUFFLE); break;
	241	case 0x102a: map_key_clear(KEY_BACK); break;
	242	case 0x102b: map_key_clear(KEY_CYCLEWINDOWS); break;
	243	case 0x1041: map_key_clear(KEY_BATTERY); break;
	244	case 0x1042: map_key_clear(KEY_WORDPROCESSOR); break;
	245	case 0x1043: map_key_clear(KEY_SPREADSHEET); break;
	246	case 0x1044: map_key_clear(KEY_PRESENTATION); break;
	247	case 0x1045: map_key_clear(KEY_UNDO); break;
	248	case 0x1046: map_key_clear(KEY_REDO); break;
	249	case 0x1047: map_key_clear(KEY_PRINT); break;
	250	case 0x1048: map_key_clear(KEY_SAVE); break;
	251	case 0x1049: map_key_clear(KEY_PROG1); break;
	252	case 0x104a: map_key_clear(KEY_PROG2); break;
	253	case 0x104b: map_key_clear(KEY_PROG3); break;
	254	case 0x104c: map_key_clear(KEY_PROG4); break;
	255
	256	default:
	257	return 0;
	258	}
	259	return 1;
	260	}
	261
	262	static int quirk_cherry_genius_29e(struct hid_usage usage, struct input_dev input,
70d215c4	263	unsigned long *bit, int max)
10bd065f JK	264	{
	265	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
	266	return 0;
	267
	268	switch (usage->hid & HID_USAGE) {
	269	case 0x156: map_key_clear(KEY_WORDPROCESSOR); break;
	270	case 0x157: map_key_clear(KEY_SPREADSHEET); break;
	271	case 0x158: map_key_clear(KEY_PRESENTATION); break;
	272	case 0x15c: map_key_clear(KEY_STOP); break;
	273
	274	default:
	275	return 0;
	276	}
	277	return 1;
	278	}
	279
36ccaad6	280	static int quirk_btc_8193(struct hid_usage usage, struct input_dev input,
70d215c4	281	unsigned long *bit, int max)
36ccaad6 JK	282	{
	283	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
	284	return 0;
	285
	286	switch (usage->hid & HID_USAGE) {
	287	case 0x230: map_key(BTN_MOUSE); break;
	288	case 0x231: map_rel(REL_WHEEL); break;
	289	/*
	290	* this keyboard has a scrollwheel implemented in
	291	* totally broken way. We map this usage temporarily
	292	* to HWHEEL and handle it in the event quirk handler
	293	*/
	294	case 0x232: map_rel(REL_HWHEEL); break;
	295
	296	default:
	297	return 0;
	298	}
	299	return 1;
	300	}
10bd065f	301
5f1ab74f JK	302	static int quirk_sunplus_wdesktop(struct hid_usage usage, struct input_dev input,
	303	unsigned long *bit, int max)
	304	{
	305	if ((usage->hid & HID_USAGE_PAGE) != HID_UP_CONSUMER)
	306	return 0;
	307
	308	switch (usage->hid & HID_USAGE) {
	309	case 0x2003: map_key_clear(KEY_ZOOMIN); break;
	310	case 0x2103: map_key_clear(KEY_ZOOMOUT); break;
	311	default:
	312	return 0;
	313	}
	314	return 1;
	315	}
	316
10bd065f JK	317	#define VENDOR_ID_BELKIN 0x1020
	318	#define DEVICE_ID_BELKIN_WIRELESS_KEYBOARD 0x0006
	319
	320	#define VENDOR_ID_CHERRY 0x046a
	321	#define DEVICE_ID_CHERRY_CYMOTION 0x0023
	322
	323	#define VENDOR_ID_CHICONY 0x04f2
	324	#define DEVICE_ID_CHICONY_TACTICAL_PAD 0x0418
	325
36ccaad6 JK	326	#define VENDOR_ID_EZKEY 0x0518
	327	#define DEVICE_ID_BTC_8193 0x0002
	328
a7f32697 DW	329	#define VENDOR_ID_GYRATION 0x0c16
	330	#define DEVICE_ID_GYRATION_REMOTE 0x0002
	331
10bd065f JK	332	#define VENDOR_ID_LOGITECH 0x046d
	333	#define DEVICE_ID_LOGITECH_RECEIVER 0xc101
	334	#define DEVICE_ID_S510_RECEIVER 0xc50c
	335	#define DEVICE_ID_S510_RECEIVER_2 0xc517
	336	#define DEVICE_ID_MX3000_RECEIVER 0xc513
	337
	338	#define VENDOR_ID_MICROSOFT 0x045e
	339	#define DEVICE_ID_MS4K 0x00db
	340	#define DEVICE_ID_MS6K 0x00f9
85c985f4 JK	341	#define DEVICE_IS_MS_PRESENTER_8K_BT 0x0701
85c985f4 JK	342	#define DEVICE_ID_MS_PRESENTER_8K_USB 0x0713
10bd065f JK	343
	344	#define VENDOR_ID_MONTEREY 0x0566
	345	#define DEVICE_ID_GENIUS_KB29E 0x3004
	346
	347	#define VENDOR_ID_PETALYNX 0x18b1
	348	#define DEVICE_ID_PETALYNX_MAXTER_REMOTE 0x0037
	349
5f1ab74f JK	350	#define VENDOR_ID_SUNPLUS 0x04fc
	351	#define DEVICE_ID_SUNPLUS_WDESKTOP 0x05d8
	352
10bd065f JK	353	static const struct hid_input_blacklist {
	354	__u16 idVendor;
	355	__u16 idProduct;
70d215c4	356	int (quirk)(struct hid_usage , struct input_dev , unsigned long , int );
10bd065f JK	357	} hid_input_blacklist[] = {
	358	{ VENDOR_ID_BELKIN, DEVICE_ID_BELKIN_WIRELESS_KEYBOARD, quirk_belkin_wkbd },
	359
	360	{ VENDOR_ID_CHERRY, DEVICE_ID_CHERRY_CYMOTION, quirk_cherry_cymotion },
	361
	362	{ VENDOR_ID_CHICONY, DEVICE_ID_CHICONY_TACTICAL_PAD, quirk_chicony_tactical_pad },
	363
36ccaad6 JK	364	{ VENDOR_ID_EZKEY, DEVICE_ID_BTC_8193, quirk_btc_8193 },
36ccaad6 JK	365
a7f32697 DW	366	{ VENDOR_ID_GYRATION, DEVICE_ID_GYRATION_REMOTE, quirk_gyration_remote },
a7f32697 DW	367
10bd065f JK	368	{ VENDOR_ID_LOGITECH, DEVICE_ID_LOGITECH_RECEIVER, quirk_logitech_ultrax_remote },
	369	{ VENDOR_ID_LOGITECH, DEVICE_ID_S510_RECEIVER, quirk_logitech_wireless },
	370	{ VENDOR_ID_LOGITECH, DEVICE_ID_S510_RECEIVER_2, quirk_logitech_wireless },
	371	{ VENDOR_ID_LOGITECH, DEVICE_ID_MX3000_RECEIVER, quirk_logitech_wireless },
	372
	373	{ VENDOR_ID_MICROSOFT, DEVICE_ID_MS4K, quirk_microsoft_ergonomy_kb },
	374	{ VENDOR_ID_MICROSOFT, DEVICE_ID_MS6K, quirk_microsoft_ergonomy_kb },
85c985f4 JK	375	{ VENDOR_ID_MICROSOFT, DEVICE_IS_MS_PRESENTER_8K_BT, quirk_microsoft_presenter_8k },
85c985f4 JK	376	{ VENDOR_ID_MICROSOFT, DEVICE_ID_MS_PRESENTER_8K_USB, quirk_microsoft_presenter_8k },
10bd065f JK	377
	378	{ VENDOR_ID_MONTEREY, DEVICE_ID_GENIUS_KB29E, quirk_cherry_genius_29e },
	379
	380	{ VENDOR_ID_PETALYNX, DEVICE_ID_PETALYNX_MAXTER_REMOTE, quirk_petalynx_remote },
5f1ab74f JK	381
	382	{ VENDOR_ID_SUNPLUS, DEVICE_ID_SUNPLUS_WDESKTOP, quirk_sunplus_wdesktop },
	383
282bfd4c	384	{ 0, 0, NULL }
10bd065f JK	385	};
	386
	387	int hidinput_mapping_quirks(struct hid_usage *usage,
	388	struct input_dev *input,
70d215c4	389	unsigned long *bit, int max)
10bd065f JK	390	{
	391	struct hid_device *device = input_get_drvdata(input);
	392	int i = 0;
	393
	394	while (hid_input_blacklist[i].quirk) {
	395	if (hid_input_blacklist[i].idVendor == device->vendor &&
	396	hid_input_blacklist[i].idProduct == device->product)
	397	return hid_input_blacklist[i].quirk(usage, input, bit, max);
	398	i++;
	399	}
	400	return 0;
	401	}
87bc2aa9	402
68a1f2cc	403	int hidinput_event_quirks(struct hid_device hid, struct hid_field field, struct hid_usage *usage, __s32 value)
87bc2aa9 JK	404	{
87bc2aa9 JK	405	struct input_dev *input;
87bc2aa9 JK	406
	407	input = field->hidinput->input;
	408
	409	if (((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_5) && (usage->hid == 0x00090005))
	410	\|\| ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_7) && (usage->hid == 0x00090007))) {
	411	if (value) hid->quirks \|= HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
	412	else hid->quirks &= ~HID_QUIRK_2WHEEL_MOUSE_HACK_ON;
68a1f2cc	413	return 1;
87bc2aa9 JK	414	}
	415
	416	if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_B8) &&
	417	(usage->type == EV_REL) &&
	418	(usage->code == REL_WHEEL)) {
	419	hid->delayed_value = value;
68a1f2cc	420	return 1;
87bc2aa9 JK	421	}
	422
	423	if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_B8) &&
	424	(usage->hid == 0x000100b8)) {
	425	input_event(input, EV_REL, value ? REL_HWHEEL : REL_WHEEL, hid->delayed_value);
68a1f2cc	426	return 1;
87bc2aa9 JK	427	}
	428
	429	if ((hid->quirks & HID_QUIRK_INVERT_HWHEEL) && (usage->code == REL_HWHEEL)) {
	430	input_event(input, usage->type, usage->code, -value);
68a1f2cc	431	return 1;
87bc2aa9 JK	432	}
	433
	434	if ((hid->quirks & HID_QUIRK_2WHEEL_MOUSE_HACK_ON) && (usage->code == REL_WHEEL)) {
	435	input_event(input, usage->type, REL_HWHEEL, value);
68a1f2cc	436	return 1;
87bc2aa9 JK	437	}
	438
	439	if ((hid->quirks & HID_QUIRK_APPLE_HAS_FN) && hidinput_apple_event(hid, input, usage, value))
68a1f2cc	440	return 1;
87bc2aa9 JK	441
87bc2aa9 JK	442	/* Handling MS keyboards special buttons */
628edcde JK	443	if (hid->quirks & HID_QUIRK_MICROSOFT_KEYS &&
628edcde JK	444	usage->hid == (HID_UP_MSVENDOR \| 0xff05)) {
87bc2aa9 JK	445	int key = 0;
	446	static int last_key = 0;
	447	switch (value) {
	448	case 0x01: key = KEY_F14; break;
	449	case 0x02: key = KEY_F15; break;
	450	case 0x04: key = KEY_F16; break;
	451	case 0x08: key = KEY_F17; break;
	452	case 0x10: key = KEY_F18; break;
	453	default: break;
	454	}
	455	if (key) {
	456	input_event(input, usage->type, key, 1);
	457	last_key = key;
	458	} else {
	459	input_event(input, usage->type, last_key, 0);
	460	}
	461	}
36ccaad6 JK	462
	463	/* handle the temporary quirky mapping to HWHEEL */
	464	if (hid->quirks & HID_QUIRK_HWHEEL_WHEEL_INVERT &&
	465	usage->type == EV_REL && usage->code == REL_HWHEEL) {
	466	input_event(input, usage->type, REL_WHEEL, -value);
68a1f2cc	467	return 1;
36ccaad6	468	}
32146dc9 JK	469
	470	/* Gyration MCE remote "Sleep" key */
	471	if (hid->vendor == VENDOR_ID_GYRATION &&
	472	hid->product == DEVICE_ID_GYRATION_REMOTE &&
	473	(usage->hid & HID_USAGE_PAGE) == HID_UP_GENDESK &&
	474	(usage->hid & 0xff) == 0x82) {
	475	input_event(input, usage->type, usage->code, 1);
	476	input_sync(input);
	477	input_event(input, usage->type, usage->code, 0);
	478	input_sync(input);
	479	return 1;
	480	}
68a1f2cc	481	return 0;
87bc2aa9 JK	482	}
87bc2aa9 JK	483
10bd065f	484