2 * Eee PC WMI hotkey driver
4 * Copyright(C) 2010 Intel Corporation.
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>
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.
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.
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
26 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28 #include <linux/kernel.h>
29 #include <linux/module.h>
30 #include <linux/init.h>
31 #include <linux/types.h>
32 #include <linux/slab.h>
33 #include <linux/input.h>
34 #include <linux/input/sparse-keymap.h>
36 #include <linux/backlight.h>
37 #include <linux/platform_device.h>
38 #include <acpi/acpi_bus.h>
39 #include <acpi/acpi_drivers.h>
41 #define EEEPC_WMI_FILE "eeepc-wmi"
43 MODULE_AUTHOR("Yong Wang <yong.y.wang@intel.com>");
44 MODULE_DESCRIPTION("Eee PC WMI Hotkey Driver");
45 MODULE_LICENSE("GPL");
47 #define EEEPC_WMI_EVENT_GUID "ABBC0F72-8EA1-11D1-00A0-C90629100000"
48 #define EEEPC_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
50 MODULE_ALIAS("wmi:"EEEPC_WMI_EVENT_GUID
);
51 MODULE_ALIAS("wmi:"EEEPC_WMI_MGMT_GUID
);
53 #define NOTIFY_BRNUP_MIN 0x11
54 #define NOTIFY_BRNUP_MAX 0x1f
55 #define NOTIFY_BRNDOWN_MIN 0x20
56 #define NOTIFY_BRNDOWN_MAX 0x2e
58 #define EEEPC_WMI_METHODID_DEVS 0x53564544
59 #define EEEPC_WMI_METHODID_DSTS 0x53544344
60 #define EEEPC_WMI_METHODID_CFVS 0x53564643
62 #define EEEPC_WMI_DEVID_BACKLIGHT 0x00050012
64 static const struct key_entry eeepc_wmi_keymap
[] = {
65 /* Sleep already handled via generic ACPI code */
66 { KE_KEY
, 0x5d, { KEY_WLAN
} },
67 { KE_KEY
, 0x32, { KEY_MUTE
} },
68 { KE_KEY
, 0x31, { KEY_VOLUMEDOWN
} },
69 { KE_KEY
, 0x30, { KEY_VOLUMEUP
} },
70 { KE_IGNORE
, NOTIFY_BRNDOWN_MIN
, { KEY_BRIGHTNESSDOWN
} },
71 { KE_IGNORE
, NOTIFY_BRNUP_MIN
, { KEY_BRIGHTNESSUP
} },
72 { KE_KEY
, 0xcc, { KEY_SWITCHVIDEOMODE
} },
73 { KE_KEY
, 0x6b, { KEY_F13
} }, /* Disable Touchpad */
74 { KE_KEY
, 0xe1, { KEY_F14
} },
75 { KE_KEY
, 0xe9, { KEY_DISPLAY_OFF
} },
76 { KE_KEY
, 0xe0, { KEY_PROG1
} },
77 { KE_KEY
, 0x5c, { KEY_F15
} },
87 struct input_dev
*inputdev
;
88 struct backlight_device
*backlight_device
;
91 static struct platform_device
*platform_device
;
93 static int eeepc_wmi_input_init(struct eeepc_wmi
*eeepc
)
97 eeepc
->inputdev
= input_allocate_device();
101 eeepc
->inputdev
->name
= "Eee PC WMI hotkeys";
102 eeepc
->inputdev
->phys
= EEEPC_WMI_FILE
"/input0";
103 eeepc
->inputdev
->id
.bustype
= BUS_HOST
;
104 eeepc
->inputdev
->dev
.parent
= &platform_device
->dev
;
106 err
= sparse_keymap_setup(eeepc
->inputdev
, eeepc_wmi_keymap
, NULL
);
110 err
= input_register_device(eeepc
->inputdev
);
112 goto err_free_keymap
;
117 sparse_keymap_free(eeepc
->inputdev
);
119 input_free_device(eeepc
->inputdev
);
123 static void eeepc_wmi_input_exit(struct eeepc_wmi
*eeepc
)
125 if (eeepc
->inputdev
) {
126 sparse_keymap_free(eeepc
->inputdev
);
127 input_unregister_device(eeepc
->inputdev
);
130 eeepc
->inputdev
= NULL
;
133 static acpi_status
eeepc_wmi_get_devstate(u32 dev_id
, u32
*ctrl_param
)
135 struct acpi_buffer input
= { (acpi_size
)sizeof(u32
), &dev_id
};
136 struct acpi_buffer output
= { ACPI_ALLOCATE_BUFFER
, NULL
};
137 union acpi_object
*obj
;
141 status
= wmi_evaluate_method(EEEPC_WMI_MGMT_GUID
,
142 1, EEEPC_WMI_METHODID_DSTS
, &input
, &output
);
144 if (ACPI_FAILURE(status
))
147 obj
= (union acpi_object
*)output
.pointer
;
148 if (obj
&& obj
->type
== ACPI_TYPE_INTEGER
)
149 tmp
= (u32
)obj
->integer
.value
;
162 static acpi_status
eeepc_wmi_set_devstate(u32 dev_id
, u32 ctrl_param
)
164 struct bios_args args
= {
166 .ctrl_param
= ctrl_param
,
168 struct acpi_buffer input
= { (acpi_size
)sizeof(args
), &args
};
171 status
= wmi_evaluate_method(EEEPC_WMI_MGMT_GUID
,
172 1, EEEPC_WMI_METHODID_DEVS
, &input
, NULL
);
177 static int read_brightness(struct backlight_device
*bd
)
179 static u32 ctrl_param
;
182 status
= eeepc_wmi_get_devstate(EEEPC_WMI_DEVID_BACKLIGHT
, &ctrl_param
);
184 if (ACPI_FAILURE(status
))
187 return ctrl_param
& 0xFF;
190 static int update_bl_status(struct backlight_device
*bd
)
193 static u32 ctrl_param
;
196 ctrl_param
= bd
->props
.brightness
;
198 status
= eeepc_wmi_set_devstate(EEEPC_WMI_DEVID_BACKLIGHT
, ctrl_param
);
200 if (ACPI_FAILURE(status
))
206 static const struct backlight_ops eeepc_wmi_bl_ops
= {
207 .get_brightness
= read_brightness
,
208 .update_status
= update_bl_status
,
211 static int eeepc_wmi_backlight_notify(struct eeepc_wmi
*eeepc
, int code
)
213 struct backlight_device
*bd
= eeepc
->backlight_device
;
214 int old
= bd
->props
.brightness
;
217 if (code
>= NOTIFY_BRNUP_MIN
&& code
<= NOTIFY_BRNUP_MAX
)
218 new = code
- NOTIFY_BRNUP_MIN
+ 1;
219 else if (code
>= NOTIFY_BRNDOWN_MIN
&& code
<= NOTIFY_BRNDOWN_MAX
)
220 new = code
- NOTIFY_BRNDOWN_MIN
;
222 bd
->props
.brightness
= new;
223 backlight_update_status(bd
);
224 backlight_force_update(bd
, BACKLIGHT_UPDATE_HOTKEY
);
229 static int eeepc_wmi_backlight_init(struct eeepc_wmi
*eeepc
)
231 struct backlight_device
*bd
;
232 struct backlight_properties props
;
234 memset(&props
, 0, sizeof(struct backlight_properties
));
235 props
.max_brightness
= 15;
236 bd
= backlight_device_register(EEEPC_WMI_FILE
,
237 &platform_device
->dev
, eeepc
,
238 &eeepc_wmi_bl_ops
, &props
);
240 pr_err("Could not register backlight device\n");
244 eeepc
->backlight_device
= bd
;
246 bd
->props
.brightness
= read_brightness(bd
);
247 bd
->props
.power
= FB_BLANK_UNBLANK
;
248 backlight_update_status(bd
);
253 static void eeepc_wmi_backlight_exit(struct eeepc_wmi
*eeepc
)
255 if (eeepc
->backlight_device
)
256 backlight_device_unregister(eeepc
->backlight_device
);
258 eeepc
->backlight_device
= NULL
;
261 static void eeepc_wmi_notify(u32 value
, void *context
)
263 struct eeepc_wmi
*eeepc
= context
;
264 struct acpi_buffer response
= { ACPI_ALLOCATE_BUFFER
, NULL
};
265 union acpi_object
*obj
;
270 status
= wmi_get_event_data(value
, &response
);
271 if (status
!= AE_OK
) {
272 pr_err("bad event status 0x%x\n", status
);
276 obj
= (union acpi_object
*)response
.pointer
;
278 if (obj
&& obj
->type
== ACPI_TYPE_INTEGER
) {
279 code
= obj
->integer
.value
;
282 if (code
>= NOTIFY_BRNUP_MIN
&& code
<= NOTIFY_BRNUP_MAX
)
283 code
= NOTIFY_BRNUP_MIN
;
284 else if (code
>= NOTIFY_BRNDOWN_MIN
&&
285 code
<= NOTIFY_BRNDOWN_MAX
)
286 code
= NOTIFY_BRNDOWN_MIN
;
288 if (code
== NOTIFY_BRNUP_MIN
|| code
== NOTIFY_BRNDOWN_MIN
) {
289 if (!acpi_video_backlight_support())
290 eeepc_wmi_backlight_notify(eeepc
, orig_code
);
293 if (!sparse_keymap_report_event(eeepc
->inputdev
,
295 pr_info("Unknown key %x pressed\n", code
);
301 static ssize_t
store_cpufv(struct device
*dev
, struct device_attribute
*attr
,
302 const char *buf
, size_t count
)
305 struct acpi_buffer input
= { (acpi_size
)sizeof(value
), &value
};
308 if (!count
|| sscanf(buf
, "%i", &value
) != 1)
310 if (value
< 0 || value
> 2)
313 status
= wmi_evaluate_method(EEEPC_WMI_MGMT_GUID
,
314 1, EEEPC_WMI_METHODID_CFVS
, &input
, NULL
);
316 if (ACPI_FAILURE(status
))
322 static DEVICE_ATTR(cpufv
, S_IRUGO
| S_IWUSR
, NULL
, store_cpufv
);
324 static void eeepc_wmi_sysfs_exit(struct platform_device
*device
)
326 device_remove_file(&device
->dev
, &dev_attr_cpufv
);
329 static int eeepc_wmi_sysfs_init(struct platform_device
*device
)
331 int retval
= -ENOMEM
;
333 retval
= device_create_file(&device
->dev
, &dev_attr_cpufv
);
340 eeepc_wmi_sysfs_exit(platform_device
);
344 static int __devinit
eeepc_wmi_platform_probe(struct platform_device
*device
)
346 struct eeepc_wmi
*eeepc
;
350 eeepc
= platform_get_drvdata(device
);
352 err
= eeepc_wmi_input_init(eeepc
);
356 if (!acpi_video_backlight_support()) {
357 err
= eeepc_wmi_backlight_init(eeepc
);
359 goto error_backlight
;
361 pr_info("Backlight controlled by ACPI video driver\n");
363 status
= wmi_install_notify_handler(EEEPC_WMI_EVENT_GUID
,
364 eeepc_wmi_notify
, eeepc
);
365 if (ACPI_FAILURE(status
)) {
366 pr_err("Unable to register notify handler - %d\n",
375 eeepc_wmi_backlight_exit(eeepc
);
377 eeepc_wmi_input_exit(eeepc
);
382 static int __devexit
eeepc_wmi_platform_remove(struct platform_device
*device
)
384 struct eeepc_wmi
*eeepc
;
386 eeepc
= platform_get_drvdata(device
);
387 wmi_remove_notify_handler(EEEPC_WMI_EVENT_GUID
);
388 eeepc_wmi_backlight_exit(eeepc
);
389 eeepc_wmi_input_exit(eeepc
);
394 static struct platform_driver platform_driver
= {
396 .name
= EEEPC_WMI_FILE
,
397 .owner
= THIS_MODULE
,
399 .probe
= eeepc_wmi_platform_probe
,
400 .remove
= __devexit_p(eeepc_wmi_platform_remove
),
403 static int __init
eeepc_wmi_init(void)
405 struct eeepc_wmi
*eeepc
;
408 if (!wmi_has_guid(EEEPC_WMI_EVENT_GUID
) ||
409 !wmi_has_guid(EEEPC_WMI_MGMT_GUID
)) {
410 pr_warning("No known WMI GUID found\n");
414 eeepc
= kzalloc(sizeof(struct eeepc_wmi
), GFP_KERNEL
);
418 platform_device
= platform_device_alloc(EEEPC_WMI_FILE
, -1);
419 if (!platform_device
) {
420 pr_warning("Unable to allocate platform device\n");
425 err
= platform_device_add(platform_device
);
427 pr_warning("Unable to add platform device\n");
431 platform_set_drvdata(platform_device
, eeepc
);
433 err
= platform_driver_register(&platform_driver
);
435 pr_warning("Unable to register platform driver\n");
439 err
= eeepc_wmi_sysfs_init(platform_device
);
446 eeepc_wmi_sysfs_exit(platform_device
);
448 platform_device_del(platform_device
);
450 platform_device_put(platform_device
);
457 static void __exit
eeepc_wmi_exit(void)
459 struct eeepc_wmi
*eeepc
;
461 eeepc_wmi_sysfs_exit(platform_device
);
462 eeepc
= platform_get_drvdata(platform_device
);
463 platform_driver_unregister(&platform_driver
);
464 platform_device_unregister(platform_device
);
468 module_init(eeepc_wmi_init
);
469 module_exit(eeepc_wmi_exit
);