4 * Copyright (C) 2008 Red Hat <mjg@redhat.com>
5 * Copyright (C) 2014-2015 Pali Rohár <pali.rohar@gmail.com>
7 * Portions based on wistron_btns.c:
8 * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
9 * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
10 * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
29 #include <linux/kernel.h>
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/slab.h>
33 #include <linux/types.h>
34 #include <linux/input.h>
35 #include <linux/input/sparse-keymap.h>
36 #include <linux/acpi.h>
37 #include <linux/string.h>
38 #include <linux/dmi.h>
39 #include <acpi/video.h>
40 #include "dell-smbios.h"
42 MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
43 MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>");
44 MODULE_DESCRIPTION("Dell laptop WMI hotkeys driver");
45 MODULE_LICENSE("GPL");
47 #define DELL_EVENT_GUID "9DBB5994-A997-11DA-B012-B622A1EF5492"
48 #define DELL_DESCRIPTOR_GUID "8D9DDCBC-A997-11DA-B012-B622A1EF5492"
50 static u32 dell_wmi_interface_version
;
51 static bool wmi_requires_smbios_request
;
53 MODULE_ALIAS("wmi:"DELL_EVENT_GUID
);
54 MODULE_ALIAS("wmi:"DELL_DESCRIPTOR_GUID
);
56 static int __init
dmi_matched(const struct dmi_system_id
*dmi
)
58 wmi_requires_smbios_request
= 1;
62 static const struct dmi_system_id dell_wmi_smbios_list
[] __initconst
= {
64 .callback
= dmi_matched
,
65 .ident
= "Dell Inspiron M5110",
67 DMI_MATCH(DMI_SYS_VENDOR
, "Dell Inc."),
68 DMI_MATCH(DMI_PRODUCT_NAME
, "Inspiron M5110"),
72 .callback
= dmi_matched
,
73 .ident
= "Dell Vostro V131",
75 DMI_MATCH(DMI_SYS_VENDOR
, "Dell Inc."),
76 DMI_MATCH(DMI_PRODUCT_NAME
, "Vostro V131"),
83 * Keymap for WMI events of type 0x0000
85 * Certain keys are flagged as KE_IGNORE. All of these are either
86 * notifications (rather than requests for change) or are also sent
87 * via the keyboard controller so should not be sent again.
89 static const struct key_entry dell_wmi_keymap_type_0000
[] __initconst
= {
90 { KE_IGNORE
, 0x003a, { KEY_CAPSLOCK
} },
92 /* Key code is followed by brightness level */
93 { KE_KEY
, 0xe005, { KEY_BRIGHTNESSDOWN
} },
94 { KE_KEY
, 0xe006, { KEY_BRIGHTNESSUP
} },
96 /* Battery health status button */
97 { KE_KEY
, 0xe007, { KEY_BATTERY
} },
99 /* Radio devices state change, key code is followed by other values */
100 { KE_IGNORE
, 0xe008, { KEY_RFKILL
} },
102 { KE_KEY
, 0xe009, { KEY_EJECTCD
} },
104 /* Key code is followed by: next, active and attached devices */
105 { KE_KEY
, 0xe00b, { KEY_SWITCHVIDEOMODE
} },
107 /* Key code is followed by keyboard illumination level */
108 { KE_IGNORE
, 0xe00c, { KEY_KBDILLUMTOGGLE
} },
110 /* BIOS error detected */
111 { KE_IGNORE
, 0xe00d, { KEY_RESERVED
} },
113 /* Unknown, defined in ACPI DSDT */
114 /* { KE_IGNORE, 0xe00e, { KEY_RESERVED } }, */
117 { KE_KEY
, 0xe011, { KEY_PROG2
} },
119 /* Ambient light sensor toggle */
120 { KE_IGNORE
, 0xe013, { KEY_RESERVED
} },
122 { KE_IGNORE
, 0xe020, { KEY_MUTE
} },
124 /* Unknown, defined in ACPI DSDT */
125 /* { KE_IGNORE, 0xe023, { KEY_RESERVED } }, */
127 /* Untested, Dell Instant Launch key on Inspiron 7520 */
128 /* { KE_IGNORE, 0xe024, { KEY_RESERVED } }, */
130 /* Dell Instant Launch key */
131 { KE_KEY
, 0xe025, { KEY_PROG4
} },
133 /* Audio panel key */
134 { KE_IGNORE
, 0xe026, { KEY_RESERVED
} },
136 /* LCD Display On/Off Control key */
137 { KE_KEY
, 0xe027, { KEY_DISPLAYTOGGLE
} },
139 /* Untested, Multimedia key on Dell Vostro 3560 */
140 /* { KE_IGNORE, 0xe028, { KEY_RESERVED } }, */
142 /* Dell Instant Launch key */
143 { KE_KEY
, 0xe029, { KEY_PROG4
} },
145 /* Untested, Windows Mobility Center button on Inspiron 7520 */
146 /* { KE_IGNORE, 0xe02a, { KEY_RESERVED } }, */
148 /* Unknown, defined in ACPI DSDT */
149 /* { KE_IGNORE, 0xe02b, { KEY_RESERVED } }, */
151 /* Untested, Dell Audio With Preset Switch button on Inspiron 7520 */
152 /* { KE_IGNORE, 0xe02c, { KEY_RESERVED } }, */
154 { KE_IGNORE
, 0xe02e, { KEY_VOLUMEDOWN
} },
155 { KE_IGNORE
, 0xe030, { KEY_VOLUMEUP
} },
156 { KE_IGNORE
, 0xe033, { KEY_KBDILLUMUP
} },
157 { KE_IGNORE
, 0xe034, { KEY_KBDILLUMDOWN
} },
158 { KE_IGNORE
, 0xe03a, { KEY_CAPSLOCK
} },
161 { KE_IGNORE
, 0xe043, { KEY_RESERVED
} },
163 /* NIC Link is Down */
164 { KE_IGNORE
, 0xe044, { KEY_RESERVED
} },
167 * This entry is very suspicious!
168 * Originally Matthew Garrett created this dell-wmi driver specially for
169 * "button with a picture of a battery" which has event code 0xe045.
170 * Later Mario Limonciello from Dell told us that event code 0xe045 is
171 * reported by Num Lock and should be ignored because key is send also
172 * by keyboard controller.
173 * So for now we will ignore this event to prevent potential double
174 * Num Lock key press.
176 { KE_IGNORE
, 0xe045, { KEY_NUMLOCK
} },
178 /* Scroll lock and also going to tablet mode on portable devices */
179 { KE_IGNORE
, 0xe046, { KEY_SCROLLLOCK
} },
181 /* Untested, going from tablet mode on portable devices */
182 /* { KE_IGNORE, 0xe047, { KEY_RESERVED } }, */
184 /* Dell Support Center key */
185 { KE_IGNORE
, 0xe06e, { KEY_RESERVED
} },
187 { KE_IGNORE
, 0xe0f7, { KEY_MUTE
} },
188 { KE_IGNORE
, 0xe0f8, { KEY_VOLUMEDOWN
} },
189 { KE_IGNORE
, 0xe0f9, { KEY_VOLUMEUP
} },
192 struct dell_bios_keymap_entry
{
197 struct dell_bios_hotkey_table
{
198 struct dmi_header header
;
199 struct dell_bios_keymap_entry keymap
[];
203 struct dell_dmi_results
{
206 struct key_entry
*keymap
;
209 /* Uninitialized entries here are KEY_RESERVED == 0. */
210 static const u16 bios_to_linux_keycode
[256] __initconst
= {
214 [3] = KEY_PREVIOUSSONG
,
221 [10] = KEY_VOLUMEDOWN
,
230 [19] = KEY_BRIGHTNESSDOWN
,
231 [20] = KEY_BRIGHTNESSUP
,
233 [22] = KEY_KBDILLUMTOGGLE
,
235 [24] = KEY_SWITCHVIDEOMODE
,
238 [27] = KEY_SWITCHVIDEOMODE
,
254 * Keymap for WMI events of type 0x0010
256 * These are applied if the 0xB2 DMI hotkey table is present and doesn't
259 static const struct key_entry dell_wmi_keymap_type_0010
[] __initconst
= {
261 { KE_IGNORE
, 0x151, { KEY_RESERVED
} },
263 /* Change keyboard illumination */
264 { KE_IGNORE
, 0x152, { KEY_KBDILLUMTOGGLE
} },
267 * Radio disable (notify only -- there is no model for which the
268 * WMI event is supposed to trigger an action).
270 { KE_IGNORE
, 0x153, { KEY_RFKILL
} },
272 /* RGB keyboard backlight control */
273 { KE_IGNORE
, 0x154, { KEY_RESERVED
} },
275 /* Stealth mode toggle */
276 { KE_IGNORE
, 0x155, { KEY_RESERVED
} },
280 * Keymap for WMI events of type 0x0011
282 static const struct key_entry dell_wmi_keymap_type_0011
[] __initconst
= {
283 /* Battery unplugged */
284 { KE_IGNORE
, 0xfff0, { KEY_RESERVED
} },
286 /* Battery inserted */
287 { KE_IGNORE
, 0xfff1, { KEY_RESERVED
} },
289 /* Keyboard backlight level changed */
290 { KE_IGNORE
, 0x01e1, { KEY_RESERVED
} },
291 { KE_IGNORE
, 0x02ea, { KEY_RESERVED
} },
292 { KE_IGNORE
, 0x02eb, { KEY_RESERVED
} },
293 { KE_IGNORE
, 0x02ec, { KEY_RESERVED
} },
294 { KE_IGNORE
, 0x02f6, { KEY_RESERVED
} },
297 static struct input_dev
*dell_wmi_input_dev
;
299 static void dell_wmi_process_key(int type
, int code
)
301 const struct key_entry
*key
;
303 key
= sparse_keymap_entry_from_scancode(dell_wmi_input_dev
,
304 (type
<< 16) | code
);
306 pr_info("Unknown key with type 0x%04x and code 0x%04x pressed\n",
311 pr_debug("Key with type 0x%04x and code 0x%04x pressed\n", type
, code
);
313 /* Don't report brightness notifications that will also come via ACPI */
314 if ((key
->keycode
== KEY_BRIGHTNESSUP
||
315 key
->keycode
== KEY_BRIGHTNESSDOWN
) &&
316 acpi_video_handles_brightness_key_presses())
319 if (type
== 0x0000 && code
== 0xe025 && !wmi_requires_smbios_request
)
322 sparse_keymap_report_entry(dell_wmi_input_dev
, key
, 1, true);
325 static void dell_wmi_notify(u32 value
, void *context
)
327 struct acpi_buffer response
= { ACPI_ALLOCATE_BUFFER
, NULL
};
328 union acpi_object
*obj
;
330 acpi_size buffer_size
;
331 u16
*buffer_entry
, *buffer_end
;
334 status
= wmi_get_event_data(value
, &response
);
335 if (status
!= AE_OK
) {
336 pr_warn("bad event status 0x%x\n", status
);
340 obj
= (union acpi_object
*)response
.pointer
;
342 pr_warn("no response\n");
346 if (obj
->type
!= ACPI_TYPE_BUFFER
) {
347 pr_warn("bad response type %x\n", obj
->type
);
352 pr_debug("Received WMI event (%*ph)\n",
353 obj
->buffer
.length
, obj
->buffer
.pointer
);
355 buffer_entry
= (u16
*)obj
->buffer
.pointer
;
356 buffer_size
= obj
->buffer
.length
/2;
357 buffer_end
= buffer_entry
+ buffer_size
;
360 * BIOS/ACPI on devices with WMI interface version 0 does not clear
361 * buffer before filling it. So next time when BIOS/ACPI send WMI event
362 * which is smaller as previous then it contains garbage in buffer from
365 * BIOS/ACPI on devices with WMI interface version 1 clears buffer and
366 * sometimes send more events in buffer at one call.
368 * So to prevent reading garbage from buffer we will process only first
369 * one event on devices with WMI interface version 0.
371 if (dell_wmi_interface_version
== 0 && buffer_entry
< buffer_end
)
372 if (buffer_end
> buffer_entry
+ buffer_entry
[0] + 1)
373 buffer_end
= buffer_entry
+ buffer_entry
[0] + 1;
375 while (buffer_entry
< buffer_end
) {
377 len
= buffer_entry
[0];
383 if (buffer_entry
+ len
> buffer_end
) {
384 pr_warn("Invalid length of WMI event\n");
388 pr_debug("Process buffer (%*ph)\n", len
*2, buffer_entry
);
390 switch (buffer_entry
[1]) {
391 case 0x0000: /* One key pressed or event occurred */
393 dell_wmi_process_key(0x0000, buffer_entry
[2]);
394 /* Other entries could contain additional information */
396 case 0x0010: /* Sequence of keys pressed */
397 case 0x0011: /* Sequence of events occurred */
398 for (i
= 2; i
< len
; ++i
)
399 dell_wmi_process_key(buffer_entry
[1],
402 default: /* Unknown event */
403 pr_info("Unknown WMI event type 0x%x\n",
404 (int)buffer_entry
[1]);
415 static bool have_scancode(u32 scancode
, const struct key_entry
*keymap
, int len
)
419 for (i
= 0; i
< len
; i
++)
420 if (keymap
[i
].code
== scancode
)
426 static void __init
handle_dmi_entry(const struct dmi_header
*dm
,
430 struct dell_dmi_results
*results
= opaque
;
431 struct dell_bios_hotkey_table
*table
;
432 int hotkey_num
, i
, pos
= 0;
433 struct key_entry
*keymap
;
435 if (results
->err
|| results
->keymap
)
436 return; /* We already found the hotkey table. */
438 if (dm
->type
!= 0xb2)
441 table
= container_of(dm
, struct dell_bios_hotkey_table
, header
);
443 hotkey_num
= (table
->header
.length
-
444 sizeof(struct dell_bios_hotkey_table
)) /
445 sizeof(struct dell_bios_keymap_entry
);
446 if (hotkey_num
< 1) {
448 * Historically, dell-wmi would ignore a DMI entry of
449 * fewer than 7 bytes. Sizes between 4 and 8 bytes are
450 * nonsensical (both the header and all entries are 4
451 * bytes), so we approximate the old behavior by
452 * ignoring tables with fewer than one entry.
457 keymap
= kcalloc(hotkey_num
, sizeof(struct key_entry
), GFP_KERNEL
);
459 results
->err
= -ENOMEM
;
463 for (i
= 0; i
< hotkey_num
; i
++) {
464 const struct dell_bios_keymap_entry
*bios_entry
=
467 /* Uninitialized entries are 0 aka KEY_RESERVED. */
468 u16 keycode
= (bios_entry
->keycode
<
469 ARRAY_SIZE(bios_to_linux_keycode
)) ?
470 bios_to_linux_keycode
[bios_entry
->keycode
] :
474 * Log if we find an entry in the DMI table that we don't
475 * understand. If this happens, we should figure out what
476 * the entry means and add it to bios_to_linux_keycode.
478 if (keycode
== KEY_RESERVED
) {
479 pr_info("firmware scancode 0x%x maps to unrecognized keycode 0x%x\n",
480 bios_entry
->scancode
, bios_entry
->keycode
);
484 if (keycode
== KEY_KBDILLUMTOGGLE
)
485 keymap
[pos
].type
= KE_IGNORE
;
487 keymap
[pos
].type
= KE_KEY
;
488 keymap
[pos
].code
= bios_entry
->scancode
;
489 keymap
[pos
].keycode
= keycode
;
494 results
->keymap
= keymap
;
495 results
->keymap_size
= pos
;
498 static int __init
dell_wmi_input_setup(void)
500 struct dell_dmi_results dmi_results
= {};
501 struct key_entry
*keymap
;
504 dell_wmi_input_dev
= input_allocate_device();
505 if (!dell_wmi_input_dev
)
508 dell_wmi_input_dev
->name
= "Dell WMI hotkeys";
509 dell_wmi_input_dev
->phys
= "wmi/input0";
510 dell_wmi_input_dev
->id
.bustype
= BUS_HOST
;
512 if (dmi_walk(handle_dmi_entry
, &dmi_results
)) {
514 * Historically, dell-wmi ignored dmi_walk errors. A failure
515 * is certainly surprising, but it probably just indicates
518 pr_warn("no DMI; using the old-style hotkey interface\n");
521 if (dmi_results
.err
) {
522 err
= dmi_results
.err
;
526 keymap
= kcalloc(dmi_results
.keymap_size
+
527 ARRAY_SIZE(dell_wmi_keymap_type_0000
) +
528 ARRAY_SIZE(dell_wmi_keymap_type_0010
) +
529 ARRAY_SIZE(dell_wmi_keymap_type_0011
) +
531 sizeof(struct key_entry
), GFP_KERNEL
);
533 kfree(dmi_results
.keymap
);
538 /* Append table with events of type 0x0010 which comes from DMI */
539 for (i
= 0; i
< dmi_results
.keymap_size
; i
++) {
540 keymap
[pos
] = dmi_results
.keymap
[i
];
541 keymap
[pos
].code
|= (0x0010 << 16);
545 kfree(dmi_results
.keymap
);
547 /* Append table with extra events of type 0x0010 which are not in DMI */
548 for (i
= 0; i
< ARRAY_SIZE(dell_wmi_keymap_type_0010
); i
++) {
549 const struct key_entry
*entry
= &dell_wmi_keymap_type_0010
[i
];
552 * Check if we've already found this scancode. This takes
553 * quadratic time, but it doesn't matter unless the list
554 * of extra keys gets very long.
556 if (dmi_results
.keymap_size
&&
557 have_scancode(entry
->code
| (0x0010 << 16),
558 keymap
, dmi_results
.keymap_size
)
562 keymap
[pos
] = *entry
;
563 keymap
[pos
].code
|= (0x0010 << 16);
567 /* Append table with events of type 0x0011 */
568 for (i
= 0; i
< ARRAY_SIZE(dell_wmi_keymap_type_0011
); i
++) {
569 keymap
[pos
] = dell_wmi_keymap_type_0011
[i
];
570 keymap
[pos
].code
|= (0x0011 << 16);
575 * Now append also table with "legacy" events of type 0x0000. Some of
576 * them are reported also on laptops which have scancodes in DMI.
578 for (i
= 0; i
< ARRAY_SIZE(dell_wmi_keymap_type_0000
); i
++) {
579 keymap
[pos
] = dell_wmi_keymap_type_0000
[i
];
583 keymap
[pos
].type
= KE_END
;
585 err
= sparse_keymap_setup(dell_wmi_input_dev
, keymap
, NULL
);
587 * Sparse keymap library makes a copy of keymap so we don't need the
588 * original one that was allocated.
594 err
= input_register_device(dell_wmi_input_dev
);
596 goto err_free_keymap
;
601 sparse_keymap_free(dell_wmi_input_dev
);
603 input_free_device(dell_wmi_input_dev
);
607 static void dell_wmi_input_destroy(void)
609 sparse_keymap_free(dell_wmi_input_dev
);
610 input_unregister_device(dell_wmi_input_dev
);
614 * Descriptor buffer is 128 byte long and contains:
616 * Name Offset Length Value
617 * Vendor Signature 0 4 "DELL"
618 * Object Signature 4 4 " WMI"
619 * WMI Interface Version 8 4 <version>
620 * WMI buffer length 12 4 4096
622 static int __init
dell_wmi_check_descriptor_buffer(void)
624 struct acpi_buffer out
= { ACPI_ALLOCATE_BUFFER
, NULL
};
625 union acpi_object
*obj
;
629 status
= wmi_query_block(DELL_DESCRIPTOR_GUID
, 0, &out
);
630 if (ACPI_FAILURE(status
)) {
631 pr_err("Cannot read Dell descriptor buffer - %d\n", status
);
635 obj
= (union acpi_object
*)out
.pointer
;
637 pr_err("Dell descriptor buffer is empty\n");
641 if (obj
->type
!= ACPI_TYPE_BUFFER
) {
642 pr_err("Cannot read Dell descriptor buffer\n");
647 if (obj
->buffer
.length
!= 128) {
648 pr_err("Dell descriptor buffer has invalid length (%d)\n",
650 if (obj
->buffer
.length
< 16) {
656 buffer
= (u32
*)obj
->buffer
.pointer
;
658 if (buffer
[0] != 0x4C4C4544 && buffer
[1] != 0x494D5720)
659 pr_warn("Dell descriptor buffer has invalid signature (%*ph)\n",
662 if (buffer
[2] != 0 && buffer
[2] != 1)
663 pr_warn("Dell descriptor buffer has unknown version (%d)\n",
666 if (buffer
[3] != 4096)
667 pr_warn("Dell descriptor buffer has invalid buffer length (%d)\n",
670 dell_wmi_interface_version
= buffer
[2];
672 pr_info("Detected Dell WMI interface version %u\n",
673 dell_wmi_interface_version
);
680 * According to Dell SMBIOS documentation:
682 * 17 3 Application Program Registration
684 * cbArg1 Application ID 1 = 0x00010000
685 * cbArg2 Application ID 2
686 * QUICKSET/DCP = 0x51534554 "QSET"
687 * ALS Driver = 0x416c7353 "AlsS"
688 * Latitude ON = 0x4c6f6e52 "LonR"
689 * cbArg3 Application version or revision number
690 * cbArg4 0 = Unregister application
691 * 1 = Register application
692 * cbRes1 Standard return codes (0, -1, -2)
695 static int dell_wmi_events_set_enabled(bool enable
)
697 struct calling_interface_buffer
*buffer
;
700 buffer
= dell_smbios_get_buffer();
701 buffer
->input
[0] = 0x10000;
702 buffer
->input
[1] = 0x51534554;
703 buffer
->input
[3] = enable
;
704 dell_smbios_send_request(17, 3);
705 ret
= buffer
->output
[0];
706 dell_smbios_release_buffer();
708 return dell_smbios_error(ret
);
711 static int __init
dell_wmi_init(void)
716 if (!wmi_has_guid(DELL_EVENT_GUID
) ||
717 !wmi_has_guid(DELL_DESCRIPTOR_GUID
)) {
718 pr_warn("Dell WMI GUID were not found\n");
722 err
= dell_wmi_check_descriptor_buffer();
726 err
= dell_wmi_input_setup();
730 status
= wmi_install_notify_handler(DELL_EVENT_GUID
,
731 dell_wmi_notify
, NULL
);
732 if (ACPI_FAILURE(status
)) {
733 dell_wmi_input_destroy();
734 pr_err("Unable to register notify handler - %d\n", status
);
738 dmi_check_system(dell_wmi_smbios_list
);
740 if (wmi_requires_smbios_request
) {
741 err
= dell_wmi_events_set_enabled(true);
743 pr_err("Failed to enable WMI events\n");
744 wmi_remove_notify_handler(DELL_EVENT_GUID
);
745 dell_wmi_input_destroy();
752 module_init(dell_wmi_init
);
754 static void __exit
dell_wmi_exit(void)
756 if (wmi_requires_smbios_request
)
757 dell_wmi_events_set_enabled(false);
758 wmi_remove_notify_handler(DELL_EVENT_GUID
);
759 dell_wmi_input_destroy();
761 module_exit(dell_wmi_exit
);