Merge branch 'for-next' of git://git.kernel.org/pub/scm/linux/kernel/git/jikos/trivial
[linux-2.6.git] / drivers / platform / x86 / dell-wmi.c
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/slab.h>
30 #include <linux/types.h>
31 #include <linux/input.h>
32 #include <linux/input/sparse-keymap.h>
33 #include <acpi/acpi_drivers.h>
34 #include <linux/acpi.h>
35 #include <linux/string.h>
36 #include <linux/dmi.h>
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
44 static int acpi_video;
45
46 MODULE_ALIAS("wmi:"DELL_EVENT_GUID);
47
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  */
53
54 static const struct key_entry dell_wmi_legacy_keymap[] __initconst = {
55         { KE_KEY, 0xe045, { KEY_PROG1 } },
56         { KE_KEY, 0xe009, { KEY_EJECTCD } },
57
58         /* These also contain the brightness level at offset 6 */
59         { KE_KEY, 0xe006, { KEY_BRIGHTNESSUP } },
60         { KE_KEY, 0xe005, { KEY_BRIGHTNESSDOWN } },
61
62         /* Battery health status button */
63         { KE_KEY, 0xe007, { KEY_BATTERY } },
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 */
68         { KE_KEY, 0xe008, { KEY_WLAN } },
69
70         /* The next device is at offset 6, the active devices are at
71            offset 8 and the attached devices at offset 10 */
72         { KE_KEY, 0xe00b, { KEY_SWITCHVIDEOMODE } },
73
74         { KE_IGNORE, 0xe00c, { KEY_KBDILLUMTOGGLE } },
75
76         /* BIOS error detected */
77         { KE_IGNORE, 0xe00d, { KEY_RESERVED } },
78
79         /* Wifi Catcher */
80         { KE_KEY, 0xe011, {KEY_PROG2 } },
81
82         /* Ambient light sensor toggle */
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 }
94 };
95
96 static bool dell_new_hk_type;
97
98 struct dell_bios_keymap_entry {
99         u16 scancode;
100         u16 keycode;
101 };
102
103 struct dell_bios_hotkey_table {
104         struct dmi_header header;
105         struct dell_bios_keymap_entry keymap[];
106
107 };
108
109 static const struct dell_bios_hotkey_table *dell_bios_hotkey_table;
110
111 static const u16 bios_to_linux_keycode[256] __initconst = {
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
134 static struct input_dev *dell_wmi_input_dev;
135
136 static void dell_wmi_notify(u32 value, void *context)
137 {
138         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
139         union acpi_object *obj;
140         acpi_status status;
141
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         }
147
148         obj = (union acpi_object *)response.pointer;
149
150         if (obj && obj->type == ACPI_TYPE_BUFFER) {
151                 const struct key_entry *key;
152                 int reported_key;
153                 u16 *buffer_entry = (u16 *)obj->buffer.pointer;
154
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]);
158                         kfree(obj);
159                         return;
160                 }
161
162                 if (dell_new_hk_type || buffer_entry[1] == 0x0)
163                         reported_key = (int)buffer_entry[2];
164                 else
165                         reported_key = (int)buffer_entry[1] & 0xffff;
166
167                 key = sparse_keymap_entry_from_scancode(dell_wmi_input_dev,
168                                                         reported_key);
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 */
176                         ;
177                 } else {
178                         sparse_keymap_report_entry(dell_wmi_input_dev, key,
179                                                    1, true);
180                 }
181         }
182         kfree(obj);
183 }
184
185 static const struct key_entry * __init dell_wmi_prepare_new_keymap(void)
186 {
187         int hotkey_num = (dell_bios_hotkey_table->header.length - 4) /
188                                 sizeof(struct dell_bios_keymap_entry);
189         struct key_entry *keymap;
190         int i;
191
192         keymap = kcalloc(hotkey_num + 1, sizeof(struct key_entry), GFP_KERNEL);
193         if (!keymap)
194                 return NULL;
195
196         for (i = 0; i < hotkey_num; i++) {
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;
204         }
205
206         keymap[hotkey_num].type = KE_END;
207
208         return keymap;
209 }
210
211 static int __init dell_wmi_input_setup(void)
212 {
213         int err;
214
215         dell_wmi_input_dev = input_allocate_device();
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;
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;
228                 }
229
230                 err = sparse_keymap_setup(dell_wmi_input_dev, keymap, NULL);
231
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);
240         }
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;
247
248         return 0;
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         }
270 }
271
272 static int __init dell_wmi_init(void)
273 {
274         int err;
275         acpi_status status;
276
277         if (!wmi_has_guid(DELL_EVENT_GUID)) {
278                 printk(KERN_WARNING "dell-wmi: No known WMI GUID found\n");
279                 return -ENODEV;
280         }
281
282         dmi_walk(find_hk_type, NULL);
283         acpi_video = acpi_video_backlight_support();
284
285         err = dell_wmi_input_setup();
286         if (err)
287                 return err;
288
289         status = wmi_install_notify_handler(DELL_EVENT_GUID,
290                                          dell_wmi_notify, NULL);
291         if (ACPI_FAILURE(status)) {
292                 dell_wmi_input_destroy();
293                 printk(KERN_ERR
294                         "dell-wmi: Unable to register notify handler - %d\n",
295                         status);
296                 return -ENODEV;
297         }
298
299         return 0;
300 }
301 module_init(dell_wmi_init);
302
303 static void __exit dell_wmi_exit(void)
304 {
305         wmi_remove_notify_handler(DELL_EVENT_GUID);
306         dell_wmi_input_destroy();
307 }
308 module_exit(dell_wmi_exit);