[linux-block.git] / drivers / platform / x86 / dell-wmi.c

/*
 * Dell WMI hotkeys
 *
 * Copyright (C) 2008 Red Hat <mjg@redhat.com>
 *
 * Portions based on wistron_btns.c:
 * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
 * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
 * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
 *
 *  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.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/types.h>
#include <linux/input.h>
#include <linux/input/sparse-keymap.h>
#include <acpi/acpi_drivers.h>
#include <linux/acpi.h>
#include <linux/string.h>
#include <linux/dmi.h>

MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
MODULE_DESCRIPTION("Dell laptop WMI hotkeys driver");
MODULE_LICENSE("GPL");

#define DELL_EVENT_GUID "9DBB5994-A997-11DA-B012-B622A1EF5492"

static int acpi_video;

MODULE_ALIAS("wmi:"DELL_EVENT_GUID);

/*
 * Certain keys are flagged as KE_IGNORE. All of these are either
 * notifications (rather than requests for change) or are also sent
 * via the keyboard controller so should not be sent again.
 */

static const struct key_entry dell_wmi_legacy_keymap[] __initconst = {
	{ KE_IGNORE, 0x003a, { KEY_CAPSLOCK } },

	{ KE_KEY, 0xe045, { KEY_PROG1 } },
	{ KE_KEY, 0xe009, { KEY_EJECTCD } },

	/* These also contain the brightness level at offset 6 */
	{ KE_KEY, 0xe006, { KEY_BRIGHTNESSUP } },
	{ KE_KEY, 0xe005, { KEY_BRIGHTNESSDOWN } },

	/* Battery health status button */
	{ KE_KEY, 0xe007, { KEY_BATTERY } },

	/* This is actually for all radios. Although physically a
	 * switch, the notification does not provide an indication of
	 * state and so it should be reported as a key */
	{ KE_KEY, 0xe008, { KEY_WLAN } },

	/* The next device is at offset 6, the active devices are at
	   offset 8 and the attached devices at offset 10 */
	{ KE_KEY, 0xe00b, { KEY_SWITCHVIDEOMODE } },

	{ KE_IGNORE, 0xe00c, { KEY_KBDILLUMTOGGLE } },

	/* BIOS error detected */
	{ KE_IGNORE, 0xe00d, { KEY_RESERVED } },

	/* Wifi Catcher */
	{ KE_KEY, 0xe011, {KEY_PROG2 } },

	/* Ambient light sensor toggle */
	{ KE_IGNORE, 0xe013, { KEY_RESERVED } },

	{ KE_IGNORE, 0xe020, { KEY_MUTE } },

	/* Shortcut and audio panel keys */
	{ KE_IGNORE, 0xe025, { KEY_RESERVED } },
	{ KE_IGNORE, 0xe026, { KEY_RESERVED } },

	{ KE_IGNORE, 0xe02e, { KEY_VOLUMEDOWN } },
	{ KE_IGNORE, 0xe030, { KEY_VOLUMEUP } },
	{ KE_IGNORE, 0xe033, { KEY_KBDILLUMUP } },
	{ KE_IGNORE, 0xe034, { KEY_KBDILLUMDOWN } },
	{ KE_IGNORE, 0xe03a, { KEY_CAPSLOCK } },
	{ KE_IGNORE, 0xe045, { KEY_NUMLOCK } },
	{ KE_IGNORE, 0xe046, { KEY_SCROLLLOCK } },
	{ KE_IGNORE, 0xe0f7, { KEY_MUTE } },
	{ KE_IGNORE, 0xe0f8, { KEY_VOLUMEDOWN } },
	{ KE_IGNORE, 0xe0f9, { KEY_VOLUMEUP } },
	{ KE_END, 0 }
};

static bool dell_new_hk_type;

struct dell_bios_keymap_entry {
	u16 scancode;
	u16 keycode;
};

struct dell_bios_hotkey_table {
	struct dmi_header header;
	struct dell_bios_keymap_entry keymap[];

};

static const struct dell_bios_hotkey_table *dell_bios_hotkey_table;

static const u16 bios_to_linux_keycode[256] __initconst = {

	KEY_MEDIA,	KEY_NEXTSONG,	KEY_PLAYPAUSE, KEY_PREVIOUSSONG,
	KEY_STOPCD,	KEY_UNKNOWN,	KEY_UNKNOWN,	KEY_UNKNOWN,
	KEY_WWW,	KEY_UNKNOWN,	KEY_VOLUMEDOWN, KEY_MUTE,
	KEY_VOLUMEUP,	KEY_UNKNOWN,	KEY_BATTERY,	KEY_EJECTCD,
	KEY_UNKNOWN,	KEY_SLEEP,	KEY_PROG1, KEY_BRIGHTNESSDOWN,
	KEY_BRIGHTNESSUP,	KEY_UNKNOWN,	KEY_KBDILLUMTOGGLE,
	KEY_UNKNOWN,	KEY_SWITCHVIDEOMODE,	KEY_UNKNOWN, KEY_UNKNOWN,
	KEY_SWITCHVIDEOMODE,	KEY_UNKNOWN,	KEY_UNKNOWN, KEY_PROG2,
	KEY_UNKNOWN,	KEY_UNKNOWN,	KEY_UNKNOWN,	KEY_UNKNOWN,
	KEY_UNKNOWN,	KEY_UNKNOWN,	KEY_UNKNOWN,	KEY_MICMUTE,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_PROG3
};

static struct input_dev *dell_wmi_input_dev;

static void dell_wmi_notify(u32 value, void *context)
{
	struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *obj;
	acpi_status status;

	status = wmi_get_event_data(value, &response);
	if (status != AE_OK) {
		pr_info("bad event status 0x%x\n", status);
		return;
	}

	obj = (union acpi_object *)response.pointer;

	if (obj && obj->type == ACPI_TYPE_BUFFER) {
		const struct key_entry *key;
		int reported_key;
		u16 *buffer_entry = (u16 *)obj->buffer.pointer;

		if (dell_new_hk_type && (buffer_entry[1] != 0x10)) {
			pr_info("Received unknown WMI event (0x%x)\n",
				buffer_entry[1]);
			kfree(obj);
			return;
		}

		if (dell_new_hk_type || buffer_entry[1] == 0x0)
			reported_key = (int)buffer_entry[2];
		else
			reported_key = (int)buffer_entry[1] & 0xffff;

		key = sparse_keymap_entry_from_scancode(dell_wmi_input_dev,
							reported_key);
		if (!key) {
			pr_info("Unknown key %x pressed\n", reported_key);
		} else if ((key->keycode == KEY_BRIGHTNESSUP ||
			    key->keycode == KEY_BRIGHTNESSDOWN) && acpi_video) {
			/* Don't report brightness notifications that will also
			 * come via ACPI */
			;
		} else {
			sparse_keymap_report_entry(dell_wmi_input_dev, key,
						   1, true);
		}
	}
	kfree(obj);
}

static const struct key_entry * __init dell_wmi_prepare_new_keymap(void)
{
	int hotkey_num = (dell_bios_hotkey_table->header.length - 4) /
				sizeof(struct dell_bios_keymap_entry);
	struct key_entry *keymap;
	int i;

	keymap = kcalloc(hotkey_num + 1, sizeof(struct key_entry), GFP_KERNEL);
	if (!keymap)
		return NULL;

	for (i = 0; i < hotkey_num; i++) {
		const struct dell_bios_keymap_entry *bios_entry =
					&dell_bios_hotkey_table->keymap[i];
		keymap[i].type = KE_KEY;
		keymap[i].code = bios_entry->scancode;
		keymap[i].keycode = bios_entry->keycode < 256 ?
				    bios_to_linux_keycode[bios_entry->keycode] :
				    KEY_RESERVED;
	}

	keymap[hotkey_num].type = KE_END;

	return keymap;
}

static int __init dell_wmi_input_setup(void)
{
	int err;

	dell_wmi_input_dev = input_allocate_device();
	if (!dell_wmi_input_dev)
		return -ENOMEM;

	dell_wmi_input_dev->name = "Dell WMI hotkeys";
	dell_wmi_input_dev->phys = "wmi/input0";
	dell_wmi_input_dev->id.bustype = BUS_HOST;

	if (dell_new_hk_type) {
		const struct key_entry *keymap = dell_wmi_prepare_new_keymap();
		if (!keymap) {
			err = -ENOMEM;
			goto err_free_dev;
		}

		err = sparse_keymap_setup(dell_wmi_input_dev, keymap, NULL);

		/*
		 * Sparse keymap library makes a copy of keymap so we
		 * don't need the original one that was allocated.
		 */
		kfree(keymap);
	} else {
		err = sparse_keymap_setup(dell_wmi_input_dev,
					  dell_wmi_legacy_keymap, NULL);
	}
	if (err)
		goto err_free_dev;

	err = input_register_device(dell_wmi_input_dev);
	if (err)
		goto err_free_keymap;

	return 0;

 err_free_keymap:
	sparse_keymap_free(dell_wmi_input_dev);
 err_free_dev:
	input_free_device(dell_wmi_input_dev);
	return err;
}

static void dell_wmi_input_destroy(void)
{
	sparse_keymap_free(dell_wmi_input_dev);
	input_unregister_device(dell_wmi_input_dev);
}

static void __init find_hk_type(const struct dmi_header *dm, void *dummy)
{
	if (dm->type == 0xb2 && dm->length > 6) {
		dell_new_hk_type = true;
		dell_bios_hotkey_table =
			container_of(dm, struct dell_bios_hotkey_table, header);
	}
}

static int __init dell_wmi_init(void)
{
	int err;
	acpi_status status;

	if (!wmi_has_guid(DELL_EVENT_GUID)) {
		pr_warn("No known WMI GUID found\n");
		return -ENODEV;
	}

	dmi_walk(find_hk_type, NULL);
	acpi_video = acpi_video_backlight_support();

	err = dell_wmi_input_setup();
	if (err)
		return err;

	status = wmi_install_notify_handler(DELL_EVENT_GUID,
					 dell_wmi_notify, NULL);
	if (ACPI_FAILURE(status)) {
		dell_wmi_input_destroy();
		pr_err("Unable to register notify handler - %d\n", status);
		return -ENODEV;
	}

	return 0;
}
module_init(dell_wmi_init);

static void __exit dell_wmi_exit(void)
{
	wmi_remove_notify_handler(DELL_EVENT_GUID);
	dell_wmi_input_destroy();
}
module_exit(dell_wmi_exit);
Commit	Line	Data
0b3f6109 MG	1	/*
	2	* Dell WMI hotkeys
	3	*
	4	* Copyright (C) 2008 Red Hat <mjg@redhat.com>
	5	*
	6	* Portions based on wistron_btns.c:
	7	* Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
	8	* Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
	9	* Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License as published by
	13	* the Free Software Foundation; either version 2 of the License, or
	14	* (at your option) any later version.
	15	*
	16	* This program is distributed in the hope that it will be useful,
	17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	19	* GNU General Public License for more details.
	20	*
	21	* You should have received a copy of the GNU General Public License
	22	* along with this program; if not, write to the Free Software
	23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
	24	*/
	25
eb889524 JP	26	#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
eb889524 JP	27
0b3f6109 MG	28	#include <linux/kernel.h>
	29	#include <linux/module.h>
	30	#include <linux/init.h>
5a0e3ad6	31	#include <linux/slab.h>
0b3f6109 MG	32	#include <linux/types.h>
0b3f6109 MG	33	#include <linux/input.h>
890a7c8e	34	#include <linux/input/sparse-keymap.h>
0b3f6109 MG	35	#include <acpi/acpi_drivers.h>
	36	#include <linux/acpi.h>
	37	#include <linux/string.h>
5ea25597	38	#include <linux/dmi.h>
0b3f6109 MG	39
	40	MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
	41	MODULE_DESCRIPTION("Dell laptop WMI hotkeys driver");
	42	MODULE_LICENSE("GPL");
	43
	44	#define DELL_EVENT_GUID "9DBB5994-A997-11DA-B012-B622A1EF5492"
	45
5ea25597 RK	46	static int acpi_video;
5ea25597 RK	47
0b3f6109 MG	48	MODULE_ALIAS("wmi:"DELL_EVENT_GUID);
0b3f6109 MG	49
5cab0098 ML	50	/*
	51	* Certain keys are flagged as KE_IGNORE. All of these are either
	52	* notifications (rather than requests for change) or are also sent
	53	* via the keyboard controller so should not be sent again.
	54	*/
0b3f6109	55
890a7c8e	56	static const struct key_entry dell_wmi_legacy_keymap[] __initconst = {
f1566f0d SF	57	{ KE_IGNORE, 0x003a, { KEY_CAPSLOCK } },
f1566f0d SF	58
890a7c8e DT	59	{ KE_KEY, 0xe045, { KEY_PROG1 } },
890a7c8e DT	60	{ KE_KEY, 0xe009, { KEY_EJECTCD } },
5cab0098 ML	61
5cab0098 ML	62	/* These also contain the brightness level at offset 6 */
890a7c8e DT	63	{ KE_KEY, 0xe006, { KEY_BRIGHTNESSUP } },
890a7c8e DT	64	{ KE_KEY, 0xe005, { KEY_BRIGHTNESSDOWN } },
5cab0098 ML	65
5cab0098 ML	66	/* Battery health status button */
890a7c8e	67	{ KE_KEY, 0xe007, { KEY_BATTERY } },
5cab0098 ML	68
	69	/* This is actually for all radios. Although physically a
	70	* switch, the notification does not provide an indication of
	71	* state and so it should be reported as a key */
890a7c8e	72	{ KE_KEY, 0xe008, { KEY_WLAN } },
5cab0098 ML	73
	74	/* The next device is at offset 6, the active devices are at
	75	offset 8 and the attached devices at offset 10 */
890a7c8e	76	{ KE_KEY, 0xe00b, { KEY_SWITCHVIDEOMODE } },
5cab0098	77
890a7c8e	78	{ KE_IGNORE, 0xe00c, { KEY_KBDILLUMTOGGLE } },
5cab0098 ML	79
5cab0098 ML	80	/* BIOS error detected */
890a7c8e	81	{ KE_IGNORE, 0xe00d, { KEY_RESERVED } },
5cab0098 ML	82
5cab0098 ML	83	/* Wifi Catcher */
890a7c8e	84	{ KE_KEY, 0xe011, {KEY_PROG2 } },
5cab0098 ML	85
5cab0098 ML	86	/* Ambient light sensor toggle */
890a7c8e DT	87	{ KE_IGNORE, 0xe013, { KEY_RESERVED } },
	88
	89	{ KE_IGNORE, 0xe020, { KEY_MUTE } },
f1566f0d SF	90
	91	/* Shortcut and audio panel keys */
	92	{ KE_IGNORE, 0xe025, { KEY_RESERVED } },
	93	{ KE_IGNORE, 0xe026, { KEY_RESERVED } },
	94
890a7c8e DT	95	{ KE_IGNORE, 0xe02e, { KEY_VOLUMEDOWN } },
	96	{ KE_IGNORE, 0xe030, { KEY_VOLUMEUP } },
	97	{ KE_IGNORE, 0xe033, { KEY_KBDILLUMUP } },
	98	{ KE_IGNORE, 0xe034, { KEY_KBDILLUMDOWN } },
	99	{ KE_IGNORE, 0xe03a, { KEY_CAPSLOCK } },
	100	{ KE_IGNORE, 0xe045, { KEY_NUMLOCK } },
	101	{ KE_IGNORE, 0xe046, { KEY_SCROLLLOCK } },
f1566f0d SF	102	{ KE_IGNORE, 0xe0f7, { KEY_MUTE } },
	103	{ KE_IGNORE, 0xe0f8, { KEY_VOLUMEDOWN } },
	104	{ KE_IGNORE, 0xe0f9, { KEY_VOLUMEUP } },
890a7c8e	105	{ KE_END, 0 }
0b3f6109 MG	106	};
0b3f6109 MG	107
5ea25597 RK	108	static bool dell_new_hk_type;
5ea25597 RK	109
890a7c8e	110	struct dell_bios_keymap_entry {
5ea25597 RK	111	u16 scancode;
	112	u16 keycode;
	113	};
	114
890a7c8e	115	struct dell_bios_hotkey_table {
5ea25597	116	struct dmi_header header;
890a7c8e	117	struct dell_bios_keymap_entry keymap[];
5ea25597 RK	118
	119	};
	120
890a7c8e	121	static const struct dell_bios_hotkey_table *dell_bios_hotkey_table;
5ea25597	122
890a7c8e	123	static const u16 bios_to_linux_keycode[256] __initconst = {
5ea25597 RK	124
	125	KEY_MEDIA, KEY_NEXTSONG, KEY_PLAYPAUSE, KEY_PREVIOUSSONG,
	126	KEY_STOPCD, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
	127	KEY_WWW, KEY_UNKNOWN, KEY_VOLUMEDOWN, KEY_MUTE,
	128	KEY_VOLUMEUP, KEY_UNKNOWN, KEY_BATTERY, KEY_EJECTCD,
	129	KEY_UNKNOWN, KEY_SLEEP, KEY_PROG1, KEY_BRIGHTNESSDOWN,
	130	KEY_BRIGHTNESSUP, KEY_UNKNOWN, KEY_KBDILLUMTOGGLE,
	131	KEY_UNKNOWN, KEY_SWITCHVIDEOMODE, KEY_UNKNOWN, KEY_UNKNOWN,
	132	KEY_SWITCHVIDEOMODE, KEY_UNKNOWN, KEY_UNKNOWN, KEY_PROG2,
cfb743bf AH	133	KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
cfb743bf AH	134	KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_MICMUTE,
5ea25597 RK	135	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	136	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	137	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	138	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	139	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	140	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	141	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	142	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
cfb743bf AH	143	0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
cfb743bf AH	144	0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_PROG3
5ea25597 RK	145	};
5ea25597 RK	146
0b3f6109 MG	147	static struct input_dev *dell_wmi_input_dev;
0b3f6109 MG	148
0b3f6109 MG	149	static void dell_wmi_notify(u32 value, void *context)
	150	{
	151	struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
0b3f6109	152	union acpi_object *obj;
fda11e61	153	acpi_status status;
0b3f6109	154
fda11e61 LB	155	status = wmi_get_event_data(value, &response);
fda11e61 LB	156	if (status != AE_OK) {
eb889524	157	pr_info("bad event status 0x%x\n", status);
fda11e61 LB	158	return;
fda11e61 LB	159	}
0b3f6109 MG	160
	161	obj = (union acpi_object *)response.pointer;
	162
	163	if (obj && obj->type == ACPI_TYPE_BUFFER) {
890a7c8e	164	const struct key_entry *key;
5ea25597 RK	165	int reported_key;
5ea25597 RK	166	u16 buffer_entry = (u16 )obj->buffer.pointer;
890a7c8e	167
5ea25597	168	if (dell_new_hk_type && (buffer_entry[1] != 0x10)) {
eb889524 JP	169	pr_info("Received unknown WMI event (0x%x)\n",
eb889524 JP	170	buffer_entry[1]);
a0624a90	171	kfree(obj);
5ea25597 RK	172	return;
	173	}
	174
d5164dbf	175	if (dell_new_hk_type \|\| buffer_entry[1] == 0x0)
5ea25597 RK	176	reported_key = (int)buffer_entry[2];
	177	else
	178	reported_key = (int)buffer_entry[1] & 0xffff;
	179
890a7c8e DT	180	key = sparse_keymap_entry_from_scancode(dell_wmi_input_dev,
890a7c8e DT	181	reported_key);
5ea25597	182	if (!key) {
eb889524	183	pr_info("Unknown key %x pressed\n", reported_key);
5ea25597 RK	184	} else if ((key->keycode == KEY_BRIGHTNESSUP \|\|
	185	key->keycode == KEY_BRIGHTNESSDOWN) && acpi_video) {
	186	/* Don't report brightness notifications that will also
	187	* come via ACPI */
a0624a90	188	;
5ea25597	189	} else {
890a7c8e DT	190	sparse_keymap_report_entry(dell_wmi_input_dev, key,
890a7c8e DT	191	1, true);
5ea25597	192	}
0b3f6109	193	}
3e9b988e	194	kfree(obj);
0b3f6109 MG	195	}
0b3f6109 MG	196
890a7c8e	197	static const struct key_entry * __init dell_wmi_prepare_new_keymap(void)
5ea25597	198	{
890a7c8e DT	199	int hotkey_num = (dell_bios_hotkey_table->header.length - 4) /
	200	sizeof(struct dell_bios_keymap_entry);
	201	struct key_entry *keymap;
5ea25597	202	int i;
5ea25597	203
890a7c8e DT	204	keymap = kcalloc(hotkey_num + 1, sizeof(struct key_entry), GFP_KERNEL);
	205	if (!keymap)
	206	return NULL;
5ea25597 RK	207
5ea25597 RK	208	for (i = 0; i < hotkey_num; i++) {
890a7c8e DT	209	const struct dell_bios_keymap_entry *bios_entry =
	210	&dell_bios_hotkey_table->keymap[i];
	211	keymap[i].type = KE_KEY;
	212	keymap[i].code = bios_entry->scancode;
	213	keymap[i].keycode = bios_entry->keycode < 256 ?
	214	bios_to_linux_keycode[bios_entry->keycode] :
	215	KEY_RESERVED;
5ea25597 RK	216	}
5ea25597 RK	217
890a7c8e	218	keymap[hotkey_num].type = KE_END;
5ea25597	219
890a7c8e	220	return keymap;
5ea25597 RK	221	}
5ea25597 RK	222
0b3f6109 MG	223	static int __init dell_wmi_input_setup(void)
0b3f6109 MG	224	{
0b3f6109 MG	225	int err;
	226
	227	dell_wmi_input_dev = input_allocate_device();
0b3f6109 MG	228	if (!dell_wmi_input_dev)
	229	return -ENOMEM;
	230
	231	dell_wmi_input_dev->name = "Dell WMI hotkeys";
	232	dell_wmi_input_dev->phys = "wmi/input0";
	233	dell_wmi_input_dev->id.bustype = BUS_HOST;
890a7c8e DT	234
	235	if (dell_new_hk_type) {
	236	const struct key_entry *keymap = dell_wmi_prepare_new_keymap();
	237	if (!keymap) {
	238	err = -ENOMEM;
	239	goto err_free_dev;
0b3f6109	240	}
0b3f6109	241
890a7c8e	242	err = sparse_keymap_setup(dell_wmi_input_dev, keymap, NULL);
0b3f6109	243
890a7c8e DT	244	/*
	245	* Sparse keymap library makes a copy of keymap so we
	246	* don't need the original one that was allocated.
	247	*/
	248	kfree(keymap);
	249	} else {
	250	err = sparse_keymap_setup(dell_wmi_input_dev,
	251	dell_wmi_legacy_keymap, NULL);
0b3f6109	252	}
890a7c8e DT	253	if (err)
	254	goto err_free_dev;
	255
	256	err = input_register_device(dell_wmi_input_dev);
	257	if (err)
	258	goto err_free_keymap;
0b3f6109 MG	259
0b3f6109 MG	260	return 0;
890a7c8e DT	261
	262	err_free_keymap:
	263	sparse_keymap_free(dell_wmi_input_dev);
	264	err_free_dev:
	265	input_free_device(dell_wmi_input_dev);
	266	return err;
	267	}
	268
	269	static void dell_wmi_input_destroy(void)
	270	{
	271	sparse_keymap_free(dell_wmi_input_dev);
	272	input_unregister_device(dell_wmi_input_dev);
	273	}
	274
	275	static void __init find_hk_type(const struct dmi_header dm, void dummy)
	276	{
	277	if (dm->type == 0xb2 && dm->length > 6) {
	278	dell_new_hk_type = true;
	279	dell_bios_hotkey_table =
	280	container_of(dm, struct dell_bios_hotkey_table, header);
	281	}
0b3f6109 MG	282	}
	283
	284	static int __init dell_wmi_init(void)
	285	{
	286	int err;
abb631bf	287	acpi_status status;
0b3f6109	288
7a9568f5	289	if (!wmi_has_guid(DELL_EVENT_GUID)) {
eb889524	290	pr_warn("No known WMI GUID found\n");
1fdd407f DT	291	return -ENODEV;
1fdd407f DT	292	}
5ea25597	293
1fdd407f DT	294	dmi_walk(find_hk_type, NULL);
1fdd407f DT	295	acpi_video = acpi_video_backlight_support();
0b3f6109	296
1fdd407f	297	err = dell_wmi_input_setup();
890a7c8e	298	if (err)
1fdd407f	299	return err;
5ea25597	300
abb631bf	301	status = wmi_install_notify_handler(DELL_EVENT_GUID,
1fdd407f	302	dell_wmi_notify, NULL);
abb631bf	303	if (ACPI_FAILURE(status)) {
890a7c8e	304	dell_wmi_input_destroy();
eb889524	305	pr_err("Unable to register notify handler - %d\n", status);
abb631bf	306	return -ENODEV;
1fdd407f	307	}
0b3f6109 MG	308
	309	return 0;
	310	}
890a7c8e	311	module_init(dell_wmi_init);
0b3f6109 MG	312
	313	static void __exit dell_wmi_exit(void)
	314	{
1fdd407f	315	wmi_remove_notify_handler(DELL_EVENT_GUID);
890a7c8e	316	dell_wmi_input_destroy();
0b3f6109	317	}
0b3f6109	318	module_exit(dell_wmi_exit);