[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/types.h>
#include <linux/input.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);

struct key_entry {
	char type;		/* See KE_* below */
	u16 code;
	u16 keycode;
};

enum { KE_KEY, KE_SW, KE_IGNORE, KE_END };

/*
 * 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 struct key_entry dell_legacy_wmi_keymap[] = {
	{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_new_keymap_entry {
	u16 scancode;
	u16 keycode;
};

struct dell_hotkey_table {
	struct dmi_header header;
	struct dell_new_keymap_entry keymap[];

};

static struct key_entry *dell_new_wmi_keymap;

static u16 bios_to_linux_keycode[256] = {

	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 key_entry *dell_wmi_keymap = dell_legacy_wmi_keymap;

static struct input_dev *dell_wmi_input_dev;

static struct key_entry *dell_wmi_get_entry_by_scancode(int code)
{
	struct key_entry *key;

	for (key = dell_wmi_keymap; key->type != KE_END; key++)
		if (code == key->code)
			return key;

	return NULL;
}

static struct key_entry *dell_wmi_get_entry_by_keycode(int keycode)
{
	struct key_entry *key;

	for (key = dell_wmi_keymap; key->type != KE_END; key++)
		if (key->type == KE_KEY && keycode == key->keycode)
			return key;

	return NULL;
}

static int dell_wmi_getkeycode(struct input_dev *dev, int scancode,
			       int *keycode)
{
	struct key_entry *key = dell_wmi_get_entry_by_scancode(scancode);

	if (key && key->type == KE_KEY) {
		*keycode = key->keycode;
		return 0;
	}

	return -EINVAL;
}

static int dell_wmi_setkeycode(struct input_dev *dev, int scancode, int keycode)
{
	struct key_entry *key;
	int old_keycode;

	if (keycode < 0 || keycode > KEY_MAX)
		return -EINVAL;

	key = dell_wmi_get_entry_by_scancode(scancode);
	if (key && key->type == KE_KEY) {
		old_keycode = key->keycode;
		key->keycode = keycode;
		set_bit(keycode, dev->keybit);
		if (!dell_wmi_get_entry_by_keycode(old_keycode))
			clear_bit(old_keycode, dev->keybit);
		return 0;
	}
	return -EINVAL;
}

static void dell_wmi_notify(u32 value, void *context)
{
	struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
	static struct key_entry *key;
	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) {
		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]);
			return;
		}

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

		key = dell_wmi_get_entry_by_scancode(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 */
			return;
		} else {
			input_report_key(dell_wmi_input_dev, key->keycode, 1);
			input_sync(dell_wmi_input_dev);
			input_report_key(dell_wmi_input_dev, key->keycode, 0);
			input_sync(dell_wmi_input_dev);
		}
	}
	kfree(obj);
}


static void setup_new_hk_map(const struct dmi_header *dm)
{

	int i;
	int hotkey_num = (dm->length-4)/sizeof(struct dell_new_keymap_entry);
	struct dell_hotkey_table *table =
		container_of(dm, struct dell_hotkey_table, header);

	dell_new_wmi_keymap = kzalloc((hotkey_num+1) *
				      sizeof(struct key_entry), GFP_KERNEL);

	for (i = 0; i < hotkey_num; i++) {
		dell_new_wmi_keymap[i].type = KE_KEY;
		dell_new_wmi_keymap[i].code = table->keymap[i].scancode;
		dell_new_wmi_keymap[i].keycode =
			(table->keymap[i].keycode > 255) ? 0 :
			bios_to_linux_keycode[table->keymap[i].keycode];
	}

	dell_new_wmi_keymap[i].type = KE_END;
	dell_new_wmi_keymap[i].code = 0;
	dell_new_wmi_keymap[i].keycode = 0;

	dell_wmi_keymap = dell_new_wmi_keymap;

}


static void find_hk_type(const struct dmi_header *dm, void *dummy)
{

	if ((dm->type == 0xb2) && (dm->length > 6)) {
		dell_new_hk_type = true;
		setup_new_hk_map(dm);
	}

}


static int __init dell_wmi_input_setup(void)
{
	struct key_entry *key;
	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;
	dell_wmi_input_dev->getkeycode = dell_wmi_getkeycode;
	dell_wmi_input_dev->setkeycode = dell_wmi_setkeycode;

	for (key = dell_wmi_keymap; key->type != KE_END; key++) {
		switch (key->type) {
		case KE_KEY:
			set_bit(EV_KEY, dell_wmi_input_dev->evbit);
			set_bit(key->keycode, dell_wmi_input_dev->keybit);
			break;
		case KE_SW:
			set_bit(EV_SW, dell_wmi_input_dev->evbit);
			set_bit(key->keycode, dell_wmi_input_dev->swbit);
			break;
		}
	}

	err = input_register_device(dell_wmi_input_dev);

	if (err) {
		input_free_device(dell_wmi_input_dev);
		return err;
	}

	return 0;
}

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)) {
		input_unregister_device(dell_wmi_input_dev);
		printk(KERN_ERR
			"dell-wmi: Unable to register notify handler - %d\n",
			status);
		return -ENODEV;
	}

	return 0;
}

static void __exit dell_wmi_exit(void)
{
	wmi_remove_notify_handler(DELL_EVENT_GUID);
	input_unregister_device(dell_wmi_input_dev);
}

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