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 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
27
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/init.h>
31 #include <linux/slab.h>
32 #include <linux/types.h>
33 #include <linux/input.h>
34 #include <linux/input/sparse-keymap.h>
35 #include <linux/acpi.h>
36 #include <linux/string.h>
37 #include <linux/dmi.h>
38 #include <acpi/video.h>
39
40 MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
41 MODULE_DESCRIPTION("Dell laptop WMI hotkeys driver");
42 MODULE_LICENSE("GPL");
43
44 #define DELL_EVENT_GUID "9DBB5994-A997-11DA-B012-B622A1EF5492"
45
46 static int acpi_video;
47
48 MODULE_ALIAS("wmi:"DELL_EVENT_GUID);
49
50 /*
51 * Certain keys are flagged as KE_IGNORE. All of these are either
52 * notifications (rather than requests for change) or are also sent
53 * via the keyboard controller so should not be sent again.
54 */
55
56 static const struct key_entry dell_wmi_legacy_keymap[] __initconst = {
57 { KE_IGNORE, 0x003a, { KEY_CAPSLOCK } },
58
59 { KE_KEY, 0xe045, { KEY_PROG1 } },
60 { KE_KEY, 0xe009, { KEY_EJECTCD } },
61
62 /* These also contain the brightness level at offset 6 */
63 { KE_KEY, 0xe006, { KEY_BRIGHTNESSUP } },
64 { KE_KEY, 0xe005, { KEY_BRIGHTNESSDOWN } },
65
66 /* Battery health status button */
67 { KE_KEY, 0xe007, { KEY_BATTERY } },
68
69 /* Radio devices state change */
70 { KE_IGNORE, 0xe008, { KEY_RFKILL } },
71
72 /* The next device is at offset 6, the active devices are at
73 offset 8 and the attached devices at offset 10 */
74 { KE_KEY, 0xe00b, { KEY_SWITCHVIDEOMODE } },
75
76 { KE_IGNORE, 0xe00c, { KEY_KBDILLUMTOGGLE } },
77
78 /* BIOS error detected */
79 { KE_IGNORE, 0xe00d, { KEY_RESERVED } },
80
81 /* Wifi Catcher */
82 { KE_KEY, 0xe011, {KEY_PROG2 } },
83
84 /* Ambient light sensor toggle */
85 { KE_IGNORE, 0xe013, { KEY_RESERVED } },
86
87 { KE_IGNORE, 0xe020, { KEY_MUTE } },
88
89 /* Shortcut and audio panel keys */
90 { KE_IGNORE, 0xe025, { KEY_RESERVED } },
91 { KE_IGNORE, 0xe026, { KEY_RESERVED } },
92
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 } },
100 { KE_IGNORE, 0xe0f7, { KEY_MUTE } },
101 { KE_IGNORE, 0xe0f8, { KEY_VOLUMEDOWN } },
102 { KE_IGNORE, 0xe0f9, { KEY_VOLUMEUP } },
103 { KE_END, 0 }
104 };
105
106 static bool dell_new_hk_type;
107
108 struct dell_bios_keymap_entry {
109 u16 scancode;
110 u16 keycode;
111 };
112
113 struct dell_bios_hotkey_table {
114 struct dmi_header header;
115 struct dell_bios_keymap_entry keymap[];
116
117 };
118
119 static const struct dell_bios_hotkey_table *dell_bios_hotkey_table;
120
121 static const u16 bios_to_linux_keycode[256] __initconst = {
122
123 KEY_MEDIA, KEY_NEXTSONG, KEY_PLAYPAUSE, KEY_PREVIOUSSONG,
124 KEY_STOPCD, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
125 KEY_WWW, KEY_UNKNOWN, KEY_VOLUMEDOWN, KEY_MUTE,
126 KEY_VOLUMEUP, KEY_UNKNOWN, KEY_BATTERY, KEY_EJECTCD,
127 KEY_UNKNOWN, KEY_SLEEP, KEY_PROG1, KEY_BRIGHTNESSDOWN,
128 KEY_BRIGHTNESSUP, KEY_UNKNOWN, KEY_KBDILLUMTOGGLE,
129 KEY_UNKNOWN, KEY_SWITCHVIDEOMODE, KEY_UNKNOWN, KEY_UNKNOWN,
130 KEY_SWITCHVIDEOMODE, KEY_UNKNOWN, KEY_UNKNOWN, KEY_PROG2,
131 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN,
132 KEY_UNKNOWN, KEY_UNKNOWN, KEY_UNKNOWN, KEY_MICMUTE,
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, 0, 0,
138 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
139 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
140 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
141 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
142 0, 0, 0, 0, 0, 0, 0, 0, 0, KEY_PROG3
143 };
144
145 static struct input_dev *dell_wmi_input_dev;
146
dell_wmi_process_key(int reported_key)147 static void dell_wmi_process_key(int reported_key)
148 {
149 const struct key_entry *key;
150
151 key = sparse_keymap_entry_from_scancode(dell_wmi_input_dev,
152 reported_key);
153 if (!key) {
154 pr_info("Unknown key %x pressed\n", reported_key);
155 return;
156 }
157
158 pr_debug("Key %x pressed\n", reported_key);
159
160 /* Don't report brightness notifications that will also come via ACPI */
161 if ((key->keycode == KEY_BRIGHTNESSUP ||
162 key->keycode == KEY_BRIGHTNESSDOWN) && acpi_video)
163 return;
164
165 sparse_keymap_report_entry(dell_wmi_input_dev, key, 1, true);
166 }
167
dell_wmi_notify(u32 value,void * context)168 static void dell_wmi_notify(u32 value, void *context)
169 {
170 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
171 union acpi_object *obj;
172 acpi_status status;
173 acpi_size buffer_size;
174 u16 *buffer_entry, *buffer_end;
175 int len, i;
176
177 status = wmi_get_event_data(value, &response);
178 if (status != AE_OK) {
179 pr_warn("bad event status 0x%x\n", status);
180 return;
181 }
182
183 obj = (union acpi_object *)response.pointer;
184 if (!obj) {
185 pr_warn("no response\n");
186 return;
187 }
188
189 if (obj->type != ACPI_TYPE_BUFFER) {
190 pr_warn("bad response type %x\n", obj->type);
191 kfree(obj);
192 return;
193 }
194
195 pr_debug("Received WMI event (%*ph)\n",
196 obj->buffer.length, obj->buffer.pointer);
197
198 buffer_entry = (u16 *)obj->buffer.pointer;
199 buffer_size = obj->buffer.length/2;
200
201 if (!dell_new_hk_type) {
202 if (buffer_size >= 3 && buffer_entry[1] == 0x0)
203 dell_wmi_process_key(buffer_entry[2]);
204 else if (buffer_size >= 2)
205 dell_wmi_process_key(buffer_entry[1]);
206 else
207 pr_info("Received unknown WMI event\n");
208 kfree(obj);
209 return;
210 }
211
212 buffer_end = buffer_entry + buffer_size;
213
214 while (buffer_entry < buffer_end) {
215
216 len = buffer_entry[0];
217 if (len == 0)
218 break;
219
220 len++;
221
222 if (buffer_entry + len > buffer_end) {
223 pr_warn("Invalid length of WMI event\n");
224 break;
225 }
226
227 pr_debug("Process buffer (%*ph)\n", len*2, buffer_entry);
228
229 switch (buffer_entry[1]) {
230 case 0x00:
231 for (i = 2; i < len; ++i) {
232 switch (buffer_entry[i]) {
233 case 0xe043:
234 /* NIC Link is Up */
235 pr_debug("NIC Link is Up\n");
236 break;
237 case 0xe044:
238 /* NIC Link is Down */
239 pr_debug("NIC Link is Down\n");
240 break;
241 case 0xe045:
242 /* Unknown event but defined in DSDT */
243 default:
244 /* Unknown event */
245 pr_info("Unknown WMI event type 0x00: "
246 "0x%x\n", (int)buffer_entry[i]);
247 break;
248 }
249 }
250 break;
251 case 0x10:
252 /* Keys pressed */
253 for (i = 2; i < len; ++i)
254 dell_wmi_process_key(buffer_entry[i]);
255 break;
256 case 0x11:
257 for (i = 2; i < len; ++i) {
258 switch (buffer_entry[i]) {
259 case 0xfff0:
260 /* Battery unplugged */
261 pr_debug("Battery unplugged\n");
262 break;
263 case 0xfff1:
264 /* Battery inserted */
265 pr_debug("Battery inserted\n");
266 break;
267 case 0x01e1:
268 case 0x02ea:
269 case 0x02eb:
270 case 0x02ec:
271 case 0x02f6:
272 /* Keyboard backlight level changed */
273 pr_debug("Keyboard backlight level "
274 "changed\n");
275 break;
276 default:
277 /* Unknown event */
278 pr_info("Unknown WMI event type 0x11: "
279 "0x%x\n", (int)buffer_entry[i]);
280 break;
281 }
282 }
283 break;
284 default:
285 /* Unknown event */
286 pr_info("Unknown WMI event type 0x%x\n",
287 (int)buffer_entry[1]);
288 break;
289 }
290
291 buffer_entry += len;
292
293 }
294
295 kfree(obj);
296 }
297
dell_wmi_prepare_new_keymap(void)298 static const struct key_entry * __init dell_wmi_prepare_new_keymap(void)
299 {
300 int hotkey_num = (dell_bios_hotkey_table->header.length - 4) /
301 sizeof(struct dell_bios_keymap_entry);
302 struct key_entry *keymap;
303 int i;
304
305 keymap = kcalloc(hotkey_num + 1, sizeof(struct key_entry), GFP_KERNEL);
306 if (!keymap)
307 return NULL;
308
309 for (i = 0; i < hotkey_num; i++) {
310 const struct dell_bios_keymap_entry *bios_entry =
311 &dell_bios_hotkey_table->keymap[i];
312 u16 keycode = bios_entry->keycode < 256 ?
313 bios_to_linux_keycode[bios_entry->keycode] :
314 KEY_RESERVED;
315
316 if (keycode == KEY_KBDILLUMTOGGLE)
317 keymap[i].type = KE_IGNORE;
318 else
319 keymap[i].type = KE_KEY;
320 keymap[i].code = bios_entry->scancode;
321 keymap[i].keycode = keycode;
322 }
323
324 keymap[hotkey_num].type = KE_END;
325
326 return keymap;
327 }
328
dell_wmi_input_setup(void)329 static int __init dell_wmi_input_setup(void)
330 {
331 int err;
332
333 dell_wmi_input_dev = input_allocate_device();
334 if (!dell_wmi_input_dev)
335 return -ENOMEM;
336
337 dell_wmi_input_dev->name = "Dell WMI hotkeys";
338 dell_wmi_input_dev->phys = "wmi/input0";
339 dell_wmi_input_dev->id.bustype = BUS_HOST;
340
341 if (dell_new_hk_type) {
342 const struct key_entry *keymap = dell_wmi_prepare_new_keymap();
343 if (!keymap) {
344 err = -ENOMEM;
345 goto err_free_dev;
346 }
347
348 err = sparse_keymap_setup(dell_wmi_input_dev, keymap, NULL);
349
350 /*
351 * Sparse keymap library makes a copy of keymap so we
352 * don't need the original one that was allocated.
353 */
354 kfree(keymap);
355 } else {
356 err = sparse_keymap_setup(dell_wmi_input_dev,
357 dell_wmi_legacy_keymap, NULL);
358 }
359 if (err)
360 goto err_free_dev;
361
362 err = input_register_device(dell_wmi_input_dev);
363 if (err)
364 goto err_free_keymap;
365
366 return 0;
367
368 err_free_keymap:
369 sparse_keymap_free(dell_wmi_input_dev);
370 err_free_dev:
371 input_free_device(dell_wmi_input_dev);
372 return err;
373 }
374
dell_wmi_input_destroy(void)375 static void dell_wmi_input_destroy(void)
376 {
377 sparse_keymap_free(dell_wmi_input_dev);
378 input_unregister_device(dell_wmi_input_dev);
379 }
380
find_hk_type(const struct dmi_header * dm,void * dummy)381 static void __init find_hk_type(const struct dmi_header *dm, void *dummy)
382 {
383 if (dm->type == 0xb2 && dm->length > 6) {
384 dell_new_hk_type = true;
385 dell_bios_hotkey_table =
386 container_of(dm, struct dell_bios_hotkey_table, header);
387 }
388 }
389
dell_wmi_init(void)390 static int __init dell_wmi_init(void)
391 {
392 int err;
393 acpi_status status;
394
395 if (!wmi_has_guid(DELL_EVENT_GUID)) {
396 pr_warn("No known WMI GUID found\n");
397 return -ENODEV;
398 }
399
400 dmi_walk(find_hk_type, NULL);
401 acpi_video = acpi_video_get_backlight_type() != acpi_backlight_vendor;
402
403 err = dell_wmi_input_setup();
404 if (err)
405 return err;
406
407 status = wmi_install_notify_handler(DELL_EVENT_GUID,
408 dell_wmi_notify, NULL);
409 if (ACPI_FAILURE(status)) {
410 dell_wmi_input_destroy();
411 pr_err("Unable to register notify handler - %d\n", status);
412 return -ENODEV;
413 }
414
415 return 0;
416 }
417 module_init(dell_wmi_init);
418
dell_wmi_exit(void)419 static void __exit dell_wmi_exit(void)
420 {
421 wmi_remove_notify_handler(DELL_EVENT_GUID);
422 dell_wmi_input_destroy();
423 }
424 module_exit(dell_wmi_exit);
425