2 * Asus PC WMI hotkey driver
4 * Copyright(C) 2010 Intel Corporation.
5 * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@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/types.h>
33 #include <linux/slab.h>
34 #include <linux/input.h>
35 #include <linux/input/sparse-keymap.h>
37 #include <linux/backlight.h>
38 #include <linux/leds.h>
39 #include <linux/rfkill.h>
40 #include <linux/pci.h>
41 #include <linux/pci_hotplug.h>
42 #include <linux/debugfs.h>
43 #include <linux/seq_file.h>
44 #include <linux/platform_device.h>
45 #include <acpi/acpi_bus.h>
46 #include <acpi/acpi_drivers.h>
50 MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>, "
51 "Yong Wang <yong.y.wang@intel.com>");
52 MODULE_DESCRIPTION("Asus Generic WMI Driver");
53 MODULE_LICENSE("GPL");
55 #define to_platform_driver(drv) \
56 (container_of((drv), struct platform_driver, driver))
58 #define to_asus_wmi_driver(pdrv) \
59 (container_of((pdrv), struct asus_wmi_driver, platform_driver))
61 #define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
63 #define NOTIFY_BRNUP_MIN 0x11
64 #define NOTIFY_BRNUP_MAX 0x1f
65 #define NOTIFY_BRNDOWN_MIN 0x20
66 #define NOTIFY_BRNDOWN_MAX 0x2e
69 #define ASUS_WMI_METHODID_DSTS 0x53544344
70 #define ASUS_WMI_METHODID_DSTS2 0x53545344
71 #define ASUS_WMI_METHODID_DEVS 0x53564544
72 #define ASUS_WMI_METHODID_CFVS 0x53564643
74 #define ASUS_WMI_UNSUPPORTED_METHOD 0xFFFFFFFE
77 #define ASUS_WMI_DEVID_WLAN 0x00010011
78 #define ASUS_WMI_DEVID_BLUETOOTH 0x00010013
79 #define ASUS_WMI_DEVID_WIMAX 0x00010017
80 #define ASUS_WMI_DEVID_WWAN3G 0x00010019
82 /* Backlight and Brightness */
83 #define ASUS_WMI_DEVID_BACKLIGHT 0x00050011
84 #define ASUS_WMI_DEVID_BRIGHTNESS 0x00050012
87 #define ASUS_WMI_DEVID_CAMERA 0x00060013
90 #define ASUS_WMI_DEVID_CARDREADER 0x00080013
93 #define ASUS_WMI_DEVID_TOUCHPAD 0x00100011
94 #define ASUS_WMI_DEVID_TOUCHPAD_LED 0x00100012
97 #define ASUS_WMI_DSTS_STATUS_BIT 0x00000001
98 #define ASUS_WMI_DSTS_UNKNOWN_BIT 0x00000002
99 #define ASUS_WMI_DSTS_PRESENCE_BIT 0x00010000
100 #define ASUS_WMI_DSTS_BRIGHTNESS_MASK 0x000000FF
101 #define ASUS_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
109 * <platform>/ - debugfs root directory
110 * dev_id - current dev_id
111 * ctrl_param - current ctrl_param
112 * devs - call DEVS(dev_id, ctrl_param) and print result
113 * dsts - call DSTS(dev_id) and print result
115 struct asus_wmi_debug {
122 struct asus_wmi *asus;
123 struct rfkill *rfkill;
130 struct input_dev *inputdev;
131 struct backlight_device *backlight_device;
132 struct platform_device *platform_device;
134 struct led_classdev tpd_led;
136 struct workqueue_struct *led_workqueue;
137 struct work_struct tpd_led_work;
139 struct asus_rfkill wlan;
140 struct asus_rfkill bluetooth;
141 struct asus_rfkill wimax;
142 struct asus_rfkill wwan3g;
144 struct hotplug_slot *hotplug_slot;
145 struct mutex hotplug_lock;
146 struct mutex wmi_lock;
147 struct workqueue_struct *hotplug_workqueue;
148 struct work_struct hotplug_work;
150 struct asus_wmi_debug debug;
152 struct asus_wmi_driver *driver;
155 static int asus_wmi_input_init(struct asus_wmi *asus)
159 asus->inputdev = input_allocate_device();
163 asus->inputdev->name = asus->driver->input_phys;
164 asus->inputdev->phys = asus->driver->input_name;
165 asus->inputdev->id.bustype = BUS_HOST;
166 asus->inputdev->dev.parent = &asus->platform_device->dev;
168 err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
172 err = input_register_device(asus->inputdev);
174 goto err_free_keymap;
179 sparse_keymap_free(asus->inputdev);
181 input_free_device(asus->inputdev);
185 static void asus_wmi_input_exit(struct asus_wmi *asus)
187 if (asus->inputdev) {
188 sparse_keymap_free(asus->inputdev);
189 input_unregister_device(asus->inputdev);
192 asus->inputdev = NULL;
195 static int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
198 struct bios_args args = {
202 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
203 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
205 union acpi_object *obj;
208 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1, method_id,
211 if (ACPI_FAILURE(status))
214 obj = (union acpi_object *)output.pointer;
215 if (obj && obj->type == ACPI_TYPE_INTEGER)
216 tmp = (u32) obj->integer.value;
226 if (ACPI_FAILURE(status))
229 if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
235 static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
237 return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
240 static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
243 return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
247 /* Helper for special devices with magic return codes */
248 static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
249 u32 dev_id, u32 mask)
254 err = asus_wmi_get_devstate(asus, dev_id, &retval);
259 if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
262 if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
263 if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
267 return retval & mask;
270 static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
272 return asus_wmi_get_devstate_bits(asus, dev_id,
273 ASUS_WMI_DSTS_STATUS_BIT);
280 * These functions actually update the LED's, and are called from a
281 * workqueue. By doing this as separate work rather than when the LED
282 * subsystem asks, we avoid messing with the Asus ACPI stuff during a
283 * potentially bad time, such as a timer interrupt.
285 static void tpd_led_update(struct work_struct *work)
288 struct asus_wmi *asus;
290 asus = container_of(work, struct asus_wmi, tpd_led_work);
292 ctrl_param = asus->tpd_led_wk;
293 asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
296 static void tpd_led_set(struct led_classdev *led_cdev,
297 enum led_brightness value)
299 struct asus_wmi *asus;
301 asus = container_of(led_cdev, struct asus_wmi, tpd_led);
303 asus->tpd_led_wk = !!value;
304 queue_work(asus->led_workqueue, &asus->tpd_led_work);
307 static int read_tpd_led_state(struct asus_wmi *asus)
309 return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
312 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
314 struct asus_wmi *asus;
316 asus = container_of(led_cdev, struct asus_wmi, tpd_led);
318 return read_tpd_led_state(asus);
321 static int asus_wmi_led_init(struct asus_wmi *asus)
325 if (read_tpd_led_state(asus) < 0)
328 asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
329 if (!asus->led_workqueue)
331 INIT_WORK(&asus->tpd_led_work, tpd_led_update);
333 asus->tpd_led.name = "asus::touchpad";
334 asus->tpd_led.brightness_set = tpd_led_set;
335 asus->tpd_led.brightness_get = tpd_led_get;
336 asus->tpd_led.max_brightness = 1;
338 rv = led_classdev_register(&asus->platform_device->dev, &asus->tpd_led);
340 destroy_workqueue(asus->led_workqueue);
347 static void asus_wmi_led_exit(struct asus_wmi *asus)
349 if (asus->tpd_led.dev)
350 led_classdev_unregister(&asus->tpd_led);
351 if (asus->led_workqueue)
352 destroy_workqueue(asus->led_workqueue);
356 * PCI hotplug (for wlan rfkill)
358 static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
360 int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
367 static void asus_rfkill_hotplug(struct asus_wmi *asus)
375 mutex_lock(&asus->wmi_lock);
376 blocked = asus_wlan_rfkill_blocked(asus);
377 mutex_unlock(&asus->wmi_lock);
379 mutex_lock(&asus->hotplug_lock);
381 if (asus->wlan.rfkill)
382 rfkill_set_sw_state(asus->wlan.rfkill, blocked);
384 if (asus->hotplug_slot) {
385 bus = pci_find_bus(0, 1);
387 pr_warning("Unable to find PCI bus 1?\n");
391 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
392 pr_err("Unable to read PCI config space?\n");
395 absent = (l == 0xffffffff);
397 if (blocked != absent) {
398 pr_warning("BIOS says wireless lan is %s, "
399 "but the pci device is %s\n",
400 blocked ? "blocked" : "unblocked",
401 absent ? "absent" : "present");
402 pr_warning("skipped wireless hotplug as probably "
403 "inappropriate for this model\n");
408 dev = pci_get_slot(bus, 0);
410 /* Device already present */
414 dev = pci_scan_single_device(bus, 0);
416 pci_bus_assign_resources(bus);
417 if (pci_bus_add_device(dev))
418 pr_err("Unable to hotplug wifi\n");
421 dev = pci_get_slot(bus, 0);
423 pci_remove_bus_device(dev);
430 mutex_unlock(&asus->hotplug_lock);
433 static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
435 struct asus_wmi *asus = data;
437 if (event != ACPI_NOTIFY_BUS_CHECK)
441 * We can't call directly asus_rfkill_hotplug because most
442 * of the time WMBC is still being executed and not reetrant.
443 * There is currently no way to tell ACPICA that we want this
444 * method to be serialized, we schedule a asus_rfkill_hotplug
445 * call later, in a safer context.
447 queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
450 static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
455 status = acpi_get_handle(NULL, node, &handle);
457 if (ACPI_SUCCESS(status)) {
458 status = acpi_install_notify_handler(handle,
460 asus_rfkill_notify, asus);
461 if (ACPI_FAILURE(status))
462 pr_warning("Failed to register notify on %s\n", node);
469 static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
471 acpi_status status = AE_OK;
474 status = acpi_get_handle(NULL, node, &handle);
476 if (ACPI_SUCCESS(status)) {
477 status = acpi_remove_notify_handler(handle,
480 if (ACPI_FAILURE(status))
481 pr_err("Error removing rfkill notify handler %s\n",
486 static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
489 struct asus_wmi *asus = hotplug_slot->private;
490 int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
499 static void asus_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
501 kfree(hotplug_slot->info);
505 static struct hotplug_slot_ops asus_hotplug_slot_ops = {
506 .owner = THIS_MODULE,
507 .get_adapter_status = asus_get_adapter_status,
508 .get_power_status = asus_get_adapter_status,
511 static void asus_hotplug_work(struct work_struct *work)
513 struct asus_wmi *asus;
515 asus = container_of(work, struct asus_wmi, hotplug_work);
516 asus_rfkill_hotplug(asus);
519 static int asus_setup_pci_hotplug(struct asus_wmi *asus)
522 struct pci_bus *bus = pci_find_bus(0, 1);
525 pr_err("Unable to find wifi PCI bus\n");
529 asus->hotplug_workqueue =
530 create_singlethread_workqueue("hotplug_workqueue");
531 if (!asus->hotplug_workqueue)
532 goto error_workqueue;
534 INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
536 asus->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
537 if (!asus->hotplug_slot)
540 asus->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
542 if (!asus->hotplug_slot->info)
545 asus->hotplug_slot->private = asus;
546 asus->hotplug_slot->release = &asus_cleanup_pci_hotplug;
547 asus->hotplug_slot->ops = &asus_hotplug_slot_ops;
548 asus_get_adapter_status(asus->hotplug_slot,
549 &asus->hotplug_slot->info->adapter_status);
551 ret = pci_hp_register(asus->hotplug_slot, bus, 0, "asus-wifi");
553 pr_err("Unable to register hotplug slot - %d\n", ret);
560 kfree(asus->hotplug_slot->info);
562 kfree(asus->hotplug_slot);
563 asus->hotplug_slot = NULL;
565 destroy_workqueue(asus->hotplug_workqueue);
573 static int asus_rfkill_set(void *data, bool blocked)
575 struct asus_rfkill *priv = data;
576 u32 ctrl_param = !blocked;
578 return asus_wmi_set_devstate(priv->dev_id, ctrl_param, NULL);
581 static void asus_rfkill_query(struct rfkill *rfkill, void *data)
583 struct asus_rfkill *priv = data;
586 result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
591 rfkill_set_sw_state(priv->rfkill, !result);
594 static int asus_rfkill_wlan_set(void *data, bool blocked)
596 struct asus_rfkill *priv = data;
597 struct asus_wmi *asus = priv->asus;
601 * This handler is enabled only if hotplug is enabled.
602 * In this case, the asus_wmi_set_devstate() will
603 * trigger a wmi notification and we need to wait
604 * this call to finish before being able to call
607 mutex_lock(&asus->wmi_lock);
608 ret = asus_rfkill_set(data, blocked);
609 mutex_unlock(&asus->wmi_lock);
613 static const struct rfkill_ops asus_rfkill_wlan_ops = {
614 .set_block = asus_rfkill_wlan_set,
615 .query = asus_rfkill_query,
618 static const struct rfkill_ops asus_rfkill_ops = {
619 .set_block = asus_rfkill_set,
620 .query = asus_rfkill_query,
623 static int asus_new_rfkill(struct asus_wmi *asus,
624 struct asus_rfkill *arfkill,
625 const char *name, enum rfkill_type type, int dev_id)
627 int result = asus_wmi_get_devstate_simple(asus, dev_id);
628 struct rfkill **rfkill = &arfkill->rfkill;
633 arfkill->dev_id = dev_id;
634 arfkill->asus = asus;
636 if (dev_id == ASUS_WMI_DEVID_WLAN && asus->driver->hotplug_wireless)
637 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
638 &asus_rfkill_wlan_ops, arfkill);
640 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
641 &asus_rfkill_ops, arfkill);
646 rfkill_init_sw_state(*rfkill, !result);
647 result = rfkill_register(*rfkill);
649 rfkill_destroy(*rfkill);
656 static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
658 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
659 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
660 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
661 if (asus->wlan.rfkill) {
662 rfkill_unregister(asus->wlan.rfkill);
663 rfkill_destroy(asus->wlan.rfkill);
664 asus->wlan.rfkill = NULL;
667 * Refresh pci hotplug in case the rfkill state was changed after
668 * asus_unregister_rfkill_notifier()
670 asus_rfkill_hotplug(asus);
671 if (asus->hotplug_slot)
672 pci_hp_deregister(asus->hotplug_slot);
673 if (asus->hotplug_workqueue)
674 destroy_workqueue(asus->hotplug_workqueue);
676 if (asus->bluetooth.rfkill) {
677 rfkill_unregister(asus->bluetooth.rfkill);
678 rfkill_destroy(asus->bluetooth.rfkill);
679 asus->bluetooth.rfkill = NULL;
681 if (asus->wimax.rfkill) {
682 rfkill_unregister(asus->wimax.rfkill);
683 rfkill_destroy(asus->wimax.rfkill);
684 asus->wimax.rfkill = NULL;
686 if (asus->wwan3g.rfkill) {
687 rfkill_unregister(asus->wwan3g.rfkill);
688 rfkill_destroy(asus->wwan3g.rfkill);
689 asus->wwan3g.rfkill = NULL;
693 static int asus_wmi_rfkill_init(struct asus_wmi *asus)
697 mutex_init(&asus->hotplug_lock);
698 mutex_init(&asus->wmi_lock);
700 result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
701 RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
703 if (result && result != -ENODEV)
706 result = asus_new_rfkill(asus, &asus->bluetooth,
707 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
708 ASUS_WMI_DEVID_BLUETOOTH);
710 if (result && result != -ENODEV)
713 result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
714 RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
716 if (result && result != -ENODEV)
719 result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
720 RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
722 if (result && result != -ENODEV)
725 if (!asus->driver->hotplug_wireless)
728 result = asus_setup_pci_hotplug(asus);
730 * If we get -EBUSY then something else is handling the PCI hotplug -
731 * don't fail in this case
733 if (result == -EBUSY)
736 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
737 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
738 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
740 * Refresh pci hotplug in case the rfkill state was changed during
743 asus_rfkill_hotplug(asus);
746 if (result && result != -ENODEV)
747 asus_wmi_rfkill_exit(asus);
749 if (result == -ENODEV)
758 static int read_backlight_power(struct asus_wmi *asus)
760 int ret = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_BACKLIGHT);
765 return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
768 static int read_brightness(struct backlight_device *bd)
770 struct asus_wmi *asus = bl_get_data(bd);
774 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
779 return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
782 static int update_bl_status(struct backlight_device *bd)
784 struct asus_wmi *asus = bl_get_data(bd);
788 ctrl_param = bd->props.brightness;
790 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
796 power = read_backlight_power(asus);
797 if (power != -ENODEV && bd->props.power != power) {
798 ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
799 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
805 static const struct backlight_ops asus_wmi_bl_ops = {
806 .get_brightness = read_brightness,
807 .update_status = update_bl_status,
810 static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
812 struct backlight_device *bd = asus->backlight_device;
813 int old = bd->props.brightness;
816 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
817 new = code - NOTIFY_BRNUP_MIN + 1;
818 else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
819 new = code - NOTIFY_BRNDOWN_MIN;
821 bd->props.brightness = new;
822 backlight_update_status(bd);
823 backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
828 static int asus_wmi_backlight_init(struct asus_wmi *asus)
830 struct backlight_device *bd;
831 struct backlight_properties props;
835 max = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_BRIGHTNESS,
836 ASUS_WMI_DSTS_MAX_BRIGTH_MASK);
837 power = read_backlight_power(asus);
839 if (max < 0 && power < 0) {
840 /* Try to keep the original error */
841 if (max == -ENODEV && power == -ENODEV)
850 if (power == -ENODEV)
851 power = FB_BLANK_UNBLANK;
853 memset(&props, 0, sizeof(struct backlight_properties));
854 props.max_brightness = max;
855 bd = backlight_device_register(asus->driver->name,
856 &asus->platform_device->dev, asus,
857 &asus_wmi_bl_ops, &props);
859 pr_err("Could not register backlight device\n");
863 asus->backlight_device = bd;
865 bd->props.brightness = read_brightness(bd);
866 bd->props.power = power;
867 backlight_update_status(bd);
872 static void asus_wmi_backlight_exit(struct asus_wmi *asus)
874 if (asus->backlight_device)
875 backlight_device_unregister(asus->backlight_device);
877 asus->backlight_device = NULL;
880 static void asus_wmi_notify(u32 value, void *context)
882 struct asus_wmi *asus = context;
883 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
884 union acpi_object *obj;
889 status = wmi_get_event_data(value, &response);
890 if (status != AE_OK) {
891 pr_err("bad event status 0x%x\n", status);
895 obj = (union acpi_object *)response.pointer;
897 if (!obj || obj->type != ACPI_TYPE_INTEGER)
900 code = obj->integer.value;
903 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
904 code = NOTIFY_BRNUP_MIN;
905 else if (code >= NOTIFY_BRNDOWN_MIN &&
906 code <= NOTIFY_BRNDOWN_MAX)
907 code = NOTIFY_BRNDOWN_MIN;
909 if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
910 if (!acpi_video_backlight_support())
911 asus_wmi_backlight_notify(asus, orig_code);
912 } else if (!sparse_keymap_report_event(asus->inputdev, code, 1, true))
913 pr_info("Unknown key %x pressed\n", code);
922 static int parse_arg(const char *buf, unsigned long count, int *val)
926 if (sscanf(buf, "%i", val) != 1)
931 static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
932 const char *buf, size_t count)
937 value = asus_wmi_get_devstate_simple(asus, devid);
938 if (value == -ENODEV) /* Check device presence */
941 rv = parse_arg(buf, count, &value);
942 err = asus_wmi_set_devstate(devid, value, &retval);
950 static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
952 int value = asus_wmi_get_devstate_simple(asus, devid);
957 return sprintf(buf, "%d\n", value);
960 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
961 static ssize_t show_##_name(struct device *dev, \
962 struct device_attribute *attr, \
965 struct asus_wmi *asus = dev_get_drvdata(dev); \
967 return show_sys_wmi(asus, _cm, buf); \
969 static ssize_t store_##_name(struct device *dev, \
970 struct device_attribute *attr, \
971 const char *buf, size_t count) \
973 struct asus_wmi *asus = dev_get_drvdata(dev); \
975 return store_sys_wmi(asus, _cm, buf, count); \
977 static struct device_attribute dev_attr_##_name = { \
979 .name = __stringify(_name), \
981 .show = show_##_name, \
982 .store = store_##_name, \
985 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
986 ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
987 ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
989 static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
990 const char *buf, size_t count)
994 if (!count || sscanf(buf, "%i", &value) != 1)
996 if (value < 0 || value > 2)
999 return asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
1002 static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
1004 static struct attribute *platform_attributes[] = {
1005 &dev_attr_cpufv.attr,
1006 &dev_attr_camera.attr,
1007 &dev_attr_cardr.attr,
1008 &dev_attr_touchpad.attr,
1012 static mode_t asus_sysfs_is_visible(struct kobject *kobj,
1013 struct attribute *attr, int idx)
1015 struct device *dev = container_of(kobj, struct device, kobj);
1016 struct platform_device *pdev = to_platform_device(dev);
1017 struct asus_wmi *asus = platform_get_drvdata(pdev);
1021 if (attr == &dev_attr_camera.attr)
1022 devid = ASUS_WMI_DEVID_CAMERA;
1023 else if (attr == &dev_attr_cardr.attr)
1024 devid = ASUS_WMI_DEVID_CARDREADER;
1025 else if (attr == &dev_attr_touchpad.attr)
1026 devid = ASUS_WMI_DEVID_TOUCHPAD;
1029 ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
1031 return ok ? attr->mode : 0;
1034 static struct attribute_group platform_attribute_group = {
1035 .is_visible = asus_sysfs_is_visible,
1036 .attrs = platform_attributes
1039 static void asus_wmi_sysfs_exit(struct platform_device *device)
1041 sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
1044 static int asus_wmi_sysfs_init(struct platform_device *device)
1046 return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
1052 static int __init asus_wmi_platform_init(struct asus_wmi *asus)
1055 * Eee PC and Notebooks seems to have different method_id for DSTS,
1056 * but it may also be related to the BIOS's SPEC.
1057 * Note, on most Eeepc, there is no way to check if a method exist
1058 * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
1059 * but once again, SPEC may probably be used for that kind of things.
1061 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, 0, 0, NULL))
1062 asus->dsts_id = ASUS_WMI_METHODID_DSTS;
1063 else if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS2, 0, 0, NULL))
1064 asus->dsts_id = ASUS_WMI_METHODID_DSTS2;
1066 if (!asus->dsts_id) {
1067 pr_err("Can't find DSTS");
1071 return asus_wmi_sysfs_init(asus->platform_device);
1074 static void asus_wmi_platform_exit(struct asus_wmi *asus)
1076 asus_wmi_sysfs_exit(asus->platform_device);
1082 struct asus_wmi_debugfs_node {
1083 struct asus_wmi *asus;
1085 int (*show) (struct seq_file *m, void *data);
1088 static int show_dsts(struct seq_file *m, void *data)
1090 struct asus_wmi *asus = m->private;
1094 err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
1099 seq_printf(m, "DSTS(%x) = %x\n", asus->debug.dev_id, retval);
1104 static int show_devs(struct seq_file *m, void *data)
1106 struct asus_wmi *asus = m->private;
1110 err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
1116 seq_printf(m, "DEVS(%x, %x) = %x\n", asus->debug.dev_id,
1117 asus->debug.ctrl_param, retval);
1122 static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
1123 {NULL, "devs", show_devs},
1124 {NULL, "dsts", show_dsts},
1127 static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
1129 struct asus_wmi_debugfs_node *node = inode->i_private;
1131 return single_open(file, node->show, node->asus);
1134 static const struct file_operations asus_wmi_debugfs_io_ops = {
1135 .owner = THIS_MODULE,
1136 .open = asus_wmi_debugfs_open,
1138 .llseek = seq_lseek,
1139 .release = single_release,
1142 static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
1144 debugfs_remove_recursive(asus->debug.root);
1147 static int asus_wmi_debugfs_init(struct asus_wmi *asus)
1149 struct dentry *dent;
1152 asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
1153 if (!asus->debug.root) {
1154 pr_err("failed to create debugfs directory");
1158 dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
1159 asus->debug.root, &asus->debug.dev_id);
1163 dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR,
1164 asus->debug.root, &asus->debug.ctrl_param);
1168 for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
1169 struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
1172 dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
1173 asus->debug.root, node,
1174 &asus_wmi_debugfs_io_ops);
1176 pr_err("failed to create debug file: %s\n", node->name);
1184 asus_wmi_debugfs_exit(asus);
1191 static int asus_wmi_add(struct platform_device *pdev)
1193 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
1194 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
1195 struct asus_wmi *asus;
1199 asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
1203 asus->driver = wdrv;
1204 asus->platform_device = pdev;
1205 wdrv->platform_device = pdev;
1206 platform_set_drvdata(asus->platform_device, asus);
1209 wdrv->quirks(asus->driver);
1211 err = asus_wmi_platform_init(asus);
1215 err = asus_wmi_input_init(asus);
1219 err = asus_wmi_led_init(asus);
1223 err = asus_wmi_rfkill_init(asus);
1227 if (!acpi_video_backlight_support()) {
1228 err = asus_wmi_backlight_init(asus);
1229 if (err && err != -ENODEV)
1230 goto fail_backlight;
1232 pr_info("Backlight controlled by ACPI video driver\n");
1234 status = wmi_install_notify_handler(asus->driver->event_guid,
1235 asus_wmi_notify, asus);
1236 if (ACPI_FAILURE(status)) {
1237 pr_err("Unable to register notify handler - %d\n", status);
1239 goto fail_wmi_handler;
1242 err = asus_wmi_debugfs_init(asus);
1249 wmi_remove_notify_handler(asus->driver->event_guid);
1251 asus_wmi_backlight_exit(asus);
1253 asus_wmi_rfkill_exit(asus);
1255 asus_wmi_led_exit(asus);
1257 asus_wmi_input_exit(asus);
1259 asus_wmi_platform_exit(asus);
1265 static int asus_wmi_remove(struct platform_device *device)
1267 struct asus_wmi *asus;
1269 asus = platform_get_drvdata(device);
1270 wmi_remove_notify_handler(asus->driver->event_guid);
1271 asus_wmi_backlight_exit(asus);
1272 asus_wmi_input_exit(asus);
1273 asus_wmi_led_exit(asus);
1274 asus_wmi_rfkill_exit(asus);
1275 asus_wmi_debugfs_exit(asus);
1276 asus_wmi_platform_exit(asus);
1283 * Platform driver - hibernate/resume callbacks
1285 static int asus_hotk_thaw(struct device *device)
1287 struct asus_wmi *asus = dev_get_drvdata(device);
1289 if (asus->wlan.rfkill) {
1293 * Work around bios bug - acpi _PTS turns off the wireless led
1294 * during suspend. Normally it restores it on resume, but
1295 * we should kick it ourselves in case hibernation is aborted.
1297 wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
1298 asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
1304 static int asus_hotk_restore(struct device *device)
1306 struct asus_wmi *asus = dev_get_drvdata(device);
1309 /* Refresh both wlan rfkill state and pci hotplug */
1310 if (asus->wlan.rfkill)
1311 asus_rfkill_hotplug(asus);
1313 if (asus->bluetooth.rfkill) {
1314 bl = !asus_wmi_get_devstate_simple(asus,
1315 ASUS_WMI_DEVID_BLUETOOTH);
1316 rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
1318 if (asus->wimax.rfkill) {
1319 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
1320 rfkill_set_sw_state(asus->wimax.rfkill, bl);
1322 if (asus->wwan3g.rfkill) {
1323 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
1324 rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
1330 static const struct dev_pm_ops asus_pm_ops = {
1331 .thaw = asus_hotk_thaw,
1332 .restore = asus_hotk_restore,
1335 static int asus_wmi_probe(struct platform_device *pdev)
1337 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
1338 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
1341 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
1342 pr_warning("Management GUID not found\n");
1346 if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
1347 pr_warning("Event GUID not found\n");
1352 ret = wdrv->probe(pdev);
1357 return asus_wmi_add(pdev);
1362 int asus_wmi_register_driver(struct asus_wmi_driver *driver)
1364 struct platform_driver *platform_driver;
1365 struct platform_device *platform_device;
1370 platform_driver = &driver->platform_driver;
1371 platform_driver->remove = asus_wmi_remove;
1372 platform_driver->driver.owner = driver->owner;
1373 platform_driver->driver.name = driver->name;
1374 platform_driver->driver.pm = &asus_pm_ops;
1376 platform_device = platform_create_bundle(platform_driver,
1379 if (IS_ERR(platform_device))
1380 return PTR_ERR(platform_device);
1385 EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
1387 void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
1389 platform_device_unregister(driver->platform_device);
1390 platform_driver_unregister(&driver->platform_driver);
1393 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
1395 static int __init asus_wmi_init(void)
1397 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
1398 pr_info("Asus Management GUID not found");
1402 pr_info("ASUS WMI generic driver loaded");
1406 static void __exit asus_wmi_exit(void)
1408 pr_info("ASUS WMI generic driver unloaded");
1411 module_init(asus_wmi_init);
1412 module_exit(asus_wmi_exit);