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 <linux/wmi.h>
40 #include <acpi/video.h>
41 #include "dell-smbios.h"
43 MODULE_AUTHOR("Matthew Garrett <mjg@redhat.com>");
44 MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>");
45 MODULE_DESCRIPTION("Dell laptop WMI hotkeys driver");
46 MODULE_LICENSE("GPL");
48 #define DELL_EVENT_GUID "9DBB5994-A997-11DA-B012-B622A1EF5492"
49 #define DELL_DESCRIPTOR_GUID "8D9DDCBC-A997-11DA-B012-B622A1EF5492"
51 static u32 dell_wmi_interface_version
;
52 static bool wmi_requires_smbios_request
;
54 MODULE_ALIAS("wmi:"DELL_EVENT_GUID
);
55 MODULE_ALIAS("wmi:"DELL_DESCRIPTOR_GUID
);
57 struct dell_wmi_priv
{
58 struct input_dev
*input_dev
;
61 static int __init
dmi_matched(const struct dmi_system_id
*dmi
)
63 wmi_requires_smbios_request
= 1;
67 static const struct dmi_system_id dell_wmi_smbios_list
[] __initconst
= {
69 .callback
= dmi_matched
,
70 .ident
= "Dell Inspiron M5110",
72 DMI_MATCH(DMI_SYS_VENDOR
, "Dell Inc."),
73 DMI_MATCH(DMI_PRODUCT_NAME
, "Inspiron M5110"),
77 .callback
= dmi_matched
,
78 .ident
= "Dell Vostro V131",
80 DMI_MATCH(DMI_SYS_VENDOR
, "Dell Inc."),
81 DMI_MATCH(DMI_PRODUCT_NAME
, "Vostro V131"),
88 * Keymap for WMI events of type 0x0000
90 * Certain keys are flagged as KE_IGNORE. All of these are either
91 * notifications (rather than requests for change) or are also sent
92 * via the keyboard controller so should not be sent again.
94 static const struct key_entry dell_wmi_keymap_type_0000
[] = {
95 { KE_IGNORE
, 0x003a, { KEY_CAPSLOCK
} },
97 /* Key code is followed by brightness level */
98 { KE_KEY
, 0xe005, { KEY_BRIGHTNESSDOWN
} },
99 { KE_KEY
, 0xe006, { KEY_BRIGHTNESSUP
} },
101 /* Battery health status button */
102 { KE_KEY
, 0xe007, { KEY_BATTERY
} },
104 /* Radio devices state change, key code is followed by other values */
105 { KE_IGNORE
, 0xe008, { KEY_RFKILL
} },
107 { KE_KEY
, 0xe009, { KEY_EJECTCD
} },
109 /* Key code is followed by: next, active and attached devices */
110 { KE_KEY
, 0xe00b, { KEY_SWITCHVIDEOMODE
} },
112 /* Key code is followed by keyboard illumination level */
113 { KE_IGNORE
, 0xe00c, { KEY_KBDILLUMTOGGLE
} },
115 /* BIOS error detected */
116 { KE_IGNORE
, 0xe00d, { KEY_RESERVED
} },
118 /* Battery was removed or inserted */
119 { KE_IGNORE
, 0xe00e, { KEY_RESERVED
} },
122 { KE_KEY
, 0xe011, { KEY_WLAN
} },
124 /* Ambient light sensor toggle */
125 { KE_IGNORE
, 0xe013, { KEY_RESERVED
} },
127 { KE_IGNORE
, 0xe020, { KEY_MUTE
} },
129 /* Unknown, defined in ACPI DSDT */
130 /* { KE_IGNORE, 0xe023, { KEY_RESERVED } }, */
132 /* Untested, Dell Instant Launch key on Inspiron 7520 */
133 /* { KE_IGNORE, 0xe024, { KEY_RESERVED } }, */
135 /* Dell Instant Launch key */
136 { KE_KEY
, 0xe025, { KEY_PROG4
} },
138 /* Audio panel key */
139 { KE_IGNORE
, 0xe026, { KEY_RESERVED
} },
141 /* LCD Display On/Off Control key */
142 { KE_KEY
, 0xe027, { KEY_DISPLAYTOGGLE
} },
144 /* Untested, Multimedia key on Dell Vostro 3560 */
145 /* { KE_IGNORE, 0xe028, { KEY_RESERVED } }, */
147 /* Dell Instant Launch key */
148 { KE_KEY
, 0xe029, { KEY_PROG4
} },
150 /* Untested, Windows Mobility Center button on Inspiron 7520 */
151 /* { KE_IGNORE, 0xe02a, { KEY_RESERVED } }, */
153 /* Unknown, defined in ACPI DSDT */
154 /* { KE_IGNORE, 0xe02b, { KEY_RESERVED } }, */
156 /* Untested, Dell Audio With Preset Switch button on Inspiron 7520 */
157 /* { KE_IGNORE, 0xe02c, { KEY_RESERVED } }, */
159 { KE_IGNORE
, 0xe02e, { KEY_VOLUMEDOWN
} },
160 { KE_IGNORE
, 0xe030, { KEY_VOLUMEUP
} },
161 { KE_IGNORE
, 0xe033, { KEY_KBDILLUMUP
} },
162 { KE_IGNORE
, 0xe034, { KEY_KBDILLUMDOWN
} },
163 { KE_IGNORE
, 0xe03a, { KEY_CAPSLOCK
} },
166 { KE_IGNORE
, 0xe043, { KEY_RESERVED
} },
168 /* NIC Link is Down */
169 { KE_IGNORE
, 0xe044, { KEY_RESERVED
} },
172 * This entry is very suspicious!
173 * Originally Matthew Garrett created this dell-wmi driver specially for
174 * "button with a picture of a battery" which has event code 0xe045.
175 * Later Mario Limonciello from Dell told us that event code 0xe045 is
176 * reported by Num Lock and should be ignored because key is send also
177 * by keyboard controller.
178 * So for now we will ignore this event to prevent potential double
179 * Num Lock key press.
181 { KE_IGNORE
, 0xe045, { KEY_NUMLOCK
} },
183 /* Scroll lock and also going to tablet mode on portable devices */
184 { KE_IGNORE
, 0xe046, { KEY_SCROLLLOCK
} },
186 /* Untested, going from tablet mode on portable devices */
187 /* { KE_IGNORE, 0xe047, { KEY_RESERVED } }, */
189 /* Dell Support Center key */
190 { KE_IGNORE
, 0xe06e, { KEY_RESERVED
} },
192 { KE_IGNORE
, 0xe0f7, { KEY_MUTE
} },
193 { KE_IGNORE
, 0xe0f8, { KEY_VOLUMEDOWN
} },
194 { KE_IGNORE
, 0xe0f9, { KEY_VOLUMEUP
} },
197 struct dell_bios_keymap_entry
{
202 struct dell_bios_hotkey_table
{
203 struct dmi_header header
;
204 struct dell_bios_keymap_entry keymap
[];
208 struct dell_dmi_results
{
211 struct key_entry
*keymap
;
214 /* Uninitialized entries here are KEY_RESERVED == 0. */
215 static const u16 bios_to_linux_keycode
[256] = {
219 [3] = KEY_PREVIOUSSONG
,
226 [10] = KEY_VOLUMEDOWN
,
235 [19] = KEY_BRIGHTNESSDOWN
,
236 [20] = KEY_BRIGHTNESSUP
,
238 [22] = KEY_KBDILLUMTOGGLE
,
240 [24] = KEY_SWITCHVIDEOMODE
,
243 [27] = KEY_SWITCHVIDEOMODE
,
259 * Keymap for WMI events of type 0x0010
261 * These are applied if the 0xB2 DMI hotkey table is present and doesn't
264 static const struct key_entry dell_wmi_keymap_type_0010
[] = {
266 { KE_IGNORE
, 0x151, { KEY_RESERVED
} },
268 /* Change keyboard illumination */
269 { KE_IGNORE
, 0x152, { KEY_KBDILLUMTOGGLE
} },
272 * Radio disable (notify only -- there is no model for which the
273 * WMI event is supposed to trigger an action).
275 { KE_IGNORE
, 0x153, { KEY_RFKILL
} },
277 /* RGB keyboard backlight control */
278 { KE_IGNORE
, 0x154, { KEY_RESERVED
} },
281 * Stealth mode toggle. This will "disable all lights and sounds".
282 * The action is performed by the BIOS and EC; the WMI event is just
283 * a notification. On the XPS 13 9350, this is Fn+F7, and there's
284 * a BIOS setting to enable and disable the hotkey.
286 { KE_IGNORE
, 0x155, { KEY_RESERVED
} },
288 /* Rugged magnetic dock attach/detach events */
289 { KE_IGNORE
, 0x156, { KEY_RESERVED
} },
290 { KE_IGNORE
, 0x157, { KEY_RESERVED
} },
292 /* Rugged programmable (P1/P2/P3 keys) */
293 { KE_KEY
, 0x850, { KEY_PROG1
} },
294 { KE_KEY
, 0x851, { KEY_PROG2
} },
295 { KE_KEY
, 0x852, { KEY_PROG3
} },
300 * Keymap for WMI events of type 0x0011
302 static const struct key_entry dell_wmi_keymap_type_0011
[] = {
303 /* Battery unplugged */
304 { KE_IGNORE
, 0xfff0, { KEY_RESERVED
} },
306 /* Battery inserted */
307 { KE_IGNORE
, 0xfff1, { KEY_RESERVED
} },
309 /* Keyboard backlight level changed */
310 { KE_IGNORE
, 0x01e1, { KEY_RESERVED
} },
311 { KE_IGNORE
, 0x02ea, { KEY_RESERVED
} },
312 { KE_IGNORE
, 0x02eb, { KEY_RESERVED
} },
313 { KE_IGNORE
, 0x02ec, { KEY_RESERVED
} },
314 { KE_IGNORE
, 0x02f6, { KEY_RESERVED
} },
317 static void dell_wmi_process_key(struct wmi_device
*wdev
, int type
, int code
)
319 struct dell_wmi_priv
*priv
= dev_get_drvdata(&wdev
->dev
);
320 const struct key_entry
*key
;
322 key
= sparse_keymap_entry_from_scancode(priv
->input_dev
,
323 (type
<< 16) | code
);
325 pr_info("Unknown key with type 0x%04x and code 0x%04x pressed\n",
330 pr_debug("Key with type 0x%04x and code 0x%04x pressed\n", type
, code
);
332 /* Don't report brightness notifications that will also come via ACPI */
333 if ((key
->keycode
== KEY_BRIGHTNESSUP
||
334 key
->keycode
== KEY_BRIGHTNESSDOWN
) &&
335 acpi_video_handles_brightness_key_presses())
338 if (type
== 0x0000 && code
== 0xe025 && !wmi_requires_smbios_request
)
341 if (key
->keycode
== KEY_KBDILLUMTOGGLE
)
342 dell_laptop_call_notifier(
343 DELL_LAPTOP_KBD_BACKLIGHT_BRIGHTNESS_CHANGED
, NULL
);
345 sparse_keymap_report_entry(priv
->input_dev
, key
, 1, true);
348 static void dell_wmi_notify(struct wmi_device
*wdev
,
349 union acpi_object
*obj
)
351 u16
*buffer_entry
, *buffer_end
;
352 acpi_size buffer_size
;
355 if (obj
->type
!= ACPI_TYPE_BUFFER
) {
356 pr_warn("bad response type %x\n", obj
->type
);
360 pr_debug("Received WMI event (%*ph)\n",
361 obj
->buffer
.length
, obj
->buffer
.pointer
);
363 buffer_entry
= (u16
*)obj
->buffer
.pointer
;
364 buffer_size
= obj
->buffer
.length
/2;
365 buffer_end
= buffer_entry
+ buffer_size
;
368 * BIOS/ACPI on devices with WMI interface version 0 does not clear
369 * buffer before filling it. So next time when BIOS/ACPI send WMI event
370 * which is smaller as previous then it contains garbage in buffer from
373 * BIOS/ACPI on devices with WMI interface version 1 clears buffer and
374 * sometimes send more events in buffer at one call.
376 * So to prevent reading garbage from buffer we will process only first
377 * one event on devices with WMI interface version 0.
379 if (dell_wmi_interface_version
== 0 && buffer_entry
< buffer_end
)
380 if (buffer_end
> buffer_entry
+ buffer_entry
[0] + 1)
381 buffer_end
= buffer_entry
+ buffer_entry
[0] + 1;
383 while (buffer_entry
< buffer_end
) {
385 len
= buffer_entry
[0];
391 if (buffer_entry
+ len
> buffer_end
) {
392 pr_warn("Invalid length of WMI event\n");
396 pr_debug("Process buffer (%*ph)\n", len
*2, buffer_entry
);
398 switch (buffer_entry
[1]) {
399 case 0x0000: /* One key pressed or event occurred */
401 dell_wmi_process_key(wdev
, 0x0000,
403 /* Other entries could contain additional information */
405 case 0x0010: /* Sequence of keys pressed */
406 case 0x0011: /* Sequence of events occurred */
407 for (i
= 2; i
< len
; ++i
)
408 dell_wmi_process_key(wdev
, buffer_entry
[1],
411 default: /* Unknown event */
412 pr_info("Unknown WMI event type 0x%x\n",
413 (int)buffer_entry
[1]);
423 static bool have_scancode(u32 scancode
, const struct key_entry
*keymap
, int len
)
427 for (i
= 0; i
< len
; i
++)
428 if (keymap
[i
].code
== scancode
)
434 static void handle_dmi_entry(const struct dmi_header
*dm
, void *opaque
)
436 struct dell_dmi_results
*results
= opaque
;
437 struct dell_bios_hotkey_table
*table
;
438 int hotkey_num
, i
, pos
= 0;
439 struct key_entry
*keymap
;
441 if (results
->err
|| results
->keymap
)
442 return; /* We already found the hotkey table. */
444 /* The Dell hotkey table is type 0xB2. Scan until we find it. */
445 if (dm
->type
!= 0xb2)
448 table
= container_of(dm
, struct dell_bios_hotkey_table
, header
);
450 hotkey_num
= (table
->header
.length
-
451 sizeof(struct dell_bios_hotkey_table
)) /
452 sizeof(struct dell_bios_keymap_entry
);
453 if (hotkey_num
< 1) {
455 * Historically, dell-wmi would ignore a DMI entry of
456 * fewer than 7 bytes. Sizes between 4 and 8 bytes are
457 * nonsensical (both the header and all entries are 4
458 * bytes), so we approximate the old behavior by
459 * ignoring tables with fewer than one entry.
464 keymap
= kcalloc(hotkey_num
, sizeof(struct key_entry
), GFP_KERNEL
);
466 results
->err
= -ENOMEM
;
470 for (i
= 0; i
< hotkey_num
; i
++) {
471 const struct dell_bios_keymap_entry
*bios_entry
=
474 /* Uninitialized entries are 0 aka KEY_RESERVED. */
475 u16 keycode
= (bios_entry
->keycode
<
476 ARRAY_SIZE(bios_to_linux_keycode
)) ?
477 bios_to_linux_keycode
[bios_entry
->keycode
] :
481 * Log if we find an entry in the DMI table that we don't
482 * understand. If this happens, we should figure out what
483 * the entry means and add it to bios_to_linux_keycode.
485 if (keycode
== KEY_RESERVED
) {
486 pr_info("firmware scancode 0x%x maps to unrecognized keycode 0x%x\n",
487 bios_entry
->scancode
, bios_entry
->keycode
);
491 if (keycode
== KEY_KBDILLUMTOGGLE
)
492 keymap
[pos
].type
= KE_IGNORE
;
494 keymap
[pos
].type
= KE_KEY
;
495 keymap
[pos
].code
= bios_entry
->scancode
;
496 keymap
[pos
].keycode
= keycode
;
501 results
->keymap
= keymap
;
502 results
->keymap_size
= pos
;
505 static int dell_wmi_input_setup(struct wmi_device
*wdev
)
507 struct dell_wmi_priv
*priv
= dev_get_drvdata(&wdev
->dev
);
508 struct dell_dmi_results dmi_results
= {};
509 struct key_entry
*keymap
;
512 priv
->input_dev
= input_allocate_device();
513 if (!priv
->input_dev
)
516 priv
->input_dev
->name
= "Dell WMI hotkeys";
517 priv
->input_dev
->id
.bustype
= BUS_HOST
;
518 priv
->input_dev
->dev
.parent
= &wdev
->dev
;
520 if (dmi_walk(handle_dmi_entry
, &dmi_results
)) {
522 * Historically, dell-wmi ignored dmi_walk errors. A failure
523 * is certainly surprising, but it probably just indicates
526 pr_warn("no DMI; using the old-style hotkey interface\n");
529 if (dmi_results
.err
) {
530 err
= dmi_results
.err
;
534 keymap
= kcalloc(dmi_results
.keymap_size
+
535 ARRAY_SIZE(dell_wmi_keymap_type_0000
) +
536 ARRAY_SIZE(dell_wmi_keymap_type_0010
) +
537 ARRAY_SIZE(dell_wmi_keymap_type_0011
) +
539 sizeof(struct key_entry
), GFP_KERNEL
);
541 kfree(dmi_results
.keymap
);
546 /* Append table with events of type 0x0010 which comes from DMI */
547 for (i
= 0; i
< dmi_results
.keymap_size
; i
++) {
548 keymap
[pos
] = dmi_results
.keymap
[i
];
549 keymap
[pos
].code
|= (0x0010 << 16);
553 kfree(dmi_results
.keymap
);
555 /* Append table with extra events of type 0x0010 which are not in DMI */
556 for (i
= 0; i
< ARRAY_SIZE(dell_wmi_keymap_type_0010
); i
++) {
557 const struct key_entry
*entry
= &dell_wmi_keymap_type_0010
[i
];
560 * Check if we've already found this scancode. This takes
561 * quadratic time, but it doesn't matter unless the list
562 * of extra keys gets very long.
564 if (dmi_results
.keymap_size
&&
565 have_scancode(entry
->code
| (0x0010 << 16),
566 keymap
, dmi_results
.keymap_size
)
570 keymap
[pos
] = *entry
;
571 keymap
[pos
].code
|= (0x0010 << 16);
575 /* Append table with events of type 0x0011 */
576 for (i
= 0; i
< ARRAY_SIZE(dell_wmi_keymap_type_0011
); i
++) {
577 keymap
[pos
] = dell_wmi_keymap_type_0011
[i
];
578 keymap
[pos
].code
|= (0x0011 << 16);
583 * Now append also table with "legacy" events of type 0x0000. Some of
584 * them are reported also on laptops which have scancodes in DMI.
586 for (i
= 0; i
< ARRAY_SIZE(dell_wmi_keymap_type_0000
); i
++) {
587 keymap
[pos
] = dell_wmi_keymap_type_0000
[i
];
591 keymap
[pos
].type
= KE_END
;
593 err
= sparse_keymap_setup(priv
->input_dev
, keymap
, NULL
);
595 * Sparse keymap library makes a copy of keymap so we don't need the
596 * original one that was allocated.
602 err
= input_register_device(priv
->input_dev
);
609 input_free_device(priv
->input_dev
);
613 static void dell_wmi_input_destroy(struct wmi_device
*wdev
)
615 struct dell_wmi_priv
*priv
= dev_get_drvdata(&wdev
->dev
);
617 input_unregister_device(priv
->input_dev
);
621 * Descriptor buffer is 128 byte long and contains:
623 * Name Offset Length Value
624 * Vendor Signature 0 4 "DELL"
625 * Object Signature 4 4 " WMI"
626 * WMI Interface Version 8 4 <version>
627 * WMI buffer length 12 4 4096
629 static int __init
dell_wmi_check_descriptor_buffer(void)
631 struct acpi_buffer out
= { ACPI_ALLOCATE_BUFFER
, NULL
};
632 union acpi_object
*obj
;
636 status
= wmi_query_block(DELL_DESCRIPTOR_GUID
, 0, &out
);
637 if (ACPI_FAILURE(status
)) {
638 pr_err("Cannot read Dell descriptor buffer - %d\n", status
);
642 obj
= (union acpi_object
*)out
.pointer
;
644 pr_err("Dell descriptor buffer is empty\n");
648 if (obj
->type
!= ACPI_TYPE_BUFFER
) {
649 pr_err("Cannot read Dell descriptor buffer\n");
654 if (obj
->buffer
.length
!= 128) {
655 pr_err("Dell descriptor buffer has invalid length (%d)\n",
657 if (obj
->buffer
.length
< 16) {
663 buffer
= (u32
*)obj
->buffer
.pointer
;
665 if (buffer
[0] != 0x4C4C4544 && buffer
[1] != 0x494D5720)
666 pr_warn("Dell descriptor buffer has invalid signature (%*ph)\n",
669 if (buffer
[2] != 0 && buffer
[2] != 1)
670 pr_warn("Dell descriptor buffer has unknown version (%d)\n",
673 if (buffer
[3] != 4096)
674 pr_warn("Dell descriptor buffer has invalid buffer length (%d)\n",
677 dell_wmi_interface_version
= buffer
[2];
679 pr_info("Detected Dell WMI interface version %u\n",
680 dell_wmi_interface_version
);
687 * According to Dell SMBIOS documentation:
689 * 17 3 Application Program Registration
691 * cbArg1 Application ID 1 = 0x00010000
692 * cbArg2 Application ID 2
693 * QUICKSET/DCP = 0x51534554 "QSET"
694 * ALS Driver = 0x416c7353 "AlsS"
695 * Latitude ON = 0x4c6f6e52 "LonR"
696 * cbArg3 Application version or revision number
697 * cbArg4 0 = Unregister application
698 * 1 = Register application
699 * cbRes1 Standard return codes (0, -1, -2)
702 static int dell_wmi_events_set_enabled(bool enable
)
704 struct calling_interface_buffer
*buffer
;
707 buffer
= dell_smbios_get_buffer();
708 buffer
->input
[0] = 0x10000;
709 buffer
->input
[1] = 0x51534554;
710 buffer
->input
[3] = enable
;
711 dell_smbios_send_request(17, 3);
712 ret
= buffer
->output
[0];
713 dell_smbios_release_buffer();
715 return dell_smbios_error(ret
);
718 static int dell_wmi_probe(struct wmi_device
*wdev
)
720 struct dell_wmi_priv
*priv
= devm_kzalloc(
721 &wdev
->dev
, sizeof(struct dell_wmi_priv
), GFP_KERNEL
);
723 dev_set_drvdata(&wdev
->dev
, priv
);
725 return dell_wmi_input_setup(wdev
);
728 static int dell_wmi_remove(struct wmi_device
*wdev
)
730 dell_wmi_input_destroy(wdev
);
733 static const struct wmi_device_id dell_wmi_id_table
[] = {
734 { .guid_string
= DELL_EVENT_GUID
},
738 static struct wmi_driver dell_wmi_driver
= {
742 .id_table
= dell_wmi_id_table
,
743 .probe
= dell_wmi_probe
,
744 .remove
= dell_wmi_remove
,
745 .notify
= dell_wmi_notify
,
748 static int __init
dell_wmi_init(void)
752 err
= dell_wmi_check_descriptor_buffer();
756 dmi_check_system(dell_wmi_smbios_list
);
758 if (wmi_requires_smbios_request
) {
759 err
= dell_wmi_events_set_enabled(true);
761 pr_err("Failed to enable WMI events\n");
766 return wmi_driver_register(&dell_wmi_driver
);
768 module_init(dell_wmi_init
);
770 static void __exit
dell_wmi_exit(void)
772 if (wmi_requires_smbios_request
)
773 dell_wmi_events_set_enabled(false);
775 wmi_driver_unregister(&dell_wmi_driver
);
777 module_exit(dell_wmi_exit
);