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

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