[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / hid / hid-apple.c

/*
 *  USB HID quirks support for Linux
 *
 *  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) 2007 Paul Walmsley
 *  Copyright (c) 2008 Jiri Slaby <jirislaby@gmail.com>
 */

/*
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the Free
 * Software Foundation; either version 2 of the License, or (at your option)
 * any later version.
 */

#include <linux/device.h>
#include <linux/hid.h>
#include <linux/module.h>
#include <linux/usb.h>

#include "hid-ids.h"

#define APPLE_RDESC_JIS		0x0001
#define APPLE_IGNORE_MOUSE	0x0002
#define APPLE_HAS_FN		0x0004
#define APPLE_HIDDEV		0x0008
#define APPLE_ISO_KEYBOARD	0x0010
#define APPLE_MIGHTYMOUSE	0x0020
#define APPLE_INVERT_HWHEEL	0x0040
#define APPLE_IGNORE_HIDINPUT	0x0080
#define APPLE_NUMLOCK_EMULATION	0x0100

#define APPLE_FLAG_FKEY		0x01

static unsigned int fnmode = 1;
module_param(fnmode, uint, 0644);
MODULE_PARM_DESC(fnmode, "Mode of fn key on Apple keyboards (0 = disabled, "
		"[1] = fkeyslast, 2 = fkeysfirst)");

struct apple_sc {
	unsigned long quirks;
	unsigned int fn_on;
	DECLARE_BITMAP(pressed_fn, KEY_CNT);
	DECLARE_BITMAP(pressed_numlock, KEY_CNT);
};

struct apple_key_translation {
	u16 from;
	u16 to;
	u8 flags;
};

static struct apple_key_translation apple_fn_keys[] = {
	{ KEY_BACKSPACE, KEY_DELETE },
	{ KEY_F1,	KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
	{ KEY_F2,	KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
	{ KEY_F3,	KEY_FN_F5,          APPLE_FLAG_FKEY }, /* Exposé */
	{ KEY_F4,	KEY_FN_F4,          APPLE_FLAG_FKEY }, /* Dashboard */
	{ KEY_F5,	KEY_KBDILLUMDOWN,   APPLE_FLAG_FKEY },
	{ KEY_F6,	KEY_KBDILLUMUP,     APPLE_FLAG_FKEY },
	{ KEY_F7,	KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
	{ KEY_F8,	KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
	{ KEY_F9,	KEY_NEXTSONG,       APPLE_FLAG_FKEY },
	{ KEY_F10,	KEY_MUTE,           APPLE_FLAG_FKEY },
	{ KEY_F11,	KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
	{ KEY_F12,	KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
	{ KEY_UP,	KEY_PAGEUP },
	{ KEY_DOWN,	KEY_PAGEDOWN },
	{ KEY_LEFT,	KEY_HOME },
	{ KEY_RIGHT,	KEY_END },
	{ }
};

static struct apple_key_translation powerbook_fn_keys[] = {
	{ KEY_BACKSPACE, KEY_DELETE },
	{ KEY_F1,	KEY_BRIGHTNESSDOWN,     APPLE_FLAG_FKEY },
	{ KEY_F2,	KEY_BRIGHTNESSUP,       APPLE_FLAG_FKEY },
	{ KEY_F3,	KEY_MUTE,               APPLE_FLAG_FKEY },
	{ KEY_F4,	KEY_VOLUMEDOWN,         APPLE_FLAG_FKEY },
	{ KEY_F5,	KEY_VOLUMEUP,           APPLE_FLAG_FKEY },
	{ KEY_F6,	KEY_NUMLOCK,            APPLE_FLAG_FKEY },
	{ KEY_F7,	KEY_SWITCHVIDEOMODE,    APPLE_FLAG_FKEY },
	{ KEY_F8,	KEY_KBDILLUMTOGGLE,     APPLE_FLAG_FKEY },
	{ KEY_F9,	KEY_KBDILLUMDOWN,       APPLE_FLAG_FKEY },
	{ KEY_F10,	KEY_KBDILLUMUP,         APPLE_FLAG_FKEY },
	{ KEY_UP,	KEY_PAGEUP },
	{ KEY_DOWN,	KEY_PAGEDOWN },
	{ KEY_LEFT,	KEY_HOME },
	{ KEY_RIGHT,	KEY_END },
	{ }
};

static struct apple_key_translation powerbook_numlock_keys[] = {
	{ KEY_J,	KEY_KP1 },
	{ KEY_K,	KEY_KP2 },
	{ KEY_L,	KEY_KP3 },
	{ KEY_U,	KEY_KP4 },
	{ KEY_I,	KEY_KP5 },
	{ KEY_O,	KEY_KP6 },
	{ KEY_7,	KEY_KP7 },
	{ KEY_8,	KEY_KP8 },
	{ KEY_9,	KEY_KP9 },
	{ KEY_M,	KEY_KP0 },
	{ KEY_DOT,	KEY_KPDOT },
	{ KEY_SLASH,	KEY_KPPLUS },
	{ KEY_SEMICOLON, KEY_KPMINUS },
	{ KEY_P,	KEY_KPASTERISK },
	{ KEY_MINUS,	KEY_KPEQUAL },
	{ KEY_0,	KEY_KPSLASH },
	{ KEY_F6,	KEY_NUMLOCK },
	{ KEY_KPENTER,	KEY_KPENTER },
	{ KEY_BACKSPACE, KEY_BACKSPACE },
	{ }
};

static struct apple_key_translation apple_iso_keyboard[] = {
	{ KEY_GRAVE,	KEY_102ND },
	{ KEY_102ND,	KEY_GRAVE },
	{ }
};

static struct apple_key_translation *apple_find_translation(
		struct apple_key_translation *table, u16 from)
{
	struct apple_key_translation *trans;

	/* Look for the translation */
	for (trans = table; trans->from; trans++)
		if (trans->from == from)
			return trans;

	return NULL;
}

static int hidinput_apple_event(struct hid_device *hid, struct input_dev *input,
		struct hid_usage *usage, __s32 value)
{
	struct apple_sc *asc = hid_get_drvdata(hid);
	struct apple_key_translation *trans;

	if (usage->code == KEY_FN) {
		asc->fn_on = !!value;
		input_event(input, usage->type, usage->code, value);
		return 1;
	}

	if (fnmode) {
		int do_translate;

		trans = apple_find_translation((hid->product < 0x220 ||
					hid->product >= 0x300) ?
					powerbook_fn_keys : apple_fn_keys,
					usage->code);
		if (trans) {
			if (test_bit(usage->code, asc->pressed_fn))
				do_translate = 1;
			else if (trans->flags & APPLE_FLAG_FKEY)
				do_translate = (fnmode == 2 && asc->fn_on) ||
					(fnmode == 1 && !asc->fn_on);
			else
				do_translate = asc->fn_on;

			if (do_translate) {
				if (value)
					set_bit(usage->code, asc->pressed_fn);
				else
					clear_bit(usage->code, asc->pressed_fn);

				input_event(input, usage->type, trans->to,
						value);

				return 1;
			}
		}

		if (asc->quirks & APPLE_NUMLOCK_EMULATION &&
				(test_bit(usage->code, asc->pressed_numlock) ||
				test_bit(LED_NUML, input->led))) {
			trans = apple_find_translation(powerbook_numlock_keys,
					usage->code);

			if (trans) {
				if (value)
					set_bit(usage->code,
							asc->pressed_numlock);
				else
					clear_bit(usage->code,
							asc->pressed_numlock);

				input_event(input, usage->type, trans->to,
						value);
			}

			return 1;
		}
	}

	if (asc->quirks & APPLE_ISO_KEYBOARD) {
		trans = apple_find_translation(apple_iso_keyboard, usage->code);
		if (trans) {
			input_event(input, usage->type, trans->to, value);
			return 1;
		}
	}

	return 0;
}

static int apple_event(struct hid_device *hdev, struct hid_field *field,
		struct hid_usage *usage, __s32 value)
{
	struct apple_sc *asc = hid_get_drvdata(hdev);

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

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

	if ((asc->quirks & APPLE_HAS_FN) &&
			hidinput_apple_event(hdev, field->hidinput->input,
				usage, value))
		return 1;


	return 0;
}

/*
 * MacBook JIS keyboard has wrong logical maximum
 */
static void apple_report_fixup(struct hid_device *hdev, __u8 *rdesc,
		unsigned int rsize)
{
	struct apple_sc *asc = hid_get_drvdata(hdev);

	if ((asc->quirks & APPLE_RDESC_JIS) && rsize >= 60 &&
			rdesc[53] == 0x65 && rdesc[59] == 0x65) {
		dev_info(&hdev->dev, "fixing up MacBook JIS keyboard report "
				"descriptor\n");
		rdesc[53] = rdesc[59] = 0xe7;
	}
}

static void apple_setup_input(struct input_dev *input)
{
	struct apple_key_translation *trans;

	set_bit(KEY_NUMLOCK, input->keybit);

	/* Enable all needed keys */
	for (trans = apple_fn_keys; trans->from; trans++)
		set_bit(trans->to, input->keybit);

	for (trans = powerbook_fn_keys; trans->from; trans++)
		set_bit(trans->to, input->keybit);

	for (trans = powerbook_numlock_keys; trans->from; trans++)
		set_bit(trans->to, input->keybit);

	for (trans = apple_iso_keyboard; trans->from; trans++)
		set_bit(trans->to, input->keybit);
}

static int apple_input_mapping(struct hid_device *hdev, struct hid_input *hi,
		struct hid_field *field, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	if (usage->hid == (HID_UP_CUSTOM | 0x0003)) {
		/* The fn key on Apple USB keyboards */
		set_bit(EV_REP, hi->input->evbit);
		hid_map_usage_clear(hi, usage, bit, max, EV_KEY, KEY_FN);
		apple_setup_input(hi->input);
		return 1;
	}

	/* we want the hid layer to go through standard path (set and ignore) */
	return 0;
}

static int apple_input_mapped(struct hid_device *hdev, struct hid_input *hi,
		struct hid_field *field, struct hid_usage *usage,
		unsigned long **bit, int *max)
{
	struct apple_sc *asc = hid_get_drvdata(hdev);

	if (asc->quirks & APPLE_MIGHTYMOUSE) {
		if (usage->hid == HID_GD_Z)
			hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
		else if (usage->code == BTN_1)
			hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_2);
		else if (usage->code == BTN_2)
			hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_1);
	}

	return 0;
}

static int apple_probe(struct hid_device *hdev,
		const struct hid_device_id *id)
{
	unsigned long quirks = id->driver_data;
	struct apple_sc *asc;
	int ret;

	/* return something else or move to hid layer? device will reside
	   allocated */
	if (id->bus == BUS_USB && (quirks & APPLE_IGNORE_MOUSE) &&
			to_usb_interface(hdev->dev.parent)->cur_altsetting->
			desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE)
		return -ENODEV;

	asc = kzalloc(sizeof(*asc), GFP_KERNEL);
	if (asc == NULL) {
		dev_err(&hdev->dev, "can't alloc apple descriptor\n");
		return -ENOMEM;
	}

	asc->quirks = quirks;

	hid_set_drvdata(hdev, asc);

	if (quirks & APPLE_HIDDEV)
		hdev->quirks |= HID_QUIRK_HIDDEV;
	if (quirks & APPLE_IGNORE_HIDINPUT)
		hdev->quirks |= HID_QUIRK_IGNORE_HIDINPUT;

	ret = hid_parse(hdev);
	if (ret) {
		dev_err(&hdev->dev, "parse failed\n");
		goto err_free;
	}

	ret = hid_hw_start(hdev);
	if (ret) {
		dev_err(&hdev->dev, "hw start failed\n");
		goto err_free;
	}

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

static void apple_remove(struct hid_device *hdev)
{
	hid_hw_stop(hdev);
	kfree(hid_get_drvdata(hdev));
}

static const struct hid_device_id apple_devices[] = {
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4),
		.driver_data = APPLE_HIDDEV | APPLE_IGNORE_HIDINPUT },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE),
		.driver_data = APPLE_MIGHTYMOUSE | APPLE_INVERT_HWHEEL },

	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE | APPLE_ISO_KEYBOARD },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE | APPLE_ISO_KEYBOARD },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE | APPLE_ISO_KEYBOARD },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE | APPLE_RDESC_JIS},
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI),
		.driver_data = APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO),
		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS),
		.driver_data = APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_ISO_KEYBOARD },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI),
		.driver_data = APPLE_HAS_FN | APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO),
		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD |
			APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS),
		.driver_data = APPLE_HAS_FN | APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI),
		.driver_data = APPLE_HAS_FN | APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO),
		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD |
			APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS),
		.driver_data = APPLE_HAS_FN | APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_IGNORE_MOUSE },

	/* Apple wireless Mighty Mouse */
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, 0x030c),
		.driver_data = APPLE_MIGHTYMOUSE | APPLE_INVERT_HWHEEL },

	{ }
};
MODULE_DEVICE_TABLE(hid, apple_devices);

static struct hid_driver apple_driver = {
	.name = "apple",
	.id_table = apple_devices,
	.report_fixup = apple_report_fixup,
	.probe = apple_probe,
	.remove = apple_remove,
	.event = apple_event,
	.input_mapping = apple_input_mapping,
	.input_mapped = apple_input_mapped,
};

static int apple_init(void)
{
	int ret;

	ret = hid_register_driver(&apple_driver);
	if (ret)
		printk(KERN_ERR "can't register apple driver\n");

	return ret;
}

static void apple_exit(void)
{
	hid_unregister_driver(&apple_driver);
}

module_init(apple_init);
module_exit(apple_exit);
MODULE_LICENSE("GPL");

HID_COMPAT_LOAD_DRIVER(apple);
Commit	Line	Data
8c19a515 JS	1	/*
	2	* USB HID quirks support for Linux
	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
	8	* Copyright (c) 2007 Paul Walmsley
	9	* Copyright (c) 2008 Jiri Slaby <jirislaby@gmail.com>
	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>
	22	#include <linux/usb.h>
	23
	24	#include "hid-ids.h"
	25
	26	#define APPLE_RDESC_JIS 0x0001
	27	#define APPLE_IGNORE_MOUSE 0x0002
	28	#define APPLE_HAS_FN 0x0004
	29	#define APPLE_HIDDEV 0x0008
	30	#define APPLE_ISO_KEYBOARD 0x0010
	31	#define APPLE_MIGHTYMOUSE 0x0020
	32	#define APPLE_INVERT_HWHEEL 0x0040
	33	#define APPLE_IGNORE_HIDINPUT 0x0080
	34	#define APPLE_NUMLOCK_EMULATION 0x0100
	35
	36	#define APPLE_FLAG_FKEY 0x01
	37
	38	static unsigned int fnmode = 1;
	39	module_param(fnmode, uint, 0644);
	40	MODULE_PARM_DESC(fnmode, "Mode of fn key on Apple keyboards (0 = disabled, "
	41	"[1] = fkeyslast, 2 = fkeysfirst)");
	42
	43	struct apple_sc {
	44	unsigned long quirks;
	45	unsigned int fn_on;
	46	DECLARE_BITMAP(pressed_fn, KEY_CNT);
	47	DECLARE_BITMAP(pressed_numlock, KEY_CNT);
	48	};
	49
	50	struct apple_key_translation {
	51	u16 from;
	52	u16 to;
	53	u8 flags;
	54	};
	55
	56	static struct apple_key_translation apple_fn_keys[] = {
	57	{ KEY_BACKSPACE, KEY_DELETE },
	58	{ KEY_F1, KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
	59	{ KEY_F2, KEY_BRIGHTNESSUP, APPLE_FLAG_FKEY },
	60	{ KEY_F3, KEY_FN_F5, APPLE_FLAG_FKEY }, /* Exposé */
	61	{ KEY_F4, KEY_FN_F4, APPLE_FLAG_FKEY }, /* Dashboard */
	62	{ KEY_F5, KEY_KBDILLUMDOWN, APPLE_FLAG_FKEY },
	63	{ KEY_F6, KEY_KBDILLUMUP, APPLE_FLAG_FKEY },
	64	{ KEY_F7, KEY_PREVIOUSSONG, APPLE_FLAG_FKEY },
65	{ KEY_F8, KEY_PLAYPAUSE, APPLE_FLAG_FKEY },
66	{ KEY_F9, KEY_NEXTSONG, APPLE_FLAG_FKEY },
67	{ KEY_F10, KEY_MUTE, APPLE_FLAG_FKEY },
68	{ KEY_F11, KEY_VOLUMEDOWN, APPLE_FLAG_FKEY },
69	{ KEY_F12, KEY_VOLUMEUP, APPLE_FLAG_FKEY },
70	{ KEY_UP, KEY_PAGEUP },
71	{ KEY_DOWN, KEY_PAGEDOWN },
72	{ KEY_LEFT, KEY_HOME },
73	{ KEY_RIGHT, KEY_END },
74	{ }
75	};
76
77	static struct apple_key_translation powerbook_fn_keys[] = {
78	{ KEY_BACKSPACE, KEY_DELETE },
79	{ KEY_F1, KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
80	{ KEY_F2, KEY_BRIGHTNESSUP, APPLE_FLAG_FKEY },
81	{ KEY_F3, KEY_MUTE, APPLE_FLAG_FKEY },
82	{ KEY_F4, KEY_VOLUMEDOWN, APPLE_FLAG_FKEY },
83	{ KEY_F5, KEY_VOLUMEUP, APPLE_FLAG_FKEY },
84	{ KEY_F6, KEY_NUMLOCK, APPLE_FLAG_FKEY },
85	{ KEY_F7, KEY_SWITCHVIDEOMODE, APPLE_FLAG_FKEY },
86	{ KEY_F8, KEY_KBDILLUMTOGGLE, APPLE_FLAG_FKEY },
87	{ KEY_F9, KEY_KBDILLUMDOWN, APPLE_FLAG_FKEY },
88	{ KEY_F10, KEY_KBDILLUMUP, APPLE_FLAG_FKEY },
89	{ KEY_UP, KEY_PAGEUP },
90	{ KEY_DOWN, KEY_PAGEDOWN },
91	{ KEY_LEFT, KEY_HOME },
92	{ KEY_RIGHT, KEY_END },
93	{ }
94	};
95
96	static struct apple_key_translation powerbook_numlock_keys[] = {
97	{ KEY_J, KEY_KP1 },
98	{ KEY_K, KEY_KP2 },
99	{ KEY_L, KEY_KP3 },
100	{ KEY_U, KEY_KP4 },
101	{ KEY_I, KEY_KP5 },
102	{ KEY_O, KEY_KP6 },
103	{ KEY_7, KEY_KP7 },
104	{ KEY_8, KEY_KP8 },
105	{ KEY_9, KEY_KP9 },
106	{ KEY_M, KEY_KP0 },
107	{ KEY_DOT, KEY_KPDOT },
108	{ KEY_SLASH, KEY_KPPLUS },
109	{ KEY_SEMICOLON, KEY_KPMINUS },
110	{ KEY_P, KEY_KPASTERISK },
111	{ KEY_MINUS, KEY_KPEQUAL },
112	{ KEY_0, KEY_KPSLASH },
113	{ KEY_F6, KEY_NUMLOCK },
114	{ KEY_KPENTER, KEY_KPENTER },
115	{ KEY_BACKSPACE, KEY_BACKSPACE },
116	{ }
117	};
118
119	static struct apple_key_translation apple_iso_keyboard[] = {
120	{ KEY_GRAVE, KEY_102ND },
121	{ KEY_102ND, KEY_GRAVE },
122	{ }
123	};
124
125	static struct apple_key_translation *apple_find_translation(
126	struct apple_key_translation *table, u16 from)
127	{
128	struct apple_key_translation *trans;
129
130	/* Look for the translation */
131	for (trans = table; trans->from; trans++)
132	if (trans->from == from)
133	return trans;
134
135	return NULL;
136	}
137
138	static int hidinput_apple_event(struct hid_device hid, struct input_dev input,
139	struct hid_usage *usage, __s32 value)
140	{
141	struct apple_sc *asc = hid_get_drvdata(hid);
142	struct apple_key_translation *trans;
143
144	if (usage->code == KEY_FN) {
145	asc->fn_on = !!value;
146	input_event(input, usage->type, usage->code, value);
147	return 1;
148	}
149
150	if (fnmode) {
151	int do_translate;
152
153	trans = apple_find_translation((hid->product < 0x220 \|\|
154	hid->product >= 0x300) ?
155	powerbook_fn_keys : apple_fn_keys,
156	usage->code);
157	if (trans) {
158	if (test_bit(usage->code, asc->pressed_fn))
159	do_translate = 1;
160	else if (trans->flags & APPLE_FLAG_FKEY)
161	do_translate = (fnmode == 2 && asc->fn_on) \|\|
162	(fnmode == 1 && !asc->fn_on);
163	else
164	do_translate = asc->fn_on;
165
166	if (do_translate) {
167	if (value)
168	set_bit(usage->code, asc->pressed_fn);
169	else
170	clear_bit(usage->code, asc->pressed_fn);
171
172	input_event(input, usage->type, trans->to,
173	value);
174
175	return 1;
176	}
177	}
178
179	if (asc->quirks & APPLE_NUMLOCK_EMULATION &&
180	(test_bit(usage->code, asc->pressed_numlock) \|\|
181	test_bit(LED_NUML, input->led))) {
182	trans = apple_find_translation(powerbook_numlock_keys,
183	usage->code);
184
185	if (trans) {
186	if (value)
187	set_bit(usage->code,
188	asc->pressed_numlock);
189	else
190	clear_bit(usage->code,
191	asc->pressed_numlock);
192
193	input_event(input, usage->type, trans->to,
194	value);
195	}
196
197	return 1;
198	}
199	}
200
201	if (asc->quirks & APPLE_ISO_KEYBOARD) {
202	trans = apple_find_translation(apple_iso_keyboard, usage->code);
203	if (trans) {
204	input_event(input, usage->type, trans->to, value);
205	return 1;
206	}
207	}
208
209	return 0;
210	}
211
212	static int apple_event(struct hid_device hdev, struct hid_field field,
213	struct hid_usage *usage, __s32 value)
214	{
215	struct apple_sc *asc = hid_get_drvdata(hdev);
216
217	if (!(hdev->claimed & HID_CLAIMED_INPUT) \|\| !field->hidinput \|\|
218	!usage->type)
219	return 0;
220
221	if ((asc->quirks & APPLE_INVERT_HWHEEL) &&
222	usage->code == REL_HWHEEL) {
223	input_event(field->hidinput->input, usage->type, usage->code,
224	-value);
225	return 1;
226	}
227
228	if ((asc->quirks & APPLE_HAS_FN) &&
229	hidinput_apple_event(hdev, field->hidinput->input,
230	usage, value))
231	return 1;
232
233
234	return 0;
235	}
236
237	/*
238	* MacBook JIS keyboard has wrong logical maximum
239	*/
240	static void apple_report_fixup(struct hid_device hdev, __u8 rdesc,
241	unsigned int rsize)
242	{
243	struct apple_sc *asc = hid_get_drvdata(hdev);
244
245	if ((asc->quirks & APPLE_RDESC_JIS) && rsize >= 60 &&
246	rdesc[53] == 0x65 && rdesc[59] == 0x65) {
247	dev_info(&hdev->dev, "fixing up MacBook JIS keyboard report "
248	"descriptor\n");
249	rdesc[53] = rdesc[59] = 0xe7;
250	}
251	}
252
253	static void apple_setup_input(struct input_dev *input)
254	{
255	struct apple_key_translation *trans;
256
257	set_bit(KEY_NUMLOCK, input->keybit);
258
259	/* Enable all needed keys */
260	for (trans = apple_fn_keys; trans->from; trans++)
261	set_bit(trans->to, input->keybit);
262
263	for (trans = powerbook_fn_keys; trans->from; trans++)
264	set_bit(trans->to, input->keybit);
265
266	for (trans = powerbook_numlock_keys; trans->from; trans++)
267	set_bit(trans->to, input->keybit);
268
269	for (trans = apple_iso_keyboard; trans->from; trans++)
270	set_bit(trans->to, input->keybit);
271	}
272
273	static int apple_input_mapping(struct hid_device hdev, struct hid_input hi,
274	struct hid_field field, struct hid_usage usage,
275	unsigned long *bit, int max)
276	{
277	if (usage->hid == (HID_UP_CUSTOM \| 0x0003)) {
278	/* The fn key on Apple USB keyboards */
279	set_bit(EV_REP, hi->input->evbit);
280	hid_map_usage_clear(hi, usage, bit, max, EV_KEY, KEY_FN);
281	apple_setup_input(hi->input);
282	return 1;
283	}
284
285	/* we want the hid layer to go through standard path (set and ignore) */
286	return 0;
287	}
288
289	static int apple_input_mapped(struct hid_device hdev, struct hid_input hi,
290	struct hid_field field, struct hid_usage usage,
291	unsigned long *bit, int max)
292	{
293	struct apple_sc *asc = hid_get_drvdata(hdev);
294
295	if (asc->quirks & APPLE_MIGHTYMOUSE) {
296	if (usage->hid == HID_GD_Z)
297	hid_map_usage(hi, usage, bit, max, EV_REL, REL_HWHEEL);
298	else if (usage->code == BTN_1)
299	hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_2);
300	else if (usage->code == BTN_2)
301	hid_map_usage(hi, usage, bit, max, EV_KEY, BTN_1);
302	}
303
304	return 0;
305	}
306
307	static int apple_probe(struct hid_device *hdev,
308	const struct hid_device_id *id)
309	{
310	unsigned long quirks = id->driver_data;
311	struct apple_sc *asc;
312	int ret;
313
314	/* return something else or move to hid layer? device will reside
315	allocated */
316	if (id->bus == BUS_USB && (quirks & APPLE_IGNORE_MOUSE) &&
317	to_usb_interface(hdev->dev.parent)->cur_altsetting->
318	desc.bInterfaceProtocol == USB_INTERFACE_PROTOCOL_MOUSE)
319	return -ENODEV;
320
321	asc = kzalloc(sizeof(*asc), GFP_KERNEL);
322	if (asc == NULL) {
323	dev_err(&hdev->dev, "can't alloc apple descriptor\n");
324	return -ENOMEM;
325	}
326
327	asc->quirks = quirks;
328
329	hid_set_drvdata(hdev, asc);
330
331	if (quirks & APPLE_HIDDEV)
332	hdev->quirks \|= HID_QUIRK_HIDDEV;
333	if (quirks & APPLE_IGNORE_HIDINPUT)
334	hdev->quirks \|= HID_QUIRK_IGNORE_HIDINPUT;
335
336	ret = hid_parse(hdev);
337	if (ret) {
338	dev_err(&hdev->dev, "parse failed\n");
339	goto err_free;
340	}
341
342	ret = hid_hw_start(hdev);
343	if (ret) {
344	dev_err(&hdev->dev, "hw start failed\n");
345	goto err_free;
346	}
347
348	return 0;
349	err_free:
350	kfree(asc);
351	return ret;
352	}
353
354	static void apple_remove(struct hid_device *hdev)
355	{
356	hid_hw_stop(hdev);
357	kfree(hid_get_drvdata(hdev));
358	}
359
360	static const struct hid_device_id apple_devices[] = {
361	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_IRCONTROL4),
362	.driver_data = APPLE_HIDDEV \| APPLE_IGNORE_HIDINPUT },
363	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_MIGHTYMOUSE),
364	.driver_data = APPLE_MIGHTYMOUSE \| APPLE_INVERT_HWHEEL },
365
366	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ANSI),
367	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
368	APPLE_IGNORE_MOUSE },
369	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO),
370	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
371	APPLE_IGNORE_MOUSE },
372	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI),
373	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
374	APPLE_IGNORE_MOUSE },
375	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO),
376	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
377	APPLE_IGNORE_MOUSE \| APPLE_ISO_KEYBOARD },
378	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS),
379	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
380	APPLE_IGNORE_MOUSE },
381	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI),
382	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
383	APPLE_IGNORE_MOUSE },
384	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO),
385	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
386	APPLE_IGNORE_MOUSE \| APPLE_ISO_KEYBOARD },
387	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_JIS),
388	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
389	APPLE_IGNORE_MOUSE },
390	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI),
391	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
392	APPLE_IGNORE_MOUSE },
393	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO),
394	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
395	APPLE_IGNORE_MOUSE \| APPLE_ISO_KEYBOARD },
396	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_JIS),
397	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
398	APPLE_IGNORE_MOUSE \| APPLE_RDESC_JIS},
399	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ANSI),
400	.driver_data = APPLE_HAS_FN },
401	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_ISO),
402	.driver_data = APPLE_HAS_FN \| APPLE_ISO_KEYBOARD },
403	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_JIS),
404	.driver_data = APPLE_HAS_FN },
405	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ANSI),
406	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
407	APPLE_IGNORE_MOUSE },
408	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO),
409	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
410	APPLE_IGNORE_MOUSE },
411	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS),
412	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
413	APPLE_IGNORE_MOUSE },
414	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
415	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN },
416	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO),
417	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
418	APPLE_ISO_KEYBOARD },
419	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_JIS),
420	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN },
421	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ANSI),
422	.driver_data = APPLE_HAS_FN \| APPLE_IGNORE_MOUSE },
423	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO),
424	.driver_data = APPLE_HAS_FN \| APPLE_ISO_KEYBOARD \|
425	APPLE_IGNORE_MOUSE },
426	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS),
427	.driver_data = APPLE_HAS_FN \| APPLE_IGNORE_MOUSE },
428	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI),
429	.driver_data = APPLE_HAS_FN \| APPLE_IGNORE_MOUSE },
430	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO),
431	.driver_data = APPLE_HAS_FN \| APPLE_ISO_KEYBOARD \|
432	APPLE_IGNORE_MOUSE },
433	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS),
434	.driver_data = APPLE_HAS_FN \| APPLE_IGNORE_MOUSE },
435	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY),
436	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
437	APPLE_IGNORE_MOUSE },
438	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY),
439	.driver_data = APPLE_NUMLOCK_EMULATION \| APPLE_HAS_FN \|
440	APPLE_IGNORE_MOUSE },
441
442	/* Apple wireless Mighty Mouse */
443	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, 0x030c),
444	.driver_data = APPLE_MIGHTYMOUSE \| APPLE_INVERT_HWHEEL },
445
446	{ }
447	};
448	MODULE_DEVICE_TABLE(hid, apple_devices);
449
450	static struct hid_driver apple_driver = {
451	.name = "apple",
452	.id_table = apple_devices,
453	.report_fixup = apple_report_fixup,
454	.probe = apple_probe,
455	.remove = apple_remove,
456	.event = apple_event,
457	.input_mapping = apple_input_mapping,
458	.input_mapped = apple_input_mapped,
459	};
460
461	static int apple_init(void)
462	{
463	int ret;
464
465	ret = hid_register_driver(&apple_driver);
466	if (ret)
467	printk(KERN_ERR "can't register apple driver\n");
468
469	return ret;
470	}
471
472	static void apple_exit(void)
473	{
474	hid_unregister_driver(&apple_driver);
475	}
476
477	module_init(apple_init);
478	module_exit(apple_exit);
479	MODULE_LICENSE("GPL");
02ae9a1a JS	480
02ae9a1a JS	481	HID_COMPAT_LOAD_DRIVER(apple);