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_DEVS 0x53564544
71 #define ASUS_WMI_METHODID_CFVS 0x53564643
74 #define ASUS_WMI_DEVID_WLAN 0x00010011
75 #define ASUS_WMI_DEVID_BLUETOOTH 0x00010013
76 #define ASUS_WMI_DEVID_WIMAX 0x00010017
77 #define ASUS_WMI_DEVID_WWAN3G 0x00010019
79 /* Backlight and Brightness */
80 #define ASUS_WMI_DEVID_BACKLIGHT 0x00050011
81 #define ASUS_WMI_DEVID_BRIGHTNESS 0x00050012
84 #define ASUS_WMI_DEVID_CAMERA 0x00060013
87 #define ASUS_WMI_DEVID_CARDREADER 0x00080013
90 #define ASUS_WMI_DEVID_TOUCHPAD 0x00100011
91 #define ASUS_WMI_DEVID_TOUCHPAD_LED 0x00100012
94 #define ASUS_WMI_DSTS_STATUS_BIT 0x00000001
95 #define ASUS_WMI_DSTS_PRESENCE_BIT 0x00010000
96 #define ASUS_WMI_DSTS_BRIGHTNESS_MASK 0x000000FF
97 #define ASUS_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
105 * <platform>/ - debugfs root directory
106 * dev_id - current dev_id
107 * ctrl_param - current ctrl_param
108 * devs - call DEVS(dev_id, ctrl_param) and print result
109 * dsts - call DSTS(dev_id) and print result
111 struct asus_wmi_debug {
118 struct input_dev *inputdev;
119 struct backlight_device *backlight_device;
120 struct platform_device *platform_device;
122 struct led_classdev tpd_led;
124 struct workqueue_struct *led_workqueue;
125 struct work_struct tpd_led_work;
127 struct rfkill *wlan_rfkill;
128 struct rfkill *bluetooth_rfkill;
129 struct rfkill *wimax_rfkill;
130 struct rfkill *wwan3g_rfkill;
132 struct hotplug_slot *hotplug_slot;
133 struct mutex hotplug_lock;
134 struct mutex wmi_lock;
135 struct workqueue_struct *hotplug_workqueue;
136 struct work_struct hotplug_work;
138 struct asus_wmi_debug debug;
140 struct asus_wmi_driver *driver;
143 static int asus_wmi_input_init(struct asus_wmi *asus)
147 asus->inputdev = input_allocate_device();
151 asus->inputdev->name = asus->driver->input_phys;
152 asus->inputdev->phys = asus->driver->input_name;
153 asus->inputdev->id.bustype = BUS_HOST;
154 asus->inputdev->dev.parent = &asus->platform_device->dev;
156 err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
160 err = input_register_device(asus->inputdev);
162 goto err_free_keymap;
167 sparse_keymap_free(asus->inputdev);
169 input_free_device(asus->inputdev);
173 static void asus_wmi_input_exit(struct asus_wmi *asus)
175 if (asus->inputdev) {
176 sparse_keymap_free(asus->inputdev);
177 input_unregister_device(asus->inputdev);
180 asus->inputdev = NULL;
183 static acpi_status asus_wmi_get_devstate(u32 dev_id, u32 *retval)
185 struct acpi_buffer input = { (acpi_size) sizeof(u32), &dev_id };
186 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
187 union acpi_object *obj;
191 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
192 1, ASUS_WMI_METHODID_DSTS,
195 if (ACPI_FAILURE(status))
198 obj = (union acpi_object *)output.pointer;
199 if (obj && obj->type == ACPI_TYPE_INTEGER)
200 tmp = (u32) obj->integer.value;
213 static acpi_status asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
216 struct bios_args args = {
218 .ctrl_param = ctrl_param,
220 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
224 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1,
225 ASUS_WMI_METHODID_DEVS,
228 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
229 union acpi_object *obj;
232 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1,
233 ASUS_WMI_METHODID_DEVS,
236 if (ACPI_FAILURE(status))
239 obj = (union acpi_object *)output.pointer;
240 if (obj && obj->type == ACPI_TYPE_INTEGER)
241 tmp = (u32) obj->integer.value;
253 /* Helper for special devices with magic return codes */
254 static int asus_wmi_get_devstate_bits(u32 dev_id, u32 mask)
259 status = asus_wmi_get_devstate(dev_id, &retval);
261 if (ACPI_FAILURE(status))
264 if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
267 return retval & mask;
270 static int asus_wmi_get_devstate_simple(u32 dev_id)
272 return asus_wmi_get_devstate_bits(dev_id, ASUS_WMI_DSTS_STATUS_BIT);
279 * These functions actually update the LED's, and are called from a
280 * workqueue. By doing this as separate work rather than when the LED
281 * subsystem asks, we avoid messing with the Asus ACPI stuff during a
282 * potentially bad time, such as a timer interrupt.
284 static void tpd_led_update(struct work_struct *work)
287 struct asus_wmi *asus;
289 asus = container_of(work, struct asus_wmi, tpd_led_work);
291 ctrl_param = asus->tpd_led_wk;
292 asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
295 static void tpd_led_set(struct led_classdev *led_cdev,
296 enum led_brightness value)
298 struct asus_wmi *asus;
300 asus = container_of(led_cdev, struct asus_wmi, tpd_led);
302 asus->tpd_led_wk = !!value;
303 queue_work(asus->led_workqueue, &asus->tpd_led_work);
306 static int read_tpd_led_state(struct asus_wmi *asus)
308 return asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_TOUCHPAD_LED);
311 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
313 struct asus_wmi *asus;
315 asus = container_of(led_cdev, struct asus_wmi, tpd_led);
317 return read_tpd_led_state(asus);
320 static int asus_wmi_led_init(struct asus_wmi *asus)
324 if (read_tpd_led_state(asus) < 0)
327 asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
328 if (!asus->led_workqueue)
330 INIT_WORK(&asus->tpd_led_work, tpd_led_update);
332 asus->tpd_led.name = "asus::touchpad";
333 asus->tpd_led.brightness_set = tpd_led_set;
334 asus->tpd_led.brightness_get = tpd_led_get;
335 asus->tpd_led.max_brightness = 1;
337 rv = led_classdev_register(&asus->platform_device->dev, &asus->tpd_led);
339 destroy_workqueue(asus->led_workqueue);
346 static void asus_wmi_led_exit(struct asus_wmi *asus)
348 if (asus->tpd_led.dev)
349 led_classdev_unregister(&asus->tpd_led);
350 if (asus->led_workqueue)
351 destroy_workqueue(asus->led_workqueue);
355 * PCI hotplug (for wlan rfkill)
357 static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
359 int result = asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WLAN);
366 static void asus_rfkill_hotplug(struct asus_wmi *asus)
374 mutex_lock(&asus->wmi_lock);
375 blocked = asus_wlan_rfkill_blocked(asus);
376 mutex_unlock(&asus->wmi_lock);
378 mutex_lock(&asus->hotplug_lock);
380 if (asus->wlan_rfkill)
381 rfkill_set_sw_state(asus->wlan_rfkill, blocked);
383 if (asus->hotplug_slot) {
384 bus = pci_find_bus(0, 1);
386 pr_warning("Unable to find PCI bus 1?\n");
390 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
391 pr_err("Unable to read PCI config space?\n");
394 absent = (l == 0xffffffff);
396 if (blocked != absent) {
397 pr_warning("BIOS says wireless lan is %s, "
398 "but the pci device is %s\n",
399 blocked ? "blocked" : "unblocked",
400 absent ? "absent" : "present");
401 pr_warning("skipped wireless hotplug as probably "
402 "inappropriate for this model\n");
407 dev = pci_get_slot(bus, 0);
409 /* Device already present */
413 dev = pci_scan_single_device(bus, 0);
415 pci_bus_assign_resources(bus);
416 if (pci_bus_add_device(dev))
417 pr_err("Unable to hotplug wifi\n");
420 dev = pci_get_slot(bus, 0);
422 pci_remove_bus_device(dev);
429 mutex_unlock(&asus->hotplug_lock);
432 static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
434 struct asus_wmi *asus = data;
436 if (event != ACPI_NOTIFY_BUS_CHECK)
440 * We can't call directly asus_rfkill_hotplug because most
441 * of the time WMBC is still being executed and not reetrant.
442 * There is currently no way to tell ACPICA that we want this
443 * method to be serialized, we schedule a asus_rfkill_hotplug
444 * call later, in a safer context.
446 queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
449 static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
454 status = acpi_get_handle(NULL, node, &handle);
456 if (ACPI_SUCCESS(status)) {
457 status = acpi_install_notify_handler(handle,
459 asus_rfkill_notify, asus);
460 if (ACPI_FAILURE(status))
461 pr_warning("Failed to register notify on %s\n", node);
468 static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
470 acpi_status status = AE_OK;
473 status = acpi_get_handle(NULL, node, &handle);
475 if (ACPI_SUCCESS(status)) {
476 status = acpi_remove_notify_handler(handle,
479 if (ACPI_FAILURE(status))
480 pr_err("Error removing rfkill notify handler %s\n",
485 static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
488 int result = asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WLAN);
497 static void asus_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
499 kfree(hotplug_slot->info);
503 static struct hotplug_slot_ops asus_hotplug_slot_ops = {
504 .owner = THIS_MODULE,
505 .get_adapter_status = asus_get_adapter_status,
506 .get_power_status = asus_get_adapter_status,
509 static void asus_hotplug_work(struct work_struct *work)
511 struct asus_wmi *asus;
513 asus = container_of(work, struct asus_wmi, hotplug_work);
514 asus_rfkill_hotplug(asus);
517 static int asus_setup_pci_hotplug(struct asus_wmi *asus)
520 struct pci_bus *bus = pci_find_bus(0, 1);
523 pr_err("Unable to find wifi PCI bus\n");
527 asus->hotplug_workqueue =
528 create_singlethread_workqueue("hotplug_workqueue");
529 if (!asus->hotplug_workqueue)
530 goto error_workqueue;
532 INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
534 asus->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
535 if (!asus->hotplug_slot)
538 asus->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
540 if (!asus->hotplug_slot->info)
543 asus->hotplug_slot->private = asus;
544 asus->hotplug_slot->release = &asus_cleanup_pci_hotplug;
545 asus->hotplug_slot->ops = &asus_hotplug_slot_ops;
546 asus_get_adapter_status(asus->hotplug_slot,
547 &asus->hotplug_slot->info->adapter_status);
549 ret = pci_hp_register(asus->hotplug_slot, bus, 0, "asus-wifi");
551 pr_err("Unable to register hotplug slot - %d\n", ret);
558 kfree(asus->hotplug_slot->info);
560 kfree(asus->hotplug_slot);
561 asus->hotplug_slot = NULL;
563 destroy_workqueue(asus->hotplug_workqueue);
571 static int asus_rfkill_set(void *data, bool blocked)
573 int dev_id = (unsigned long)data;
574 u32 ctrl_param = !blocked;
577 status = asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
579 if (ACPI_FAILURE(status))
585 static void asus_rfkill_query(struct rfkill *rfkill, void *data)
587 int dev_id = (unsigned long)data;
590 result = asus_wmi_get_devstate_simple(dev_id);
595 rfkill_set_sw_state(rfkill, !result);
598 static int asus_rfkill_wlan_set(void *data, bool blocked)
600 struct asus_wmi *asus = data;
604 * This handler is enabled only if hotplug is enabled.
605 * In this case, the asus_wmi_set_devstate() will
606 * trigger a wmi notification and we need to wait
607 * this call to finish before being able to call
610 mutex_lock(&asus->wmi_lock);
611 ret = asus_rfkill_set((void *)(long)ASUS_WMI_DEVID_WLAN, blocked);
612 mutex_unlock(&asus->wmi_lock);
616 static void asus_rfkill_wlan_query(struct rfkill *rfkill, void *data)
618 asus_rfkill_query(rfkill, (void *)(long)ASUS_WMI_DEVID_WLAN);
621 static const struct rfkill_ops asus_rfkill_wlan_ops = {
622 .set_block = asus_rfkill_wlan_set,
623 .query = asus_rfkill_wlan_query,
626 static const struct rfkill_ops asus_rfkill_ops = {
627 .set_block = asus_rfkill_set,
628 .query = asus_rfkill_query,
631 static int asus_new_rfkill(struct asus_wmi *asus,
632 struct rfkill **rfkill,
633 const char *name, enum rfkill_type type, int dev_id)
635 int result = asus_wmi_get_devstate_simple(dev_id);
640 if (dev_id == ASUS_WMI_DEVID_WLAN && asus->driver->hotplug_wireless)
641 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
642 &asus_rfkill_wlan_ops, asus);
644 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
645 &asus_rfkill_ops, (void *)(long)dev_id);
650 rfkill_init_sw_state(*rfkill, !result);
651 result = rfkill_register(*rfkill);
653 rfkill_destroy(*rfkill);
660 static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
662 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
663 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
664 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
665 if (asus->wlan_rfkill) {
666 rfkill_unregister(asus->wlan_rfkill);
667 rfkill_destroy(asus->wlan_rfkill);
668 asus->wlan_rfkill = NULL;
671 * Refresh pci hotplug in case the rfkill state was changed after
672 * asus_unregister_rfkill_notifier()
674 asus_rfkill_hotplug(asus);
675 if (asus->hotplug_slot)
676 pci_hp_deregister(asus->hotplug_slot);
677 if (asus->hotplug_workqueue)
678 destroy_workqueue(asus->hotplug_workqueue);
680 if (asus->bluetooth_rfkill) {
681 rfkill_unregister(asus->bluetooth_rfkill);
682 rfkill_destroy(asus->bluetooth_rfkill);
683 asus->bluetooth_rfkill = NULL;
685 if (asus->wimax_rfkill) {
686 rfkill_unregister(asus->wimax_rfkill);
687 rfkill_destroy(asus->wimax_rfkill);
688 asus->wimax_rfkill = NULL;
690 if (asus->wwan3g_rfkill) {
691 rfkill_unregister(asus->wwan3g_rfkill);
692 rfkill_destroy(asus->wwan3g_rfkill);
693 asus->wwan3g_rfkill = NULL;
697 static int asus_wmi_rfkill_init(struct asus_wmi *asus)
701 mutex_init(&asus->hotplug_lock);
702 mutex_init(&asus->wmi_lock);
704 result = asus_new_rfkill(asus, &asus->wlan_rfkill,
705 "asus-wlan", RFKILL_TYPE_WLAN,
706 ASUS_WMI_DEVID_WLAN);
708 if (result && result != -ENODEV)
711 result = asus_new_rfkill(asus, &asus->bluetooth_rfkill,
712 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
713 ASUS_WMI_DEVID_BLUETOOTH);
715 if (result && result != -ENODEV)
718 result = asus_new_rfkill(asus, &asus->wimax_rfkill,
719 "asus-wimax", RFKILL_TYPE_WIMAX,
720 ASUS_WMI_DEVID_WIMAX);
722 if (result && result != -ENODEV)
725 result = asus_new_rfkill(asus, &asus->wwan3g_rfkill,
726 "asus-wwan3g", RFKILL_TYPE_WWAN,
727 ASUS_WMI_DEVID_WWAN3G);
729 if (result && result != -ENODEV)
732 if (!asus->driver->hotplug_wireless)
735 result = asus_setup_pci_hotplug(asus);
737 * If we get -EBUSY then something else is handling the PCI hotplug -
738 * don't fail in this case
740 if (result == -EBUSY)
743 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
744 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
745 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
747 * Refresh pci hotplug in case the rfkill state was changed during
750 asus_rfkill_hotplug(asus);
753 if (result && result != -ENODEV)
754 asus_wmi_rfkill_exit(asus);
756 if (result == -ENODEV)
765 static int read_backlight_power(void)
767 int ret = asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_BACKLIGHT);
772 return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
775 static int read_brightness(struct backlight_device *bd)
780 status = asus_wmi_get_devstate(ASUS_WMI_DEVID_BRIGHTNESS, &retval);
782 if (ACPI_FAILURE(status))
785 return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
788 static int update_bl_status(struct backlight_device *bd)
794 ctrl_param = bd->props.brightness;
796 status = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
799 if (ACPI_FAILURE(status))
802 power = read_backlight_power();
803 if (power != -ENODEV && bd->props.power != power) {
804 ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
805 status = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
808 if (ACPI_FAILURE(status))
814 static const struct backlight_ops asus_wmi_bl_ops = {
815 .get_brightness = read_brightness,
816 .update_status = update_bl_status,
819 static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
821 struct backlight_device *bd = asus->backlight_device;
822 int old = bd->props.brightness;
825 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
826 new = code - NOTIFY_BRNUP_MIN + 1;
827 else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
828 new = code - NOTIFY_BRNDOWN_MIN;
830 bd->props.brightness = new;
831 backlight_update_status(bd);
832 backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
837 static int asus_wmi_backlight_init(struct asus_wmi *asus)
839 struct backlight_device *bd;
840 struct backlight_properties props;
844 max = asus_wmi_get_devstate_bits(ASUS_WMI_DEVID_BRIGHTNESS,
845 ASUS_WMI_DSTS_MAX_BRIGTH_MASK);
846 power = read_backlight_power();
848 if (max < 0 && power < 0) {
849 /* Try to keep the original error */
850 if (max == -ENODEV && power == -ENODEV)
859 if (power == -ENODEV)
860 power = FB_BLANK_UNBLANK;
862 memset(&props, 0, sizeof(struct backlight_properties));
863 props.max_brightness = max;
864 bd = backlight_device_register(asus->driver->name,
865 &asus->platform_device->dev, asus,
866 &asus_wmi_bl_ops, &props);
868 pr_err("Could not register backlight device\n");
872 asus->backlight_device = bd;
874 bd->props.brightness = read_brightness(bd);
875 bd->props.power = power;
876 backlight_update_status(bd);
881 static void asus_wmi_backlight_exit(struct asus_wmi *asus)
883 if (asus->backlight_device)
884 backlight_device_unregister(asus->backlight_device);
886 asus->backlight_device = NULL;
889 static void asus_wmi_notify(u32 value, void *context)
891 struct asus_wmi *asus = context;
892 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
893 union acpi_object *obj;
898 status = wmi_get_event_data(value, &response);
899 if (status != AE_OK) {
900 pr_err("bad event status 0x%x\n", status);
904 obj = (union acpi_object *)response.pointer;
906 if (!obj || obj->type != ACPI_TYPE_INTEGER)
909 code = obj->integer.value;
912 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
913 code = NOTIFY_BRNUP_MIN;
914 else if (code >= NOTIFY_BRNDOWN_MIN &&
915 code <= NOTIFY_BRNDOWN_MAX)
916 code = NOTIFY_BRNDOWN_MIN;
918 if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
919 if (!acpi_video_backlight_support())
920 asus_wmi_backlight_notify(asus, orig_code);
921 } else if (!sparse_keymap_report_event(asus->inputdev, code, 1, true))
922 pr_info("Unknown key %x pressed\n", code);
931 static int parse_arg(const char *buf, unsigned long count, int *val)
935 if (sscanf(buf, "%i", val) != 1)
940 static ssize_t store_sys_wmi(int devid, const char *buf, size_t count)
946 value = asus_wmi_get_devstate_simple(devid);
947 if (value == -ENODEV) /* Check device presence */
950 rv = parse_arg(buf, count, &value);
951 status = asus_wmi_set_devstate(devid, value, &retval);
953 if (ACPI_FAILURE(status))
958 static ssize_t show_sys_wmi(int devid, char *buf)
960 int value = asus_wmi_get_devstate_simple(devid);
965 return sprintf(buf, "%d\n", value);
968 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
969 static ssize_t show_##_name(struct device *dev, \
970 struct device_attribute *attr, \
973 return show_sys_wmi(_cm, buf); \
975 static ssize_t store_##_name(struct device *dev, \
976 struct device_attribute *attr, \
977 const char *buf, size_t count) \
979 return store_sys_wmi(_cm, buf, count); \
981 static struct device_attribute dev_attr_##_name = { \
983 .name = __stringify(_name), \
985 .show = show_##_name, \
986 .store = store_##_name, \
989 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
990 ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
991 ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
993 static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
994 const char *buf, size_t count)
997 struct acpi_buffer input = { (acpi_size) sizeof(value), &value };
1000 if (!count || sscanf(buf, "%i", &value) != 1)
1002 if (value < 0 || value > 2)
1005 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
1006 1, ASUS_WMI_METHODID_CFVS, &input, NULL);
1008 if (ACPI_FAILURE(status))
1014 static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
1016 static struct attribute *platform_attributes[] = {
1017 &dev_attr_cpufv.attr,
1018 &dev_attr_camera.attr,
1019 &dev_attr_cardr.attr,
1020 &dev_attr_touchpad.attr,
1024 static mode_t asus_sysfs_is_visible(struct kobject *kobj,
1025 struct attribute *attr, int idx)
1027 bool supported = true;
1030 if (attr == &dev_attr_camera.attr)
1031 devid = ASUS_WMI_DEVID_CAMERA;
1032 else if (attr == &dev_attr_cardr.attr)
1033 devid = ASUS_WMI_DEVID_CARDREADER;
1034 else if (attr == &dev_attr_touchpad.attr)
1035 devid = ASUS_WMI_DEVID_TOUCHPAD;
1038 supported = asus_wmi_get_devstate_simple(devid) != -ENODEV;
1040 return supported ? attr->mode : 0;
1043 static struct attribute_group platform_attribute_group = {
1044 .is_visible = asus_sysfs_is_visible,
1045 .attrs = platform_attributes
1048 static void asus_wmi_sysfs_exit(struct platform_device *device)
1050 sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
1053 static int asus_wmi_sysfs_init(struct platform_device *device)
1055 return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
1061 static int __init asus_wmi_platform_init(struct asus_wmi *asus)
1063 return asus_wmi_sysfs_init(asus->platform_device);
1066 static void asus_wmi_platform_exit(struct asus_wmi *asus)
1068 asus_wmi_sysfs_exit(asus->platform_device);
1074 struct asus_wmi_debugfs_node {
1075 struct asus_wmi *asus;
1077 int (*show) (struct seq_file *m, void *data);
1080 static int show_dsts(struct seq_file *m, void *data)
1082 struct asus_wmi *asus = m->private;
1086 status = asus_wmi_get_devstate(asus->debug.dev_id, &retval);
1088 if (ACPI_FAILURE(status))
1091 seq_printf(m, "DSTS(%x) = %x\n", asus->debug.dev_id, retval);
1096 static int show_devs(struct seq_file *m, void *data)
1098 struct asus_wmi *asus = m->private;
1102 status = asus_wmi_set_devstate(asus->debug.dev_id,
1103 asus->debug.ctrl_param, &retval);
1104 if (ACPI_FAILURE(status))
1107 seq_printf(m, "DEVS(%x, %x) = %x\n", asus->debug.dev_id,
1108 asus->debug.ctrl_param, retval);
1113 static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
1114 {NULL, "devs", show_devs},
1115 {NULL, "dsts", show_dsts},
1118 static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
1120 struct asus_wmi_debugfs_node *node = inode->i_private;
1122 return single_open(file, node->show, node->asus);
1125 static const struct file_operations asus_wmi_debugfs_io_ops = {
1126 .owner = THIS_MODULE,
1127 .open = asus_wmi_debugfs_open,
1129 .llseek = seq_lseek,
1130 .release = single_release,
1133 static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
1135 debugfs_remove_recursive(asus->debug.root);
1138 static int asus_wmi_debugfs_init(struct asus_wmi *asus)
1140 struct dentry *dent;
1143 asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
1144 if (!asus->debug.root) {
1145 pr_err("failed to create debugfs directory");
1149 dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
1150 asus->debug.root, &asus->debug.dev_id);
1154 dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR,
1155 asus->debug.root, &asus->debug.ctrl_param);
1159 for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
1160 struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
1163 dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
1164 asus->debug.root, node,
1165 &asus_wmi_debugfs_io_ops);
1167 pr_err("failed to create debug file: %s\n", node->name);
1175 asus_wmi_debugfs_exit(asus);
1182 static int asus_wmi_add(struct platform_device *pdev)
1184 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
1185 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
1186 struct asus_wmi *asus;
1190 asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
1194 asus->driver = wdrv;
1195 asus->platform_device = pdev;
1196 wdrv->platform_device = pdev;
1197 platform_set_drvdata(asus->platform_device, asus);
1200 wdrv->quirks(asus->driver);
1202 err = asus_wmi_platform_init(asus);
1206 err = asus_wmi_input_init(asus);
1210 err = asus_wmi_led_init(asus);
1214 err = asus_wmi_rfkill_init(asus);
1218 if (!acpi_video_backlight_support()) {
1219 err = asus_wmi_backlight_init(asus);
1220 if (err && err != -ENODEV)
1221 goto fail_backlight;
1223 pr_info("Backlight controlled by ACPI video driver\n");
1225 status = wmi_install_notify_handler(asus->driver->event_guid,
1226 asus_wmi_notify, asus);
1227 if (ACPI_FAILURE(status)) {
1228 pr_err("Unable to register notify handler - %d\n", status);
1230 goto fail_wmi_handler;
1233 err = asus_wmi_debugfs_init(asus);
1240 wmi_remove_notify_handler(asus->driver->event_guid);
1242 asus_wmi_backlight_exit(asus);
1244 asus_wmi_rfkill_exit(asus);
1246 asus_wmi_led_exit(asus);
1248 asus_wmi_input_exit(asus);
1250 asus_wmi_platform_exit(asus);
1256 static int asus_wmi_remove(struct platform_device *device)
1258 struct asus_wmi *asus;
1260 asus = platform_get_drvdata(device);
1261 wmi_remove_notify_handler(asus->driver->event_guid);
1262 asus_wmi_backlight_exit(asus);
1263 asus_wmi_input_exit(asus);
1264 asus_wmi_led_exit(asus);
1265 asus_wmi_rfkill_exit(asus);
1266 asus_wmi_debugfs_exit(asus);
1267 asus_wmi_platform_exit(asus);
1274 * Platform driver - hibernate/resume callbacks
1276 static int asus_hotk_thaw(struct device *device)
1278 struct asus_wmi *asus = dev_get_drvdata(device);
1280 if (asus->wlan_rfkill) {
1284 * Work around bios bug - acpi _PTS turns off the wireless led
1285 * during suspend. Normally it restores it on resume, but
1286 * we should kick it ourselves in case hibernation is aborted.
1288 wlan = asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WLAN);
1289 asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
1295 static int asus_hotk_restore(struct device *device)
1297 struct asus_wmi *asus = dev_get_drvdata(device);
1300 /* Refresh both wlan rfkill state and pci hotplug */
1301 if (asus->wlan_rfkill)
1302 asus_rfkill_hotplug(asus);
1304 if (asus->bluetooth_rfkill) {
1305 bl = !asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_BLUETOOTH);
1306 rfkill_set_sw_state(asus->bluetooth_rfkill, bl);
1308 if (asus->wimax_rfkill) {
1309 bl = !asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WIMAX);
1310 rfkill_set_sw_state(asus->wimax_rfkill, bl);
1312 if (asus->wwan3g_rfkill) {
1313 bl = !asus_wmi_get_devstate_simple(ASUS_WMI_DEVID_WWAN3G);
1314 rfkill_set_sw_state(asus->wwan3g_rfkill, bl);
1320 static const struct dev_pm_ops asus_pm_ops = {
1321 .thaw = asus_hotk_thaw,
1322 .restore = asus_hotk_restore,
1325 static int asus_wmi_probe(struct platform_device *pdev)
1327 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
1328 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
1331 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
1332 pr_warning("Management GUID not found\n");
1336 if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
1337 pr_warning("Event GUID not found\n");
1342 ret = wdrv->probe(pdev);
1347 return asus_wmi_add(pdev);
1352 int asus_wmi_register_driver(struct asus_wmi_driver *driver)
1354 struct platform_driver *platform_driver;
1355 struct platform_device *platform_device;
1360 platform_driver = &driver->platform_driver;
1361 platform_driver->remove = asus_wmi_remove;
1362 platform_driver->driver.owner = driver->owner;
1363 platform_driver->driver.name = driver->name;
1364 platform_driver->driver.pm = &asus_pm_ops;
1366 platform_device = platform_create_bundle(platform_driver,
1369 if (IS_ERR(platform_device))
1370 return PTR_ERR(platform_device);
1375 EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
1377 void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
1379 platform_device_unregister(driver->platform_device);
1380 platform_driver_unregister(&driver->platform_driver);
1383 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
1385 static int __init asus_wmi_init(void)
1387 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
1388 pr_info("Asus Management GUID not found");
1392 pr_info("ASUS WMI generic driver loaded");
1396 static void __exit asus_wmi_exit(void)
1398 pr_info("ASUS WMI generic driver unloaded");
1401 module_init(asus_wmi_init);
1402 module_exit(asus_wmi_exit);