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/hwmon.h>
43 #include <linux/hwmon-sysfs.h>
44 #include <linux/debugfs.h>
45 #include <linux/seq_file.h>
46 #include <linux/platform_device.h>
47 #include <linux/thermal.h>
48 #include <linux/acpi.h>
49 #include <linux/dmi.h>
50 #include <acpi/video.h>
54 MODULE_AUTHOR("Corentin Chary <corentin.chary@gmail.com>, "
55 "Yong Wang <yong.y.wang@intel.com>");
56 MODULE_DESCRIPTION("Asus Generic WMI Driver");
57 MODULE_LICENSE("GPL");
59 #define to_asus_wmi_driver(pdrv) \
60 (container_of((pdrv), struct asus_wmi_driver, platform_driver))
62 #define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
64 #define NOTIFY_BRNUP_MIN 0x11
65 #define NOTIFY_BRNUP_MAX 0x1f
66 #define NOTIFY_BRNDOWN_MIN 0x20
67 #define NOTIFY_BRNDOWN_MAX 0x2e
68 #define NOTIFY_KBD_BRTUP 0xc4
69 #define NOTIFY_KBD_BRTDWN 0xc5
72 #define ASUS_WMI_METHODID_SPEC 0x43455053 /* BIOS SPECification */
73 #define ASUS_WMI_METHODID_SFBD 0x44424653 /* Set First Boot Device */
74 #define ASUS_WMI_METHODID_GLCD 0x44434C47 /* Get LCD status */
75 #define ASUS_WMI_METHODID_GPID 0x44495047 /* Get Panel ID?? (Resol) */
76 #define ASUS_WMI_METHODID_QMOD 0x444F4D51 /* Quiet MODe */
77 #define ASUS_WMI_METHODID_SPLV 0x4C425053 /* Set Panel Light Value */
78 #define ASUS_WMI_METHODID_AGFN 0x4E464741 /* FaN? */
79 #define ASUS_WMI_METHODID_SFUN 0x4E554653 /* FUNCtionalities */
80 #define ASUS_WMI_METHODID_SDSP 0x50534453 /* Set DiSPlay output */
81 #define ASUS_WMI_METHODID_GDSP 0x50534447 /* Get DiSPlay output */
82 #define ASUS_WMI_METHODID_DEVP 0x50564544 /* DEVice Policy */
83 #define ASUS_WMI_METHODID_OSVR 0x5256534F /* OS VeRsion */
84 #define ASUS_WMI_METHODID_DSTS 0x53544344 /* Device STatuS */
85 #define ASUS_WMI_METHODID_DSTS2 0x53545344 /* Device STatuS #2*/
86 #define ASUS_WMI_METHODID_BSTS 0x53545342 /* Bios STatuS ? */
87 #define ASUS_WMI_METHODID_DEVS 0x53564544 /* DEVice Set */
88 #define ASUS_WMI_METHODID_CFVS 0x53564643 /* CPU Frequency Volt Set */
89 #define ASUS_WMI_METHODID_KBFT 0x5446424B /* KeyBoard FilTer */
90 #define ASUS_WMI_METHODID_INIT 0x54494E49 /* INITialize */
91 #define ASUS_WMI_METHODID_HKEY 0x59454B48 /* Hot KEY ?? */
93 #define ASUS_WMI_UNSUPPORTED_METHOD 0xFFFFFFFE
96 #define ASUS_WMI_DEVID_HW_SWITCH 0x00010001
97 #define ASUS_WMI_DEVID_WIRELESS_LED 0x00010002
98 #define ASUS_WMI_DEVID_CWAP 0x00010003
99 #define ASUS_WMI_DEVID_WLAN 0x00010011
100 #define ASUS_WMI_DEVID_WLAN_LED 0x00010012
101 #define ASUS_WMI_DEVID_BLUETOOTH 0x00010013
102 #define ASUS_WMI_DEVID_GPS 0x00010015
103 #define ASUS_WMI_DEVID_WIMAX 0x00010017
104 #define ASUS_WMI_DEVID_WWAN3G 0x00010019
105 #define ASUS_WMI_DEVID_UWB 0x00010021
108 /* 0x000200XX and 0x000400XX */
109 #define ASUS_WMI_DEVID_LED1 0x00020011
110 #define ASUS_WMI_DEVID_LED2 0x00020012
111 #define ASUS_WMI_DEVID_LED3 0x00020013
112 #define ASUS_WMI_DEVID_LED4 0x00020014
113 #define ASUS_WMI_DEVID_LED5 0x00020015
114 #define ASUS_WMI_DEVID_LED6 0x00020016
116 /* Backlight and Brightness */
117 #define ASUS_WMI_DEVID_BACKLIGHT 0x00050011
118 #define ASUS_WMI_DEVID_BRIGHTNESS 0x00050012
119 #define ASUS_WMI_DEVID_KBD_BACKLIGHT 0x00050021
120 #define ASUS_WMI_DEVID_LIGHT_SENSOR 0x00050022 /* ?? */
123 #define ASUS_WMI_DEVID_CAMERA 0x00060013
126 #define ASUS_WMI_DEVID_CARDREADER 0x00080013
129 #define ASUS_WMI_DEVID_TOUCHPAD 0x00100011
130 #define ASUS_WMI_DEVID_TOUCHPAD_LED 0x00100012
133 #define ASUS_WMI_DEVID_THERMAL_CTRL 0x00110011
134 #define ASUS_WMI_DEVID_FAN_CTRL 0x00110012
137 #define ASUS_WMI_DEVID_PROCESSOR_STATE 0x00120012
139 /* Deep S3 / Resume on LID open */
140 #define ASUS_WMI_DEVID_LID_RESUME 0x00120031
143 #define ASUS_WMI_DSTS_STATUS_BIT 0x00000001
144 #define ASUS_WMI_DSTS_UNKNOWN_BIT 0x00000002
145 #define ASUS_WMI_DSTS_PRESENCE_BIT 0x00010000
146 #define ASUS_WMI_DSTS_USER_BIT 0x00020000
147 #define ASUS_WMI_DSTS_BIOS_BIT 0x00040000
148 #define ASUS_WMI_DSTS_BRIGHTNESS_MASK 0x000000FF
149 #define ASUS_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
151 #define ASUS_FAN_DESC "cpu_fan"
152 #define ASUS_FAN_MFUN 0x13
153 #define ASUS_FAN_SFUN_READ 0x06
154 #define ASUS_FAN_SFUN_WRITE 0x07
155 #define ASUS_FAN_CTRL_MANUAL 1
156 #define ASUS_FAN_CTRL_AUTO 2
164 * Struct that's used for all methods called via AGFN. Naming is
165 * identically to the AML code.
168 u16 mfun
; /* probably "Multi-function" to be called */
169 u16 sfun
; /* probably "Sub-function" to be called */
170 u16 len
; /* size of the hole struct, including subfunction fields */
171 u8 stas
; /* not used by now */
172 u8 err
; /* zero on success */
175 /* struct used for calling fan read and write methods */
177 struct agfn_args agfn
; /* common fields */
178 u8 fan
; /* fan number: 0: set auto mode 1: 1st fan */
179 u32 speed
; /* read: RPM/100 - write: 0-255 */
183 * <platform>/ - debugfs root directory
184 * dev_id - current dev_id
185 * ctrl_param - current ctrl_param
186 * method_id - current method_id
187 * devs - call DEVS(dev_id, ctrl_param) and print result
188 * dsts - call DSTS(dev_id) and print result
189 * call - call method_id(dev_id, ctrl_param) and print result
191 struct asus_wmi_debug
{
199 struct asus_wmi
*asus
;
200 struct rfkill
*rfkill
;
209 struct input_dev
*inputdev
;
210 struct backlight_device
*backlight_device
;
211 struct platform_device
*platform_device
;
213 struct led_classdev wlan_led
;
215 struct led_classdev tpd_led
;
217 struct led_classdev kbd_led
;
219 struct workqueue_struct
*led_workqueue
;
220 struct work_struct tpd_led_work
;
221 struct work_struct kbd_led_work
;
222 struct work_struct wlan_led_work
;
224 struct asus_rfkill wlan
;
225 struct asus_rfkill bluetooth
;
226 struct asus_rfkill wimax
;
227 struct asus_rfkill wwan3g
;
228 struct asus_rfkill gps
;
229 struct asus_rfkill uwb
;
231 bool asus_hwmon_fan_manual_mode
;
232 int asus_hwmon_num_fans
;
235 struct hotplug_slot
*hotplug_slot
;
236 struct mutex hotplug_lock
;
237 struct mutex wmi_lock
;
238 struct workqueue_struct
*hotplug_workqueue
;
239 struct work_struct hotplug_work
;
241 struct asus_wmi_debug debug
;
243 struct asus_wmi_driver
*driver
;
246 static int asus_wmi_input_init(struct asus_wmi
*asus
)
250 asus
->inputdev
= input_allocate_device();
254 asus
->inputdev
->name
= asus
->driver
->input_name
;
255 asus
->inputdev
->phys
= asus
->driver
->input_phys
;
256 asus
->inputdev
->id
.bustype
= BUS_HOST
;
257 asus
->inputdev
->dev
.parent
= &asus
->platform_device
->dev
;
258 set_bit(EV_REP
, asus
->inputdev
->evbit
);
260 err
= sparse_keymap_setup(asus
->inputdev
, asus
->driver
->keymap
, NULL
);
264 err
= input_register_device(asus
->inputdev
);
266 goto err_free_keymap
;
271 sparse_keymap_free(asus
->inputdev
);
273 input_free_device(asus
->inputdev
);
277 static void asus_wmi_input_exit(struct asus_wmi
*asus
)
279 if (asus
->inputdev
) {
280 sparse_keymap_free(asus
->inputdev
);
281 input_unregister_device(asus
->inputdev
);
284 asus
->inputdev
= NULL
;
287 static int asus_wmi_evaluate_method(u32 method_id
, u32 arg0
, u32 arg1
,
290 struct bios_args args
= {
294 struct acpi_buffer input
= { (acpi_size
) sizeof(args
), &args
};
295 struct acpi_buffer output
= { ACPI_ALLOCATE_BUFFER
, NULL
};
297 union acpi_object
*obj
;
300 status
= wmi_evaluate_method(ASUS_WMI_MGMT_GUID
, 1, method_id
,
303 if (ACPI_FAILURE(status
))
306 obj
= (union acpi_object
*)output
.pointer
;
307 if (obj
&& obj
->type
== ACPI_TYPE_INTEGER
)
308 tmp
= (u32
) obj
->integer
.value
;
316 if (ACPI_FAILURE(status
))
319 if (tmp
== ASUS_WMI_UNSUPPORTED_METHOD
)
325 static int asus_wmi_evaluate_method_agfn(const struct acpi_buffer args
)
327 struct acpi_buffer input
;
333 * Copy to dma capable address otherwise memory corruption occurs as
334 * bios has to be able to access it.
336 input
.pointer
= kzalloc(args
.length
, GFP_DMA
| GFP_KERNEL
);
337 input
.length
= args
.length
;
340 phys_addr
= virt_to_phys(input
.pointer
);
341 memcpy(input
.pointer
, args
.pointer
, args
.length
);
343 status
= asus_wmi_evaluate_method(ASUS_WMI_METHODID_AGFN
,
344 phys_addr
, 0, &retval
);
346 memcpy(args
.pointer
, input
.pointer
, args
.length
);
348 kfree(input
.pointer
);
355 static int asus_wmi_get_devstate(struct asus_wmi
*asus
, u32 dev_id
, u32
*retval
)
357 return asus_wmi_evaluate_method(asus
->dsts_id
, dev_id
, 0, retval
);
360 static int asus_wmi_set_devstate(u32 dev_id
, u32 ctrl_param
,
363 return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS
, dev_id
,
367 /* Helper for special devices with magic return codes */
368 static int asus_wmi_get_devstate_bits(struct asus_wmi
*asus
,
369 u32 dev_id
, u32 mask
)
374 err
= asus_wmi_get_devstate(asus
, dev_id
, &retval
);
379 if (!(retval
& ASUS_WMI_DSTS_PRESENCE_BIT
))
382 if (mask
== ASUS_WMI_DSTS_STATUS_BIT
) {
383 if (retval
& ASUS_WMI_DSTS_UNKNOWN_BIT
)
387 return retval
& mask
;
390 static int asus_wmi_get_devstate_simple(struct asus_wmi
*asus
, u32 dev_id
)
392 return asus_wmi_get_devstate_bits(asus
, dev_id
,
393 ASUS_WMI_DSTS_STATUS_BIT
);
400 * These functions actually update the LED's, and are called from a
401 * workqueue. By doing this as separate work rather than when the LED
402 * subsystem asks, we avoid messing with the Asus ACPI stuff during a
403 * potentially bad time, such as a timer interrupt.
405 static void tpd_led_update(struct work_struct
*work
)
408 struct asus_wmi
*asus
;
410 asus
= container_of(work
, struct asus_wmi
, tpd_led_work
);
412 ctrl_param
= asus
->tpd_led_wk
;
413 asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED
, ctrl_param
, NULL
);
416 static void tpd_led_set(struct led_classdev
*led_cdev
,
417 enum led_brightness value
)
419 struct asus_wmi
*asus
;
421 asus
= container_of(led_cdev
, struct asus_wmi
, tpd_led
);
423 asus
->tpd_led_wk
= !!value
;
424 queue_work(asus
->led_workqueue
, &asus
->tpd_led_work
);
427 static int read_tpd_led_state(struct asus_wmi
*asus
)
429 return asus_wmi_get_devstate_simple(asus
, ASUS_WMI_DEVID_TOUCHPAD_LED
);
432 static enum led_brightness
tpd_led_get(struct led_classdev
*led_cdev
)
434 struct asus_wmi
*asus
;
436 asus
= container_of(led_cdev
, struct asus_wmi
, tpd_led
);
438 return read_tpd_led_state(asus
);
441 static void kbd_led_update(struct work_struct
*work
)
444 struct asus_wmi
*asus
;
446 asus
= container_of(work
, struct asus_wmi
, kbd_led_work
);
450 * bit 7: light on/off
452 if (asus
->kbd_led_wk
> 0)
453 ctrl_param
= 0x80 | (asus
->kbd_led_wk
& 0x7F);
455 asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT
, ctrl_param
, NULL
);
458 static int kbd_led_read(struct asus_wmi
*asus
, int *level
, int *env
)
464 * bit 7: light on/off
465 * bit 8-10: environment (0: dark, 1: normal, 2: light)
466 * bit 17: status unknown
468 retval
= asus_wmi_get_devstate_bits(asus
, ASUS_WMI_DEVID_KBD_BACKLIGHT
,
471 /* Unknown status is considered as off */
472 if (retval
== 0x8000)
477 *level
= retval
& 0x7F;
479 *env
= (retval
>> 8) & 0x7F;
486 static void kbd_led_set(struct led_classdev
*led_cdev
,
487 enum led_brightness value
)
489 struct asus_wmi
*asus
;
491 asus
= container_of(led_cdev
, struct asus_wmi
, kbd_led
);
493 if (value
> asus
->kbd_led
.max_brightness
)
494 value
= asus
->kbd_led
.max_brightness
;
498 asus
->kbd_led_wk
= value
;
499 queue_work(asus
->led_workqueue
, &asus
->kbd_led_work
);
502 static enum led_brightness
kbd_led_get(struct led_classdev
*led_cdev
)
504 struct asus_wmi
*asus
;
507 asus
= container_of(led_cdev
, struct asus_wmi
, kbd_led
);
509 retval
= kbd_led_read(asus
, &value
, NULL
);
517 static int wlan_led_unknown_state(struct asus_wmi
*asus
)
521 asus_wmi_get_devstate(asus
, ASUS_WMI_DEVID_WIRELESS_LED
, &result
);
523 return result
& ASUS_WMI_DSTS_UNKNOWN_BIT
;
526 static int wlan_led_presence(struct asus_wmi
*asus
)
530 asus_wmi_get_devstate(asus
, ASUS_WMI_DEVID_WIRELESS_LED
, &result
);
532 return result
& ASUS_WMI_DSTS_PRESENCE_BIT
;
535 static void wlan_led_update(struct work_struct
*work
)
538 struct asus_wmi
*asus
;
540 asus
= container_of(work
, struct asus_wmi
, wlan_led_work
);
542 ctrl_param
= asus
->wlan_led_wk
;
543 asus_wmi_set_devstate(ASUS_WMI_DEVID_WIRELESS_LED
, ctrl_param
, NULL
);
546 static void wlan_led_set(struct led_classdev
*led_cdev
,
547 enum led_brightness value
)
549 struct asus_wmi
*asus
;
551 asus
= container_of(led_cdev
, struct asus_wmi
, wlan_led
);
553 asus
->wlan_led_wk
= !!value
;
554 queue_work(asus
->led_workqueue
, &asus
->wlan_led_work
);
557 static enum led_brightness
wlan_led_get(struct led_classdev
*led_cdev
)
559 struct asus_wmi
*asus
;
562 asus
= container_of(led_cdev
, struct asus_wmi
, wlan_led
);
563 asus_wmi_get_devstate(asus
, ASUS_WMI_DEVID_WIRELESS_LED
, &result
);
565 return result
& ASUS_WMI_DSTS_BRIGHTNESS_MASK
;
568 static void asus_wmi_led_exit(struct asus_wmi
*asus
)
570 if (!IS_ERR_OR_NULL(asus
->kbd_led
.dev
))
571 led_classdev_unregister(&asus
->kbd_led
);
572 if (!IS_ERR_OR_NULL(asus
->tpd_led
.dev
))
573 led_classdev_unregister(&asus
->tpd_led
);
574 if (!IS_ERR_OR_NULL(asus
->wlan_led
.dev
))
575 led_classdev_unregister(&asus
->wlan_led
);
576 if (asus
->led_workqueue
)
577 destroy_workqueue(asus
->led_workqueue
);
580 static int asus_wmi_led_init(struct asus_wmi
*asus
)
584 asus
->led_workqueue
= create_singlethread_workqueue("led_workqueue");
585 if (!asus
->led_workqueue
)
588 if (read_tpd_led_state(asus
) >= 0) {
589 INIT_WORK(&asus
->tpd_led_work
, tpd_led_update
);
591 asus
->tpd_led
.name
= "asus::touchpad";
592 asus
->tpd_led
.brightness_set
= tpd_led_set
;
593 asus
->tpd_led
.brightness_get
= tpd_led_get
;
594 asus
->tpd_led
.max_brightness
= 1;
596 rv
= led_classdev_register(&asus
->platform_device
->dev
,
602 led_val
= kbd_led_read(asus
, NULL
, NULL
);
604 INIT_WORK(&asus
->kbd_led_work
, kbd_led_update
);
606 asus
->kbd_led_wk
= led_val
;
607 asus
->kbd_led
.name
= "asus::kbd_backlight";
608 asus
->kbd_led
.brightness_set
= kbd_led_set
;
609 asus
->kbd_led
.brightness_get
= kbd_led_get
;
610 asus
->kbd_led
.max_brightness
= 3;
612 rv
= led_classdev_register(&asus
->platform_device
->dev
,
618 if (wlan_led_presence(asus
) && (asus
->driver
->quirks
->wapf
> 0)) {
619 INIT_WORK(&asus
->wlan_led_work
, wlan_led_update
);
621 asus
->wlan_led
.name
= "asus::wlan";
622 asus
->wlan_led
.brightness_set
= wlan_led_set
;
623 if (!wlan_led_unknown_state(asus
))
624 asus
->wlan_led
.brightness_get
= wlan_led_get
;
625 asus
->wlan_led
.flags
= LED_CORE_SUSPENDRESUME
;
626 asus
->wlan_led
.max_brightness
= 1;
627 asus
->wlan_led
.default_trigger
= "asus-wlan";
629 rv
= led_classdev_register(&asus
->platform_device
->dev
,
635 asus_wmi_led_exit(asus
);
642 * PCI hotplug (for wlan rfkill)
644 static bool asus_wlan_rfkill_blocked(struct asus_wmi
*asus
)
646 int result
= asus_wmi_get_devstate_simple(asus
, ASUS_WMI_DEVID_WLAN
);
653 static void asus_rfkill_hotplug(struct asus_wmi
*asus
)
661 mutex_lock(&asus
->wmi_lock
);
662 blocked
= asus_wlan_rfkill_blocked(asus
);
663 mutex_unlock(&asus
->wmi_lock
);
665 mutex_lock(&asus
->hotplug_lock
);
666 pci_lock_rescan_remove();
668 if (asus
->wlan
.rfkill
)
669 rfkill_set_sw_state(asus
->wlan
.rfkill
, blocked
);
671 if (asus
->hotplug_slot
) {
672 bus
= pci_find_bus(0, 1);
674 pr_warn("Unable to find PCI bus 1?\n");
678 if (pci_bus_read_config_dword(bus
, 0, PCI_VENDOR_ID
, &l
)) {
679 pr_err("Unable to read PCI config space?\n");
682 absent
= (l
== 0xffffffff);
684 if (blocked
!= absent
) {
685 pr_warn("BIOS says wireless lan is %s, "
686 "but the pci device is %s\n",
687 blocked
? "blocked" : "unblocked",
688 absent
? "absent" : "present");
689 pr_warn("skipped wireless hotplug as probably "
690 "inappropriate for this model\n");
695 dev
= pci_get_slot(bus
, 0);
697 /* Device already present */
701 dev
= pci_scan_single_device(bus
, 0);
703 pci_bus_assign_resources(bus
);
704 pci_bus_add_device(dev
);
707 dev
= pci_get_slot(bus
, 0);
709 pci_stop_and_remove_bus_device(dev
);
716 pci_unlock_rescan_remove();
717 mutex_unlock(&asus
->hotplug_lock
);
720 static void asus_rfkill_notify(acpi_handle handle
, u32 event
, void *data
)
722 struct asus_wmi
*asus
= data
;
724 if (event
!= ACPI_NOTIFY_BUS_CHECK
)
728 * We can't call directly asus_rfkill_hotplug because most
729 * of the time WMBC is still being executed and not reetrant.
730 * There is currently no way to tell ACPICA that we want this
731 * method to be serialized, we schedule a asus_rfkill_hotplug
732 * call later, in a safer context.
734 queue_work(asus
->hotplug_workqueue
, &asus
->hotplug_work
);
737 static int asus_register_rfkill_notifier(struct asus_wmi
*asus
, char *node
)
742 status
= acpi_get_handle(NULL
, node
, &handle
);
744 if (ACPI_SUCCESS(status
)) {
745 status
= acpi_install_notify_handler(handle
,
747 asus_rfkill_notify
, asus
);
748 if (ACPI_FAILURE(status
))
749 pr_warn("Failed to register notify on %s\n", node
);
756 static void asus_unregister_rfkill_notifier(struct asus_wmi
*asus
, char *node
)
758 acpi_status status
= AE_OK
;
761 status
= acpi_get_handle(NULL
, node
, &handle
);
763 if (ACPI_SUCCESS(status
)) {
764 status
= acpi_remove_notify_handler(handle
,
767 if (ACPI_FAILURE(status
))
768 pr_err("Error removing rfkill notify handler %s\n",
773 static int asus_get_adapter_status(struct hotplug_slot
*hotplug_slot
,
776 struct asus_wmi
*asus
= hotplug_slot
->private;
777 int result
= asus_wmi_get_devstate_simple(asus
, ASUS_WMI_DEVID_WLAN
);
786 static void asus_cleanup_pci_hotplug(struct hotplug_slot
*hotplug_slot
)
788 kfree(hotplug_slot
->info
);
792 static struct hotplug_slot_ops asus_hotplug_slot_ops
= {
793 .owner
= THIS_MODULE
,
794 .get_adapter_status
= asus_get_adapter_status
,
795 .get_power_status
= asus_get_adapter_status
,
798 static void asus_hotplug_work(struct work_struct
*work
)
800 struct asus_wmi
*asus
;
802 asus
= container_of(work
, struct asus_wmi
, hotplug_work
);
803 asus_rfkill_hotplug(asus
);
806 static int asus_setup_pci_hotplug(struct asus_wmi
*asus
)
809 struct pci_bus
*bus
= pci_find_bus(0, 1);
812 pr_err("Unable to find wifi PCI bus\n");
816 asus
->hotplug_workqueue
=
817 create_singlethread_workqueue("hotplug_workqueue");
818 if (!asus
->hotplug_workqueue
)
819 goto error_workqueue
;
821 INIT_WORK(&asus
->hotplug_work
, asus_hotplug_work
);
823 asus
->hotplug_slot
= kzalloc(sizeof(struct hotplug_slot
), GFP_KERNEL
);
824 if (!asus
->hotplug_slot
)
827 asus
->hotplug_slot
->info
= kzalloc(sizeof(struct hotplug_slot_info
),
829 if (!asus
->hotplug_slot
->info
)
832 asus
->hotplug_slot
->private = asus
;
833 asus
->hotplug_slot
->release
= &asus_cleanup_pci_hotplug
;
834 asus
->hotplug_slot
->ops
= &asus_hotplug_slot_ops
;
835 asus_get_adapter_status(asus
->hotplug_slot
,
836 &asus
->hotplug_slot
->info
->adapter_status
);
838 ret
= pci_hp_register(asus
->hotplug_slot
, bus
, 0, "asus-wifi");
840 pr_err("Unable to register hotplug slot - %d\n", ret
);
847 kfree(asus
->hotplug_slot
->info
);
849 kfree(asus
->hotplug_slot
);
850 asus
->hotplug_slot
= NULL
;
852 destroy_workqueue(asus
->hotplug_workqueue
);
860 static int asus_rfkill_set(void *data
, bool blocked
)
862 struct asus_rfkill
*priv
= data
;
863 u32 ctrl_param
= !blocked
;
864 u32 dev_id
= priv
->dev_id
;
867 * If the user bit is set, BIOS can't set and record the wlan status,
868 * it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
869 * while we query the wlan status through WMI(ASUS_WMI_DEVID_WLAN).
870 * So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
871 * while setting the wlan status through WMI.
872 * This is also the behavior that windows app will do.
874 if ((dev_id
== ASUS_WMI_DEVID_WLAN
) &&
875 priv
->asus
->driver
->wlan_ctrl_by_user
)
876 dev_id
= ASUS_WMI_DEVID_WLAN_LED
;
878 return asus_wmi_set_devstate(dev_id
, ctrl_param
, NULL
);
881 static void asus_rfkill_query(struct rfkill
*rfkill
, void *data
)
883 struct asus_rfkill
*priv
= data
;
886 result
= asus_wmi_get_devstate_simple(priv
->asus
, priv
->dev_id
);
891 rfkill_set_sw_state(priv
->rfkill
, !result
);
894 static int asus_rfkill_wlan_set(void *data
, bool blocked
)
896 struct asus_rfkill
*priv
= data
;
897 struct asus_wmi
*asus
= priv
->asus
;
901 * This handler is enabled only if hotplug is enabled.
902 * In this case, the asus_wmi_set_devstate() will
903 * trigger a wmi notification and we need to wait
904 * this call to finish before being able to call
907 mutex_lock(&asus
->wmi_lock
);
908 ret
= asus_rfkill_set(data
, blocked
);
909 mutex_unlock(&asus
->wmi_lock
);
913 static const struct rfkill_ops asus_rfkill_wlan_ops
= {
914 .set_block
= asus_rfkill_wlan_set
,
915 .query
= asus_rfkill_query
,
918 static const struct rfkill_ops asus_rfkill_ops
= {
919 .set_block
= asus_rfkill_set
,
920 .query
= asus_rfkill_query
,
923 static int asus_new_rfkill(struct asus_wmi
*asus
,
924 struct asus_rfkill
*arfkill
,
925 const char *name
, enum rfkill_type type
, int dev_id
)
927 int result
= asus_wmi_get_devstate_simple(asus
, dev_id
);
928 struct rfkill
**rfkill
= &arfkill
->rfkill
;
933 arfkill
->dev_id
= dev_id
;
934 arfkill
->asus
= asus
;
936 if (dev_id
== ASUS_WMI_DEVID_WLAN
&&
937 asus
->driver
->quirks
->hotplug_wireless
)
938 *rfkill
= rfkill_alloc(name
, &asus
->platform_device
->dev
, type
,
939 &asus_rfkill_wlan_ops
, arfkill
);
941 *rfkill
= rfkill_alloc(name
, &asus
->platform_device
->dev
, type
,
942 &asus_rfkill_ops
, arfkill
);
947 if ((dev_id
== ASUS_WMI_DEVID_WLAN
) &&
948 (asus
->driver
->quirks
->wapf
> 0))
949 rfkill_set_led_trigger_name(*rfkill
, "asus-wlan");
951 rfkill_init_sw_state(*rfkill
, !result
);
952 result
= rfkill_register(*rfkill
);
954 rfkill_destroy(*rfkill
);
961 static void asus_wmi_rfkill_exit(struct asus_wmi
*asus
)
963 asus_unregister_rfkill_notifier(asus
, "\\_SB.PCI0.P0P5");
964 asus_unregister_rfkill_notifier(asus
, "\\_SB.PCI0.P0P6");
965 asus_unregister_rfkill_notifier(asus
, "\\_SB.PCI0.P0P7");
966 if (asus
->wlan
.rfkill
) {
967 rfkill_unregister(asus
->wlan
.rfkill
);
968 rfkill_destroy(asus
->wlan
.rfkill
);
969 asus
->wlan
.rfkill
= NULL
;
972 * Refresh pci hotplug in case the rfkill state was changed after
973 * asus_unregister_rfkill_notifier()
975 asus_rfkill_hotplug(asus
);
976 if (asus
->hotplug_slot
)
977 pci_hp_deregister(asus
->hotplug_slot
);
978 if (asus
->hotplug_workqueue
)
979 destroy_workqueue(asus
->hotplug_workqueue
);
981 if (asus
->bluetooth
.rfkill
) {
982 rfkill_unregister(asus
->bluetooth
.rfkill
);
983 rfkill_destroy(asus
->bluetooth
.rfkill
);
984 asus
->bluetooth
.rfkill
= NULL
;
986 if (asus
->wimax
.rfkill
) {
987 rfkill_unregister(asus
->wimax
.rfkill
);
988 rfkill_destroy(asus
->wimax
.rfkill
);
989 asus
->wimax
.rfkill
= NULL
;
991 if (asus
->wwan3g
.rfkill
) {
992 rfkill_unregister(asus
->wwan3g
.rfkill
);
993 rfkill_destroy(asus
->wwan3g
.rfkill
);
994 asus
->wwan3g
.rfkill
= NULL
;
996 if (asus
->gps
.rfkill
) {
997 rfkill_unregister(asus
->gps
.rfkill
);
998 rfkill_destroy(asus
->gps
.rfkill
);
999 asus
->gps
.rfkill
= NULL
;
1001 if (asus
->uwb
.rfkill
) {
1002 rfkill_unregister(asus
->uwb
.rfkill
);
1003 rfkill_destroy(asus
->uwb
.rfkill
);
1004 asus
->uwb
.rfkill
= NULL
;
1008 static int asus_wmi_rfkill_init(struct asus_wmi
*asus
)
1012 mutex_init(&asus
->hotplug_lock
);
1013 mutex_init(&asus
->wmi_lock
);
1015 result
= asus_new_rfkill(asus
, &asus
->wlan
, "asus-wlan",
1016 RFKILL_TYPE_WLAN
, ASUS_WMI_DEVID_WLAN
);
1018 if (result
&& result
!= -ENODEV
)
1021 result
= asus_new_rfkill(asus
, &asus
->bluetooth
,
1022 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH
,
1023 ASUS_WMI_DEVID_BLUETOOTH
);
1025 if (result
&& result
!= -ENODEV
)
1028 result
= asus_new_rfkill(asus
, &asus
->wimax
, "asus-wimax",
1029 RFKILL_TYPE_WIMAX
, ASUS_WMI_DEVID_WIMAX
);
1031 if (result
&& result
!= -ENODEV
)
1034 result
= asus_new_rfkill(asus
, &asus
->wwan3g
, "asus-wwan3g",
1035 RFKILL_TYPE_WWAN
, ASUS_WMI_DEVID_WWAN3G
);
1037 if (result
&& result
!= -ENODEV
)
1040 result
= asus_new_rfkill(asus
, &asus
->gps
, "asus-gps",
1041 RFKILL_TYPE_GPS
, ASUS_WMI_DEVID_GPS
);
1043 if (result
&& result
!= -ENODEV
)
1046 result
= asus_new_rfkill(asus
, &asus
->uwb
, "asus-uwb",
1047 RFKILL_TYPE_UWB
, ASUS_WMI_DEVID_UWB
);
1049 if (result
&& result
!= -ENODEV
)
1052 if (!asus
->driver
->quirks
->hotplug_wireless
)
1055 result
= asus_setup_pci_hotplug(asus
);
1057 * If we get -EBUSY then something else is handling the PCI hotplug -
1058 * don't fail in this case
1060 if (result
== -EBUSY
)
1063 asus_register_rfkill_notifier(asus
, "\\_SB.PCI0.P0P5");
1064 asus_register_rfkill_notifier(asus
, "\\_SB.PCI0.P0P6");
1065 asus_register_rfkill_notifier(asus
, "\\_SB.PCI0.P0P7");
1067 * Refresh pci hotplug in case the rfkill state was changed during
1070 asus_rfkill_hotplug(asus
);
1073 if (result
&& result
!= -ENODEV
)
1074 asus_wmi_rfkill_exit(asus
);
1076 if (result
== -ENODEV
)
1085 static int asus_hwmon_agfn_fan_speed_read(struct asus_wmi
*asus
, int fan
,
1088 struct fan_args args
= {
1089 .agfn
.len
= sizeof(args
),
1090 .agfn
.mfun
= ASUS_FAN_MFUN
,
1091 .agfn
.sfun
= ASUS_FAN_SFUN_READ
,
1095 struct acpi_buffer input
= { (acpi_size
) sizeof(args
), &args
};
1101 status
= asus_wmi_evaluate_method_agfn(input
);
1103 if (status
|| args
.agfn
.err
)
1107 *speed
= args
.speed
;
1112 static int asus_hwmon_agfn_fan_speed_write(struct asus_wmi
*asus
, int fan
,
1115 struct fan_args args
= {
1116 .agfn
.len
= sizeof(args
),
1117 .agfn
.mfun
= ASUS_FAN_MFUN
,
1118 .agfn
.sfun
= ASUS_FAN_SFUN_WRITE
,
1120 .speed
= speed
? *speed
: 0,
1122 struct acpi_buffer input
= { (acpi_size
) sizeof(args
), &args
};
1125 /* 1: for setting 1st fan's speed 0: setting auto mode */
1126 if (fan
!= 1 && fan
!= 0)
1129 status
= asus_wmi_evaluate_method_agfn(input
);
1131 if (status
|| args
.agfn
.err
)
1134 if (speed
&& fan
== 1)
1135 asus
->asus_hwmon_pwm
= *speed
;
1141 * Check if we can read the speed of one fan. If true we assume we can also
1144 static int asus_hwmon_get_fan_number(struct asus_wmi
*asus
, int *num_fans
)
1151 status
= asus_hwmon_agfn_fan_speed_read(asus
, 1, &speed
);
1158 static int asus_hwmon_fan_set_auto(struct asus_wmi
*asus
)
1162 status
= asus_hwmon_agfn_fan_speed_write(asus
, 0, NULL
);
1166 asus
->asus_hwmon_fan_manual_mode
= false;
1171 static int asus_hwmon_fan_rpm_show(struct device
*dev
, int fan
)
1173 struct asus_wmi
*asus
= dev_get_drvdata(dev
);
1177 /* no speed readable on manual mode */
1178 if (asus
->asus_hwmon_fan_manual_mode
)
1181 ret
= asus_hwmon_agfn_fan_speed_read(asus
, fan
+1, &value
);
1183 pr_warn("reading fan speed failed: %d\n", ret
);
1190 static void asus_hwmon_pwm_show(struct asus_wmi
*asus
, int fan
, int *value
)
1194 if (asus
->asus_hwmon_pwm
>= 0) {
1195 *value
= asus
->asus_hwmon_pwm
;
1199 err
= asus_wmi_get_devstate(asus
, ASUS_WMI_DEVID_FAN_CTRL
, value
);
1205 if (*value
== 1) /* Low Speed */
1207 else if (*value
== 2)
1209 else if (*value
== 3)
1212 pr_err("Unknown fan speed %#x\n", *value
);
1217 static ssize_t
pwm1_show(struct device
*dev
,
1218 struct device_attribute
*attr
,
1221 struct asus_wmi
*asus
= dev_get_drvdata(dev
);
1224 asus_hwmon_pwm_show(asus
, 0, &value
);
1226 return sprintf(buf
, "%d\n", value
);
1229 static ssize_t
pwm1_store(struct device
*dev
,
1230 struct device_attribute
*attr
,
1231 const char *buf
, size_t count
) {
1232 struct asus_wmi
*asus
= dev_get_drvdata(dev
);
1237 ret
= kstrtouint(buf
, 10, &value
);
1242 value
= clamp(value
, 0, 255);
1244 state
= asus_hwmon_agfn_fan_speed_write(asus
, 1, &value
);
1246 pr_warn("Setting fan speed failed: %d\n", state
);
1248 asus
->asus_hwmon_fan_manual_mode
= true;
1253 static ssize_t
fan1_input_show(struct device
*dev
,
1254 struct device_attribute
*attr
,
1257 int value
= asus_hwmon_fan_rpm_show(dev
, 0);
1259 return sprintf(buf
, "%d\n", value
< 0 ? -1 : value
*100);
1263 static ssize_t
pwm1_enable_show(struct device
*dev
,
1264 struct device_attribute
*attr
,
1267 struct asus_wmi
*asus
= dev_get_drvdata(dev
);
1269 if (asus
->asus_hwmon_fan_manual_mode
)
1270 return sprintf(buf
, "%d\n", ASUS_FAN_CTRL_MANUAL
);
1272 return sprintf(buf
, "%d\n", ASUS_FAN_CTRL_AUTO
);
1275 static ssize_t
pwm1_enable_store(struct device
*dev
,
1276 struct device_attribute
*attr
,
1277 const char *buf
, size_t count
)
1279 struct asus_wmi
*asus
= dev_get_drvdata(dev
);
1284 ret
= kstrtouint(buf
, 10, &state
);
1289 if (state
== ASUS_FAN_CTRL_MANUAL
)
1290 asus
->asus_hwmon_fan_manual_mode
= true;
1292 status
= asus_hwmon_fan_set_auto(asus
);
1300 static ssize_t
fan1_label_show(struct device
*dev
,
1301 struct device_attribute
*attr
,
1304 return sprintf(buf
, "%s\n", ASUS_FAN_DESC
);
1307 static ssize_t
asus_hwmon_temp1(struct device
*dev
,
1308 struct device_attribute
*attr
,
1311 struct asus_wmi
*asus
= dev_get_drvdata(dev
);
1315 err
= asus_wmi_get_devstate(asus
, ASUS_WMI_DEVID_THERMAL_CTRL
, &value
);
1320 value
= DECI_KELVIN_TO_CELSIUS((value
& 0xFFFF)) * 1000;
1322 return sprintf(buf
, "%d\n", value
);
1326 static DEVICE_ATTR_RW(pwm1
);
1327 static DEVICE_ATTR_RW(pwm1_enable
);
1328 static DEVICE_ATTR_RO(fan1_input
);
1329 static DEVICE_ATTR_RO(fan1_label
);
1332 static DEVICE_ATTR(temp1_input
, S_IRUGO
, asus_hwmon_temp1
, NULL
);
1334 static struct attribute
*hwmon_attributes
[] = {
1335 &dev_attr_pwm1
.attr
,
1336 &dev_attr_pwm1_enable
.attr
,
1337 &dev_attr_fan1_input
.attr
,
1338 &dev_attr_fan1_label
.attr
,
1340 &dev_attr_temp1_input
.attr
,
1344 static umode_t
asus_hwmon_sysfs_is_visible(struct kobject
*kobj
,
1345 struct attribute
*attr
, int idx
)
1347 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
1348 struct platform_device
*pdev
= to_platform_device(dev
->parent
);
1349 struct asus_wmi
*asus
= platform_get_drvdata(pdev
);
1352 u32 value
= ASUS_WMI_UNSUPPORTED_METHOD
;
1355 if (attr
== &dev_attr_pwm1
.attr
)
1356 dev_id
= ASUS_WMI_DEVID_FAN_CTRL
;
1357 else if (attr
== &dev_attr_temp1_input
.attr
)
1358 dev_id
= ASUS_WMI_DEVID_THERMAL_CTRL
;
1361 if (attr
== &dev_attr_fan1_input
.attr
1362 || attr
== &dev_attr_fan1_label
.attr
1363 || attr
== &dev_attr_pwm1
.attr
1364 || attr
== &dev_attr_pwm1_enable
.attr
) {
1369 int err
= asus_wmi_get_devstate(asus
, dev_id
, &value
);
1371 if (err
< 0 && fan_attr
== -1)
1372 return 0; /* can't return negative here */
1375 if (dev_id
== ASUS_WMI_DEVID_FAN_CTRL
) {
1377 * We need to find a better way, probably using sfun,
1379 * Currently we disable it if:
1380 * - ASUS_WMI_UNSUPPORTED_METHOD is returned
1381 * - reverved bits are non-zero
1382 * - sfun and presence bit are not set
1384 if (value
== ASUS_WMI_UNSUPPORTED_METHOD
|| value
& 0xFFF80000
1385 || (!asus
->sfun
&& !(value
& ASUS_WMI_DSTS_PRESENCE_BIT
)))
1388 ok
= fan_attr
<= asus
->asus_hwmon_num_fans
;
1389 } else if (dev_id
== ASUS_WMI_DEVID_THERMAL_CTRL
) {
1390 /* If value is zero, something is clearly wrong */
1393 } else if (fan_attr
<= asus
->asus_hwmon_num_fans
&& fan_attr
!= -1) {
1399 return ok
? attr
->mode
: 0;
1402 static struct attribute_group hwmon_attribute_group
= {
1403 .is_visible
= asus_hwmon_sysfs_is_visible
,
1404 .attrs
= hwmon_attributes
1406 __ATTRIBUTE_GROUPS(hwmon_attribute
);
1408 static int asus_wmi_hwmon_init(struct asus_wmi
*asus
)
1410 struct device
*hwmon
;
1412 hwmon
= hwmon_device_register_with_groups(&asus
->platform_device
->dev
,
1414 hwmon_attribute_groups
);
1415 if (IS_ERR(hwmon
)) {
1416 pr_err("Could not register asus hwmon device\n");
1417 return PTR_ERR(hwmon
);
1425 static int read_backlight_power(struct asus_wmi
*asus
)
1428 if (asus
->driver
->quirks
->store_backlight_power
)
1429 ret
= !asus
->driver
->panel_power
;
1431 ret
= asus_wmi_get_devstate_simple(asus
,
1432 ASUS_WMI_DEVID_BACKLIGHT
);
1437 return ret
? FB_BLANK_UNBLANK
: FB_BLANK_POWERDOWN
;
1440 static int read_brightness_max(struct asus_wmi
*asus
)
1445 err
= asus_wmi_get_devstate(asus
, ASUS_WMI_DEVID_BRIGHTNESS
, &retval
);
1450 retval
= retval
& ASUS_WMI_DSTS_MAX_BRIGTH_MASK
;
1459 static int read_brightness(struct backlight_device
*bd
)
1461 struct asus_wmi
*asus
= bl_get_data(bd
);
1465 err
= asus_wmi_get_devstate(asus
, ASUS_WMI_DEVID_BRIGHTNESS
, &retval
);
1470 return retval
& ASUS_WMI_DSTS_BRIGHTNESS_MASK
;
1473 static u32
get_scalar_command(struct backlight_device
*bd
)
1475 struct asus_wmi
*asus
= bl_get_data(bd
);
1478 if ((asus
->driver
->brightness
< bd
->props
.brightness
) ||
1479 bd
->props
.brightness
== bd
->props
.max_brightness
)
1480 ctrl_param
= 0x00008001;
1481 else if ((asus
->driver
->brightness
> bd
->props
.brightness
) ||
1482 bd
->props
.brightness
== 0)
1483 ctrl_param
= 0x00008000;
1485 asus
->driver
->brightness
= bd
->props
.brightness
;
1490 static int update_bl_status(struct backlight_device
*bd
)
1492 struct asus_wmi
*asus
= bl_get_data(bd
);
1496 power
= read_backlight_power(asus
);
1497 if (power
!= -ENODEV
&& bd
->props
.power
!= power
) {
1498 ctrl_param
= !!(bd
->props
.power
== FB_BLANK_UNBLANK
);
1499 err
= asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT
,
1501 if (asus
->driver
->quirks
->store_backlight_power
)
1502 asus
->driver
->panel_power
= bd
->props
.power
;
1504 /* When using scalar brightness, updating the brightness
1505 * will mess with the backlight power */
1506 if (asus
->driver
->quirks
->scalar_panel_brightness
)
1510 if (asus
->driver
->quirks
->scalar_panel_brightness
)
1511 ctrl_param
= get_scalar_command(bd
);
1513 ctrl_param
= bd
->props
.brightness
;
1515 err
= asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS
,
1521 static const struct backlight_ops asus_wmi_bl_ops
= {
1522 .get_brightness
= read_brightness
,
1523 .update_status
= update_bl_status
,
1526 static int asus_wmi_backlight_notify(struct asus_wmi
*asus
, int code
)
1528 struct backlight_device
*bd
= asus
->backlight_device
;
1529 int old
= bd
->props
.brightness
;
1532 if (code
>= NOTIFY_BRNUP_MIN
&& code
<= NOTIFY_BRNUP_MAX
)
1533 new = code
- NOTIFY_BRNUP_MIN
+ 1;
1534 else if (code
>= NOTIFY_BRNDOWN_MIN
&& code
<= NOTIFY_BRNDOWN_MAX
)
1535 new = code
- NOTIFY_BRNDOWN_MIN
;
1537 bd
->props
.brightness
= new;
1538 backlight_update_status(bd
);
1539 backlight_force_update(bd
, BACKLIGHT_UPDATE_HOTKEY
);
1544 static int asus_wmi_backlight_init(struct asus_wmi
*asus
)
1546 struct backlight_device
*bd
;
1547 struct backlight_properties props
;
1551 max
= read_brightness_max(asus
);
1555 power
= read_backlight_power(asus
);
1557 if (power
== -ENODEV
)
1558 power
= FB_BLANK_UNBLANK
;
1562 memset(&props
, 0, sizeof(struct backlight_properties
));
1563 props
.type
= BACKLIGHT_PLATFORM
;
1564 props
.max_brightness
= max
;
1565 bd
= backlight_device_register(asus
->driver
->name
,
1566 &asus
->platform_device
->dev
, asus
,
1567 &asus_wmi_bl_ops
, &props
);
1569 pr_err("Could not register backlight device\n");
1573 asus
->backlight_device
= bd
;
1575 if (asus
->driver
->quirks
->store_backlight_power
)
1576 asus
->driver
->panel_power
= power
;
1578 bd
->props
.brightness
= read_brightness(bd
);
1579 bd
->props
.power
= power
;
1580 backlight_update_status(bd
);
1582 asus
->driver
->brightness
= bd
->props
.brightness
;
1587 static void asus_wmi_backlight_exit(struct asus_wmi
*asus
)
1589 backlight_device_unregister(asus
->backlight_device
);
1591 asus
->backlight_device
= NULL
;
1594 static int is_display_toggle(int code
)
1596 /* display toggle keys */
1597 if ((code
>= 0x61 && code
<= 0x67) ||
1598 (code
>= 0x8c && code
<= 0x93) ||
1599 (code
>= 0xa0 && code
<= 0xa7) ||
1600 (code
>= 0xd0 && code
<= 0xd5))
1606 static void asus_wmi_notify(u32 value
, void *context
)
1608 struct asus_wmi
*asus
= context
;
1609 struct acpi_buffer response
= { ACPI_ALLOCATE_BUFFER
, NULL
};
1610 union acpi_object
*obj
;
1614 unsigned int key_value
= 1;
1615 bool autorelease
= 1;
1617 status
= wmi_get_event_data(value
, &response
);
1618 if (status
!= AE_OK
) {
1619 pr_err("bad event status 0x%x\n", status
);
1623 obj
= (union acpi_object
*)response
.pointer
;
1625 if (!obj
|| obj
->type
!= ACPI_TYPE_INTEGER
)
1628 code
= obj
->integer
.value
;
1631 if (asus
->driver
->key_filter
) {
1632 asus
->driver
->key_filter(asus
->driver
, &code
, &key_value
,
1634 if (code
== ASUS_WMI_KEY_IGNORE
)
1638 if (code
>= NOTIFY_BRNUP_MIN
&& code
<= NOTIFY_BRNUP_MAX
)
1639 code
= ASUS_WMI_BRN_UP
;
1640 else if (code
>= NOTIFY_BRNDOWN_MIN
&&
1641 code
<= NOTIFY_BRNDOWN_MAX
)
1642 code
= ASUS_WMI_BRN_DOWN
;
1644 if (code
== ASUS_WMI_BRN_DOWN
|| code
== ASUS_WMI_BRN_UP
) {
1645 if (acpi_video_get_backlight_type() == acpi_backlight_vendor
) {
1646 asus_wmi_backlight_notify(asus
, orig_code
);
1651 if (is_display_toggle(code
) &&
1652 asus
->driver
->quirks
->no_display_toggle
)
1655 if (!sparse_keymap_report_event(asus
->inputdev
, code
,
1656 key_value
, autorelease
))
1657 pr_info("Unknown key %x pressed\n", code
);
1666 static int parse_arg(const char *buf
, unsigned long count
, int *val
)
1670 if (sscanf(buf
, "%i", val
) != 1)
1675 static ssize_t
store_sys_wmi(struct asus_wmi
*asus
, int devid
,
1676 const char *buf
, size_t count
)
1681 value
= asus_wmi_get_devstate_simple(asus
, devid
);
1685 rv
= parse_arg(buf
, count
, &value
);
1686 err
= asus_wmi_set_devstate(devid
, value
, &retval
);
1694 static ssize_t
show_sys_wmi(struct asus_wmi
*asus
, int devid
, char *buf
)
1696 int value
= asus_wmi_get_devstate_simple(asus
, devid
);
1701 return sprintf(buf
, "%d\n", value
);
1704 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
1705 static ssize_t show_##_name(struct device *dev, \
1706 struct device_attribute *attr, \
1709 struct asus_wmi *asus = dev_get_drvdata(dev); \
1711 return show_sys_wmi(asus, _cm, buf); \
1713 static ssize_t store_##_name(struct device *dev, \
1714 struct device_attribute *attr, \
1715 const char *buf, size_t count) \
1717 struct asus_wmi *asus = dev_get_drvdata(dev); \
1719 return store_sys_wmi(asus, _cm, buf, count); \
1721 static struct device_attribute dev_attr_##_name = { \
1723 .name = __stringify(_name), \
1725 .show = show_##_name, \
1726 .store = store_##_name, \
1729 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad
, 0644, ASUS_WMI_DEVID_TOUCHPAD
);
1730 ASUS_WMI_CREATE_DEVICE_ATTR(camera
, 0644, ASUS_WMI_DEVID_CAMERA
);
1731 ASUS_WMI_CREATE_DEVICE_ATTR(cardr
, 0644, ASUS_WMI_DEVID_CARDREADER
);
1732 ASUS_WMI_CREATE_DEVICE_ATTR(lid_resume
, 0644, ASUS_WMI_DEVID_LID_RESUME
);
1734 static ssize_t
store_cpufv(struct device
*dev
, struct device_attribute
*attr
,
1735 const char *buf
, size_t count
)
1739 if (!count
|| sscanf(buf
, "%i", &value
) != 1)
1741 if (value
< 0 || value
> 2)
1744 rv
= asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS
, value
, 0, NULL
);
1751 static DEVICE_ATTR(cpufv
, S_IRUGO
| S_IWUSR
, NULL
, store_cpufv
);
1753 static struct attribute
*platform_attributes
[] = {
1754 &dev_attr_cpufv
.attr
,
1755 &dev_attr_camera
.attr
,
1756 &dev_attr_cardr
.attr
,
1757 &dev_attr_touchpad
.attr
,
1758 &dev_attr_lid_resume
.attr
,
1762 static umode_t
asus_sysfs_is_visible(struct kobject
*kobj
,
1763 struct attribute
*attr
, int idx
)
1765 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
1766 struct platform_device
*pdev
= to_platform_device(dev
);
1767 struct asus_wmi
*asus
= platform_get_drvdata(pdev
);
1771 if (attr
== &dev_attr_camera
.attr
)
1772 devid
= ASUS_WMI_DEVID_CAMERA
;
1773 else if (attr
== &dev_attr_cardr
.attr
)
1774 devid
= ASUS_WMI_DEVID_CARDREADER
;
1775 else if (attr
== &dev_attr_touchpad
.attr
)
1776 devid
= ASUS_WMI_DEVID_TOUCHPAD
;
1777 else if (attr
== &dev_attr_lid_resume
.attr
)
1778 devid
= ASUS_WMI_DEVID_LID_RESUME
;
1781 ok
= !(asus_wmi_get_devstate_simple(asus
, devid
) < 0);
1783 return ok
? attr
->mode
: 0;
1786 static struct attribute_group platform_attribute_group
= {
1787 .is_visible
= asus_sysfs_is_visible
,
1788 .attrs
= platform_attributes
1791 static void asus_wmi_sysfs_exit(struct platform_device
*device
)
1793 sysfs_remove_group(&device
->dev
.kobj
, &platform_attribute_group
);
1796 static int asus_wmi_sysfs_init(struct platform_device
*device
)
1798 return sysfs_create_group(&device
->dev
.kobj
, &platform_attribute_group
);
1804 static int asus_wmi_platform_init(struct asus_wmi
*asus
)
1808 /* INIT enable hotkeys on some models */
1809 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT
, 0, 0, &rv
))
1810 pr_info("Initialization: %#x\n", rv
);
1812 /* We don't know yet what to do with this version... */
1813 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC
, 0, 0x9, &rv
)) {
1814 pr_info("BIOS WMI version: %d.%d\n", rv
>> 16, rv
& 0xFF);
1819 * The SFUN method probably allows the original driver to get the list
1820 * of features supported by a given model. For now, 0x0100 or 0x0800
1821 * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
1822 * The significance of others is yet to be found.
1824 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN
, 0, 0, &rv
)) {
1825 pr_info("SFUN value: %#x\n", rv
);
1830 * Eee PC and Notebooks seems to have different method_id for DSTS,
1831 * but it may also be related to the BIOS's SPEC.
1832 * Note, on most Eeepc, there is no way to check if a method exist
1833 * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
1834 * but once again, SPEC may probably be used for that kind of things.
1836 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS
, 0, 0, NULL
))
1837 asus
->dsts_id
= ASUS_WMI_METHODID_DSTS
;
1839 asus
->dsts_id
= ASUS_WMI_METHODID_DSTS2
;
1841 /* CWAP allow to define the behavior of the Fn+F2 key,
1842 * this method doesn't seems to be present on Eee PCs */
1843 if (asus
->driver
->quirks
->wapf
>= 0)
1844 asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP
,
1845 asus
->driver
->quirks
->wapf
, NULL
);
1847 return asus_wmi_sysfs_init(asus
->platform_device
);
1850 static void asus_wmi_platform_exit(struct asus_wmi
*asus
)
1852 asus_wmi_sysfs_exit(asus
->platform_device
);
1858 struct asus_wmi_debugfs_node
{
1859 struct asus_wmi
*asus
;
1861 int (*show
) (struct seq_file
*m
, void *data
);
1864 static int show_dsts(struct seq_file
*m
, void *data
)
1866 struct asus_wmi
*asus
= m
->private;
1870 err
= asus_wmi_get_devstate(asus
, asus
->debug
.dev_id
, &retval
);
1875 seq_printf(m
, "DSTS(%#x) = %#x\n", asus
->debug
.dev_id
, retval
);
1880 static int show_devs(struct seq_file
*m
, void *data
)
1882 struct asus_wmi
*asus
= m
->private;
1886 err
= asus_wmi_set_devstate(asus
->debug
.dev_id
, asus
->debug
.ctrl_param
,
1892 seq_printf(m
, "DEVS(%#x, %#x) = %#x\n", asus
->debug
.dev_id
,
1893 asus
->debug
.ctrl_param
, retval
);
1898 static int show_call(struct seq_file
*m
, void *data
)
1900 struct asus_wmi
*asus
= m
->private;
1901 struct bios_args args
= {
1902 .arg0
= asus
->debug
.dev_id
,
1903 .arg1
= asus
->debug
.ctrl_param
,
1905 struct acpi_buffer input
= { (acpi_size
) sizeof(args
), &args
};
1906 struct acpi_buffer output
= { ACPI_ALLOCATE_BUFFER
, NULL
};
1907 union acpi_object
*obj
;
1910 status
= wmi_evaluate_method(ASUS_WMI_MGMT_GUID
,
1911 1, asus
->debug
.method_id
,
1914 if (ACPI_FAILURE(status
))
1917 obj
= (union acpi_object
*)output
.pointer
;
1918 if (obj
&& obj
->type
== ACPI_TYPE_INTEGER
)
1919 seq_printf(m
, "%#x(%#x, %#x) = %#x\n", asus
->debug
.method_id
,
1920 asus
->debug
.dev_id
, asus
->debug
.ctrl_param
,
1921 (u32
) obj
->integer
.value
);
1923 seq_printf(m
, "%#x(%#x, %#x) = t:%d\n", asus
->debug
.method_id
,
1924 asus
->debug
.dev_id
, asus
->debug
.ctrl_param
,
1925 obj
? obj
->type
: -1);
1932 static struct asus_wmi_debugfs_node asus_wmi_debug_files
[] = {
1933 {NULL
, "devs", show_devs
},
1934 {NULL
, "dsts", show_dsts
},
1935 {NULL
, "call", show_call
},
1938 static int asus_wmi_debugfs_open(struct inode
*inode
, struct file
*file
)
1940 struct asus_wmi_debugfs_node
*node
= inode
->i_private
;
1942 return single_open(file
, node
->show
, node
->asus
);
1945 static const struct file_operations asus_wmi_debugfs_io_ops
= {
1946 .owner
= THIS_MODULE
,
1947 .open
= asus_wmi_debugfs_open
,
1949 .llseek
= seq_lseek
,
1950 .release
= single_release
,
1953 static void asus_wmi_debugfs_exit(struct asus_wmi
*asus
)
1955 debugfs_remove_recursive(asus
->debug
.root
);
1958 static int asus_wmi_debugfs_init(struct asus_wmi
*asus
)
1960 struct dentry
*dent
;
1963 asus
->debug
.root
= debugfs_create_dir(asus
->driver
->name
, NULL
);
1964 if (!asus
->debug
.root
) {
1965 pr_err("failed to create debugfs directory\n");
1969 dent
= debugfs_create_x32("method_id", S_IRUGO
| S_IWUSR
,
1970 asus
->debug
.root
, &asus
->debug
.method_id
);
1974 dent
= debugfs_create_x32("dev_id", S_IRUGO
| S_IWUSR
,
1975 asus
->debug
.root
, &asus
->debug
.dev_id
);
1979 dent
= debugfs_create_x32("ctrl_param", S_IRUGO
| S_IWUSR
,
1980 asus
->debug
.root
, &asus
->debug
.ctrl_param
);
1984 for (i
= 0; i
< ARRAY_SIZE(asus_wmi_debug_files
); i
++) {
1985 struct asus_wmi_debugfs_node
*node
= &asus_wmi_debug_files
[i
];
1988 dent
= debugfs_create_file(node
->name
, S_IFREG
| S_IRUGO
,
1989 asus
->debug
.root
, node
,
1990 &asus_wmi_debugfs_io_ops
);
1992 pr_err("failed to create debug file: %s\n", node
->name
);
2000 asus_wmi_debugfs_exit(asus
);
2004 static int asus_wmi_fan_init(struct asus_wmi
*asus
)
2008 asus
->asus_hwmon_pwm
= -1;
2009 asus
->asus_hwmon_num_fans
= -1;
2010 asus
->asus_hwmon_fan_manual_mode
= false;
2012 status
= asus_hwmon_get_fan_number(asus
, &asus
->asus_hwmon_num_fans
);
2014 asus
->asus_hwmon_num_fans
= 0;
2015 pr_warn("Could not determine number of fans: %d\n", status
);
2019 pr_info("Number of fans: %d\n", asus
->asus_hwmon_num_fans
);
2026 static int asus_wmi_add(struct platform_device
*pdev
)
2028 struct platform_driver
*pdrv
= to_platform_driver(pdev
->dev
.driver
);
2029 struct asus_wmi_driver
*wdrv
= to_asus_wmi_driver(pdrv
);
2030 struct asus_wmi
*asus
;
2031 const char *chassis_type
;
2036 asus
= kzalloc(sizeof(struct asus_wmi
), GFP_KERNEL
);
2040 asus
->driver
= wdrv
;
2041 asus
->platform_device
= pdev
;
2042 wdrv
->platform_device
= pdev
;
2043 platform_set_drvdata(asus
->platform_device
, asus
);
2045 if (wdrv
->detect_quirks
)
2046 wdrv
->detect_quirks(asus
->driver
);
2048 err
= asus_wmi_platform_init(asus
);
2052 err
= asus_wmi_input_init(asus
);
2056 err
= asus_wmi_fan_init(asus
); /* probably no problems on error */
2057 asus_hwmon_fan_set_auto(asus
);
2059 err
= asus_wmi_hwmon_init(asus
);
2063 err
= asus_wmi_led_init(asus
);
2067 err
= asus_wmi_rfkill_init(asus
);
2071 /* Some Asus desktop boards export an acpi-video backlight interface,
2072 stop this from showing up */
2073 chassis_type
= dmi_get_system_info(DMI_CHASSIS_TYPE
);
2074 if (chassis_type
&& !strcmp(chassis_type
, "3"))
2075 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor
);
2077 if (asus
->driver
->quirks
->wmi_backlight_power
)
2078 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor
);
2080 if (acpi_video_get_backlight_type() == acpi_backlight_vendor
) {
2081 err
= asus_wmi_backlight_init(asus
);
2082 if (err
&& err
!= -ENODEV
)
2083 goto fail_backlight
;
2086 status
= wmi_install_notify_handler(asus
->driver
->event_guid
,
2087 asus_wmi_notify
, asus
);
2088 if (ACPI_FAILURE(status
)) {
2089 pr_err("Unable to register notify handler - %d\n", status
);
2091 goto fail_wmi_handler
;
2094 err
= asus_wmi_debugfs_init(asus
);
2098 asus_wmi_get_devstate(asus
, ASUS_WMI_DEVID_WLAN
, &result
);
2099 if (result
& (ASUS_WMI_DSTS_PRESENCE_BIT
| ASUS_WMI_DSTS_USER_BIT
))
2100 asus
->driver
->wlan_ctrl_by_user
= 1;
2105 wmi_remove_notify_handler(asus
->driver
->event_guid
);
2107 asus_wmi_backlight_exit(asus
);
2109 asus_wmi_rfkill_exit(asus
);
2111 asus_wmi_led_exit(asus
);
2114 asus_wmi_input_exit(asus
);
2116 asus_wmi_platform_exit(asus
);
2122 static int asus_wmi_remove(struct platform_device
*device
)
2124 struct asus_wmi
*asus
;
2126 asus
= platform_get_drvdata(device
);
2127 wmi_remove_notify_handler(asus
->driver
->event_guid
);
2128 asus_wmi_backlight_exit(asus
);
2129 asus_wmi_input_exit(asus
);
2130 asus_wmi_led_exit(asus
);
2131 asus_wmi_rfkill_exit(asus
);
2132 asus_wmi_debugfs_exit(asus
);
2133 asus_wmi_platform_exit(asus
);
2134 asus_hwmon_fan_set_auto(asus
);
2141 * Platform driver - hibernate/resume callbacks
2143 static int asus_hotk_thaw(struct device
*device
)
2145 struct asus_wmi
*asus
= dev_get_drvdata(device
);
2147 if (asus
->wlan
.rfkill
) {
2151 * Work around bios bug - acpi _PTS turns off the wireless led
2152 * during suspend. Normally it restores it on resume, but
2153 * we should kick it ourselves in case hibernation is aborted.
2155 wlan
= asus_wmi_get_devstate_simple(asus
, ASUS_WMI_DEVID_WLAN
);
2156 asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN
, wlan
, NULL
);
2162 static int asus_hotk_resume(struct device
*device
)
2164 struct asus_wmi
*asus
= dev_get_drvdata(device
);
2166 if (!IS_ERR_OR_NULL(asus
->kbd_led
.dev
))
2167 queue_work(asus
->led_workqueue
, &asus
->kbd_led_work
);
2172 static int asus_hotk_restore(struct device
*device
)
2174 struct asus_wmi
*asus
= dev_get_drvdata(device
);
2177 /* Refresh both wlan rfkill state and pci hotplug */
2178 if (asus
->wlan
.rfkill
)
2179 asus_rfkill_hotplug(asus
);
2181 if (asus
->bluetooth
.rfkill
) {
2182 bl
= !asus_wmi_get_devstate_simple(asus
,
2183 ASUS_WMI_DEVID_BLUETOOTH
);
2184 rfkill_set_sw_state(asus
->bluetooth
.rfkill
, bl
);
2186 if (asus
->wimax
.rfkill
) {
2187 bl
= !asus_wmi_get_devstate_simple(asus
, ASUS_WMI_DEVID_WIMAX
);
2188 rfkill_set_sw_state(asus
->wimax
.rfkill
, bl
);
2190 if (asus
->wwan3g
.rfkill
) {
2191 bl
= !asus_wmi_get_devstate_simple(asus
, ASUS_WMI_DEVID_WWAN3G
);
2192 rfkill_set_sw_state(asus
->wwan3g
.rfkill
, bl
);
2194 if (asus
->gps
.rfkill
) {
2195 bl
= !asus_wmi_get_devstate_simple(asus
, ASUS_WMI_DEVID_GPS
);
2196 rfkill_set_sw_state(asus
->gps
.rfkill
, bl
);
2198 if (asus
->uwb
.rfkill
) {
2199 bl
= !asus_wmi_get_devstate_simple(asus
, ASUS_WMI_DEVID_UWB
);
2200 rfkill_set_sw_state(asus
->uwb
.rfkill
, bl
);
2202 if (!IS_ERR_OR_NULL(asus
->kbd_led
.dev
))
2203 queue_work(asus
->led_workqueue
, &asus
->kbd_led_work
);
2208 static const struct dev_pm_ops asus_pm_ops
= {
2209 .thaw
= asus_hotk_thaw
,
2210 .restore
= asus_hotk_restore
,
2211 .resume
= asus_hotk_resume
,
2214 static int asus_wmi_probe(struct platform_device
*pdev
)
2216 struct platform_driver
*pdrv
= to_platform_driver(pdev
->dev
.driver
);
2217 struct asus_wmi_driver
*wdrv
= to_asus_wmi_driver(pdrv
);
2220 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID
)) {
2221 pr_warn("Management GUID not found\n");
2225 if (wdrv
->event_guid
&& !wmi_has_guid(wdrv
->event_guid
)) {
2226 pr_warn("Event GUID not found\n");
2231 ret
= wdrv
->probe(pdev
);
2236 return asus_wmi_add(pdev
);
2241 int __init_or_module
asus_wmi_register_driver(struct asus_wmi_driver
*driver
)
2243 struct platform_driver
*platform_driver
;
2244 struct platform_device
*platform_device
;
2249 platform_driver
= &driver
->platform_driver
;
2250 platform_driver
->remove
= asus_wmi_remove
;
2251 platform_driver
->driver
.owner
= driver
->owner
;
2252 platform_driver
->driver
.name
= driver
->name
;
2253 platform_driver
->driver
.pm
= &asus_pm_ops
;
2255 platform_device
= platform_create_bundle(platform_driver
,
2258 if (IS_ERR(platform_device
))
2259 return PTR_ERR(platform_device
);
2264 EXPORT_SYMBOL_GPL(asus_wmi_register_driver
);
2266 void asus_wmi_unregister_driver(struct asus_wmi_driver
*driver
)
2268 platform_device_unregister(driver
->platform_device
);
2269 platform_driver_unregister(&driver
->platform_driver
);
2272 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver
);
2274 static int __init
asus_wmi_init(void)
2276 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID
)) {
2277 pr_info("Asus Management GUID not found\n");
2281 pr_info("ASUS WMI generic driver loaded\n");
2285 static void __exit
asus_wmi_exit(void)
2287 pr_info("ASUS WMI generic driver unloaded\n");
2290 module_init(asus_wmi_init
);
2291 module_exit(asus_wmi_exit
);