[mirror_ubuntu-hirsute-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(unsigned 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(unsigned 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,
				unsigned int scancode, unsigned 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,
				unsigned int scancode, unsigned int keycode)
{
	struct key_entry *key;
	unsigned int old_keycode;

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