[mirror_ubuntu-artful-kernel.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.
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/device.h>
#include <linux/hid.h>
#include <linux/module.h>
#include <linux/slab.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)");

static unsigned int iso_layout = 1;
module_param(iso_layout, uint, 0644);
MODULE_PARM_DESC(iso_layout, "Enable/Disable hardcoded ISO-layout of the keyboard. "
		"(0 = disabled, [1] = enabled)");

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 const struct apple_key_translation macbookair_fn_keys[] = {
	{ KEY_BACKSPACE, KEY_DELETE },
	{ KEY_ENTER,	KEY_INSERT },
	{ KEY_F1,	KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
	{ KEY_F2,	KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
	{ KEY_F3,	KEY_SCALE,          APPLE_FLAG_FKEY },
	{ KEY_F4,	KEY_DASHBOARD,      APPLE_FLAG_FKEY },
	{ KEY_F6,	KEY_PREVIOUSSONG,   APPLE_FLAG_FKEY },
	{ KEY_F7,	KEY_PLAYPAUSE,      APPLE_FLAG_FKEY },
	{ KEY_F8,	KEY_NEXTSONG,       APPLE_FLAG_FKEY },
	{ KEY_F9,	KEY_MUTE,           APPLE_FLAG_FKEY },
	{ KEY_F10,	KEY_VOLUMEDOWN,     APPLE_FLAG_FKEY },
	{ KEY_F11,	KEY_VOLUMEUP,       APPLE_FLAG_FKEY },
	{ KEY_F12,	KEY_EJECTCD,        APPLE_FLAG_FKEY },
	{ KEY_UP,	KEY_PAGEUP },
	{ KEY_DOWN,	KEY_PAGEDOWN },
	{ KEY_LEFT,	KEY_HOME },
	{ KEY_RIGHT,	KEY_END },
	{ }
};

static const struct apple_key_translation apple_fn_keys[] = {
	{ KEY_BACKSPACE, KEY_DELETE },
	{ KEY_ENTER,	KEY_INSERT },
	{ KEY_F1,	KEY_BRIGHTNESSDOWN, APPLE_FLAG_FKEY },
	{ KEY_F2,	KEY_BRIGHTNESSUP,   APPLE_FLAG_FKEY },
	{ KEY_F3,	KEY_SCALE,          APPLE_FLAG_FKEY },
	{ KEY_F4,	KEY_DASHBOARD,      APPLE_FLAG_FKEY },
	{ 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 const 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 const 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 const struct apple_key_translation apple_iso_keyboard[] = {
	{ KEY_GRAVE,	KEY_102ND },
	{ KEY_102ND,	KEY_GRAVE },
	{ }
};

static const struct apple_key_translation *apple_find_translation(
		const struct apple_key_translation *table, u16 from)
{
	const 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);
	const struct apple_key_translation *trans, *table;

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

	if (fnmode) {
		int do_translate;

		if (hid->product >= USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI &&
				hid->product <= USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS)
			table = macbookair_fn_keys;
		else if (hid->product < 0x21d || hid->product >= 0x300)
			table = powerbook_fn_keys;
		else
			table = apple_fn_keys;

		trans = apple_find_translation (table, 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 (iso_layout) {
		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 __u8 *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) {
		hid_info(hdev,
			 "fixing up MacBook JIS keyboard report descriptor\n");
		rdesc[53] = rdesc[59] = 0xe7;
	}
	return rdesc;
}

static void apple_setup_input(struct input_dev *input)
{
	const 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;
	unsigned int connect_mask = HID_CONNECT_DEFAULT;
	int ret;

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

	asc->quirks = quirks;

	hid_set_drvdata(hdev, asc);

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

	if (quirks & APPLE_HIDDEV)
		connect_mask |= HID_CONNECT_HIDDEV_FORCE;
	if (quirks & APPLE_IGNORE_HIDINPUT)
		connect_mask &= ~HID_CONNECT_HIDINPUT;

	ret = hid_hw_start(hdev, connect_mask);
	if (ret) {
		hid_err(hdev, "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_ATV_IRCONTROL),
		.driver_data = APPLE_HIDDEV | APPLE_IGNORE_HIDINPUT },
	{ 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 },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_ISO),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ANSI),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_ISO),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_ISO_KEYBOARD },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER_JIS),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ANSI),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER3_ISO),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			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_RDESC_JIS },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ANSI),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_ISO),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			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_RDESC_JIS },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ANSI),
		.driver_data = APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_ISO),
		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_MINI_JIS),
		.driver_data = APPLE_HAS_FN },
	{ 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 },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_ISO),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER4_HF_JIS),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_RDESC_JIS },
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ANSI),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_ISO),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_ISO_KEYBOARD },
	{ HID_BLUETOOTH_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 },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_ISO),
		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING_JIS),
		.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ANSI),
		.driver_data = APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_ISO),
		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING2_JIS),
		.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ANSI),
		.driver_data = APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_ISO),
		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING3_JIS),
		.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ANSI),
		.driver_data = APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_ISO),
		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4_JIS),
		.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ANSI),
		.driver_data = APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_ISO),
		.driver_data = APPLE_HAS_FN | APPLE_ISO_KEYBOARD },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_WELLSPRING4A_JIS),
		.driver_data = APPLE_HAS_FN | APPLE_RDESC_JIS },
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ANSI),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_ISO),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN |
			APPLE_ISO_KEYBOARD },
	{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_ALU_WIRELESS_2009_JIS),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_FOUNTAIN_TP_ONLY),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },
	{ HID_USB_DEVICE(USB_VENDOR_ID_APPLE, USB_DEVICE_ID_APPLE_GEYSER1_TP_ONLY),
		.driver_data = APPLE_NUMLOCK_EMULATION | APPLE_HAS_FN },

	{ }
};
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 __init apple_init(void)
{
	int ret;

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

	return ret;
}

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

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