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