[net-next-2.6.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;

	wmi_get_event_data(value, &response);

	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;
	205
	206	wmi_get_event_data(value, &response);
207
208	obj = (union acpi_object *)response.pointer;
209
210	if (obj && obj->type == ACPI_TYPE_BUFFER) {
5ea25597 RK	211	int reported_key;
	212	u16 buffer_entry = (u16 )obj->buffer.pointer;
	213	if (dell_new_hk_type && (buffer_entry[1] != 0x10)) {
	214	printk(KERN_INFO "dell-wmi: Received unknown WMI event"
	215	" (0x%x)\n", buffer_entry[1]);
	216	return;
	217	}
	218
	219	if (dell_new_hk_type)
	220	reported_key = (int)buffer_entry[2];
	221	else
	222	reported_key = (int)buffer_entry[1] & 0xffff;
	223
	224	key = dell_wmi_get_entry_by_scancode(reported_key);
	225
	226	if (!key) {
	227	printk(KERN_INFO "dell-wmi: Unknown key %x pressed\n",
	228	reported_key);
	229	} else if ((key->keycode == KEY_BRIGHTNESSUP \|\|
	230	key->keycode == KEY_BRIGHTNESSDOWN) && acpi_video) {
	231	/* Don't report brightness notifications that will also
	232	* come via ACPI */
	233	return;
	234	} else {
0b3f6109 MG	235	input_report_key(dell_wmi_input_dev, key->keycode, 1);
	236	input_sync(dell_wmi_input_dev);
	237	input_report_key(dell_wmi_input_dev, key->keycode, 0);
	238	input_sync(dell_wmi_input_dev);
5ea25597	239	}
0b3f6109	240	}
3e9b988e	241	kfree(obj);
0b3f6109 MG	242	}
0b3f6109 MG	243
5ea25597 RK	244
	245	static void setup_new_hk_map(const struct dmi_header *dm)
	246	{
	247
	248	int i;
	249	int hotkey_num = (dm->length-4)/sizeof(struct dell_new_keymap_entry);
	250	struct dell_hotkey_table *table =
	251	container_of(dm, struct dell_hotkey_table, header);
	252
	253	dell_new_wmi_keymap = kzalloc((hotkey_num+1) *
	254	sizeof(struct key_entry), GFP_KERNEL);
	255
	256	for (i = 0; i < hotkey_num; i++) {
	257	dell_new_wmi_keymap[i].type = KE_KEY;
	258	dell_new_wmi_keymap[i].code = table->keymap[i].scancode;
	259	dell_new_wmi_keymap[i].keycode =
	260	(table->keymap[i].keycode > 255) ? 0 :
	261	bios_to_linux_keycode[table->keymap[i].keycode];
	262	}
	263
	264	dell_new_wmi_keymap[i].type = KE_END;
	265	dell_new_wmi_keymap[i].code = 0;
	266	dell_new_wmi_keymap[i].keycode = 0;
	267
	268	dell_wmi_keymap = dell_new_wmi_keymap;
	269
	270	}
	271
	272
	273	static void find_hk_type(const struct dmi_header dm, void dummy)
	274	{
	275
	276	if ((dm->type == 0xb2) && (dm->length > 6)) {
	277	dell_new_hk_type = true;
	278	setup_new_hk_map(dm);
	279	}
	280
	281	}
	282
	283
0b3f6109 MG	284	static int __init dell_wmi_input_setup(void)
	285	{
	286	struct key_entry *key;
	287	int err;
	288
	289	dell_wmi_input_dev = input_allocate_device();
	290
	291	if (!dell_wmi_input_dev)
	292	return -ENOMEM;
	293
	294	dell_wmi_input_dev->name = "Dell WMI hotkeys";
	295	dell_wmi_input_dev->phys = "wmi/input0";
	296	dell_wmi_input_dev->id.bustype = BUS_HOST;
	297	dell_wmi_input_dev->getkeycode = dell_wmi_getkeycode;
	298	dell_wmi_input_dev->setkeycode = dell_wmi_setkeycode;
	299
	300	for (key = dell_wmi_keymap; key->type != KE_END; key++) {
	301	switch (key->type) {
	302	case KE_KEY:
	303	set_bit(EV_KEY, dell_wmi_input_dev->evbit);
	304	set_bit(key->keycode, dell_wmi_input_dev->keybit);
	305	break;
	306	case KE_SW:
	307	set_bit(EV_SW, dell_wmi_input_dev->evbit);
	308	set_bit(key->keycode, dell_wmi_input_dev->swbit);
	309	break;
	310	}
	311	}
	312
	313	err = input_register_device(dell_wmi_input_dev);
	314
	315	if (err) {
	316	input_free_device(dell_wmi_input_dev);
	317	return err;
	318	}
	319
	320	return 0;
	321	}
	322
	323	static int __init dell_wmi_init(void)
	324	{
	325	int err;
5ccf73bb	326	acpi_status status;
0b3f6109 MG	327
0b3f6109 MG	328	if (wmi_has_guid(DELL_EVENT_GUID)) {
1fdd407f DT	329	printk(KERN_WARNING "dell-wmi: No known WMI GUID found\n");
	330	return -ENODEV;
	331	}
5ea25597	332
1fdd407f DT	333	dmi_walk(find_hk_type, NULL);
1fdd407f DT	334	acpi_video = acpi_video_backlight_support();
0b3f6109	335
1fdd407f DT	336	err = dell_wmi_input_setup();
	337	if (err)
	338	return err;
5ea25597	339
5ccf73bb	340	status = wmi_install_notify_handler(DELL_EVENT_GUID,
1fdd407f	341	dell_wmi_notify, NULL);
5ccf73bb	342	if (ACPI_FAILURE(status)) {
1fdd407f DT	343	input_unregister_device(dell_wmi_input_dev);
	344	printk(KERN_ERR
	345	"dell-wmi: Unable to register notify handler - %d\n",
5ccf73bb LB	346	status);
5ccf73bb LB	347	return -ENODEV;
1fdd407f	348	}
0b3f6109 MG	349
	350	return 0;
	351	}
	352
	353	static void __exit dell_wmi_exit(void)
	354	{
1fdd407f DT	355	wmi_remove_notify_handler(DELL_EVENT_GUID);
1fdd407f DT	356	input_unregister_device(dell_wmi_input_dev);
0b3f6109 MG	357	}
	358
	359	module_init(dell_wmi_init);
	360	module_exit(dell_wmi_exit);