2019-05-27 14:55:05 +08:00
|
|
|
// SPDX-License-Identifier: GPL-2.0-or-later
|
2010-03-21 10:26:34 +08:00
|
|
|
/*
|
2011-02-26 17:20:31 +08:00
|
|
|
* Asus PC WMI hotkey driver
|
2010-03-21 10:26:34 +08:00
|
|
|
*
|
|
|
|
* Copyright(C) 2010 Intel Corporation.
|
2011-02-26 17:20:32 +08:00
|
|
|
* Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
|
2010-03-21 10:26:34 +08:00
|
|
|
*
|
|
|
|
* Portions based on wistron_btns.c:
|
|
|
|
* Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
|
|
|
|
* Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
|
|
|
|
* Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
|
|
|
|
*/
|
|
|
|
|
2010-04-11 09:26:33 +08:00
|
|
|
#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
|
|
|
|
|
2010-03-21 10:26:34 +08:00
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/types.h>
|
2010-04-05 10:37:59 +08:00
|
|
|
#include <linux/slab.h>
|
2010-03-21 10:26:34 +08:00
|
|
|
#include <linux/input.h>
|
|
|
|
#include <linux/input/sparse-keymap.h>
|
2010-04-11 09:27:54 +08:00
|
|
|
#include <linux/fb.h>
|
|
|
|
#include <linux/backlight.h>
|
2010-11-29 15:14:06 +08:00
|
|
|
#include <linux/leds.h>
|
2010-11-29 15:14:07 +08:00
|
|
|
#include <linux/rfkill.h>
|
2011-02-06 20:28:28 +08:00
|
|
|
#include <linux/pci.h>
|
|
|
|
#include <linux/pci_hotplug.h>
|
2019-09-10 01:31:28 +08:00
|
|
|
#include <linux/power_supply.h>
|
2011-02-26 17:20:42 +08:00
|
|
|
#include <linux/hwmon.h>
|
|
|
|
#include <linux/hwmon-sysfs.h>
|
2010-11-29 15:14:09 +08:00
|
|
|
#include <linux/debugfs.h>
|
|
|
|
#include <linux/seq_file.h>
|
2018-10-09 14:40:55 +08:00
|
|
|
#include <linux/platform_data/x86/asus-wmi.h>
|
2010-04-11 09:27:19 +08:00
|
|
|
#include <linux/platform_device.h>
|
2011-07-01 17:34:36 +08:00
|
|
|
#include <linux/thermal.h>
|
2013-12-03 08:49:16 +08:00
|
|
|
#include <linux/acpi.h>
|
2014-07-08 16:47:21 +08:00
|
|
|
#include <linux/dmi.h>
|
2019-09-10 01:31:28 +08:00
|
|
|
|
|
|
|
#include <acpi/battery.h>
|
2012-06-13 15:32:06 +08:00
|
|
|
#include <acpi/video.h>
|
2010-03-21 10:26:34 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
#include "asus-wmi.h"
|
2010-04-11 09:27:19 +08:00
|
|
|
|
2012-12-18 08:00:05 +08:00
|
|
|
MODULE_AUTHOR("Corentin Chary <corentin.chary@gmail.com>, "
|
2011-02-26 17:20:31 +08:00
|
|
|
"Yong Wang <yong.y.wang@intel.com>");
|
|
|
|
MODULE_DESCRIPTION("Asus Generic WMI Driver");
|
2010-03-21 10:26:34 +08:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
#define to_asus_wmi_driver(pdrv) \
|
|
|
|
(container_of((pdrv), struct asus_wmi_driver, platform_driver))
|
2010-03-21 10:26:34 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
#define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
|
2010-03-21 10:26:34 +08:00
|
|
|
|
2011-02-06 20:28:34 +08:00
|
|
|
#define NOTIFY_BRNUP_MIN 0x11
|
|
|
|
#define NOTIFY_BRNUP_MAX 0x1f
|
|
|
|
#define NOTIFY_BRNDOWN_MIN 0x20
|
|
|
|
#define NOTIFY_BRNDOWN_MAX 0x2e
|
2019-04-18 14:46:48 +08:00
|
|
|
#define NOTIFY_FNLOCK_TOGGLE 0x4e
|
2011-07-01 17:34:31 +08:00
|
|
|
#define NOTIFY_KBD_BRTUP 0xc4
|
|
|
|
#define NOTIFY_KBD_BRTDWN 0xc5
|
2018-06-20 22:46:45 +08:00
|
|
|
#define NOTIFY_KBD_BRTTOGGLE 0xc7
|
2019-05-15 03:07:05 +08:00
|
|
|
#define NOTIFY_KBD_FBM 0x99
|
2010-03-21 10:26:34 +08:00
|
|
|
|
2019-04-18 14:46:48 +08:00
|
|
|
#define ASUS_WMI_FNLOCK_BIOS_DISABLED BIT(0)
|
|
|
|
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
#define ASUS_FAN_DESC "cpu_fan"
|
|
|
|
#define ASUS_FAN_MFUN 0x13
|
|
|
|
#define ASUS_FAN_SFUN_READ 0x06
|
|
|
|
#define ASUS_FAN_SFUN_WRITE 0x07
|
2019-07-29 16:27:37 +08:00
|
|
|
|
|
|
|
/* Based on standard hwmon pwmX_enable values */
|
2019-07-29 16:27:39 +08:00
|
|
|
#define ASUS_FAN_CTRL_FULLSPEED 0
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
#define ASUS_FAN_CTRL_MANUAL 1
|
|
|
|
#define ASUS_FAN_CTRL_AUTO 2
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
#define ASUS_FAN_BOOST_MODE_NORMAL 0
|
|
|
|
#define ASUS_FAN_BOOST_MODE_OVERBOOST 1
|
|
|
|
#define ASUS_FAN_BOOST_MODE_OVERBOOST_MASK 0x01
|
|
|
|
#define ASUS_FAN_BOOST_MODE_SILENT 2
|
|
|
|
#define ASUS_FAN_BOOST_MODE_SILENT_MASK 0x02
|
|
|
|
#define ASUS_FAN_BOOST_MODES_MASK 0x03
|
2019-05-15 03:07:05 +08:00
|
|
|
|
platform/x86: asus-wmi: Set specified XUSB2PR value for X550LB
The bluetooth adapter Atheros AR3012 can't be enumerated
and make the bluetooth function broken.
T: Bus=02 Lev=01 Prnt=01 Port=05 Cnt=02 Dev#= 5 Spd=12 MxCh= 0
D: Ver= 1.10 Cls=e0(wlcon) Sub=01 Prot=01 MxPS=64 #Cfgs= 1
P: Vendor=13d3 ProdID=3362 Rev=00.02
S: Manufacturer=Atheros Communications
S: Product=Bluetooth USB Host Controller
S: SerialNumber=Alaska Day 2006
C: #Ifs= 2 Cfg#= 1 Atr=e0 MxPwr=100mA
I: If#= 0 Alt= 0 #EPs= 3 Cls=e0(wlcon) Sub=01 Prot=01 Driver=btusb
I: If#= 1 Alt= 0 #EPs= 2 Cls=e0(wlcon) Sub=01 Prot=01 Driver=btusb
The error is:
usb 2-6: device not accepting address 7, error -62
usb usb2-port6: unable to enumerate USB device
It is caused by adapter's connected port is mapped to xHC
controller, but the xHCI is not supported by the usb device.
The output of 'sudo lspci -nnxxx -s 00:14.0':
00:14.0 USB controller [0c03]: Intel Corporation 8 Series USB xHCI HC [8086:9c31] (rev 04)
00: 86 80 31 9c 06 04 90 02 04 30 03 0c 00 00 00 00
10: 04 00 a0 f7 00 00 00 00 00 00 00 00 00 00 00 00
20: 00 00 00 00 00 00 00 00 00 00 00 00 43 10 1f 20
30: 00 00 00 00 70 00 00 00 00 00 00 00 0b 01 00 00
40: fd 01 36 80 89 c6 0f 80 00 00 00 00 00 00 00 00
50: 5f 2e ce 0f 00 00 00 00 00 00 00 00 00 00 00 00
60: 30 20 00 00 00 00 00 00 00 00 00 00 00 00 00 00
70: 01 80 c2 c1 08 00 00 00 00 00 00 00 00 00 00 00
80: 05 00 87 00 0c a0 e0 fe 00 00 00 00 a1 41 00 00
90: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
a0: 00 01 04 00 00 00 00 00 00 00 00 00 00 00 00 00
b0: 0f 00 03 00 00 00 00 00 00 00 00 00 00 00 00 00
c0: 03 c0 30 00 00 00 00 00 03 0c 00 00 00 00 00 00
d0: f9 01 00 00 f9 01 00 00 0f 00 00 00 0f 00 00 00
e0: 00 08 00 00 00 00 00 00 00 00 00 00 d8 d8 00 00
f0: 00 00 00 00 00 00 00 00 b1 0f 04 08 00 00 00 00
By referencing Intel Platform Controller Hub(PCH) datasheet,
the xHC USB 2.0 Port Routing(XUSB2PR) at offset 0xD0-0xD3h
decides the setting of mapping the port to EHCI controller or
xHC controller. And the port mapped to xHC will enable xHCI
during bus resume.
The setting of disabling bluetooth adapter's connected port is
0x000001D9. The value can be obtained by few times 1 bit flip
operation. The suited configuration should have the 'lsusb -t'
result with bluetooth using ehci:
/: Bus 03.Port 1: Dev 1, Class=root_hub, Driver=xhci_hcd/4p, 5000M
/: Bus 02.Port 1: Dev 1, Class=root_hub, Driver=xhci_hcd/9p, 480M
|__ Port 5: Dev 2, If 0, Class=Video, Driver=uvcvideo, 480M
|__ Port 5: Dev 2, If 1, Class=Video, Driver=uvcvideo, 480M
/: Bus 01.Port 1: Dev 1, Class=root_hub, Driver=ehci-pci/2p, 480M
|__ Port 1: Dev 2, If 0, Class=Hub, Driver=hub/8p, 480M
|__ Port 6: Dev 3, If 0, Class=Wireless, Driver=btusb, 12M
|__ Port 6: Dev 3, If 1, Class=Wireless, Driver=btusb, 12M
Signed-off-by: Kai-Chuan Hsieh <kai.chiuan@gmail.com>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com>
[andy: resolve merge conflict in asus-wmi.h]
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2016-09-01 23:55:55 +08:00
|
|
|
#define USB_INTEL_XUSB2PR 0xD0
|
|
|
|
#define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI 0x9c31
|
|
|
|
|
2019-05-15 03:00:31 +08:00
|
|
|
#define ASUS_ACPI_UID_ASUSWMI "ASUSWMI"
|
platform/x86: asus-wmi: Support WMI event queue
Event codes are expected to be retrieved from a queue on at least some
models. Specifically, very likely the ACPI WMI devices with _UID ATK are
queued whereas those with ASUSWMI are not [1].
The WMI event codes are pushed into a circular buffer queue. After the INIT
method is called, ACPI code is allowed to push events into this buffer.
The INIT method cannot be reverted. If the module is unloaded and an event
(such as hotkey press) gets emitted before inserting it back the events get
processed delayed by one or if the queue overflows, additionally delayed by
about 3 seconds.
It might be considered a minor issue and no normal user would likely
observe this (there is little reason unloading the driver), but it does
significantly frustrate a developer who is unlucky enough to encounter
this. Therefore, the fallback to unqueued behavior occurs whenever
something unexpected happens.
The fix flushes the old key codes out of the queue on load. After receiving
event the queue is read until either ..FFFF or 1 is encountered. Also as
noted in [1] it is checked whether notify code is equal to 0xFF before
enabling queue processing in WMI notify handler.
DSDT examples:
FX505GM
Device (ATKD)
{ ..
Name (ATKQ, Package (0x10)
{
0xFFFFFFFF, ..
}
Method (IANQ, 1, Serialized)
{
If ((AQNO >= 0x10))
{
Local0 = 0x64
While ((Local0 && (AQNO >= 0x10)))
{
Local0--
Sleep (0x0A)
}
...
..
AQTI++
AQTI &= 0x0F
ATKQ [AQTI] = Arg0
...
}
Method (GANQ, 0, Serialized)
{
..
If (AQNO)
{
...
Local0 = DerefOf (ATKQ [AQHI])
AQHI++
AQHI &= 0x0F
Return (Local0)
}
Return (One)
}
This code is almost identical to K54C, which does return Ones on empty
queue.
K54C:
Method (GANQ, 0, Serialized)
{
If (AQNO)
{
...
Return (Local0)
}
Return (Ones)
}
[1] Link: https://lkml.org/lkml/2019/4/12/104
Signed-off-by: Yurii Pavlovskyi <yurii.pavlovskyi@gmail.com>
Suggested-by: Daniel Drake <drake@endlessm.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2019-05-15 03:02:09 +08:00
|
|
|
#define ASUS_ACPI_UID_ATK "ATK"
|
|
|
|
|
|
|
|
#define WMI_EVENT_QUEUE_SIZE 0x10
|
|
|
|
#define WMI_EVENT_QUEUE_END 0x1
|
|
|
|
#define WMI_EVENT_MASK 0xFFFF
|
|
|
|
/* The WMI hotkey event value is always the same. */
|
|
|
|
#define WMI_EVENT_VALUE_ATK 0xFF
|
2019-05-15 03:00:31 +08:00
|
|
|
|
2019-05-15 03:01:24 +08:00
|
|
|
#define WMI_EVENT_MASK 0xFFFF
|
|
|
|
|
2017-02-21 03:50:22 +08:00
|
|
|
static const char * const ashs_ids[] = { "ATK4001", "ATK4002", NULL };
|
|
|
|
|
2018-05-23 05:30:15 +08:00
|
|
|
static bool ashs_present(void)
|
|
|
|
{
|
|
|
|
int i = 0;
|
|
|
|
while (ashs_ids[i]) {
|
|
|
|
if (acpi_dev_found(ashs_ids[i++]))
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2010-04-11 09:27:54 +08:00
|
|
|
struct bios_args {
|
2011-02-26 17:20:35 +08:00
|
|
|
u32 arg0;
|
|
|
|
u32 arg1;
|
platform/x86: asus-wmi: Increase input buffer size of WMI methods
The asus-nb-wmi driver is matched by WMI alias but fails to load on TUF
Gaming series laptops producing multiple ACPI errors in the kernel log.
The input buffer for WMI method invocation size is 2 dwords, whereas
3 are expected by this model.
FX505GM:
..
Method (WMNB, 3, Serialized)
{
P8XH (Zero, 0x11)
CreateDWordField (Arg2, Zero, IIA0)
CreateDWordField (Arg2, 0x04, IIA1)
CreateDWordField (Arg2, 0x08, IIA2)
Local0 = (Arg1 & 0xFFFFFFFF)
...
Compare with older K54C:
...
Method (WMNB, 3, NotSerialized)
{
CreateDWordField (Arg2, 0x00, IIA0)
CreateDWordField (Arg2, 0x04, IIA1)
Local0 = (Arg1 & 0xFFFFFFFF)
...
Increase buffer size to 3 dwords. No negative consequences of this change
are expected, as the input buffer size is not verified. The original
function is replaced by a wrapper for a new method passing value 0 for the
last parameter. The new function will be used to control RGB keyboard
backlight.
Signed-off-by: Yurii Pavlovskyi <yurii.pavlovskyi@gmail.com>
Reviewed-by: Daniel Drake <drake@endlessm.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2019-05-15 02:54:50 +08:00
|
|
|
u32 arg2; /* At least TUF Gaming series uses 3 dword input buffer. */
|
2011-02-26 17:20:35 +08:00
|
|
|
} __packed;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
/*
|
|
|
|
* Struct that's used for all methods called via AGFN. Naming is
|
|
|
|
* identically to the AML code.
|
|
|
|
*/
|
|
|
|
struct agfn_args {
|
|
|
|
u16 mfun; /* probably "Multi-function" to be called */
|
|
|
|
u16 sfun; /* probably "Sub-function" to be called */
|
|
|
|
u16 len; /* size of the hole struct, including subfunction fields */
|
|
|
|
u8 stas; /* not used by now */
|
|
|
|
u8 err; /* zero on success */
|
|
|
|
} __packed;
|
|
|
|
|
|
|
|
/* struct used for calling fan read and write methods */
|
2019-07-29 16:27:37 +08:00
|
|
|
struct agfn_fan_args {
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
struct agfn_args agfn; /* common fields */
|
|
|
|
u8 fan; /* fan number: 0: set auto mode 1: 1st fan */
|
|
|
|
u32 speed; /* read: RPM/100 - write: 0-255 */
|
|
|
|
} __packed;
|
|
|
|
|
2010-11-29 15:14:09 +08:00
|
|
|
/*
|
2011-02-26 17:20:31 +08:00
|
|
|
* <platform>/ - debugfs root directory
|
2010-11-29 15:14:09 +08:00
|
|
|
* dev_id - current dev_id
|
|
|
|
* ctrl_param - current ctrl_param
|
2011-02-26 17:20:39 +08:00
|
|
|
* method_id - current method_id
|
2010-11-29 15:14:09 +08:00
|
|
|
* devs - call DEVS(dev_id, ctrl_param) and print result
|
|
|
|
* dsts - call DSTS(dev_id) and print result
|
2011-02-26 17:20:39 +08:00
|
|
|
* call - call method_id(dev_id, ctrl_param) and print result
|
2010-11-29 15:14:09 +08:00
|
|
|
*/
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi_debug {
|
2010-11-29 15:14:09 +08:00
|
|
|
struct dentry *root;
|
2011-02-26 17:20:39 +08:00
|
|
|
u32 method_id;
|
2010-11-29 15:14:09 +08:00
|
|
|
u32 dev_id;
|
|
|
|
u32 ctrl_param;
|
|
|
|
};
|
|
|
|
|
2011-02-26 17:20:33 +08:00
|
|
|
struct asus_rfkill {
|
|
|
|
struct asus_wmi *asus;
|
|
|
|
struct rfkill *rfkill;
|
|
|
|
u32 dev_id;
|
|
|
|
};
|
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
enum fan_type {
|
|
|
|
FAN_TYPE_NONE = 0,
|
|
|
|
FAN_TYPE_AGFN, /* deprecated on newer platforms */
|
2019-07-29 16:27:39 +08:00
|
|
|
FAN_TYPE_SPEC83, /* starting in Spec 8.3, use CPU_FAN_CTRL */
|
2019-07-29 16:27:37 +08:00
|
|
|
};
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi {
|
2011-02-26 17:20:36 +08:00
|
|
|
int dsts_id;
|
2011-02-26 17:20:38 +08:00
|
|
|
int spec;
|
|
|
|
int sfun;
|
platform/x86: asus-wmi: Support WMI event queue
Event codes are expected to be retrieved from a queue on at least some
models. Specifically, very likely the ACPI WMI devices with _UID ATK are
queued whereas those with ASUSWMI are not [1].
The WMI event codes are pushed into a circular buffer queue. After the INIT
method is called, ACPI code is allowed to push events into this buffer.
The INIT method cannot be reverted. If the module is unloaded and an event
(such as hotkey press) gets emitted before inserting it back the events get
processed delayed by one or if the queue overflows, additionally delayed by
about 3 seconds.
It might be considered a minor issue and no normal user would likely
observe this (there is little reason unloading the driver), but it does
significantly frustrate a developer who is unlucky enough to encounter
this. Therefore, the fallback to unqueued behavior occurs whenever
something unexpected happens.
The fix flushes the old key codes out of the queue on load. After receiving
event the queue is read until either ..FFFF or 1 is encountered. Also as
noted in [1] it is checked whether notify code is equal to 0xFF before
enabling queue processing in WMI notify handler.
DSDT examples:
FX505GM
Device (ATKD)
{ ..
Name (ATKQ, Package (0x10)
{
0xFFFFFFFF, ..
}
Method (IANQ, 1, Serialized)
{
If ((AQNO >= 0x10))
{
Local0 = 0x64
While ((Local0 && (AQNO >= 0x10)))
{
Local0--
Sleep (0x0A)
}
...
..
AQTI++
AQTI &= 0x0F
ATKQ [AQTI] = Arg0
...
}
Method (GANQ, 0, Serialized)
{
..
If (AQNO)
{
...
Local0 = DerefOf (ATKQ [AQHI])
AQHI++
AQHI &= 0x0F
Return (Local0)
}
Return (One)
}
This code is almost identical to K54C, which does return Ones on empty
queue.
K54C:
Method (GANQ, 0, Serialized)
{
If (AQNO)
{
...
Return (Local0)
}
Return (Ones)
}
[1] Link: https://lkml.org/lkml/2019/4/12/104
Signed-off-by: Yurii Pavlovskyi <yurii.pavlovskyi@gmail.com>
Suggested-by: Daniel Drake <drake@endlessm.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2019-05-15 03:02:09 +08:00
|
|
|
bool wmi_event_queue;
|
2011-02-26 17:20:36 +08:00
|
|
|
|
2010-04-11 09:26:33 +08:00
|
|
|
struct input_dev *inputdev;
|
2010-04-11 09:27:54 +08:00
|
|
|
struct backlight_device *backlight_device;
|
2010-11-29 15:14:05 +08:00
|
|
|
struct platform_device *platform_device;
|
2010-11-29 15:14:06 +08:00
|
|
|
|
2012-07-27 16:51:59 +08:00
|
|
|
struct led_classdev wlan_led;
|
|
|
|
int wlan_led_wk;
|
2010-11-29 15:14:06 +08:00
|
|
|
struct led_classdev tpd_led;
|
|
|
|
int tpd_led_wk;
|
2011-07-01 17:34:31 +08:00
|
|
|
struct led_classdev kbd_led;
|
|
|
|
int kbd_led_wk;
|
2017-09-24 00:23:37 +08:00
|
|
|
struct led_classdev lightbar_led;
|
|
|
|
int lightbar_led_wk;
|
2010-11-29 15:14:06 +08:00
|
|
|
struct workqueue_struct *led_workqueue;
|
|
|
|
struct work_struct tpd_led_work;
|
2012-07-27 16:51:59 +08:00
|
|
|
struct work_struct wlan_led_work;
|
2017-09-24 00:23:37 +08:00
|
|
|
struct work_struct lightbar_led_work;
|
2010-11-29 15:14:07 +08:00
|
|
|
|
2011-02-26 17:20:33 +08:00
|
|
|
struct asus_rfkill wlan;
|
|
|
|
struct asus_rfkill bluetooth;
|
|
|
|
struct asus_rfkill wimax;
|
|
|
|
struct asus_rfkill wwan3g;
|
2011-07-01 17:34:40 +08:00
|
|
|
struct asus_rfkill gps;
|
2011-07-01 17:34:41 +08:00
|
|
|
struct asus_rfkill uwb;
|
2010-11-29 15:14:09 +08:00
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
enum fan_type fan_type;
|
|
|
|
int fan_pwm_mode;
|
|
|
|
int agfn_pwm;
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
bool fan_boost_mode_available;
|
|
|
|
u8 fan_boost_mode_mask;
|
|
|
|
u8 fan_boost_mode;
|
2019-05-15 03:07:05 +08:00
|
|
|
|
2019-09-10 01:31:28 +08:00
|
|
|
// The RSOC controls the maximum charging percentage.
|
|
|
|
bool battery_rsoc_available;
|
2019-08-06 03:23:05 +08:00
|
|
|
|
2018-09-08 15:59:01 +08:00
|
|
|
struct hotplug_slot hotplug_slot;
|
2011-02-06 20:28:28 +08:00
|
|
|
struct mutex hotplug_lock;
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
struct mutex wmi_lock;
|
|
|
|
struct workqueue_struct *hotplug_workqueue;
|
|
|
|
struct work_struct hotplug_work;
|
2011-02-06 20:28:28 +08:00
|
|
|
|
2019-04-18 14:46:48 +08:00
|
|
|
bool fnlock_locked;
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi_debug debug;
|
|
|
|
|
|
|
|
struct asus_wmi_driver *driver;
|
2010-04-11 09:26:33 +08:00
|
|
|
};
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* Input **********************************************************************/
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_wmi_input_init(struct asus_wmi *asus)
|
2010-03-21 10:26:34 +08:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus->inputdev = input_allocate_device();
|
|
|
|
if (!asus->inputdev)
|
2010-03-21 10:26:34 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2011-03-30 22:32:32 +08:00
|
|
|
asus->inputdev->name = asus->driver->input_name;
|
|
|
|
asus->inputdev->phys = asus->driver->input_phys;
|
2011-02-26 17:20:31 +08:00
|
|
|
asus->inputdev->id.bustype = BUS_HOST;
|
|
|
|
asus->inputdev->dev.parent = &asus->platform_device->dev;
|
2011-07-04 15:49:20 +08:00
|
|
|
set_bit(EV_REP, asus->inputdev->evbit);
|
2010-03-21 10:26:34 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
|
2010-03-21 10:26:34 +08:00
|
|
|
if (err)
|
|
|
|
goto err_free_dev;
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
err = input_register_device(asus->inputdev);
|
2010-03-21 10:26:34 +08:00
|
|
|
if (err)
|
2017-03-09 20:11:39 +08:00
|
|
|
goto err_free_dev;
|
2010-03-21 10:26:34 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_free_dev:
|
2011-02-26 17:20:31 +08:00
|
|
|
input_free_device(asus->inputdev);
|
2010-03-21 10:26:34 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static void asus_wmi_input_exit(struct asus_wmi *asus)
|
2010-04-11 09:26:33 +08:00
|
|
|
{
|
2017-03-09 20:11:39 +08:00
|
|
|
if (asus->inputdev)
|
2011-02-26 17:20:31 +08:00
|
|
|
input_unregister_device(asus->inputdev);
|
2010-04-11 09:26:33 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus->inputdev = NULL;
|
2010-04-11 09:26:33 +08:00
|
|
|
}
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* WMI ************************************************************************/
|
|
|
|
|
platform/x86: asus-wmi: Increase input buffer size of WMI methods
The asus-nb-wmi driver is matched by WMI alias but fails to load on TUF
Gaming series laptops producing multiple ACPI errors in the kernel log.
The input buffer for WMI method invocation size is 2 dwords, whereas
3 are expected by this model.
FX505GM:
..
Method (WMNB, 3, Serialized)
{
P8XH (Zero, 0x11)
CreateDWordField (Arg2, Zero, IIA0)
CreateDWordField (Arg2, 0x04, IIA1)
CreateDWordField (Arg2, 0x08, IIA2)
Local0 = (Arg1 & 0xFFFFFFFF)
...
Compare with older K54C:
...
Method (WMNB, 3, NotSerialized)
{
CreateDWordField (Arg2, 0x00, IIA0)
CreateDWordField (Arg2, 0x04, IIA1)
Local0 = (Arg1 & 0xFFFFFFFF)
...
Increase buffer size to 3 dwords. No negative consequences of this change
are expected, as the input buffer size is not verified. The original
function is replaced by a wrapper for a new method passing value 0 for the
last parameter. The new function will be used to control RGB keyboard
backlight.
Signed-off-by: Yurii Pavlovskyi <yurii.pavlovskyi@gmail.com>
Reviewed-by: Daniel Drake <drake@endlessm.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2019-05-15 02:54:50 +08:00
|
|
|
static int asus_wmi_evaluate_method3(u32 method_id,
|
|
|
|
u32 arg0, u32 arg1, u32 arg2, u32 *retval)
|
2010-04-11 09:27:54 +08:00
|
|
|
{
|
2011-02-26 17:20:35 +08:00
|
|
|
struct bios_args args = {
|
|
|
|
.arg0 = arg0,
|
|
|
|
.arg1 = arg1,
|
platform/x86: asus-wmi: Increase input buffer size of WMI methods
The asus-nb-wmi driver is matched by WMI alias but fails to load on TUF
Gaming series laptops producing multiple ACPI errors in the kernel log.
The input buffer for WMI method invocation size is 2 dwords, whereas
3 are expected by this model.
FX505GM:
..
Method (WMNB, 3, Serialized)
{
P8XH (Zero, 0x11)
CreateDWordField (Arg2, Zero, IIA0)
CreateDWordField (Arg2, 0x04, IIA1)
CreateDWordField (Arg2, 0x08, IIA2)
Local0 = (Arg1 & 0xFFFFFFFF)
...
Compare with older K54C:
...
Method (WMNB, 3, NotSerialized)
{
CreateDWordField (Arg2, 0x00, IIA0)
CreateDWordField (Arg2, 0x04, IIA1)
Local0 = (Arg1 & 0xFFFFFFFF)
...
Increase buffer size to 3 dwords. No negative consequences of this change
are expected, as the input buffer size is not verified. The original
function is replaced by a wrapper for a new method passing value 0 for the
last parameter. The new function will be used to control RGB keyboard
backlight.
Signed-off-by: Yurii Pavlovskyi <yurii.pavlovskyi@gmail.com>
Reviewed-by: Daniel Drake <drake@endlessm.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2019-05-15 02:54:50 +08:00
|
|
|
.arg2 = arg2,
|
2011-02-26 17:20:35 +08:00
|
|
|
};
|
|
|
|
struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
|
2010-04-11 09:27:54 +08:00
|
|
|
struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
acpi_status status;
|
2011-02-26 17:20:35 +08:00
|
|
|
union acpi_object *obj;
|
2014-06-01 20:58:52 +08:00
|
|
|
u32 tmp = 0;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
platform/x86: asus-wmi: Evaluate wmi method with instance number 0x0
According to available DSDT dump from Asus machine, there is the only one
instance of the WMI GUID 97845ED0-4E6D-11DE-8A39-0800200C9A66 and so it is
0x0. Moreover corresponding method WMBC does not check Arg0 (instance
number) at all.
DSDT dump is available at:
https://lwn.net/Articles/391249/
_WDG dump:
0xD0, 0x5E, 0x84, 0x97, 0x6D, 0x4E, 0xDE, 0x11, 0x8A, 0x39, 0x08,
0x00, 0x20, 0x0C, 0x9A, 0x66,
0x42, 0x43, // Object ID "BC" = method "WMBC"
0x01, // Instance count
0x02, // Flags
Signed-off-by: Pali Rohár <pali.rohar@gmail.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2017-08-12 15:44:16 +08:00
|
|
|
status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
|
2011-02-06 20:28:28 +08:00
|
|
|
&input, &output);
|
2010-04-11 09:27:54 +08:00
|
|
|
|
|
|
|
if (ACPI_FAILURE(status))
|
2019-05-15 03:03:50 +08:00
|
|
|
return -EIO;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
|
|
|
obj = (union acpi_object *)output.pointer;
|
|
|
|
if (obj && obj->type == ACPI_TYPE_INTEGER)
|
2011-02-26 17:20:31 +08:00
|
|
|
tmp = (u32) obj->integer.value;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
2010-11-29 15:14:10 +08:00
|
|
|
if (retval)
|
|
|
|
*retval = tmp;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
|
|
|
kfree(obj);
|
|
|
|
|
2011-02-26 17:20:35 +08:00
|
|
|
if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
|
|
|
|
return -ENODEV;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
2011-02-26 17:20:35 +08:00
|
|
|
return 0;
|
2010-04-11 09:27:54 +08:00
|
|
|
}
|
platform/x86: asus-wmi: Increase input buffer size of WMI methods
The asus-nb-wmi driver is matched by WMI alias but fails to load on TUF
Gaming series laptops producing multiple ACPI errors in the kernel log.
The input buffer for WMI method invocation size is 2 dwords, whereas
3 are expected by this model.
FX505GM:
..
Method (WMNB, 3, Serialized)
{
P8XH (Zero, 0x11)
CreateDWordField (Arg2, Zero, IIA0)
CreateDWordField (Arg2, 0x04, IIA1)
CreateDWordField (Arg2, 0x08, IIA2)
Local0 = (Arg1 & 0xFFFFFFFF)
...
Compare with older K54C:
...
Method (WMNB, 3, NotSerialized)
{
CreateDWordField (Arg2, 0x00, IIA0)
CreateDWordField (Arg2, 0x04, IIA1)
Local0 = (Arg1 & 0xFFFFFFFF)
...
Increase buffer size to 3 dwords. No negative consequences of this change
are expected, as the input buffer size is not verified. The original
function is replaced by a wrapper for a new method passing value 0 for the
last parameter. The new function will be used to control RGB keyboard
backlight.
Signed-off-by: Yurii Pavlovskyi <yurii.pavlovskyi@gmail.com>
Reviewed-by: Daniel Drake <drake@endlessm.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2019-05-15 02:54:50 +08:00
|
|
|
|
|
|
|
int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1, u32 *retval)
|
|
|
|
{
|
|
|
|
return asus_wmi_evaluate_method3(method_id, arg0, arg1, 0, retval);
|
|
|
|
}
|
2018-10-09 14:40:55 +08:00
|
|
|
EXPORT_SYMBOL_GPL(asus_wmi_evaluate_method);
|
2010-04-11 09:27:54 +08:00
|
|
|
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
static int asus_wmi_evaluate_method_agfn(const struct acpi_buffer args)
|
|
|
|
{
|
|
|
|
struct acpi_buffer input;
|
|
|
|
u64 phys_addr;
|
|
|
|
u32 retval;
|
|
|
|
u32 status = -1;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Copy to dma capable address otherwise memory corruption occurs as
|
|
|
|
* bios has to be able to access it.
|
|
|
|
*/
|
2019-07-04 00:29:51 +08:00
|
|
|
input.pointer = kmemdup(args.pointer, args.length, GFP_DMA | GFP_KERNEL);
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
input.length = args.length;
|
|
|
|
if (!input.pointer)
|
|
|
|
return -ENOMEM;
|
|
|
|
phys_addr = virt_to_phys(input.pointer);
|
|
|
|
|
|
|
|
status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_AGFN,
|
|
|
|
phys_addr, 0, &retval);
|
|
|
|
if (!status)
|
|
|
|
memcpy(args.pointer, input.pointer, args.length);
|
|
|
|
|
|
|
|
kfree(input.pointer);
|
|
|
|
if (status)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:36 +08:00
|
|
|
static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
|
2010-04-11 09:27:54 +08:00
|
|
|
{
|
2011-02-26 17:20:36 +08:00
|
|
|
return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
|
2011-02-26 17:20:35 +08:00
|
|
|
}
|
2010-04-11 09:27:54 +08:00
|
|
|
|
2011-02-26 17:20:35 +08:00
|
|
|
static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
|
2011-02-26 17:20:36 +08:00
|
|
|
u32 *retval)
|
2011-02-26 17:20:35 +08:00
|
|
|
{
|
|
|
|
return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
|
|
|
|
ctrl_param, retval);
|
2010-04-11 09:27:54 +08:00
|
|
|
}
|
|
|
|
|
2011-02-06 20:28:31 +08:00
|
|
|
/* Helper for special devices with magic return codes */
|
2011-02-26 17:20:36 +08:00
|
|
|
static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
|
|
|
|
u32 dev_id, u32 mask)
|
2011-02-06 20:28:31 +08:00
|
|
|
{
|
|
|
|
u32 retval = 0;
|
2011-02-26 17:20:35 +08:00
|
|
|
int err;
|
2011-02-06 20:28:31 +08:00
|
|
|
|
2011-02-26 17:20:36 +08:00
|
|
|
err = asus_wmi_get_devstate(asus, dev_id, &retval);
|
2011-02-26 17:20:35 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2011-02-06 20:28:31 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
|
2011-02-06 20:28:31 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
2011-02-26 17:20:34 +08:00
|
|
|
if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
|
|
|
|
if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2011-02-06 20:28:39 +08:00
|
|
|
return retval & mask;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:36 +08:00
|
|
|
static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
|
2011-02-06 20:28:39 +08:00
|
|
|
{
|
2011-02-26 17:20:36 +08:00
|
|
|
return asus_wmi_get_devstate_bits(asus, dev_id,
|
|
|
|
ASUS_WMI_DSTS_STATUS_BIT);
|
2011-02-06 20:28:31 +08:00
|
|
|
}
|
|
|
|
|
2019-07-29 16:27:38 +08:00
|
|
|
static bool asus_wmi_dev_is_present(struct asus_wmi *asus, u32 dev_id)
|
|
|
|
{
|
|
|
|
u32 retval;
|
|
|
|
int status = asus_wmi_get_devstate(asus, dev_id, &retval);
|
|
|
|
|
|
|
|
return status == 0 && (retval & ASUS_WMI_DSTS_PRESENCE_BIT);
|
|
|
|
}
|
|
|
|
|
2019-09-10 01:31:28 +08:00
|
|
|
/* Battery ********************************************************************/
|
|
|
|
|
|
|
|
/* The battery maximum charging percentage */
|
|
|
|
static int charge_end_threshold;
|
|
|
|
|
|
|
|
static ssize_t charge_control_end_threshold_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
int value, ret, rv;
|
|
|
|
|
|
|
|
ret = kstrtouint(buf, 10, &value);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (value < 0 || value > 100)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, value, &rv);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (rv != 1)
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
/* There isn't any method in the DSDT to read the threshold, so we
|
|
|
|
* save the threshold.
|
|
|
|
*/
|
|
|
|
charge_end_threshold = value;
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t charge_control_end_threshold_show(struct device *device,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
return sprintf(buf, "%d\n", charge_end_threshold);
|
|
|
|
}
|
|
|
|
|
|
|
|
static DEVICE_ATTR_RW(charge_control_end_threshold);
|
|
|
|
|
|
|
|
static int asus_wmi_battery_add(struct power_supply *battery)
|
|
|
|
{
|
|
|
|
/* The WMI method does not provide a way to specific a battery, so we
|
|
|
|
* just assume it is the first battery.
|
|
|
|
*/
|
|
|
|
if (strcmp(battery->desc->name, "BAT0") != 0)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (device_create_file(&battery->dev,
|
|
|
|
&dev_attr_charge_control_end_threshold))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
/* The charge threshold is only reset when the system is power cycled,
|
|
|
|
* and we can't get the current threshold so let set it to 100% when
|
|
|
|
* a battery is added.
|
|
|
|
*/
|
|
|
|
asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, 100, NULL);
|
|
|
|
charge_end_threshold = 100;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int asus_wmi_battery_remove(struct power_supply *battery)
|
|
|
|
{
|
|
|
|
device_remove_file(&battery->dev,
|
|
|
|
&dev_attr_charge_control_end_threshold);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static struct acpi_battery_hook battery_hook = {
|
|
|
|
.add_battery = asus_wmi_battery_add,
|
|
|
|
.remove_battery = asus_wmi_battery_remove,
|
|
|
|
.name = "ASUS Battery Extension",
|
|
|
|
};
|
|
|
|
|
|
|
|
static void asus_wmi_battery_init(struct asus_wmi *asus)
|
|
|
|
{
|
|
|
|
asus->battery_rsoc_available = false;
|
|
|
|
if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_RSOC)) {
|
|
|
|
asus->battery_rsoc_available = true;
|
|
|
|
battery_hook_register(&battery_hook);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void asus_wmi_battery_exit(struct asus_wmi *asus)
|
|
|
|
{
|
|
|
|
if (asus->battery_rsoc_available)
|
|
|
|
battery_hook_unregister(&battery_hook);
|
|
|
|
}
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* LEDs ***********************************************************************/
|
|
|
|
|
2010-11-29 15:14:06 +08:00
|
|
|
/*
|
|
|
|
* These functions actually update the LED's, and are called from a
|
|
|
|
* workqueue. By doing this as separate work rather than when the LED
|
2011-02-26 17:20:31 +08:00
|
|
|
* subsystem asks, we avoid messing with the Asus ACPI stuff during a
|
2010-11-29 15:14:06 +08:00
|
|
|
* potentially bad time, such as a timer interrupt.
|
|
|
|
*/
|
|
|
|
static void tpd_led_update(struct work_struct *work)
|
|
|
|
{
|
|
|
|
int ctrl_param;
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi *asus;
|
2010-11-29 15:14:06 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus = container_of(work, struct asus_wmi, tpd_led_work);
|
2010-11-29 15:14:06 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
ctrl_param = asus->tpd_led_wk;
|
|
|
|
asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
|
2010-11-29 15:14:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static void tpd_led_set(struct led_classdev *led_cdev,
|
|
|
|
enum led_brightness value)
|
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi *asus;
|
2010-11-29 15:14:06 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus = container_of(led_cdev, struct asus_wmi, tpd_led);
|
2010-11-29 15:14:06 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus->tpd_led_wk = !!value;
|
|
|
|
queue_work(asus->led_workqueue, &asus->tpd_led_work);
|
2010-11-29 15:14:06 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int read_tpd_led_state(struct asus_wmi *asus)
|
2010-11-29 15:14:06 +08:00
|
|
|
{
|
2011-02-26 17:20:36 +08:00
|
|
|
return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
|
2010-11-29 15:14:06 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
|
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi *asus;
|
2010-11-29 15:14:06 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus = container_of(led_cdev, struct asus_wmi, tpd_led);
|
2010-11-29 15:14:06 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
return read_tpd_led_state(asus);
|
2010-11-29 15:14:06 +08:00
|
|
|
}
|
|
|
|
|
2018-09-27 16:50:09 +08:00
|
|
|
static void kbd_led_update(struct asus_wmi *asus)
|
2010-11-29 15:14:06 +08:00
|
|
|
{
|
2011-07-01 17:34:31 +08:00
|
|
|
int ctrl_param = 0;
|
2010-11-29 15:14:06 +08:00
|
|
|
|
2011-07-01 17:34:31 +08:00
|
|
|
/*
|
|
|
|
* bits 0-2: level
|
|
|
|
* bit 7: light on/off
|
|
|
|
*/
|
|
|
|
if (asus->kbd_led_wk > 0)
|
|
|
|
ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
|
2010-11-29 15:14:06 +08:00
|
|
|
|
2011-07-01 17:34:31 +08:00
|
|
|
asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
|
|
|
|
}
|
2010-11-29 15:14:06 +08:00
|
|
|
|
2011-07-01 17:34:31 +08:00
|
|
|
static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
|
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* bits 0-2: level
|
|
|
|
* bit 7: light on/off
|
|
|
|
* bit 8-10: environment (0: dark, 1: normal, 2: light)
|
|
|
|
* bit 17: status unknown
|
|
|
|
*/
|
|
|
|
retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
|
|
|
|
0xFFFF);
|
|
|
|
|
2011-07-01 17:34:34 +08:00
|
|
|
/* Unknown status is considered as off */
|
2011-07-01 17:34:31 +08:00
|
|
|
if (retval == 0x8000)
|
2011-07-01 17:34:34 +08:00
|
|
|
retval = 0;
|
2011-07-01 17:34:31 +08:00
|
|
|
|
2019-08-16 19:07:17 +08:00
|
|
|
if (retval < 0)
|
|
|
|
return retval;
|
2010-11-29 15:14:06 +08:00
|
|
|
|
2019-08-16 19:07:17 +08:00
|
|
|
if (level)
|
|
|
|
*level = retval & 0x7F;
|
|
|
|
if (env)
|
|
|
|
*env = (retval >> 8) & 0x7F;
|
|
|
|
return 0;
|
2011-07-01 17:34:31 +08:00
|
|
|
}
|
|
|
|
|
2018-06-20 22:46:44 +08:00
|
|
|
static void do_kbd_led_set(struct led_classdev *led_cdev, int value)
|
2011-07-01 17:34:31 +08:00
|
|
|
{
|
|
|
|
struct asus_wmi *asus;
|
2018-06-20 22:46:44 +08:00
|
|
|
int max_level;
|
2011-07-01 17:34:31 +08:00
|
|
|
|
|
|
|
asus = container_of(led_cdev, struct asus_wmi, kbd_led);
|
2018-06-20 22:46:44 +08:00
|
|
|
max_level = asus->kbd_led.max_brightness;
|
2011-07-01 17:34:31 +08:00
|
|
|
|
2019-08-16 19:10:03 +08:00
|
|
|
asus->kbd_led_wk = clamp_val(value, 0, max_level);
|
2018-09-27 16:50:09 +08:00
|
|
|
kbd_led_update(asus);
|
2011-07-01 17:34:31 +08:00
|
|
|
}
|
|
|
|
|
2018-06-20 22:46:44 +08:00
|
|
|
static void kbd_led_set(struct led_classdev *led_cdev,
|
|
|
|
enum led_brightness value)
|
|
|
|
{
|
2019-05-15 03:07:46 +08:00
|
|
|
/* Prevent disabling keyboard backlight on module unregister */
|
|
|
|
if (led_cdev->flags & LED_UNREGISTERING)
|
|
|
|
return;
|
|
|
|
|
2018-06-20 22:46:44 +08:00
|
|
|
do_kbd_led_set(led_cdev, value);
|
|
|
|
}
|
|
|
|
|
2018-10-22 18:00:04 +08:00
|
|
|
static void kbd_led_set_by_kbd(struct asus_wmi *asus, enum led_brightness value)
|
|
|
|
{
|
|
|
|
struct led_classdev *led_cdev = &asus->kbd_led;
|
|
|
|
|
|
|
|
do_kbd_led_set(led_cdev, value);
|
|
|
|
led_classdev_notify_brightness_hw_changed(led_cdev, asus->kbd_led_wk);
|
|
|
|
}
|
|
|
|
|
2011-07-01 17:34:31 +08:00
|
|
|
static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
|
|
|
|
{
|
|
|
|
struct asus_wmi *asus;
|
|
|
|
int retval, value;
|
|
|
|
|
|
|
|
asus = container_of(led_cdev, struct asus_wmi, kbd_led);
|
|
|
|
|
|
|
|
retval = kbd_led_read(asus, &value, NULL);
|
|
|
|
if (retval < 0)
|
|
|
|
return retval;
|
|
|
|
|
|
|
|
return value;
|
2010-11-29 15:14:06 +08:00
|
|
|
}
|
|
|
|
|
2012-07-27 16:51:59 +08:00
|
|
|
static int wlan_led_unknown_state(struct asus_wmi *asus)
|
|
|
|
{
|
|
|
|
u32 result;
|
|
|
|
|
|
|
|
asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
|
|
|
|
|
|
|
|
return result & ASUS_WMI_DSTS_UNKNOWN_BIT;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void wlan_led_update(struct work_struct *work)
|
|
|
|
{
|
|
|
|
int ctrl_param;
|
|
|
|
struct asus_wmi *asus;
|
|
|
|
|
|
|
|
asus = container_of(work, struct asus_wmi, wlan_led_work);
|
|
|
|
|
|
|
|
ctrl_param = asus->wlan_led_wk;
|
|
|
|
asus_wmi_set_devstate(ASUS_WMI_DEVID_WIRELESS_LED, ctrl_param, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void wlan_led_set(struct led_classdev *led_cdev,
|
|
|
|
enum led_brightness value)
|
|
|
|
{
|
|
|
|
struct asus_wmi *asus;
|
|
|
|
|
|
|
|
asus = container_of(led_cdev, struct asus_wmi, wlan_led);
|
|
|
|
|
|
|
|
asus->wlan_led_wk = !!value;
|
|
|
|
queue_work(asus->led_workqueue, &asus->wlan_led_work);
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum led_brightness wlan_led_get(struct led_classdev *led_cdev)
|
|
|
|
{
|
|
|
|
struct asus_wmi *asus;
|
|
|
|
u32 result;
|
|
|
|
|
|
|
|
asus = container_of(led_cdev, struct asus_wmi, wlan_led);
|
|
|
|
asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
|
|
|
|
|
|
|
|
return result & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
|
|
|
|
}
|
|
|
|
|
2017-09-24 00:23:37 +08:00
|
|
|
static void lightbar_led_update(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct asus_wmi *asus;
|
|
|
|
int ctrl_param;
|
|
|
|
|
|
|
|
asus = container_of(work, struct asus_wmi, lightbar_led_work);
|
|
|
|
|
|
|
|
ctrl_param = asus->lightbar_led_wk;
|
|
|
|
asus_wmi_set_devstate(ASUS_WMI_DEVID_LIGHTBAR, ctrl_param, NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void lightbar_led_set(struct led_classdev *led_cdev,
|
|
|
|
enum led_brightness value)
|
|
|
|
{
|
|
|
|
struct asus_wmi *asus;
|
|
|
|
|
|
|
|
asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
|
|
|
|
|
|
|
|
asus->lightbar_led_wk = !!value;
|
|
|
|
queue_work(asus->led_workqueue, &asus->lightbar_led_work);
|
|
|
|
}
|
|
|
|
|
|
|
|
static enum led_brightness lightbar_led_get(struct led_classdev *led_cdev)
|
|
|
|
{
|
|
|
|
struct asus_wmi *asus;
|
|
|
|
u32 result;
|
|
|
|
|
|
|
|
asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
|
|
|
|
asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_LIGHTBAR, &result);
|
|
|
|
|
|
|
|
return result & ASUS_WMI_DSTS_LIGHTBAR_MASK;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static void asus_wmi_led_exit(struct asus_wmi *asus)
|
2010-11-29 15:14:06 +08:00
|
|
|
{
|
2011-08-08 17:16:01 +08:00
|
|
|
if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
|
|
|
|
led_classdev_unregister(&asus->kbd_led);
|
|
|
|
if (!IS_ERR_OR_NULL(asus->tpd_led.dev))
|
2011-02-26 17:20:31 +08:00
|
|
|
led_classdev_unregister(&asus->tpd_led);
|
2012-07-27 16:51:59 +08:00
|
|
|
if (!IS_ERR_OR_NULL(asus->wlan_led.dev))
|
|
|
|
led_classdev_unregister(&asus->wlan_led);
|
2017-09-24 00:23:37 +08:00
|
|
|
if (!IS_ERR_OR_NULL(asus->lightbar_led.dev))
|
|
|
|
led_classdev_unregister(&asus->lightbar_led);
|
2011-02-26 17:20:31 +08:00
|
|
|
if (asus->led_workqueue)
|
|
|
|
destroy_workqueue(asus->led_workqueue);
|
2010-11-29 15:14:06 +08:00
|
|
|
}
|
|
|
|
|
2011-07-01 17:34:31 +08:00
|
|
|
static int asus_wmi_led_init(struct asus_wmi *asus)
|
|
|
|
{
|
2015-09-14 17:16:30 +08:00
|
|
|
int rv = 0, led_val;
|
2011-07-01 17:34:31 +08:00
|
|
|
|
|
|
|
asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
|
|
|
|
if (!asus->led_workqueue)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
if (read_tpd_led_state(asus) >= 0) {
|
|
|
|
INIT_WORK(&asus->tpd_led_work, tpd_led_update);
|
|
|
|
|
|
|
|
asus->tpd_led.name = "asus::touchpad";
|
|
|
|
asus->tpd_led.brightness_set = tpd_led_set;
|
|
|
|
asus->tpd_led.brightness_get = tpd_led_get;
|
|
|
|
asus->tpd_led.max_brightness = 1;
|
|
|
|
|
|
|
|
rv = led_classdev_register(&asus->platform_device->dev,
|
|
|
|
&asus->tpd_led);
|
|
|
|
if (rv)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2019-05-15 02:51:25 +08:00
|
|
|
if (!kbd_led_read(asus, &led_val, NULL)) {
|
2015-09-14 17:16:30 +08:00
|
|
|
asus->kbd_led_wk = led_val;
|
2011-07-01 17:34:31 +08:00
|
|
|
asus->kbd_led.name = "asus::kbd_backlight";
|
2018-06-20 22:46:44 +08:00
|
|
|
asus->kbd_led.flags = LED_BRIGHT_HW_CHANGED;
|
2011-07-01 17:34:31 +08:00
|
|
|
asus->kbd_led.brightness_set = kbd_led_set;
|
|
|
|
asus->kbd_led.brightness_get = kbd_led_get;
|
|
|
|
asus->kbd_led.max_brightness = 3;
|
|
|
|
|
|
|
|
rv = led_classdev_register(&asus->platform_device->dev,
|
|
|
|
&asus->kbd_led);
|
2012-07-27 16:51:59 +08:00
|
|
|
if (rv)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2019-07-29 16:27:38 +08:00
|
|
|
if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_WIRELESS_LED)
|
|
|
|
&& (asus->driver->quirks->wapf > 0)) {
|
2012-07-27 16:51:59 +08:00
|
|
|
INIT_WORK(&asus->wlan_led_work, wlan_led_update);
|
|
|
|
|
|
|
|
asus->wlan_led.name = "asus::wlan";
|
|
|
|
asus->wlan_led.brightness_set = wlan_led_set;
|
|
|
|
if (!wlan_led_unknown_state(asus))
|
|
|
|
asus->wlan_led.brightness_get = wlan_led_get;
|
|
|
|
asus->wlan_led.flags = LED_CORE_SUSPENDRESUME;
|
|
|
|
asus->wlan_led.max_brightness = 1;
|
|
|
|
asus->wlan_led.default_trigger = "asus-wlan";
|
|
|
|
|
|
|
|
rv = led_classdev_register(&asus->platform_device->dev,
|
|
|
|
&asus->wlan_led);
|
2017-09-24 00:23:37 +08:00
|
|
|
if (rv)
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2019-07-29 16:27:38 +08:00
|
|
|
if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_LIGHTBAR)) {
|
2017-09-24 00:23:37 +08:00
|
|
|
INIT_WORK(&asus->lightbar_led_work, lightbar_led_update);
|
|
|
|
|
|
|
|
asus->lightbar_led.name = "asus::lightbar";
|
|
|
|
asus->lightbar_led.brightness_set = lightbar_led_set;
|
|
|
|
asus->lightbar_led.brightness_get = lightbar_led_get;
|
|
|
|
asus->lightbar_led.max_brightness = 1;
|
|
|
|
|
|
|
|
rv = led_classdev_register(&asus->platform_device->dev,
|
|
|
|
&asus->lightbar_led);
|
2011-07-01 17:34:31 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
error:
|
|
|
|
if (rv)
|
|
|
|
asus_wmi_led_exit(asus);
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* RF *************************************************************************/
|
2011-07-01 17:34:31 +08:00
|
|
|
|
2011-02-06 20:28:28 +08:00
|
|
|
/*
|
|
|
|
* PCI hotplug (for wlan rfkill)
|
|
|
|
*/
|
2011-02-26 17:20:31 +08:00
|
|
|
static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
|
2011-02-06 20:28:28 +08:00
|
|
|
{
|
2011-02-26 17:20:36 +08:00
|
|
|
int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
|
2011-02-06 20:28:28 +08:00
|
|
|
|
2011-02-06 20:28:31 +08:00
|
|
|
if (result < 0)
|
2011-02-06 20:28:28 +08:00
|
|
|
return false;
|
2011-02-06 20:28:31 +08:00
|
|
|
return !result;
|
2011-02-06 20:28:28 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static void asus_rfkill_hotplug(struct asus_wmi *asus)
|
2011-02-06 20:28:28 +08:00
|
|
|
{
|
|
|
|
struct pci_dev *dev;
|
|
|
|
struct pci_bus *bus;
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
bool blocked;
|
2011-02-06 20:28:28 +08:00
|
|
|
bool absent;
|
|
|
|
u32 l;
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
mutex_lock(&asus->wmi_lock);
|
|
|
|
blocked = asus_wlan_rfkill_blocked(asus);
|
|
|
|
mutex_unlock(&asus->wmi_lock);
|
2011-02-06 20:28:28 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
mutex_lock(&asus->hotplug_lock);
|
2014-01-10 22:27:08 +08:00
|
|
|
pci_lock_rescan_remove();
|
2011-02-06 20:28:28 +08:00
|
|
|
|
2011-02-26 17:20:33 +08:00
|
|
|
if (asus->wlan.rfkill)
|
|
|
|
rfkill_set_sw_state(asus->wlan.rfkill, blocked);
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
|
2018-09-08 15:59:01 +08:00
|
|
|
if (asus->hotplug_slot.ops) {
|
2011-02-06 20:28:28 +08:00
|
|
|
bus = pci_find_bus(0, 1);
|
|
|
|
if (!bus) {
|
2011-03-30 06:21:35 +08:00
|
|
|
pr_warn("Unable to find PCI bus 1?\n");
|
2011-02-06 20:28:28 +08:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
|
|
|
|
pr_err("Unable to read PCI config space?\n");
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
absent = (l == 0xffffffff);
|
|
|
|
|
|
|
|
if (blocked != absent) {
|
2011-03-30 06:21:35 +08:00
|
|
|
pr_warn("BIOS says wireless lan is %s, "
|
|
|
|
"but the pci device is %s\n",
|
|
|
|
blocked ? "blocked" : "unblocked",
|
|
|
|
absent ? "absent" : "present");
|
|
|
|
pr_warn("skipped wireless hotplug as probably "
|
|
|
|
"inappropriate for this model\n");
|
2011-02-06 20:28:28 +08:00
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!blocked) {
|
|
|
|
dev = pci_get_slot(bus, 0);
|
|
|
|
if (dev) {
|
|
|
|
/* Device already present */
|
|
|
|
pci_dev_put(dev);
|
|
|
|
goto out_unlock;
|
|
|
|
}
|
|
|
|
dev = pci_scan_single_device(bus, 0);
|
|
|
|
if (dev) {
|
|
|
|
pci_bus_assign_resources(bus);
|
2014-05-30 11:01:03 +08:00
|
|
|
pci_bus_add_device(dev);
|
2011-02-06 20:28:28 +08:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
dev = pci_get_slot(bus, 0);
|
|
|
|
if (dev) {
|
2012-02-26 05:54:20 +08:00
|
|
|
pci_stop_and_remove_bus_device(dev);
|
2011-02-06 20:28:28 +08:00
|
|
|
pci_dev_put(dev);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out_unlock:
|
2014-01-10 22:27:08 +08:00
|
|
|
pci_unlock_rescan_remove();
|
2011-02-26 17:20:31 +08:00
|
|
|
mutex_unlock(&asus->hotplug_lock);
|
2011-02-06 20:28:28 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
|
2011-02-06 20:28:28 +08:00
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi *asus = data;
|
2011-02-06 20:28:28 +08:00
|
|
|
|
|
|
|
if (event != ACPI_NOTIFY_BUS_CHECK)
|
|
|
|
return;
|
|
|
|
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
/*
|
2011-02-26 17:20:31 +08:00
|
|
|
* We can't call directly asus_rfkill_hotplug because most
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
* of the time WMBC is still being executed and not reetrant.
|
|
|
|
* There is currently no way to tell ACPICA that we want this
|
2011-02-26 17:20:31 +08:00
|
|
|
* method to be serialized, we schedule a asus_rfkill_hotplug
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
* call later, in a safer context.
|
|
|
|
*/
|
2011-02-26 17:20:31 +08:00
|
|
|
queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
|
2011-02-06 20:28:28 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
|
2011-02-06 20:28:28 +08:00
|
|
|
{
|
|
|
|
acpi_status status;
|
|
|
|
acpi_handle handle;
|
|
|
|
|
|
|
|
status = acpi_get_handle(NULL, node, &handle);
|
2019-08-16 19:07:17 +08:00
|
|
|
if (ACPI_FAILURE(status))
|
2011-02-06 20:28:28 +08:00
|
|
|
return -ENODEV;
|
|
|
|
|
2019-08-16 19:07:17 +08:00
|
|
|
status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
|
|
|
|
asus_rfkill_notify, asus);
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
pr_warn("Failed to register notify on %s\n", node);
|
|
|
|
|
2011-02-06 20:28:28 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
|
2011-02-06 20:28:28 +08:00
|
|
|
{
|
|
|
|
acpi_status status = AE_OK;
|
|
|
|
acpi_handle handle;
|
|
|
|
|
|
|
|
status = acpi_get_handle(NULL, node, &handle);
|
2019-08-16 19:07:17 +08:00
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return;
|
2011-02-06 20:28:28 +08:00
|
|
|
|
2019-08-16 19:07:17 +08:00
|
|
|
status = acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
|
|
|
|
asus_rfkill_notify);
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
pr_err("Error removing rfkill notify handler %s\n", node);
|
2011-02-06 20:28:28 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
|
|
|
|
u8 *value)
|
2011-02-06 20:28:28 +08:00
|
|
|
{
|
2018-09-08 15:59:01 +08:00
|
|
|
struct asus_wmi *asus = container_of(hotplug_slot,
|
|
|
|
struct asus_wmi, hotplug_slot);
|
2011-02-26 17:20:36 +08:00
|
|
|
int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
|
2011-02-06 20:28:28 +08:00
|
|
|
|
2011-02-06 20:28:31 +08:00
|
|
|
if (result < 0)
|
|
|
|
return result;
|
2011-02-06 20:28:28 +08:00
|
|
|
|
2011-02-06 20:28:31 +08:00
|
|
|
*value = !!result;
|
2011-02-06 20:28:28 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-09-08 15:59:01 +08:00
|
|
|
static const struct hotplug_slot_ops asus_hotplug_slot_ops = {
|
2011-02-26 17:20:31 +08:00
|
|
|
.get_adapter_status = asus_get_adapter_status,
|
|
|
|
.get_power_status = asus_get_adapter_status,
|
2011-02-06 20:28:28 +08:00
|
|
|
};
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static void asus_hotplug_work(struct work_struct *work)
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi *asus;
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus = container_of(work, struct asus_wmi, hotplug_work);
|
|
|
|
asus_rfkill_hotplug(asus);
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_setup_pci_hotplug(struct asus_wmi *asus)
|
2011-02-06 20:28:28 +08:00
|
|
|
{
|
|
|
|
int ret = -ENOMEM;
|
|
|
|
struct pci_bus *bus = pci_find_bus(0, 1);
|
|
|
|
|
|
|
|
if (!bus) {
|
|
|
|
pr_err("Unable to find wifi PCI bus\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus->hotplug_workqueue =
|
|
|
|
create_singlethread_workqueue("hotplug_workqueue");
|
|
|
|
if (!asus->hotplug_workqueue)
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
goto error_workqueue;
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
|
2018-09-08 15:59:01 +08:00
|
|
|
asus->hotplug_slot.ops = &asus_hotplug_slot_ops;
|
2011-02-06 20:28:28 +08:00
|
|
|
|
2018-09-08 15:59:01 +08:00
|
|
|
ret = pci_hp_register(&asus->hotplug_slot, bus, 0, "asus-wifi");
|
2011-02-06 20:28:28 +08:00
|
|
|
if (ret) {
|
|
|
|
pr_err("Unable to register hotplug slot - %d\n", ret);
|
|
|
|
goto error_register;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
error_register:
|
2018-09-08 15:59:01 +08:00
|
|
|
asus->hotplug_slot.ops = NULL;
|
2011-02-26 17:20:31 +08:00
|
|
|
destroy_workqueue(asus->hotplug_workqueue);
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
error_workqueue:
|
2011-02-06 20:28:28 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-11-29 15:14:07 +08:00
|
|
|
/*
|
|
|
|
* Rfkill devices
|
|
|
|
*/
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_rfkill_set(void *data, bool blocked)
|
2010-11-29 15:14:07 +08:00
|
|
|
{
|
2011-02-26 17:20:33 +08:00
|
|
|
struct asus_rfkill *priv = data;
|
2010-11-29 15:14:07 +08:00
|
|
|
u32 ctrl_param = !blocked;
|
asus-wmi: record wlan status while controlled by userapp
If the user bit is set, that mean BIOS can't set and record the wlan
status, it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
(0x00010012) while we query the wlan status by id ASUS_WMI_DEVID_WLAN
(0x00010011) through WMI.
So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
(0x00010012) while setting the wlan status through WMI.
This is also the behavior that windows app will do.
Quote from ASUS application engineer
===
When you call WMIMethod(DSTS, 0x00010011) to get WLAN status, it may return
(1) 0x00050001 (On)
(2) 0x00050000 (Off)
(3) 0x00030001 (On)
(4) 0x00030000 (Off)
(5) 0x00000002 (Unknown)
(1), (2) means that the model has hardware GPIO for WLAN, you can call
WMIMethod(DEVS, 0x00010011, 1 or 0) to turn WLAN on/off.
(3), (4) means that the model doesn’t have hardware GPIO, you need to use
API or driver library to turn WLAN on/off, and call
WMIMethod(DEVS, 0x00010012, 1 or 0) to set WLAN LED status.
After you set WLAN LED status, you can see the WLAN status is changed with
WMIMethod(DSTS, 0x00010011). Because the status is recorded lastly
(ex: Windows), you can use it for synchronization.
(5) means that the model doesn’t have WLAN device.
WLAN is the ONLY special case with upper rule.
For other device, like Bluetooth, you just need use
WMIMethod(DSTS, 0x00010013) to get, and WMIMethod(DEVS, 0x00010013, 1 or 0)
to set.
===
Signed-off-by: AceLan Kao <acelan.kao@canonical.com>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2012-07-26 17:13:31 +08:00
|
|
|
u32 dev_id = priv->dev_id;
|
2010-11-29 15:14:07 +08:00
|
|
|
|
asus-wmi: record wlan status while controlled by userapp
If the user bit is set, that mean BIOS can't set and record the wlan
status, it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
(0x00010012) while we query the wlan status by id ASUS_WMI_DEVID_WLAN
(0x00010011) through WMI.
So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
(0x00010012) while setting the wlan status through WMI.
This is also the behavior that windows app will do.
Quote from ASUS application engineer
===
When you call WMIMethod(DSTS, 0x00010011) to get WLAN status, it may return
(1) 0x00050001 (On)
(2) 0x00050000 (Off)
(3) 0x00030001 (On)
(4) 0x00030000 (Off)
(5) 0x00000002 (Unknown)
(1), (2) means that the model has hardware GPIO for WLAN, you can call
WMIMethod(DEVS, 0x00010011, 1 or 0) to turn WLAN on/off.
(3), (4) means that the model doesn’t have hardware GPIO, you need to use
API or driver library to turn WLAN on/off, and call
WMIMethod(DEVS, 0x00010012, 1 or 0) to set WLAN LED status.
After you set WLAN LED status, you can see the WLAN status is changed with
WMIMethod(DSTS, 0x00010011). Because the status is recorded lastly
(ex: Windows), you can use it for synchronization.
(5) means that the model doesn’t have WLAN device.
WLAN is the ONLY special case with upper rule.
For other device, like Bluetooth, you just need use
WMIMethod(DSTS, 0x00010013) to get, and WMIMethod(DEVS, 0x00010013, 1 or 0)
to set.
===
Signed-off-by: AceLan Kao <acelan.kao@canonical.com>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2012-07-26 17:13:31 +08:00
|
|
|
/*
|
|
|
|
* If the user bit is set, BIOS can't set and record the wlan status,
|
|
|
|
* it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
|
|
|
|
* while we query the wlan status through WMI(ASUS_WMI_DEVID_WLAN).
|
|
|
|
* So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
|
|
|
|
* while setting the wlan status through WMI.
|
|
|
|
* This is also the behavior that windows app will do.
|
|
|
|
*/
|
|
|
|
if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
|
|
|
|
priv->asus->driver->wlan_ctrl_by_user)
|
|
|
|
dev_id = ASUS_WMI_DEVID_WLAN_LED;
|
|
|
|
|
|
|
|
return asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
|
2010-11-29 15:14:07 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static void asus_rfkill_query(struct rfkill *rfkill, void *data)
|
2010-11-29 15:14:07 +08:00
|
|
|
{
|
2011-02-26 17:20:33 +08:00
|
|
|
struct asus_rfkill *priv = data;
|
2011-02-06 20:28:31 +08:00
|
|
|
int result;
|
2010-11-29 15:14:07 +08:00
|
|
|
|
2011-02-26 17:20:36 +08:00
|
|
|
result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
|
2010-11-29 15:14:07 +08:00
|
|
|
|
2011-02-06 20:28:31 +08:00
|
|
|
if (result < 0)
|
2011-02-26 17:20:31 +08:00
|
|
|
return;
|
2010-11-29 15:14:07 +08:00
|
|
|
|
2011-02-26 17:20:33 +08:00
|
|
|
rfkill_set_sw_state(priv->rfkill, !result);
|
2010-11-29 15:14:07 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_rfkill_wlan_set(void *data, bool blocked)
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
{
|
2011-02-26 17:20:33 +08:00
|
|
|
struct asus_rfkill *priv = data;
|
|
|
|
struct asus_wmi *asus = priv->asus;
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This handler is enabled only if hotplug is enabled.
|
2011-02-26 17:20:31 +08:00
|
|
|
* In this case, the asus_wmi_set_devstate() will
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
* trigger a wmi notification and we need to wait
|
|
|
|
* this call to finish before being able to call
|
|
|
|
* any wmi method
|
|
|
|
*/
|
2011-02-26 17:20:31 +08:00
|
|
|
mutex_lock(&asus->wmi_lock);
|
2011-02-26 17:20:33 +08:00
|
|
|
ret = asus_rfkill_set(data, blocked);
|
2011-02-26 17:20:31 +08:00
|
|
|
mutex_unlock(&asus->wmi_lock);
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static const struct rfkill_ops asus_rfkill_wlan_ops = {
|
|
|
|
.set_block = asus_rfkill_wlan_set,
|
2011-02-26 17:20:33 +08:00
|
|
|
.query = asus_rfkill_query,
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
};
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static const struct rfkill_ops asus_rfkill_ops = {
|
|
|
|
.set_block = asus_rfkill_set,
|
|
|
|
.query = asus_rfkill_query,
|
2010-11-29 15:14:07 +08:00
|
|
|
};
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_new_rfkill(struct asus_wmi *asus,
|
2011-02-26 17:20:33 +08:00
|
|
|
struct asus_rfkill *arfkill,
|
2011-02-26 17:20:31 +08:00
|
|
|
const char *name, enum rfkill_type type, int dev_id)
|
2010-11-29 15:14:07 +08:00
|
|
|
{
|
2011-02-26 17:20:36 +08:00
|
|
|
int result = asus_wmi_get_devstate_simple(asus, dev_id);
|
2011-02-26 17:20:33 +08:00
|
|
|
struct rfkill **rfkill = &arfkill->rfkill;
|
2010-11-29 15:14:07 +08:00
|
|
|
|
2011-02-06 20:28:31 +08:00
|
|
|
if (result < 0)
|
|
|
|
return result;
|
2010-11-29 15:14:07 +08:00
|
|
|
|
2011-02-26 17:20:33 +08:00
|
|
|
arfkill->dev_id = dev_id;
|
|
|
|
arfkill->asus = asus;
|
|
|
|
|
2012-03-20 16:53:08 +08:00
|
|
|
if (dev_id == ASUS_WMI_DEVID_WLAN &&
|
|
|
|
asus->driver->quirks->hotplug_wireless)
|
2011-02-26 17:20:31 +08:00
|
|
|
*rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
|
2011-02-26 17:20:33 +08:00
|
|
|
&asus_rfkill_wlan_ops, arfkill);
|
eeepc-wmi: serialize access to wmi method
\AMW0.WMBC, which is the main method that we use,
is not reentrant. When wireless hotpluging is enabled,
toggling the status of the wireless device using WMBC will
trigger a notification and the notification handler need to
call WMBC again to get the new status of the device, this
will trigger the following error:
ACPI Error (dswload-0802): [_T_0] Namespace lookup failure, AE_ALREADY_EXISTS
ACPI Exception: AE_ALREADY_EXISTS, During name lookup/catalog (20100428/psloop-231)
ACPI Error (psparse-0537): Method parse/execution failed [\AMW0.WMBC] (Node f7023b88), AE_ALREADY_EXISTS
ACPI: Marking method WMBC as Serialized because of AE_ALREADY_EXISTS error
Since there is currently no way to tell the acpi subsystem to mark
a method as serialized, we do it in eeepc-wmi.
Of course, we could let the first call fail, and then it would work,
but it doesn't seems really clean, and it will make the first
WMBC call return a random value.
This patch was tested on EeePc 1000H with a RaLink RT2860
wireless card using the rt2800pci driver. rt2860sta driver
seems to deadlock when we remove the pci device...
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2011-02-06 20:28:29 +08:00
|
|
|
else
|
2011-02-26 17:20:31 +08:00
|
|
|
*rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
|
2011-02-26 17:20:33 +08:00
|
|
|
&asus_rfkill_ops, arfkill);
|
2010-11-29 15:14:07 +08:00
|
|
|
|
|
|
|
if (!*rfkill)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2013-05-30 10:31:50 +08:00
|
|
|
if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
|
2014-07-09 16:18:18 +08:00
|
|
|
(asus->driver->quirks->wapf > 0))
|
2012-07-27 16:51:59 +08:00
|
|
|
rfkill_set_led_trigger_name(*rfkill, "asus-wlan");
|
|
|
|
|
2011-02-06 20:28:31 +08:00
|
|
|
rfkill_init_sw_state(*rfkill, !result);
|
2010-11-29 15:14:07 +08:00
|
|
|
result = rfkill_register(*rfkill);
|
|
|
|
if (result) {
|
|
|
|
rfkill_destroy(*rfkill);
|
|
|
|
*rfkill = NULL;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
|
2010-11-29 15:14:07 +08:00
|
|
|
{
|
2018-05-23 05:30:15 +08:00
|
|
|
if (asus->driver->wlan_ctrl_by_user && ashs_present())
|
|
|
|
return;
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
|
|
|
|
asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
|
|
|
|
asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
|
2011-02-26 17:20:33 +08:00
|
|
|
if (asus->wlan.rfkill) {
|
|
|
|
rfkill_unregister(asus->wlan.rfkill);
|
|
|
|
rfkill_destroy(asus->wlan.rfkill);
|
|
|
|
asus->wlan.rfkill = NULL;
|
2010-11-29 15:14:07 +08:00
|
|
|
}
|
2011-02-06 20:28:28 +08:00
|
|
|
/*
|
|
|
|
* Refresh pci hotplug in case the rfkill state was changed after
|
2011-02-26 17:20:31 +08:00
|
|
|
* asus_unregister_rfkill_notifier()
|
2011-02-06 20:28:28 +08:00
|
|
|
*/
|
2011-02-26 17:20:31 +08:00
|
|
|
asus_rfkill_hotplug(asus);
|
2018-09-08 15:59:01 +08:00
|
|
|
if (asus->hotplug_slot.ops)
|
|
|
|
pci_hp_deregister(&asus->hotplug_slot);
|
2011-02-26 17:20:31 +08:00
|
|
|
if (asus->hotplug_workqueue)
|
|
|
|
destroy_workqueue(asus->hotplug_workqueue);
|
|
|
|
|
2011-02-26 17:20:33 +08:00
|
|
|
if (asus->bluetooth.rfkill) {
|
|
|
|
rfkill_unregister(asus->bluetooth.rfkill);
|
|
|
|
rfkill_destroy(asus->bluetooth.rfkill);
|
|
|
|
asus->bluetooth.rfkill = NULL;
|
2010-11-29 15:14:07 +08:00
|
|
|
}
|
2011-02-26 17:20:33 +08:00
|
|
|
if (asus->wimax.rfkill) {
|
|
|
|
rfkill_unregister(asus->wimax.rfkill);
|
|
|
|
rfkill_destroy(asus->wimax.rfkill);
|
|
|
|
asus->wimax.rfkill = NULL;
|
2011-02-06 20:28:37 +08:00
|
|
|
}
|
2011-02-26 17:20:33 +08:00
|
|
|
if (asus->wwan3g.rfkill) {
|
|
|
|
rfkill_unregister(asus->wwan3g.rfkill);
|
|
|
|
rfkill_destroy(asus->wwan3g.rfkill);
|
|
|
|
asus->wwan3g.rfkill = NULL;
|
2010-11-29 15:14:07 +08:00
|
|
|
}
|
2011-07-01 17:34:40 +08:00
|
|
|
if (asus->gps.rfkill) {
|
|
|
|
rfkill_unregister(asus->gps.rfkill);
|
|
|
|
rfkill_destroy(asus->gps.rfkill);
|
|
|
|
asus->gps.rfkill = NULL;
|
|
|
|
}
|
2011-07-01 17:34:41 +08:00
|
|
|
if (asus->uwb.rfkill) {
|
|
|
|
rfkill_unregister(asus->uwb.rfkill);
|
|
|
|
rfkill_destroy(asus->uwb.rfkill);
|
|
|
|
asus->uwb.rfkill = NULL;
|
|
|
|
}
|
2010-11-29 15:14:07 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_wmi_rfkill_init(struct asus_wmi *asus)
|
2010-11-29 15:14:07 +08:00
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
mutex_init(&asus->hotplug_lock);
|
|
|
|
mutex_init(&asus->wmi_lock);
|
2011-02-06 20:28:28 +08:00
|
|
|
|
2011-02-26 17:20:33 +08:00
|
|
|
result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
|
|
|
|
RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
|
2010-11-29 15:14:07 +08:00
|
|
|
|
|
|
|
if (result && result != -ENODEV)
|
|
|
|
goto exit;
|
|
|
|
|
2011-02-26 17:20:33 +08:00
|
|
|
result = asus_new_rfkill(asus, &asus->bluetooth,
|
2011-02-26 17:20:31 +08:00
|
|
|
"asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
|
|
|
|
ASUS_WMI_DEVID_BLUETOOTH);
|
2010-11-29 15:14:07 +08:00
|
|
|
|
|
|
|
if (result && result != -ENODEV)
|
|
|
|
goto exit;
|
|
|
|
|
2011-02-26 17:20:33 +08:00
|
|
|
result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
|
|
|
|
RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
|
2011-02-06 20:28:37 +08:00
|
|
|
|
|
|
|
if (result && result != -ENODEV)
|
|
|
|
goto exit;
|
|
|
|
|
2011-02-26 17:20:33 +08:00
|
|
|
result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
|
|
|
|
RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
|
2010-11-29 15:14:07 +08:00
|
|
|
|
|
|
|
if (result && result != -ENODEV)
|
|
|
|
goto exit;
|
|
|
|
|
2011-07-01 17:34:40 +08:00
|
|
|
result = asus_new_rfkill(asus, &asus->gps, "asus-gps",
|
|
|
|
RFKILL_TYPE_GPS, ASUS_WMI_DEVID_GPS);
|
|
|
|
|
|
|
|
if (result && result != -ENODEV)
|
|
|
|
goto exit;
|
|
|
|
|
2011-07-01 17:34:41 +08:00
|
|
|
result = asus_new_rfkill(asus, &asus->uwb, "asus-uwb",
|
|
|
|
RFKILL_TYPE_UWB, ASUS_WMI_DEVID_UWB);
|
|
|
|
|
|
|
|
if (result && result != -ENODEV)
|
|
|
|
goto exit;
|
|
|
|
|
2012-03-20 16:53:08 +08:00
|
|
|
if (!asus->driver->quirks->hotplug_wireless)
|
2011-02-06 20:28:40 +08:00
|
|
|
goto exit;
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
result = asus_setup_pci_hotplug(asus);
|
2011-02-06 20:28:28 +08:00
|
|
|
/*
|
|
|
|
* If we get -EBUSY then something else is handling the PCI hotplug -
|
|
|
|
* don't fail in this case
|
|
|
|
*/
|
|
|
|
if (result == -EBUSY)
|
|
|
|
result = 0;
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
|
|
|
|
asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
|
|
|
|
asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
|
2011-02-06 20:28:28 +08:00
|
|
|
/*
|
|
|
|
* Refresh pci hotplug in case the rfkill state was changed during
|
|
|
|
* setup.
|
|
|
|
*/
|
2011-02-26 17:20:31 +08:00
|
|
|
asus_rfkill_hotplug(asus);
|
2011-02-06 20:28:28 +08:00
|
|
|
|
2010-11-29 15:14:07 +08:00
|
|
|
exit:
|
|
|
|
if (result && result != -ENODEV)
|
2011-02-26 17:20:31 +08:00
|
|
|
asus_wmi_rfkill_exit(asus);
|
2010-11-29 15:14:07 +08:00
|
|
|
|
|
|
|
if (result == -ENODEV)
|
|
|
|
result = 0;
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* Quirks *********************************************************************/
|
|
|
|
|
platform/x86: asus-wmi: Set specified XUSB2PR value for X550LB
The bluetooth adapter Atheros AR3012 can't be enumerated
and make the bluetooth function broken.
T: Bus=02 Lev=01 Prnt=01 Port=05 Cnt=02 Dev#= 5 Spd=12 MxCh= 0
D: Ver= 1.10 Cls=e0(wlcon) Sub=01 Prot=01 MxPS=64 #Cfgs= 1
P: Vendor=13d3 ProdID=3362 Rev=00.02
S: Manufacturer=Atheros Communications
S: Product=Bluetooth USB Host Controller
S: SerialNumber=Alaska Day 2006
C: #Ifs= 2 Cfg#= 1 Atr=e0 MxPwr=100mA
I: If#= 0 Alt= 0 #EPs= 3 Cls=e0(wlcon) Sub=01 Prot=01 Driver=btusb
I: If#= 1 Alt= 0 #EPs= 2 Cls=e0(wlcon) Sub=01 Prot=01 Driver=btusb
The error is:
usb 2-6: device not accepting address 7, error -62
usb usb2-port6: unable to enumerate USB device
It is caused by adapter's connected port is mapped to xHC
controller, but the xHCI is not supported by the usb device.
The output of 'sudo lspci -nnxxx -s 00:14.0':
00:14.0 USB controller [0c03]: Intel Corporation 8 Series USB xHCI HC [8086:9c31] (rev 04)
00: 86 80 31 9c 06 04 90 02 04 30 03 0c 00 00 00 00
10: 04 00 a0 f7 00 00 00 00 00 00 00 00 00 00 00 00
20: 00 00 00 00 00 00 00 00 00 00 00 00 43 10 1f 20
30: 00 00 00 00 70 00 00 00 00 00 00 00 0b 01 00 00
40: fd 01 36 80 89 c6 0f 80 00 00 00 00 00 00 00 00
50: 5f 2e ce 0f 00 00 00 00 00 00 00 00 00 00 00 00
60: 30 20 00 00 00 00 00 00 00 00 00 00 00 00 00 00
70: 01 80 c2 c1 08 00 00 00 00 00 00 00 00 00 00 00
80: 05 00 87 00 0c a0 e0 fe 00 00 00 00 a1 41 00 00
90: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
a0: 00 01 04 00 00 00 00 00 00 00 00 00 00 00 00 00
b0: 0f 00 03 00 00 00 00 00 00 00 00 00 00 00 00 00
c0: 03 c0 30 00 00 00 00 00 03 0c 00 00 00 00 00 00
d0: f9 01 00 00 f9 01 00 00 0f 00 00 00 0f 00 00 00
e0: 00 08 00 00 00 00 00 00 00 00 00 00 d8 d8 00 00
f0: 00 00 00 00 00 00 00 00 b1 0f 04 08 00 00 00 00
By referencing Intel Platform Controller Hub(PCH) datasheet,
the xHC USB 2.0 Port Routing(XUSB2PR) at offset 0xD0-0xD3h
decides the setting of mapping the port to EHCI controller or
xHC controller. And the port mapped to xHC will enable xHCI
during bus resume.
The setting of disabling bluetooth adapter's connected port is
0x000001D9. The value can be obtained by few times 1 bit flip
operation. The suited configuration should have the 'lsusb -t'
result with bluetooth using ehci:
/: Bus 03.Port 1: Dev 1, Class=root_hub, Driver=xhci_hcd/4p, 5000M
/: Bus 02.Port 1: Dev 1, Class=root_hub, Driver=xhci_hcd/9p, 480M
|__ Port 5: Dev 2, If 0, Class=Video, Driver=uvcvideo, 480M
|__ Port 5: Dev 2, If 1, Class=Video, Driver=uvcvideo, 480M
/: Bus 01.Port 1: Dev 1, Class=root_hub, Driver=ehci-pci/2p, 480M
|__ Port 1: Dev 2, If 0, Class=Hub, Driver=hub/8p, 480M
|__ Port 6: Dev 3, If 0, Class=Wireless, Driver=btusb, 12M
|__ Port 6: Dev 3, If 1, Class=Wireless, Driver=btusb, 12M
Signed-off-by: Kai-Chuan Hsieh <kai.chiuan@gmail.com>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com>
[andy: resolve merge conflict in asus-wmi.h]
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2016-09-01 23:55:55 +08:00
|
|
|
static void asus_wmi_set_xusb2pr(struct asus_wmi *asus)
|
|
|
|
{
|
|
|
|
struct pci_dev *xhci_pdev;
|
|
|
|
u32 orig_ports_available;
|
|
|
|
u32 ports_available = asus->driver->quirks->xusb2pr;
|
|
|
|
|
|
|
|
xhci_pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
|
|
|
|
PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI,
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
if (!xhci_pdev)
|
|
|
|
return;
|
|
|
|
|
|
|
|
pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
|
|
|
|
&orig_ports_available);
|
|
|
|
|
|
|
|
pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
|
|
|
|
cpu_to_le32(ports_available));
|
|
|
|
|
|
|
|
pr_info("set USB_INTEL_XUSB2PR old: 0x%04x, new: 0x%04x\n",
|
|
|
|
orig_ports_available, ports_available);
|
|
|
|
}
|
|
|
|
|
2017-04-28 22:19:49 +08:00
|
|
|
/*
|
|
|
|
* Some devices dont support or have borcken get_als method
|
|
|
|
* but still support set method.
|
|
|
|
*/
|
|
|
|
static void asus_wmi_set_als(void)
|
|
|
|
{
|
|
|
|
asus_wmi_set_devstate(ASUS_WMI_DEVID_ALS_ENABLE, 1, NULL);
|
|
|
|
}
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* Hwmon device ***************************************************************/
|
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
static int asus_agfn_fan_speed_read(struct asus_wmi *asus, int fan,
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
int *speed)
|
|
|
|
{
|
2019-07-29 16:27:37 +08:00
|
|
|
struct agfn_fan_args args = {
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
.agfn.len = sizeof(args),
|
|
|
|
.agfn.mfun = ASUS_FAN_MFUN,
|
|
|
|
.agfn.sfun = ASUS_FAN_SFUN_READ,
|
|
|
|
.fan = fan,
|
|
|
|
.speed = 0,
|
|
|
|
};
|
|
|
|
struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
|
|
|
|
int status;
|
|
|
|
|
|
|
|
if (fan != 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
status = asus_wmi_evaluate_method_agfn(input);
|
|
|
|
|
|
|
|
if (status || args.agfn.err)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
if (speed)
|
|
|
|
*speed = args.speed;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
static int asus_agfn_fan_speed_write(struct asus_wmi *asus, int fan,
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
int *speed)
|
|
|
|
{
|
2019-07-29 16:27:37 +08:00
|
|
|
struct agfn_fan_args args = {
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
.agfn.len = sizeof(args),
|
|
|
|
.agfn.mfun = ASUS_FAN_MFUN,
|
|
|
|
.agfn.sfun = ASUS_FAN_SFUN_WRITE,
|
|
|
|
.fan = fan,
|
|
|
|
.speed = speed ? *speed : 0,
|
|
|
|
};
|
|
|
|
struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
|
|
|
|
int status;
|
|
|
|
|
|
|
|
/* 1: for setting 1st fan's speed 0: setting auto mode */
|
|
|
|
if (fan != 1 && fan != 0)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
status = asus_wmi_evaluate_method_agfn(input);
|
|
|
|
|
|
|
|
if (status || args.agfn.err)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
if (speed && fan == 1)
|
2019-07-29 16:27:37 +08:00
|
|
|
asus->agfn_pwm = *speed;
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Check if we can read the speed of one fan. If true we assume we can also
|
|
|
|
* control it.
|
|
|
|
*/
|
2019-07-29 16:27:37 +08:00
|
|
|
static bool asus_wmi_has_agfn_fan(struct asus_wmi *asus)
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
{
|
|
|
|
int status;
|
2019-07-29 16:27:37 +08:00
|
|
|
int speed;
|
|
|
|
u32 value;
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
status = asus_agfn_fan_speed_read(asus, 1, &speed);
|
|
|
|
if (status != 0)
|
|
|
|
return false;
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
status = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
|
|
|
|
if (status != 0)
|
|
|
|
return false;
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
/*
|
|
|
|
* We need to find a better way, probably using sfun,
|
|
|
|
* bits or spec ...
|
|
|
|
* Currently we disable it if:
|
|
|
|
* - ASUS_WMI_UNSUPPORTED_METHOD is returned
|
|
|
|
* - reverved bits are non-zero
|
|
|
|
* - sfun and presence bit are not set
|
|
|
|
*/
|
|
|
|
return !(value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
|
|
|
|
|| (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)));
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
}
|
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
static int asus_fan_set_auto(struct asus_wmi *asus)
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
{
|
|
|
|
int status;
|
2019-07-29 16:27:39 +08:00
|
|
|
u32 retval;
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
2019-07-29 16:27:39 +08:00
|
|
|
switch (asus->fan_type) {
|
|
|
|
case FAN_TYPE_SPEC83:
|
|
|
|
status = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
|
|
|
|
0, &retval);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
|
|
|
|
if (retval != 1)
|
|
|
|
return -EIO;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case FAN_TYPE_AGFN:
|
|
|
|
status = asus_agfn_fan_speed_write(asus, 0, NULL);
|
|
|
|
if (status)
|
|
|
|
return -ENXIO;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
return -ENXIO;
|
2019-07-29 16:27:39 +08:00
|
|
|
}
|
|
|
|
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
static ssize_t pwm1_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
2011-02-26 17:20:42 +08:00
|
|
|
{
|
|
|
|
struct asus_wmi *asus = dev_get_drvdata(dev);
|
|
|
|
int err;
|
2019-07-29 16:27:37 +08:00
|
|
|
int value;
|
2011-02-26 17:20:42 +08:00
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
/* If we already set a value then just return it */
|
|
|
|
if (asus->agfn_pwm >= 0)
|
|
|
|
return sprintf(buf, "%d\n", asus->agfn_pwm);
|
2011-02-26 17:20:42 +08:00
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
/*
|
|
|
|
* If we haven't set already set a value through the AGFN interface,
|
|
|
|
* we read a current value through the (now-deprecated) FAN_CTRL device.
|
|
|
|
*/
|
|
|
|
err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
|
2011-02-26 17:20:42 +08:00
|
|
|
if (err < 0)
|
2019-07-29 16:27:37 +08:00
|
|
|
return err;
|
2011-02-26 17:20:42 +08:00
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
value &= 0xFF;
|
|
|
|
|
|
|
|
if (value == 1) /* Low Speed */
|
|
|
|
value = 85;
|
|
|
|
else if (value == 2)
|
|
|
|
value = 170;
|
|
|
|
else if (value == 3)
|
|
|
|
value = 255;
|
|
|
|
else if (value) {
|
|
|
|
pr_err("Unknown fan speed %#x\n", value);
|
|
|
|
value = -1;
|
2011-02-26 17:20:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", value);
|
|
|
|
}
|
|
|
|
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
static ssize_t pwm1_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count) {
|
|
|
|
struct asus_wmi *asus = dev_get_drvdata(dev);
|
|
|
|
int value;
|
|
|
|
int state;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = kstrtouint(buf, 10, &value);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
value = clamp(value, 0, 255);
|
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
state = asus_agfn_fan_speed_write(asus, 1, &value);
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
if (state)
|
|
|
|
pr_warn("Setting fan speed failed: %d\n", state);
|
|
|
|
else
|
2019-07-29 16:27:37 +08:00
|
|
|
asus->fan_pwm_mode = ASUS_FAN_CTRL_MANUAL;
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t fan1_input_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
2019-07-29 16:27:37 +08:00
|
|
|
struct asus_wmi *asus = dev_get_drvdata(dev);
|
|
|
|
int value;
|
|
|
|
int ret;
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
2019-07-29 16:27:39 +08:00
|
|
|
switch (asus->fan_type) {
|
|
|
|
case FAN_TYPE_SPEC83:
|
|
|
|
ret = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL,
|
|
|
|
&value);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
2019-07-29 16:27:37 +08:00
|
|
|
|
2019-07-29 16:27:39 +08:00
|
|
|
value &= 0xffff;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case FAN_TYPE_AGFN:
|
|
|
|
/* no speed readable on manual mode */
|
|
|
|
if (asus->fan_pwm_mode == ASUS_FAN_CTRL_MANUAL)
|
|
|
|
return -ENXIO;
|
|
|
|
|
|
|
|
ret = asus_agfn_fan_speed_read(asus, 1, &value);
|
|
|
|
if (ret) {
|
|
|
|
pr_warn("reading fan speed failed: %d\n", ret);
|
|
|
|
return -ENXIO;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
2019-07-29 16:27:37 +08:00
|
|
|
return -ENXIO;
|
|
|
|
}
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
return sprintf(buf, "%d\n", value < 0 ? -1 : value*100);
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t pwm1_enable_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct asus_wmi *asus = dev_get_drvdata(dev);
|
|
|
|
|
2019-07-29 16:27:39 +08:00
|
|
|
/*
|
|
|
|
* Just read back the cached pwm mode.
|
|
|
|
*
|
|
|
|
* For the CPU_FAN device, the spec indicates that we should be
|
|
|
|
* able to read the device status and consult bit 19 to see if we
|
|
|
|
* are in Full On or Automatic mode. However, this does not work
|
|
|
|
* in practice on X532FL at least (the bit is always 0) and there's
|
|
|
|
* also nothing in the DSDT to indicate that this behaviour exists.
|
|
|
|
*/
|
2019-07-29 16:27:37 +08:00
|
|
|
return sprintf(buf, "%d\n", asus->fan_pwm_mode);
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t pwm1_enable_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct asus_wmi *asus = dev_get_drvdata(dev);
|
|
|
|
int status = 0;
|
|
|
|
int state;
|
2019-07-29 16:27:39 +08:00
|
|
|
int value;
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
int ret;
|
2019-07-29 16:27:39 +08:00
|
|
|
u32 retval;
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
|
|
|
ret = kstrtouint(buf, 10, &state);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
2019-07-29 16:27:39 +08:00
|
|
|
if (asus->fan_type == FAN_TYPE_SPEC83) {
|
|
|
|
switch (state) { /* standard documented hwmon values */
|
|
|
|
case ASUS_FAN_CTRL_FULLSPEED:
|
|
|
|
value = 1;
|
|
|
|
break;
|
|
|
|
case ASUS_FAN_CTRL_AUTO:
|
|
|
|
value = 0;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
2019-07-29 16:27:39 +08:00
|
|
|
ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
|
|
|
|
value, &retval);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
if (retval != 1)
|
|
|
|
return -EIO;
|
|
|
|
} else if (asus->fan_type == FAN_TYPE_AGFN) {
|
|
|
|
switch (state) {
|
|
|
|
case ASUS_FAN_CTRL_MANUAL:
|
|
|
|
break;
|
|
|
|
|
|
|
|
case ASUS_FAN_CTRL_AUTO:
|
|
|
|
status = asus_fan_set_auto(asus);
|
|
|
|
if (status)
|
|
|
|
return status;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
2019-07-29 16:27:37 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
asus->fan_pwm_mode = state;
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t fan1_label_show(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
return sprintf(buf, "%s\n", ASUS_FAN_DESC);
|
|
|
|
}
|
|
|
|
|
2011-07-01 17:34:36 +08:00
|
|
|
static ssize_t asus_hwmon_temp1(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
char *buf)
|
|
|
|
{
|
|
|
|
struct asus_wmi *asus = dev_get_drvdata(dev);
|
|
|
|
u32 value;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_THERMAL_CTRL, &value);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
2015-10-02 05:45:31 +08:00
|
|
|
value = DECI_KELVIN_TO_CELSIUS((value & 0xFFFF)) * 1000;
|
2011-07-01 17:34:36 +08:00
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", value);
|
|
|
|
}
|
|
|
|
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
/* Fan1 */
|
|
|
|
static DEVICE_ATTR_RW(pwm1);
|
|
|
|
static DEVICE_ATTR_RW(pwm1_enable);
|
|
|
|
static DEVICE_ATTR_RO(fan1_input);
|
|
|
|
static DEVICE_ATTR_RO(fan1_label);
|
|
|
|
|
|
|
|
/* Temperature */
|
2013-11-24 03:03:17 +08:00
|
|
|
static DEVICE_ATTR(temp1_input, S_IRUGO, asus_hwmon_temp1, NULL);
|
2011-02-26 17:20:42 +08:00
|
|
|
|
|
|
|
static struct attribute *hwmon_attributes[] = {
|
2013-11-24 03:03:17 +08:00
|
|
|
&dev_attr_pwm1.attr,
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
&dev_attr_pwm1_enable.attr,
|
|
|
|
&dev_attr_fan1_input.attr,
|
|
|
|
&dev_attr_fan1_label.attr,
|
|
|
|
|
2013-11-24 03:03:17 +08:00
|
|
|
&dev_attr_temp1_input.attr,
|
2011-02-26 17:20:42 +08:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2011-07-24 11:11:19 +08:00
|
|
|
static umode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
|
2011-07-01 17:34:37 +08:00
|
|
|
struct attribute *attr, int idx)
|
2011-02-26 17:20:42 +08:00
|
|
|
{
|
|
|
|
struct device *dev = container_of(kobj, struct device, kobj);
|
2019-07-01 11:24:26 +08:00
|
|
|
struct asus_wmi *asus = dev_get_drvdata(dev->parent);
|
2011-02-26 17:20:42 +08:00
|
|
|
u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
2019-07-29 16:27:39 +08:00
|
|
|
if (attr == &dev_attr_pwm1.attr) {
|
|
|
|
if (asus->fan_type != FAN_TYPE_AGFN)
|
|
|
|
return 0;
|
|
|
|
} else if (attr == &dev_attr_fan1_input.attr
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|| attr == &dev_attr_fan1_label.attr
|
|
|
|
|| attr == &dev_attr_pwm1_enable.attr) {
|
2019-07-29 16:27:37 +08:00
|
|
|
if (asus->fan_type == FAN_TYPE_NONE)
|
|
|
|
return 0;
|
|
|
|
} else if (attr == &dev_attr_temp1_input.attr) {
|
|
|
|
int err = asus_wmi_get_devstate(asus,
|
|
|
|
ASUS_WMI_DEVID_THERMAL_CTRL,
|
|
|
|
&value);
|
2011-02-26 17:20:42 +08:00
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
if (err < 0)
|
2011-07-24 08:59:40 +08:00
|
|
|
return 0; /* can't return negative here */
|
2011-02-26 17:20:42 +08:00
|
|
|
|
2019-05-15 03:05:46 +08:00
|
|
|
/*
|
|
|
|
* If the temperature value in deci-Kelvin is near the absolute
|
|
|
|
* zero temperature, something is clearly wrong
|
|
|
|
*/
|
|
|
|
if (value == 0 || value == 1)
|
2019-07-29 16:27:37 +08:00
|
|
|
return 0;
|
2011-02-26 17:20:42 +08:00
|
|
|
}
|
|
|
|
|
2019-07-29 16:27:37 +08:00
|
|
|
return attr->mode;
|
2011-02-26 17:20:42 +08:00
|
|
|
}
|
|
|
|
|
2017-07-11 18:48:19 +08:00
|
|
|
static const struct attribute_group hwmon_attribute_group = {
|
2011-02-26 17:20:42 +08:00
|
|
|
.is_visible = asus_hwmon_sysfs_is_visible,
|
|
|
|
.attrs = hwmon_attributes
|
|
|
|
};
|
2013-11-24 03:03:17 +08:00
|
|
|
__ATTRIBUTE_GROUPS(hwmon_attribute);
|
2011-02-26 17:20:42 +08:00
|
|
|
|
|
|
|
static int asus_wmi_hwmon_init(struct asus_wmi *asus)
|
|
|
|
{
|
2019-05-15 02:50:30 +08:00
|
|
|
struct device *dev = &asus->platform_device->dev;
|
2011-02-26 17:20:42 +08:00
|
|
|
struct device *hwmon;
|
|
|
|
|
2019-05-15 02:50:30 +08:00
|
|
|
hwmon = devm_hwmon_device_register_with_groups(dev, "asus", asus,
|
|
|
|
hwmon_attribute_groups);
|
|
|
|
|
2011-02-26 17:20:42 +08:00
|
|
|
if (IS_ERR(hwmon)) {
|
|
|
|
pr_err("Could not register asus hwmon device\n");
|
|
|
|
return PTR_ERR(hwmon);
|
|
|
|
}
|
2013-11-24 03:03:17 +08:00
|
|
|
return 0;
|
2011-02-26 17:20:42 +08:00
|
|
|
}
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
static int asus_wmi_fan_init(struct asus_wmi *asus)
|
|
|
|
{
|
2019-07-29 16:27:37 +08:00
|
|
|
asus->fan_type = FAN_TYPE_NONE;
|
|
|
|
asus->agfn_pwm = -1;
|
2019-05-15 03:04:48 +08:00
|
|
|
|
2019-07-29 16:27:39 +08:00
|
|
|
if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL))
|
|
|
|
asus->fan_type = FAN_TYPE_SPEC83;
|
|
|
|
else if (asus_wmi_has_agfn_fan(asus))
|
2019-07-29 16:27:37 +08:00
|
|
|
asus->fan_type = FAN_TYPE_AGFN;
|
2019-05-15 03:04:48 +08:00
|
|
|
|
2019-07-29 16:27:39 +08:00
|
|
|
if (asus->fan_type == FAN_TYPE_NONE)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
asus_fan_set_auto(asus);
|
|
|
|
asus->fan_pwm_mode = ASUS_FAN_CTRL_AUTO;
|
|
|
|
return 0;
|
2019-05-15 03:04:48 +08:00
|
|
|
}
|
|
|
|
|
2019-05-15 03:07:05 +08:00
|
|
|
/* Fan mode *******************************************************************/
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
static int fan_boost_mode_check_present(struct asus_wmi *asus)
|
2019-05-15 03:07:05 +08:00
|
|
|
{
|
|
|
|
u32 result;
|
|
|
|
int err;
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
asus->fan_boost_mode_available = false;
|
2019-05-15 03:07:05 +08:00
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_BOOST_MODE,
|
|
|
|
&result);
|
2019-05-15 03:07:05 +08:00
|
|
|
if (err) {
|
|
|
|
if (err == -ENODEV)
|
|
|
|
return 0;
|
|
|
|
else
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
|
2019-07-17 13:10:58 +08:00
|
|
|
(result & ASUS_FAN_BOOST_MODES_MASK)) {
|
|
|
|
asus->fan_boost_mode_available = true;
|
|
|
|
asus->fan_boost_mode_mask = result & ASUS_FAN_BOOST_MODES_MASK;
|
2019-05-15 03:07:05 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
static int fan_boost_mode_write(struct asus_wmi *asus)
|
2019-05-15 03:07:05 +08:00
|
|
|
{
|
|
|
|
int err;
|
|
|
|
u8 value;
|
|
|
|
u32 retval;
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
value = asus->fan_boost_mode;
|
2019-05-15 03:07:05 +08:00
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
pr_info("Set fan boost mode: %u\n", value);
|
|
|
|
err = asus_wmi_set_devstate(ASUS_WMI_DEVID_FAN_BOOST_MODE, value,
|
|
|
|
&retval);
|
2019-05-15 03:07:05 +08:00
|
|
|
if (err) {
|
2019-07-17 13:10:58 +08:00
|
|
|
pr_warn("Failed to set fan boost mode: %d\n", err);
|
2019-05-15 03:07:05 +08:00
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (retval != 1) {
|
2019-07-17 13:10:58 +08:00
|
|
|
pr_warn("Failed to set fan boost mode (retval): 0x%x\n",
|
|
|
|
retval);
|
2019-05-15 03:07:05 +08:00
|
|
|
return -EIO;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
static int fan_boost_mode_switch_next(struct asus_wmi *asus)
|
2019-05-15 03:07:05 +08:00
|
|
|
{
|
2019-07-17 13:10:58 +08:00
|
|
|
u8 mask = asus->fan_boost_mode_mask;
|
|
|
|
|
|
|
|
if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_NORMAL) {
|
|
|
|
if (mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK)
|
|
|
|
asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_OVERBOOST;
|
|
|
|
else if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
|
|
|
|
asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
|
|
|
|
} else if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
|
|
|
|
if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
|
|
|
|
asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
|
2019-05-15 03:07:05 +08:00
|
|
|
else
|
2019-07-17 13:10:58 +08:00
|
|
|
asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
|
2019-05-15 03:07:05 +08:00
|
|
|
} else {
|
2019-07-17 13:10:58 +08:00
|
|
|
asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
|
2019-05-15 03:07:05 +08:00
|
|
|
}
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
return fan_boost_mode_write(asus);
|
2019-05-15 03:07:05 +08:00
|
|
|
}
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
static ssize_t fan_boost_mode_show(struct device *dev,
|
|
|
|
struct device_attribute *attr, char *buf)
|
2019-05-15 03:07:05 +08:00
|
|
|
{
|
|
|
|
struct asus_wmi *asus = dev_get_drvdata(dev);
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", asus->fan_boost_mode);
|
2019-05-15 03:07:05 +08:00
|
|
|
}
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
static ssize_t fan_boost_mode_store(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
2019-05-15 03:07:05 +08:00
|
|
|
{
|
|
|
|
int result;
|
|
|
|
u8 new_mode;
|
|
|
|
struct asus_wmi *asus = dev_get_drvdata(dev);
|
2019-07-17 13:10:58 +08:00
|
|
|
u8 mask = asus->fan_boost_mode_mask;
|
2019-05-15 03:07:05 +08:00
|
|
|
|
|
|
|
result = kstrtou8(buf, 10, &new_mode);
|
|
|
|
if (result < 0) {
|
|
|
|
pr_warn("Trying to store invalid value\n");
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
if (new_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
|
|
|
|
if (!(mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK))
|
2019-05-15 03:07:05 +08:00
|
|
|
return -EINVAL;
|
2019-07-17 13:10:58 +08:00
|
|
|
} else if (new_mode == ASUS_FAN_BOOST_MODE_SILENT) {
|
|
|
|
if (!(mask & ASUS_FAN_BOOST_MODE_SILENT_MASK))
|
2019-05-15 03:07:05 +08:00
|
|
|
return -EINVAL;
|
2019-07-17 13:10:58 +08:00
|
|
|
} else if (new_mode != ASUS_FAN_BOOST_MODE_NORMAL) {
|
2019-05-15 03:07:05 +08:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
asus->fan_boost_mode = new_mode;
|
|
|
|
fan_boost_mode_write(asus);
|
2019-05-15 03:07:05 +08:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
// Fan boost mode: 0 - normal, 1 - overboost, 2 - silent
|
|
|
|
static DEVICE_ATTR_RW(fan_boost_mode);
|
2019-05-15 03:07:05 +08:00
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* Backlight ******************************************************************/
|
|
|
|
|
2011-02-26 17:20:36 +08:00
|
|
|
static int read_backlight_power(struct asus_wmi *asus)
|
2011-02-06 20:28:39 +08:00
|
|
|
{
|
asus-wmi: store backlight power status for AIO machine
Due to some implementation reasons, ASUS ET2012 All-in-One machines
can't report the correct backlight power status, it will always return
1. To track the backlight power status correctly, we have to store the
status by ourselves.
BTW, by the BIOS design, the backlight power will be turn on/off
sequently, no matter what the value of the parameter will be.
More over, the brightness adjustment command will turn on the backlight
power. Those behaviors will make us fail to track the backlight power
status.
For example, While we are trying to turn on the backlight power,
we will send out the brightness adjustment command and then trying to
figure out if we have to turn on the backlight power, then send out
the command. But, the real case is that, the backlight power turns on
while sending the brightness adjustment command, and then we send out
the command to turn on the backlight power, it actually will turn off
the backlight power and the backlight power status we recorded becomes
wrong. So, we have to seperate these two commands by a if statement.
Signed-off-by: AceLan Kao <acelan.kao@canonical.com>
Signed-off-by: Corentin Chary <corentin.chary@gmail.com>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2012-03-20 16:53:09 +08:00
|
|
|
int ret;
|
2019-08-16 19:17:34 +08:00
|
|
|
|
asus-wmi: store backlight power status for AIO machine
Due to some implementation reasons, ASUS ET2012 All-in-One machines
can't report the correct backlight power status, it will always return
1. To track the backlight power status correctly, we have to store the
status by ourselves.
BTW, by the BIOS design, the backlight power will be turn on/off
sequently, no matter what the value of the parameter will be.
More over, the brightness adjustment command will turn on the backlight
power. Those behaviors will make us fail to track the backlight power
status.
For example, While we are trying to turn on the backlight power,
we will send out the brightness adjustment command and then trying to
figure out if we have to turn on the backlight power, then send out
the command. But, the real case is that, the backlight power turns on
while sending the brightness adjustment command, and then we send out
the command to turn on the backlight power, it actually will turn off
the backlight power and the backlight power status we recorded becomes
wrong. So, we have to seperate these two commands by a if statement.
Signed-off-by: AceLan Kao <acelan.kao@canonical.com>
Signed-off-by: Corentin Chary <corentin.chary@gmail.com>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2012-03-20 16:53:09 +08:00
|
|
|
if (asus->driver->quirks->store_backlight_power)
|
|
|
|
ret = !asus->driver->panel_power;
|
|
|
|
else
|
|
|
|
ret = asus_wmi_get_devstate_simple(asus,
|
|
|
|
ASUS_WMI_DEVID_BACKLIGHT);
|
2011-02-06 20:28:39 +08:00
|
|
|
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:37 +08:00
|
|
|
static int read_brightness_max(struct asus_wmi *asus)
|
2010-04-11 09:27:54 +08:00
|
|
|
{
|
2010-11-29 15:14:12 +08:00
|
|
|
u32 retval;
|
2011-02-26 17:20:35 +08:00
|
|
|
int err;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
2011-02-26 17:20:36 +08:00
|
|
|
err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
|
2011-02-26 17:20:37 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
|
|
|
|
retval >>= 8;
|
|
|
|
|
|
|
|
if (!retval)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int read_brightness(struct backlight_device *bd)
|
|
|
|
{
|
|
|
|
struct asus_wmi *asus = bl_get_data(bd);
|
2011-03-15 15:06:23 +08:00
|
|
|
u32 retval;
|
|
|
|
int err;
|
2011-02-26 17:20:37 +08:00
|
|
|
|
|
|
|
err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
|
2011-02-26 17:20:35 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
|
2010-04-11 09:27:54 +08:00
|
|
|
}
|
|
|
|
|
2012-03-20 16:53:08 +08:00
|
|
|
static u32 get_scalar_command(struct backlight_device *bd)
|
2010-04-11 09:27:54 +08:00
|
|
|
{
|
2011-02-26 17:20:36 +08:00
|
|
|
struct asus_wmi *asus = bl_get_data(bd);
|
2012-03-20 16:53:08 +08:00
|
|
|
u32 ctrl_param = 0;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
2012-03-20 16:53:08 +08:00
|
|
|
if ((asus->driver->brightness < bd->props.brightness) ||
|
|
|
|
bd->props.brightness == bd->props.max_brightness)
|
|
|
|
ctrl_param = 0x00008001;
|
|
|
|
else if ((asus->driver->brightness > bd->props.brightness) ||
|
|
|
|
bd->props.brightness == 0)
|
|
|
|
ctrl_param = 0x00008000;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
2012-03-20 16:53:08 +08:00
|
|
|
asus->driver->brightness = bd->props.brightness;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
2012-03-20 16:53:08 +08:00
|
|
|
return ctrl_param;
|
|
|
|
}
|
|
|
|
|
2010-04-11 09:27:54 +08:00
|
|
|
static int update_bl_status(struct backlight_device *bd)
|
|
|
|
{
|
2011-02-26 17:20:36 +08:00
|
|
|
struct asus_wmi *asus = bl_get_data(bd);
|
2010-11-29 15:14:12 +08:00
|
|
|
u32 ctrl_param;
|
asus-wmi: store backlight power status for AIO machine
Due to some implementation reasons, ASUS ET2012 All-in-One machines
can't report the correct backlight power status, it will always return
1. To track the backlight power status correctly, we have to store the
status by ourselves.
BTW, by the BIOS design, the backlight power will be turn on/off
sequently, no matter what the value of the parameter will be.
More over, the brightness adjustment command will turn on the backlight
power. Those behaviors will make us fail to track the backlight power
status.
For example, While we are trying to turn on the backlight power,
we will send out the brightness adjustment command and then trying to
figure out if we have to turn on the backlight power, then send out
the command. But, the real case is that, the backlight power turns on
while sending the brightness adjustment command, and then we send out
the command to turn on the backlight power, it actually will turn off
the backlight power and the backlight power status we recorded becomes
wrong. So, we have to seperate these two commands by a if statement.
Signed-off-by: AceLan Kao <acelan.kao@canonical.com>
Signed-off-by: Corentin Chary <corentin.chary@gmail.com>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2012-03-20 16:53:09 +08:00
|
|
|
int power, err = 0;
|
2011-02-06 20:28:39 +08:00
|
|
|
|
2011-02-26 17:20:36 +08:00
|
|
|
power = read_backlight_power(asus);
|
2011-02-06 20:28:39 +08:00
|
|
|
if (power != -ENODEV && bd->props.power != power) {
|
|
|
|
ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
|
2011-02-26 17:20:35 +08:00
|
|
|
err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
|
|
|
|
ctrl_param, NULL);
|
asus-wmi: store backlight power status for AIO machine
Due to some implementation reasons, ASUS ET2012 All-in-One machines
can't report the correct backlight power status, it will always return
1. To track the backlight power status correctly, we have to store the
status by ourselves.
BTW, by the BIOS design, the backlight power will be turn on/off
sequently, no matter what the value of the parameter will be.
More over, the brightness adjustment command will turn on the backlight
power. Those behaviors will make us fail to track the backlight power
status.
For example, While we are trying to turn on the backlight power,
we will send out the brightness adjustment command and then trying to
figure out if we have to turn on the backlight power, then send out
the command. But, the real case is that, the backlight power turns on
while sending the brightness adjustment command, and then we send out
the command to turn on the backlight power, it actually will turn off
the backlight power and the backlight power status we recorded becomes
wrong. So, we have to seperate these two commands by a if statement.
Signed-off-by: AceLan Kao <acelan.kao@canonical.com>
Signed-off-by: Corentin Chary <corentin.chary@gmail.com>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2012-03-20 16:53:09 +08:00
|
|
|
if (asus->driver->quirks->store_backlight_power)
|
|
|
|
asus->driver->panel_power = bd->props.power;
|
|
|
|
|
2012-03-20 16:53:14 +08:00
|
|
|
/* When using scalar brightness, updating the brightness
|
|
|
|
* will mess with the backlight power */
|
|
|
|
if (asus->driver->quirks->scalar_panel_brightness)
|
|
|
|
return err;
|
2011-02-06 20:28:39 +08:00
|
|
|
}
|
2012-03-20 16:53:14 +08:00
|
|
|
|
|
|
|
if (asus->driver->quirks->scalar_panel_brightness)
|
|
|
|
ctrl_param = get_scalar_command(bd);
|
|
|
|
else
|
|
|
|
ctrl_param = bd->props.brightness;
|
|
|
|
|
|
|
|
err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
|
|
|
|
ctrl_param, NULL);
|
|
|
|
|
2011-02-26 17:20:37 +08:00
|
|
|
return err;
|
2010-04-11 09:27:54 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static const struct backlight_ops asus_wmi_bl_ops = {
|
2010-04-11 09:27:54 +08:00
|
|
|
.get_brightness = read_brightness,
|
|
|
|
.update_status = update_bl_status,
|
|
|
|
};
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
|
2010-04-11 09:27:54 +08:00
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct backlight_device *bd = asus->backlight_device;
|
2010-04-11 09:27:54 +08:00
|
|
|
int old = bd->props.brightness;
|
2010-05-19 18:37:01 +08:00
|
|
|
int new = old;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
|
|
|
if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
|
|
|
|
new = code - NOTIFY_BRNUP_MIN + 1;
|
|
|
|
else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
|
|
|
|
new = code - NOTIFY_BRNDOWN_MIN;
|
|
|
|
|
|
|
|
bd->props.brightness = new;
|
|
|
|
backlight_update_status(bd);
|
|
|
|
backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
|
|
|
|
|
|
|
|
return old;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_wmi_backlight_init(struct asus_wmi *asus)
|
2010-04-11 09:27:54 +08:00
|
|
|
{
|
|
|
|
struct backlight_device *bd;
|
|
|
|
struct backlight_properties props;
|
2011-02-06 20:28:39 +08:00
|
|
|
int max;
|
|
|
|
int power;
|
|
|
|
|
2011-02-26 17:20:37 +08:00
|
|
|
max = read_brightness_max(asus);
|
2014-07-08 16:47:22 +08:00
|
|
|
if (max < 0)
|
2011-02-26 17:20:37 +08:00
|
|
|
return max;
|
|
|
|
|
|
|
|
power = read_backlight_power(asus);
|
2011-02-06 20:28:39 +08:00
|
|
|
if (power == -ENODEV)
|
|
|
|
power = FB_BLANK_UNBLANK;
|
2011-02-26 17:20:37 +08:00
|
|
|
else if (power < 0)
|
|
|
|
return power;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
|
|
|
memset(&props, 0, sizeof(struct backlight_properties));
|
2011-06-29 11:43:30 +08:00
|
|
|
props.type = BACKLIGHT_PLATFORM;
|
2011-02-06 20:28:39 +08:00
|
|
|
props.max_brightness = max;
|
2011-02-26 17:20:31 +08:00
|
|
|
bd = backlight_device_register(asus->driver->name,
|
|
|
|
&asus->platform_device->dev, asus,
|
|
|
|
&asus_wmi_bl_ops, &props);
|
2010-04-11 09:27:54 +08:00
|
|
|
if (IS_ERR(bd)) {
|
|
|
|
pr_err("Could not register backlight device\n");
|
|
|
|
return PTR_ERR(bd);
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus->backlight_device = bd;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
asus-wmi: store backlight power status for AIO machine
Due to some implementation reasons, ASUS ET2012 All-in-One machines
can't report the correct backlight power status, it will always return
1. To track the backlight power status correctly, we have to store the
status by ourselves.
BTW, by the BIOS design, the backlight power will be turn on/off
sequently, no matter what the value of the parameter will be.
More over, the brightness adjustment command will turn on the backlight
power. Those behaviors will make us fail to track the backlight power
status.
For example, While we are trying to turn on the backlight power,
we will send out the brightness adjustment command and then trying to
figure out if we have to turn on the backlight power, then send out
the command. But, the real case is that, the backlight power turns on
while sending the brightness adjustment command, and then we send out
the command to turn on the backlight power, it actually will turn off
the backlight power and the backlight power status we recorded becomes
wrong. So, we have to seperate these two commands by a if statement.
Signed-off-by: AceLan Kao <acelan.kao@canonical.com>
Signed-off-by: Corentin Chary <corentin.chary@gmail.com>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2012-03-20 16:53:09 +08:00
|
|
|
if (asus->driver->quirks->store_backlight_power)
|
|
|
|
asus->driver->panel_power = power;
|
|
|
|
|
2010-04-11 09:27:54 +08:00
|
|
|
bd->props.brightness = read_brightness(bd);
|
2011-02-06 20:28:39 +08:00
|
|
|
bd->props.power = power;
|
2010-04-11 09:27:54 +08:00
|
|
|
backlight_update_status(bd);
|
|
|
|
|
2012-03-20 16:53:08 +08:00
|
|
|
asus->driver->brightness = bd->props.brightness;
|
|
|
|
|
2010-04-11 09:27:54 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static void asus_wmi_backlight_exit(struct asus_wmi *asus)
|
2010-04-11 09:27:54 +08:00
|
|
|
{
|
2014-11-25 03:30:29 +08:00
|
|
|
backlight_device_unregister(asus->backlight_device);
|
2010-04-11 09:27:54 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus->backlight_device = NULL;
|
2010-04-11 09:27:54 +08:00
|
|
|
}
|
|
|
|
|
asus-wmi: add display toggle quirk
For machines with AMD graphic chips, it will send out WMI event and ACPI
interrupt at the same time while hitting the hotkey. BIOS will notify the
system the next display output mode throught WMI event code, so that
windows' application can show an OSD to tell the user which mode will be
taken effect. User can hit the display toggle key many times within 2
seconds to choose the mode they want. After 2 seconds, WMI dirver should
send a WMIMethod(SDSP) command to tell the BIOS which mode the user chose.
And then BIOS will raise another ACPI interrupt to tell the system to
really switch the display mode.
In Linux desktop, we don't have this kind of OSD to let users to choose
the mode they want, so we don't need to call WMIMethod(SDSP) to have
another ACPI interrupt. To simplify the problem, we just have to ignore
the WMI event, and let the first ACPI interrupt to send out the key event.
For the need, here comes another quirk to add machines with this kind of
behavior. When the WMI driver receives the display toggle WMI event, and
found the machin is in the list, it will do nothing and let ACPI video
driver to report the key event.
Signed-off-by: AceLan Kao <acelan.kao@canonical.com>
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <matthew.garrett@nebula.com>
2012-10-03 17:26:31 +08:00
|
|
|
static int is_display_toggle(int code)
|
|
|
|
{
|
|
|
|
/* display toggle keys */
|
|
|
|
if ((code >= 0x61 && code <= 0x67) ||
|
|
|
|
(code >= 0x8c && code <= 0x93) ||
|
|
|
|
(code >= 0xa0 && code <= 0xa7) ||
|
|
|
|
(code >= 0xd0 && code <= 0xd5))
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* Fn-lock ********************************************************************/
|
|
|
|
|
2019-04-18 14:46:48 +08:00
|
|
|
static bool asus_wmi_has_fnlock_key(struct asus_wmi *asus)
|
|
|
|
{
|
|
|
|
u32 result;
|
|
|
|
|
|
|
|
asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FNLOCK, &result);
|
|
|
|
|
|
|
|
return (result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
|
|
|
|
!(result & ASUS_WMI_FNLOCK_BIOS_DISABLED);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void asus_wmi_fnlock_update(struct asus_wmi *asus)
|
|
|
|
{
|
|
|
|
int mode = asus->fnlock_locked;
|
|
|
|
|
|
|
|
asus_wmi_set_devstate(ASUS_WMI_DEVID_FNLOCK, mode, NULL);
|
|
|
|
}
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* WMI events *****************************************************************/
|
|
|
|
|
2019-05-15 03:01:24 +08:00
|
|
|
static int asus_wmi_get_event_code(u32 value)
|
2010-04-11 09:27:54 +08:00
|
|
|
{
|
|
|
|
struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
union acpi_object *obj;
|
|
|
|
acpi_status status;
|
|
|
|
int code;
|
|
|
|
|
|
|
|
status = wmi_get_event_data(value, &response);
|
2019-05-15 03:01:24 +08:00
|
|
|
if (ACPI_FAILURE(status)) {
|
|
|
|
pr_warn("Failed to get WMI notify code: %s\n",
|
|
|
|
acpi_format_exception(status));
|
|
|
|
return -EIO;
|
2010-04-11 09:27:54 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
obj = (union acpi_object *)response.pointer;
|
|
|
|
|
2019-05-15 03:01:24 +08:00
|
|
|
if (obj && obj->type == ACPI_TYPE_INTEGER)
|
|
|
|
code = (int)(obj->integer.value & WMI_EVENT_MASK);
|
|
|
|
else
|
|
|
|
code = -EIO;
|
|
|
|
|
|
|
|
kfree(obj);
|
|
|
|
return code;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void asus_wmi_handle_event_code(int code, struct asus_wmi *asus)
|
|
|
|
{
|
|
|
|
int orig_code;
|
|
|
|
unsigned int key_value = 1;
|
|
|
|
bool autorelease = 1;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
2011-02-26 17:20:32 +08:00
|
|
|
orig_code = code;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
2011-07-01 17:34:27 +08:00
|
|
|
if (asus->driver->key_filter) {
|
|
|
|
asus->driver->key_filter(asus->driver, &code, &key_value,
|
|
|
|
&autorelease);
|
|
|
|
if (code == ASUS_WMI_KEY_IGNORE)
|
2019-05-15 03:01:24 +08:00
|
|
|
return;
|
2011-07-01 17:34:27 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:32 +08:00
|
|
|
if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
|
2012-11-29 16:12:38 +08:00
|
|
|
code = ASUS_WMI_BRN_UP;
|
2019-05-15 03:01:24 +08:00
|
|
|
else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
|
2012-11-29 16:12:38 +08:00
|
|
|
code = ASUS_WMI_BRN_DOWN;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
2012-11-29 16:12:38 +08:00
|
|
|
if (code == ASUS_WMI_BRN_DOWN || code == ASUS_WMI_BRN_UP) {
|
2015-06-16 22:27:58 +08:00
|
|
|
if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
|
2011-02-26 17:20:32 +08:00
|
|
|
asus_wmi_backlight_notify(asus, orig_code);
|
2019-05-15 03:01:24 +08:00
|
|
|
return;
|
asus-wmi: add display toggle quirk
For machines with AMD graphic chips, it will send out WMI event and ACPI
interrupt at the same time while hitting the hotkey. BIOS will notify the
system the next display output mode throught WMI event code, so that
windows' application can show an OSD to tell the user which mode will be
taken effect. User can hit the display toggle key many times within 2
seconds to choose the mode they want. After 2 seconds, WMI dirver should
send a WMIMethod(SDSP) command to tell the BIOS which mode the user chose.
And then BIOS will raise another ACPI interrupt to tell the system to
really switch the display mode.
In Linux desktop, we don't have this kind of OSD to let users to choose
the mode they want, so we don't need to call WMIMethod(SDSP) to have
another ACPI interrupt. To simplify the problem, we just have to ignore
the WMI event, and let the first ACPI interrupt to send out the key event.
For the need, here comes another quirk to add machines with this kind of
behavior. When the WMI driver receives the display toggle WMI event, and
found the machin is in the list, it will do nothing and let ACPI video
driver to report the key event.
Signed-off-by: AceLan Kao <acelan.kao@canonical.com>
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <matthew.garrett@nebula.com>
2012-10-03 17:26:31 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-06-20 22:46:44 +08:00
|
|
|
if (code == NOTIFY_KBD_BRTUP) {
|
2018-10-22 18:00:04 +08:00
|
|
|
kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
|
2019-05-15 03:01:24 +08:00
|
|
|
return;
|
2018-06-20 22:46:44 +08:00
|
|
|
}
|
|
|
|
if (code == NOTIFY_KBD_BRTDWN) {
|
2018-10-22 18:00:04 +08:00
|
|
|
kbd_led_set_by_kbd(asus, asus->kbd_led_wk - 1);
|
2019-05-15 03:01:24 +08:00
|
|
|
return;
|
2018-06-20 22:46:44 +08:00
|
|
|
}
|
2018-06-20 22:46:45 +08:00
|
|
|
if (code == NOTIFY_KBD_BRTTOGGLE) {
|
|
|
|
if (asus->kbd_led_wk == asus->kbd_led.max_brightness)
|
2018-10-22 18:00:04 +08:00
|
|
|
kbd_led_set_by_kbd(asus, 0);
|
2018-06-20 22:46:45 +08:00
|
|
|
else
|
2018-10-22 18:00:04 +08:00
|
|
|
kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
|
2019-05-15 03:01:24 +08:00
|
|
|
return;
|
2018-06-20 22:46:45 +08:00
|
|
|
}
|
2018-06-20 22:46:44 +08:00
|
|
|
|
2019-04-18 14:46:48 +08:00
|
|
|
if (code == NOTIFY_FNLOCK_TOGGLE) {
|
|
|
|
asus->fnlock_locked = !asus->fnlock_locked;
|
|
|
|
asus_wmi_fnlock_update(asus);
|
2019-05-15 03:01:24 +08:00
|
|
|
return;
|
2019-04-18 14:46:48 +08:00
|
|
|
}
|
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
if (asus->fan_boost_mode_available && code == NOTIFY_KBD_FBM) {
|
|
|
|
fan_boost_mode_switch_next(asus);
|
2019-05-15 03:07:05 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2019-05-15 03:01:24 +08:00
|
|
|
if (is_display_toggle(code) && asus->driver->quirks->no_display_toggle)
|
|
|
|
return;
|
asus-wmi: add display toggle quirk
For machines with AMD graphic chips, it will send out WMI event and ACPI
interrupt at the same time while hitting the hotkey. BIOS will notify the
system the next display output mode throught WMI event code, so that
windows' application can show an OSD to tell the user which mode will be
taken effect. User can hit the display toggle key many times within 2
seconds to choose the mode they want. After 2 seconds, WMI dirver should
send a WMIMethod(SDSP) command to tell the BIOS which mode the user chose.
And then BIOS will raise another ACPI interrupt to tell the system to
really switch the display mode.
In Linux desktop, we don't have this kind of OSD to let users to choose
the mode they want, so we don't need to call WMIMethod(SDSP) to have
another ACPI interrupt. To simplify the problem, we just have to ignore
the WMI event, and let the first ACPI interrupt to send out the key event.
For the need, here comes another quirk to add machines with this kind of
behavior. When the WMI driver receives the display toggle WMI event, and
found the machin is in the list, it will do nothing and let ACPI video
driver to report the key event.
Signed-off-by: AceLan Kao <acelan.kao@canonical.com>
Signed-off-by: Corentin Chary <corentincj@iksaif.net>
Signed-off-by: Matthew Garrett <matthew.garrett@nebula.com>
2012-10-03 17:26:31 +08:00
|
|
|
|
|
|
|
if (!sparse_keymap_report_event(asus->inputdev, code,
|
|
|
|
key_value, autorelease))
|
2011-02-26 17:20:32 +08:00
|
|
|
pr_info("Unknown key %x pressed\n", code);
|
2019-05-15 03:01:24 +08:00
|
|
|
}
|
2010-04-11 09:27:54 +08:00
|
|
|
|
2019-05-15 03:01:24 +08:00
|
|
|
static void asus_wmi_notify(u32 value, void *context)
|
|
|
|
{
|
|
|
|
struct asus_wmi *asus = context;
|
platform/x86: asus-wmi: Support WMI event queue
Event codes are expected to be retrieved from a queue on at least some
models. Specifically, very likely the ACPI WMI devices with _UID ATK are
queued whereas those with ASUSWMI are not [1].
The WMI event codes are pushed into a circular buffer queue. After the INIT
method is called, ACPI code is allowed to push events into this buffer.
The INIT method cannot be reverted. If the module is unloaded and an event
(such as hotkey press) gets emitted before inserting it back the events get
processed delayed by one or if the queue overflows, additionally delayed by
about 3 seconds.
It might be considered a minor issue and no normal user would likely
observe this (there is little reason unloading the driver), but it does
significantly frustrate a developer who is unlucky enough to encounter
this. Therefore, the fallback to unqueued behavior occurs whenever
something unexpected happens.
The fix flushes the old key codes out of the queue on load. After receiving
event the queue is read until either ..FFFF or 1 is encountered. Also as
noted in [1] it is checked whether notify code is equal to 0xFF before
enabling queue processing in WMI notify handler.
DSDT examples:
FX505GM
Device (ATKD)
{ ..
Name (ATKQ, Package (0x10)
{
0xFFFFFFFF, ..
}
Method (IANQ, 1, Serialized)
{
If ((AQNO >= 0x10))
{
Local0 = 0x64
While ((Local0 && (AQNO >= 0x10)))
{
Local0--
Sleep (0x0A)
}
...
..
AQTI++
AQTI &= 0x0F
ATKQ [AQTI] = Arg0
...
}
Method (GANQ, 0, Serialized)
{
..
If (AQNO)
{
...
Local0 = DerefOf (ATKQ [AQHI])
AQHI++
AQHI &= 0x0F
Return (Local0)
}
Return (One)
}
This code is almost identical to K54C, which does return Ones on empty
queue.
K54C:
Method (GANQ, 0, Serialized)
{
If (AQNO)
{
...
Return (Local0)
}
Return (Ones)
}
[1] Link: https://lkml.org/lkml/2019/4/12/104
Signed-off-by: Yurii Pavlovskyi <yurii.pavlovskyi@gmail.com>
Suggested-by: Daniel Drake <drake@endlessm.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2019-05-15 03:02:09 +08:00
|
|
|
int code;
|
|
|
|
int i;
|
2019-05-15 03:01:24 +08:00
|
|
|
|
platform/x86: asus-wmi: Support WMI event queue
Event codes are expected to be retrieved from a queue on at least some
models. Specifically, very likely the ACPI WMI devices with _UID ATK are
queued whereas those with ASUSWMI are not [1].
The WMI event codes are pushed into a circular buffer queue. After the INIT
method is called, ACPI code is allowed to push events into this buffer.
The INIT method cannot be reverted. If the module is unloaded and an event
(such as hotkey press) gets emitted before inserting it back the events get
processed delayed by one or if the queue overflows, additionally delayed by
about 3 seconds.
It might be considered a minor issue and no normal user would likely
observe this (there is little reason unloading the driver), but it does
significantly frustrate a developer who is unlucky enough to encounter
this. Therefore, the fallback to unqueued behavior occurs whenever
something unexpected happens.
The fix flushes the old key codes out of the queue on load. After receiving
event the queue is read until either ..FFFF or 1 is encountered. Also as
noted in [1] it is checked whether notify code is equal to 0xFF before
enabling queue processing in WMI notify handler.
DSDT examples:
FX505GM
Device (ATKD)
{ ..
Name (ATKQ, Package (0x10)
{
0xFFFFFFFF, ..
}
Method (IANQ, 1, Serialized)
{
If ((AQNO >= 0x10))
{
Local0 = 0x64
While ((Local0 && (AQNO >= 0x10)))
{
Local0--
Sleep (0x0A)
}
...
..
AQTI++
AQTI &= 0x0F
ATKQ [AQTI] = Arg0
...
}
Method (GANQ, 0, Serialized)
{
..
If (AQNO)
{
...
Local0 = DerefOf (ATKQ [AQHI])
AQHI++
AQHI &= 0x0F
Return (Local0)
}
Return (One)
}
This code is almost identical to K54C, which does return Ones on empty
queue.
K54C:
Method (GANQ, 0, Serialized)
{
If (AQNO)
{
...
Return (Local0)
}
Return (Ones)
}
[1] Link: https://lkml.org/lkml/2019/4/12/104
Signed-off-by: Yurii Pavlovskyi <yurii.pavlovskyi@gmail.com>
Suggested-by: Daniel Drake <drake@endlessm.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2019-05-15 03:02:09 +08:00
|
|
|
for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) {
|
|
|
|
code = asus_wmi_get_event_code(value);
|
|
|
|
if (code < 0) {
|
|
|
|
pr_warn("Failed to get notify code: %d\n", code);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK)
|
|
|
|
return;
|
|
|
|
|
|
|
|
asus_wmi_handle_event_code(code, asus);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Double check that queue is present:
|
|
|
|
* ATK (with queue) uses 0xff, ASUSWMI (without) 0xd2.
|
|
|
|
*/
|
|
|
|
if (!asus->wmi_event_queue || value != WMI_EVENT_VALUE_ATK)
|
|
|
|
return;
|
2019-05-15 03:01:24 +08:00
|
|
|
}
|
|
|
|
|
platform/x86: asus-wmi: Support WMI event queue
Event codes are expected to be retrieved from a queue on at least some
models. Specifically, very likely the ACPI WMI devices with _UID ATK are
queued whereas those with ASUSWMI are not [1].
The WMI event codes are pushed into a circular buffer queue. After the INIT
method is called, ACPI code is allowed to push events into this buffer.
The INIT method cannot be reverted. If the module is unloaded and an event
(such as hotkey press) gets emitted before inserting it back the events get
processed delayed by one or if the queue overflows, additionally delayed by
about 3 seconds.
It might be considered a minor issue and no normal user would likely
observe this (there is little reason unloading the driver), but it does
significantly frustrate a developer who is unlucky enough to encounter
this. Therefore, the fallback to unqueued behavior occurs whenever
something unexpected happens.
The fix flushes the old key codes out of the queue on load. After receiving
event the queue is read until either ..FFFF or 1 is encountered. Also as
noted in [1] it is checked whether notify code is equal to 0xFF before
enabling queue processing in WMI notify handler.
DSDT examples:
FX505GM
Device (ATKD)
{ ..
Name (ATKQ, Package (0x10)
{
0xFFFFFFFF, ..
}
Method (IANQ, 1, Serialized)
{
If ((AQNO >= 0x10))
{
Local0 = 0x64
While ((Local0 && (AQNO >= 0x10)))
{
Local0--
Sleep (0x0A)
}
...
..
AQTI++
AQTI &= 0x0F
ATKQ [AQTI] = Arg0
...
}
Method (GANQ, 0, Serialized)
{
..
If (AQNO)
{
...
Local0 = DerefOf (ATKQ [AQHI])
AQHI++
AQHI &= 0x0F
Return (Local0)
}
Return (One)
}
This code is almost identical to K54C, which does return Ones on empty
queue.
K54C:
Method (GANQ, 0, Serialized)
{
If (AQNO)
{
...
Return (Local0)
}
Return (Ones)
}
[1] Link: https://lkml.org/lkml/2019/4/12/104
Signed-off-by: Yurii Pavlovskyi <yurii.pavlovskyi@gmail.com>
Suggested-by: Daniel Drake <drake@endlessm.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2019-05-15 03:02:09 +08:00
|
|
|
pr_warn("Failed to process event queue, last code: 0x%x\n", code);
|
2010-04-11 09:27:54 +08:00
|
|
|
}
|
|
|
|
|
platform/x86: asus-wmi: Support WMI event queue
Event codes are expected to be retrieved from a queue on at least some
models. Specifically, very likely the ACPI WMI devices with _UID ATK are
queued whereas those with ASUSWMI are not [1].
The WMI event codes are pushed into a circular buffer queue. After the INIT
method is called, ACPI code is allowed to push events into this buffer.
The INIT method cannot be reverted. If the module is unloaded and an event
(such as hotkey press) gets emitted before inserting it back the events get
processed delayed by one or if the queue overflows, additionally delayed by
about 3 seconds.
It might be considered a minor issue and no normal user would likely
observe this (there is little reason unloading the driver), but it does
significantly frustrate a developer who is unlucky enough to encounter
this. Therefore, the fallback to unqueued behavior occurs whenever
something unexpected happens.
The fix flushes the old key codes out of the queue on load. After receiving
event the queue is read until either ..FFFF or 1 is encountered. Also as
noted in [1] it is checked whether notify code is equal to 0xFF before
enabling queue processing in WMI notify handler.
DSDT examples:
FX505GM
Device (ATKD)
{ ..
Name (ATKQ, Package (0x10)
{
0xFFFFFFFF, ..
}
Method (IANQ, 1, Serialized)
{
If ((AQNO >= 0x10))
{
Local0 = 0x64
While ((Local0 && (AQNO >= 0x10)))
{
Local0--
Sleep (0x0A)
}
...
..
AQTI++
AQTI &= 0x0F
ATKQ [AQTI] = Arg0
...
}
Method (GANQ, 0, Serialized)
{
..
If (AQNO)
{
...
Local0 = DerefOf (ATKQ [AQHI])
AQHI++
AQHI &= 0x0F
Return (Local0)
}
Return (One)
}
This code is almost identical to K54C, which does return Ones on empty
queue.
K54C:
Method (GANQ, 0, Serialized)
{
If (AQNO)
{
...
Return (Local0)
}
Return (Ones)
}
[1] Link: https://lkml.org/lkml/2019/4/12/104
Signed-off-by: Yurii Pavlovskyi <yurii.pavlovskyi@gmail.com>
Suggested-by: Daniel Drake <drake@endlessm.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2019-05-15 03:02:09 +08:00
|
|
|
static int asus_wmi_notify_queue_flush(struct asus_wmi *asus)
|
|
|
|
{
|
|
|
|
int code;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) {
|
|
|
|
code = asus_wmi_get_event_code(WMI_EVENT_VALUE_ATK);
|
|
|
|
if (code < 0) {
|
|
|
|
pr_warn("Failed to get event during flush: %d\n", code);
|
|
|
|
return code;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
pr_warn("Failed to flush event queue\n");
|
|
|
|
return -EIO;
|
2010-04-11 09:27:54 +08:00
|
|
|
}
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* Sysfs **********************************************************************/
|
|
|
|
|
2011-02-26 17:20:36 +08:00
|
|
|
static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
|
|
|
|
const char *buf, size_t count)
|
2011-02-06 20:28:36 +08:00
|
|
|
{
|
|
|
|
u32 retval;
|
2019-08-16 19:15:55 +08:00
|
|
|
int err, value;
|
2011-02-06 20:28:36 +08:00
|
|
|
|
2011-02-26 17:20:36 +08:00
|
|
|
value = asus_wmi_get_devstate_simple(asus, devid);
|
2015-11-11 06:18:16 +08:00
|
|
|
if (value < 0)
|
2011-02-06 20:28:36 +08:00
|
|
|
return value;
|
|
|
|
|
2019-08-16 19:15:55 +08:00
|
|
|
err = kstrtoint(buf, 0, &value);
|
|
|
|
if (err)
|
|
|
|
return err;
|
2011-02-26 17:20:35 +08:00
|
|
|
|
2019-08-16 19:15:55 +08:00
|
|
|
err = asus_wmi_set_devstate(devid, value, &retval);
|
2011-02-26 17:20:35 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2011-02-06 20:28:36 +08:00
|
|
|
|
2019-08-16 19:15:55 +08:00
|
|
|
return count;
|
2011-02-06 20:28:36 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:36 +08:00
|
|
|
static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
|
2011-02-06 20:28:36 +08:00
|
|
|
{
|
2011-02-26 17:20:36 +08:00
|
|
|
int value = asus_wmi_get_devstate_simple(asus, devid);
|
2011-02-06 20:28:36 +08:00
|
|
|
|
|
|
|
if (value < 0)
|
|
|
|
return value;
|
|
|
|
|
|
|
|
return sprintf(buf, "%d\n", value);
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
#define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
|
2011-02-06 20:28:36 +08:00
|
|
|
static ssize_t show_##_name(struct device *dev, \
|
|
|
|
struct device_attribute *attr, \
|
|
|
|
char *buf) \
|
|
|
|
{ \
|
2011-02-26 17:20:36 +08:00
|
|
|
struct asus_wmi *asus = dev_get_drvdata(dev); \
|
|
|
|
\
|
|
|
|
return show_sys_wmi(asus, _cm, buf); \
|
2011-02-06 20:28:36 +08:00
|
|
|
} \
|
|
|
|
static ssize_t store_##_name(struct device *dev, \
|
|
|
|
struct device_attribute *attr, \
|
|
|
|
const char *buf, size_t count) \
|
|
|
|
{ \
|
2011-02-26 17:20:36 +08:00
|
|
|
struct asus_wmi *asus = dev_get_drvdata(dev); \
|
|
|
|
\
|
|
|
|
return store_sys_wmi(asus, _cm, buf, count); \
|
2011-02-06 20:28:36 +08:00
|
|
|
} \
|
|
|
|
static struct device_attribute dev_attr_##_name = { \
|
|
|
|
.attr = { \
|
|
|
|
.name = __stringify(_name), \
|
|
|
|
.mode = _mode }, \
|
|
|
|
.show = show_##_name, \
|
|
|
|
.store = store_##_name, \
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
|
|
|
|
ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
|
|
|
|
ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
|
2012-06-13 15:32:07 +08:00
|
|
|
ASUS_WMI_CREATE_DEVICE_ATTR(lid_resume, 0644, ASUS_WMI_DEVID_LID_RESUME);
|
2016-04-01 19:35:21 +08:00
|
|
|
ASUS_WMI_CREATE_DEVICE_ATTR(als_enable, 0644, ASUS_WMI_DEVID_ALS_ENABLE);
|
2011-02-06 20:28:36 +08:00
|
|
|
|
2017-04-22 10:19:45 +08:00
|
|
|
static ssize_t cpufv_store(struct device *dev, struct device_attribute *attr,
|
2010-11-04 02:14:01 +08:00
|
|
|
const char *buf, size_t count)
|
2010-10-12 07:47:18 +08:00
|
|
|
{
|
2011-07-01 17:34:38 +08:00
|
|
|
int value, rv;
|
2010-10-12 07:47:18 +08:00
|
|
|
|
2019-08-16 19:15:55 +08:00
|
|
|
rv = kstrtoint(buf, 0, &value);
|
|
|
|
if (rv)
|
|
|
|
return rv;
|
|
|
|
|
2010-10-12 07:47:18 +08:00
|
|
|
if (value < 0 || value > 2)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2011-07-01 17:34:38 +08:00
|
|
|
rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
|
|
|
|
if (rv < 0)
|
|
|
|
return rv;
|
|
|
|
|
|
|
|
return count;
|
2010-10-12 07:47:18 +08:00
|
|
|
}
|
|
|
|
|
2017-04-22 10:19:45 +08:00
|
|
|
static DEVICE_ATTR_WO(cpufv);
|
2010-10-12 07:47:18 +08:00
|
|
|
|
2010-11-29 15:14:08 +08:00
|
|
|
static struct attribute *platform_attributes[] = {
|
|
|
|
&dev_attr_cpufv.attr,
|
2011-02-06 20:28:36 +08:00
|
|
|
&dev_attr_camera.attr,
|
|
|
|
&dev_attr_cardr.attr,
|
2011-02-06 20:28:42 +08:00
|
|
|
&dev_attr_touchpad.attr,
|
2012-06-13 15:32:07 +08:00
|
|
|
&dev_attr_lid_resume.attr,
|
2016-04-01 19:35:21 +08:00
|
|
|
&dev_attr_als_enable.attr,
|
2019-07-17 13:10:58 +08:00
|
|
|
&dev_attr_fan_boost_mode.attr,
|
2010-11-29 15:14:08 +08:00
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2011-07-24 11:11:19 +08:00
|
|
|
static umode_t asus_sysfs_is_visible(struct kobject *kobj,
|
2011-02-26 17:20:31 +08:00
|
|
|
struct attribute *attr, int idx)
|
2011-02-06 20:28:36 +08:00
|
|
|
{
|
2011-02-26 17:20:36 +08:00
|
|
|
struct device *dev = container_of(kobj, struct device, kobj);
|
2018-04-19 22:06:10 +08:00
|
|
|
struct asus_wmi *asus = dev_get_drvdata(dev);
|
2011-02-26 17:20:36 +08:00
|
|
|
bool ok = true;
|
2011-02-06 20:28:36 +08:00
|
|
|
int devid = -1;
|
|
|
|
|
|
|
|
if (attr == &dev_attr_camera.attr)
|
2011-02-26 17:20:31 +08:00
|
|
|
devid = ASUS_WMI_DEVID_CAMERA;
|
2011-02-06 20:28:36 +08:00
|
|
|
else if (attr == &dev_attr_cardr.attr)
|
2011-02-26 17:20:31 +08:00
|
|
|
devid = ASUS_WMI_DEVID_CARDREADER;
|
2011-02-06 20:28:42 +08:00
|
|
|
else if (attr == &dev_attr_touchpad.attr)
|
2011-02-26 17:20:31 +08:00
|
|
|
devid = ASUS_WMI_DEVID_TOUCHPAD;
|
2012-06-13 15:32:07 +08:00
|
|
|
else if (attr == &dev_attr_lid_resume.attr)
|
|
|
|
devid = ASUS_WMI_DEVID_LID_RESUME;
|
2016-04-01 19:35:21 +08:00
|
|
|
else if (attr == &dev_attr_als_enable.attr)
|
|
|
|
devid = ASUS_WMI_DEVID_ALS_ENABLE;
|
2019-07-17 13:10:58 +08:00
|
|
|
else if (attr == &dev_attr_fan_boost_mode.attr)
|
|
|
|
ok = asus->fan_boost_mode_available;
|
2011-02-06 20:28:36 +08:00
|
|
|
|
|
|
|
if (devid != -1)
|
2011-02-26 17:20:36 +08:00
|
|
|
ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
|
2011-02-06 20:28:36 +08:00
|
|
|
|
2011-02-26 17:20:36 +08:00
|
|
|
return ok ? attr->mode : 0;
|
2011-02-06 20:28:36 +08:00
|
|
|
}
|
|
|
|
|
2017-07-11 18:48:19 +08:00
|
|
|
static const struct attribute_group platform_attribute_group = {
|
2011-02-26 17:20:31 +08:00
|
|
|
.is_visible = asus_sysfs_is_visible,
|
|
|
|
.attrs = platform_attributes
|
2010-11-29 15:14:08 +08:00
|
|
|
};
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static void asus_wmi_sysfs_exit(struct platform_device *device)
|
2010-10-12 07:47:18 +08:00
|
|
|
{
|
2010-11-29 15:14:08 +08:00
|
|
|
sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
|
2010-10-12 07:47:18 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_wmi_sysfs_init(struct platform_device *device)
|
2010-10-12 07:47:18 +08:00
|
|
|
{
|
2010-11-29 15:14:08 +08:00
|
|
|
return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
|
2010-10-12 07:47:18 +08:00
|
|
|
}
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* Platform device ************************************************************/
|
|
|
|
|
2011-03-30 06:21:32 +08:00
|
|
|
static int asus_wmi_platform_init(struct asus_wmi *asus)
|
2010-03-21 10:26:34 +08:00
|
|
|
{
|
2019-05-15 03:00:31 +08:00
|
|
|
struct device *dev = &asus->platform_device->dev;
|
|
|
|
char *wmi_uid;
|
2011-02-26 17:20:38 +08:00
|
|
|
int rv;
|
|
|
|
|
|
|
|
/* INIT enable hotkeys on some models */
|
|
|
|
if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
|
2013-05-23 02:32:10 +08:00
|
|
|
pr_info("Initialization: %#x\n", rv);
|
2011-02-26 17:20:38 +08:00
|
|
|
|
|
|
|
/* We don't know yet what to do with this version... */
|
|
|
|
if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
|
2013-05-23 02:32:10 +08:00
|
|
|
pr_info("BIOS WMI version: %d.%d\n", rv >> 16, rv & 0xFF);
|
2011-02-26 17:20:38 +08:00
|
|
|
asus->spec = rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The SFUN method probably allows the original driver to get the list
|
|
|
|
* of features supported by a given model. For now, 0x0100 or 0x0800
|
|
|
|
* bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
|
|
|
|
* The significance of others is yet to be found.
|
|
|
|
*/
|
|
|
|
if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
|
2013-05-23 02:32:10 +08:00
|
|
|
pr_info("SFUN value: %#x\n", rv);
|
2011-02-26 17:20:38 +08:00
|
|
|
asus->sfun = rv;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:36 +08:00
|
|
|
/*
|
|
|
|
* Eee PC and Notebooks seems to have different method_id for DSTS,
|
|
|
|
* but it may also be related to the BIOS's SPEC.
|
|
|
|
* Note, on most Eeepc, there is no way to check if a method exist
|
|
|
|
* or note, while on notebooks, they returns 0xFFFFFFFE on failure,
|
|
|
|
* but once again, SPEC may probably be used for that kind of things.
|
2019-05-15 03:00:31 +08:00
|
|
|
*
|
|
|
|
* Additionally at least TUF Gaming series laptops return nothing for
|
|
|
|
* unknown methods, so the detection in this way is not possible.
|
|
|
|
*
|
|
|
|
* There is strong indication that only ACPI WMI devices that have _UID
|
|
|
|
* equal to "ASUSWMI" use DCTS whereas those with "ATK" use DSTS.
|
2011-02-26 17:20:36 +08:00
|
|
|
*/
|
2019-05-15 03:00:31 +08:00
|
|
|
wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
|
|
|
|
if (!wmi_uid)
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI)) {
|
|
|
|
dev_info(dev, "Detected ASUSWMI, use DCTS\n");
|
|
|
|
asus->dsts_id = ASUS_WMI_METHODID_DCTS;
|
|
|
|
} else {
|
|
|
|
dev_info(dev, "Detected %s, not ASUSWMI, use DSTS\n", wmi_uid);
|
2011-02-26 17:20:36 +08:00
|
|
|
asus->dsts_id = ASUS_WMI_METHODID_DSTS;
|
2019-05-15 03:00:31 +08:00
|
|
|
}
|
2011-02-26 17:20:36 +08:00
|
|
|
|
platform/x86: asus-wmi: Support WMI event queue
Event codes are expected to be retrieved from a queue on at least some
models. Specifically, very likely the ACPI WMI devices with _UID ATK are
queued whereas those with ASUSWMI are not [1].
The WMI event codes are pushed into a circular buffer queue. After the INIT
method is called, ACPI code is allowed to push events into this buffer.
The INIT method cannot be reverted. If the module is unloaded and an event
(such as hotkey press) gets emitted before inserting it back the events get
processed delayed by one or if the queue overflows, additionally delayed by
about 3 seconds.
It might be considered a minor issue and no normal user would likely
observe this (there is little reason unloading the driver), but it does
significantly frustrate a developer who is unlucky enough to encounter
this. Therefore, the fallback to unqueued behavior occurs whenever
something unexpected happens.
The fix flushes the old key codes out of the queue on load. After receiving
event the queue is read until either ..FFFF or 1 is encountered. Also as
noted in [1] it is checked whether notify code is equal to 0xFF before
enabling queue processing in WMI notify handler.
DSDT examples:
FX505GM
Device (ATKD)
{ ..
Name (ATKQ, Package (0x10)
{
0xFFFFFFFF, ..
}
Method (IANQ, 1, Serialized)
{
If ((AQNO >= 0x10))
{
Local0 = 0x64
While ((Local0 && (AQNO >= 0x10)))
{
Local0--
Sleep (0x0A)
}
...
..
AQTI++
AQTI &= 0x0F
ATKQ [AQTI] = Arg0
...
}
Method (GANQ, 0, Serialized)
{
..
If (AQNO)
{
...
Local0 = DerefOf (ATKQ [AQHI])
AQHI++
AQHI &= 0x0F
Return (Local0)
}
Return (One)
}
This code is almost identical to K54C, which does return Ones on empty
queue.
K54C:
Method (GANQ, 0, Serialized)
{
If (AQNO)
{
...
Return (Local0)
}
Return (Ones)
}
[1] Link: https://lkml.org/lkml/2019/4/12/104
Signed-off-by: Yurii Pavlovskyi <yurii.pavlovskyi@gmail.com>
Suggested-by: Daniel Drake <drake@endlessm.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2019-05-15 03:02:09 +08:00
|
|
|
/*
|
|
|
|
* Some devices can have multiple event codes stored in a queue before
|
|
|
|
* the module load if it was unloaded intermittently after calling
|
|
|
|
* the INIT method (enables event handling). The WMI notify handler is
|
|
|
|
* expected to retrieve all event codes until a retrieved code equals
|
|
|
|
* queue end marker (One or Ones). Old codes are flushed from the queue
|
|
|
|
* upon module load. Not enabling this when it should be has minimal
|
|
|
|
* visible impact so fall back if anything goes wrong.
|
|
|
|
*/
|
|
|
|
wmi_uid = wmi_get_acpi_device_uid(asus->driver->event_guid);
|
|
|
|
if (wmi_uid && !strcmp(wmi_uid, ASUS_ACPI_UID_ATK)) {
|
|
|
|
dev_info(dev, "Detected ATK, enable event queue\n");
|
|
|
|
|
|
|
|
if (!asus_wmi_notify_queue_flush(asus))
|
|
|
|
asus->wmi_event_queue = true;
|
|
|
|
}
|
2011-02-26 17:20:36 +08:00
|
|
|
|
2011-07-01 17:34:39 +08:00
|
|
|
/* CWAP allow to define the behavior of the Fn+F2 key,
|
|
|
|
* this method doesn't seems to be present on Eee PCs */
|
2012-03-20 16:53:10 +08:00
|
|
|
if (asus->driver->quirks->wapf >= 0)
|
2011-07-01 17:34:39 +08:00
|
|
|
asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP,
|
2012-03-20 16:53:10 +08:00
|
|
|
asus->driver->quirks->wapf, NULL);
|
2011-07-01 17:34:39 +08:00
|
|
|
|
2019-05-15 03:07:05 +08:00
|
|
|
return 0;
|
2010-11-29 15:14:05 +08:00
|
|
|
}
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* debugfs ********************************************************************/
|
2010-11-29 15:14:05 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi_debugfs_node {
|
|
|
|
struct asus_wmi *asus;
|
2010-11-29 15:14:09 +08:00
|
|
|
char *name;
|
2011-02-26 17:20:31 +08:00
|
|
|
int (*show) (struct seq_file *m, void *data);
|
2010-11-29 15:14:09 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
static int show_dsts(struct seq_file *m, void *data)
|
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi *asus = m->private;
|
2011-02-26 17:20:35 +08:00
|
|
|
int err;
|
2010-11-29 15:14:09 +08:00
|
|
|
u32 retval = -1;
|
|
|
|
|
2011-02-26 17:20:36 +08:00
|
|
|
err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
|
2011-02-26 17:20:35 +08:00
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2010-11-29 15:14:09 +08:00
|
|
|
|
2011-02-26 17:20:39 +08:00
|
|
|
seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
|
2010-11-29 15:14:09 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int show_devs(struct seq_file *m, void *data)
|
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi *asus = m->private;
|
2011-02-26 17:20:35 +08:00
|
|
|
int err;
|
2010-11-29 15:14:09 +08:00
|
|
|
u32 retval = -1;
|
|
|
|
|
2011-02-26 17:20:35 +08:00
|
|
|
err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
|
|
|
|
&retval);
|
|
|
|
if (err < 0)
|
|
|
|
return err;
|
2010-11-29 15:14:09 +08:00
|
|
|
|
2011-02-26 17:20:39 +08:00
|
|
|
seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
|
2011-02-26 17:20:31 +08:00
|
|
|
asus->debug.ctrl_param, retval);
|
2010-11-29 15:14:09 +08:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:39 +08:00
|
|
|
static int show_call(struct seq_file *m, void *data)
|
|
|
|
{
|
|
|
|
struct asus_wmi *asus = m->private;
|
|
|
|
struct bios_args args = {
|
|
|
|
.arg0 = asus->debug.dev_id,
|
|
|
|
.arg1 = asus->debug.ctrl_param,
|
|
|
|
};
|
|
|
|
struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
|
|
|
|
struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
|
|
|
|
union acpi_object *obj;
|
|
|
|
acpi_status status;
|
|
|
|
|
|
|
|
status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
|
platform/x86: asus-wmi: Evaluate wmi method with instance number 0x0
According to available DSDT dump from Asus machine, there is the only one
instance of the WMI GUID 97845ED0-4E6D-11DE-8A39-0800200C9A66 and so it is
0x0. Moreover corresponding method WMBC does not check Arg0 (instance
number) at all.
DSDT dump is available at:
https://lwn.net/Articles/391249/
_WDG dump:
0xD0, 0x5E, 0x84, 0x97, 0x6D, 0x4E, 0xDE, 0x11, 0x8A, 0x39, 0x08,
0x00, 0x20, 0x0C, 0x9A, 0x66,
0x42, 0x43, // Object ID "BC" = method "WMBC"
0x01, // Instance count
0x02, // Flags
Signed-off-by: Pali Rohár <pali.rohar@gmail.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2017-08-12 15:44:16 +08:00
|
|
|
0, asus->debug.method_id,
|
2011-02-26 17:20:39 +08:00
|
|
|
&input, &output);
|
|
|
|
|
|
|
|
if (ACPI_FAILURE(status))
|
|
|
|
return -EIO;
|
|
|
|
|
|
|
|
obj = (union acpi_object *)output.pointer;
|
|
|
|
if (obj && obj->type == ACPI_TYPE_INTEGER)
|
|
|
|
seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
|
|
|
|
asus->debug.dev_id, asus->debug.ctrl_param,
|
|
|
|
(u32) obj->integer.value);
|
|
|
|
else
|
|
|
|
seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
|
|
|
|
asus->debug.dev_id, asus->debug.ctrl_param,
|
2011-03-15 15:07:37 +08:00
|
|
|
obj ? obj->type : -1);
|
2011-02-26 17:20:39 +08:00
|
|
|
|
|
|
|
kfree(obj);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
|
|
|
|
{NULL, "devs", show_devs},
|
|
|
|
{NULL, "dsts", show_dsts},
|
2011-02-26 17:20:39 +08:00
|
|
|
{NULL, "call", show_call},
|
2010-11-29 15:14:09 +08:00
|
|
|
};
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
|
2010-11-29 15:14:09 +08:00
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi_debugfs_node *node = inode->i_private;
|
2010-11-29 15:14:09 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
return single_open(file, node->show, node->asus);
|
2010-11-29 15:14:09 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static const struct file_operations asus_wmi_debugfs_io_ops = {
|
2010-11-29 15:14:09 +08:00
|
|
|
.owner = THIS_MODULE,
|
2011-02-26 17:20:31 +08:00
|
|
|
.open = asus_wmi_debugfs_open,
|
2010-11-29 15:14:09 +08:00
|
|
|
.read = seq_read,
|
|
|
|
.llseek = seq_lseek,
|
|
|
|
.release = single_release,
|
|
|
|
};
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
|
2010-11-29 15:14:09 +08:00
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
debugfs_remove_recursive(asus->debug.root);
|
2010-11-29 15:14:09 +08:00
|
|
|
}
|
|
|
|
|
2019-06-12 20:12:52 +08:00
|
|
|
static void asus_wmi_debugfs_init(struct asus_wmi *asus)
|
2010-11-29 15:14:09 +08:00
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
|
2010-11-29 15:14:09 +08:00
|
|
|
|
2019-06-12 20:12:52 +08:00
|
|
|
debugfs_create_x32("method_id", S_IRUGO | S_IWUSR, asus->debug.root,
|
|
|
|
&asus->debug.method_id);
|
2011-02-26 17:20:39 +08:00
|
|
|
|
2019-06-12 20:12:52 +08:00
|
|
|
debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR, asus->debug.root,
|
|
|
|
&asus->debug.dev_id);
|
2010-11-29 15:14:09 +08:00
|
|
|
|
2019-06-12 20:12:52 +08:00
|
|
|
debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR, asus->debug.root,
|
|
|
|
&asus->debug.ctrl_param);
|
2010-11-29 15:14:09 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
|
|
|
|
struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
|
2010-11-29 15:14:09 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
node->asus = asus;
|
2019-06-12 20:12:52 +08:00
|
|
|
debugfs_create_file(node->name, S_IFREG | S_IRUGO,
|
|
|
|
asus->debug.root, node,
|
|
|
|
&asus_wmi_debugfs_io_ops);
|
2010-11-29 15:14:09 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* Init / exit ****************************************************************/
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_wmi_add(struct platform_device *pdev)
|
2011-02-06 20:28:28 +08:00
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
|
|
|
|
struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
|
|
|
|
struct asus_wmi *asus;
|
2014-07-08 16:47:21 +08:00
|
|
|
const char *chassis_type;
|
2010-03-21 10:26:34 +08:00
|
|
|
acpi_status status;
|
2010-11-29 15:14:05 +08:00
|
|
|
int err;
|
asus-wmi: record wlan status while controlled by userapp
If the user bit is set, that mean BIOS can't set and record the wlan
status, it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
(0x00010012) while we query the wlan status by id ASUS_WMI_DEVID_WLAN
(0x00010011) through WMI.
So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
(0x00010012) while setting the wlan status through WMI.
This is also the behavior that windows app will do.
Quote from ASUS application engineer
===
When you call WMIMethod(DSTS, 0x00010011) to get WLAN status, it may return
(1) 0x00050001 (On)
(2) 0x00050000 (Off)
(3) 0x00030001 (On)
(4) 0x00030000 (Off)
(5) 0x00000002 (Unknown)
(1), (2) means that the model has hardware GPIO for WLAN, you can call
WMIMethod(DEVS, 0x00010011, 1 or 0) to turn WLAN on/off.
(3), (4) means that the model doesn’t have hardware GPIO, you need to use
API or driver library to turn WLAN on/off, and call
WMIMethod(DEVS, 0x00010012, 1 or 0) to set WLAN LED status.
After you set WLAN LED status, you can see the WLAN status is changed with
WMIMethod(DSTS, 0x00010011). Because the status is recorded lastly
(ex: Windows), you can use it for synchronization.
(5) means that the model doesn’t have WLAN device.
WLAN is the ONLY special case with upper rule.
For other device, like Bluetooth, you just need use
WMIMethod(DSTS, 0x00010013) to get, and WMIMethod(DEVS, 0x00010013, 1 or 0)
to set.
===
Signed-off-by: AceLan Kao <acelan.kao@canonical.com>
Signed-off-by: Matthew Garrett <mjg@redhat.com>
2012-07-26 17:13:31 +08:00
|
|
|
u32 result;
|
2010-03-21 10:26:34 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
|
|
|
|
if (!asus)
|
2011-02-06 20:28:33 +08:00
|
|
|
return -ENOMEM;
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
asus->driver = wdrv;
|
|
|
|
asus->platform_device = pdev;
|
|
|
|
wdrv->platform_device = pdev;
|
|
|
|
platform_set_drvdata(asus->platform_device, asus);
|
2010-11-29 15:14:05 +08:00
|
|
|
|
2012-03-20 16:53:08 +08:00
|
|
|
if (wdrv->detect_quirks)
|
|
|
|
wdrv->detect_quirks(asus->driver);
|
2011-02-06 20:28:28 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
err = asus_wmi_platform_init(asus);
|
2010-11-29 15:14:05 +08:00
|
|
|
if (err)
|
|
|
|
goto fail_platform;
|
2010-04-11 09:27:19 +08:00
|
|
|
|
2019-07-17 13:10:58 +08:00
|
|
|
err = fan_boost_mode_check_present(asus);
|
2019-05-15 03:07:05 +08:00
|
|
|
if (err)
|
2019-07-17 13:10:58 +08:00
|
|
|
goto fail_fan_boost_mode;
|
2019-05-15 03:07:05 +08:00
|
|
|
|
|
|
|
err = asus_wmi_sysfs_init(asus->platform_device);
|
|
|
|
if (err)
|
|
|
|
goto fail_sysfs;
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
err = asus_wmi_input_init(asus);
|
2010-04-11 09:27:19 +08:00
|
|
|
if (err)
|
2010-11-29 15:14:05 +08:00
|
|
|
goto fail_input;
|
2010-04-11 09:27:54 +08:00
|
|
|
|
asus-wmi: add fan control
This patch is partially based on Felipe Contrera's earlier patch, that
was discussed here: https://lkml.org/lkml/2013/10/8/800
Some problems of that patch are solved, now:
1) The main obstacle for the earlier patch seemed to be the use of
virt_to_phys, which is accepted, now
2) random memory corruption occurred on my notebook, thus DMA-able memory
is allocated now, which solves this problem
3) hwmon interface is used instead of the thermal interface, as a
hwmon device is already set up by this driver and seemed more
appropriate than the thermal interface
4) Calling the ACPI-functions was modularized thus it's possible to call
some multifunctions easily, now (by using
asus_wmi_evaluate_method_agfn).
Unfortunately the WMI doesn't support controlling both fans on
a dual-fan notebook because of an restriction in the acpi-method
"SFNS", that is callable through the wmi. If "SFNV" would be called
directly even dual fan configurations could be controlled, but not by using
wmi.
Speed readings only work on auto-mode, thus "-1" will be reported in
manual mode.
Additionally the speed readings are reported as hundreds of RPM thus
they are not too precise.
This patch is tested only on one notebook (N551JK) but a similar module,
that contained some code to try to control the second fan also, was
reported to work on an UX32VD, at least for the first fan.
As Felipe already mentioned the low-level functions are described here:
http://forum.notebookreview.com/threads/fan-control-on-asus-prime-ux31-ux31a-ux32a-ux32vd.705656/
Signed-off-by: Kast Bernd <kastbernd@gmx.de>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Cc: Corentin Chary <corentin.chary@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Matthew Garrett <mjg59@srcf.ucam.org>
Cc: Rafael J. Wysocki <rjw@rjwysocki.net>
Signed-off-by: Darren Hart <dvhart@linux.intel.com>
2015-05-13 22:24:16 +08:00
|
|
|
err = asus_wmi_fan_init(asus); /* probably no problems on error */
|
|
|
|
|
2011-02-26 17:20:42 +08:00
|
|
|
err = asus_wmi_hwmon_init(asus);
|
|
|
|
if (err)
|
|
|
|
goto fail_hwmon;
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
err = asus_wmi_led_init(asus);
|
2010-11-29 15:14:06 +08:00
|
|
|
if (err)
|
|
|
|
goto fail_leds;
|
|
|
|
|
2017-02-21 03:50:22 +08:00
|
|
|
asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result);
|
|
|
|
if (result & (ASUS_WMI_DSTS_PRESENCE_BIT | ASUS_WMI_DSTS_USER_BIT))
|
|
|
|
asus->driver->wlan_ctrl_by_user = 1;
|
|
|
|
|
2017-02-21 03:50:23 +08:00
|
|
|
if (!(asus->driver->wlan_ctrl_by_user && ashs_present())) {
|
2016-06-14 04:57:31 +08:00
|
|
|
err = asus_wmi_rfkill_init(asus);
|
|
|
|
if (err)
|
|
|
|
goto fail_rfkill;
|
|
|
|
}
|
2010-11-29 15:14:07 +08:00
|
|
|
|
2017-04-28 22:19:49 +08:00
|
|
|
if (asus->driver->quirks->wmi_force_als_set)
|
|
|
|
asus_wmi_set_als();
|
|
|
|
|
2014-07-08 16:47:21 +08:00
|
|
|
/* Some Asus desktop boards export an acpi-video backlight interface,
|
|
|
|
stop this from showing up */
|
|
|
|
chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE);
|
|
|
|
if (chassis_type && !strcmp(chassis_type, "3"))
|
2015-06-16 22:27:58 +08:00
|
|
|
acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
|
|
|
|
|
2012-06-13 15:32:06 +08:00
|
|
|
if (asus->driver->quirks->wmi_backlight_power)
|
2015-06-16 22:27:58 +08:00
|
|
|
acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
|
|
|
|
|
2016-08-28 16:12:06 +08:00
|
|
|
if (asus->driver->quirks->wmi_backlight_native)
|
|
|
|
acpi_video_set_dmi_backlight_type(acpi_backlight_native);
|
|
|
|
|
platform/x86: asus-wmi: Set specified XUSB2PR value for X550LB
The bluetooth adapter Atheros AR3012 can't be enumerated
and make the bluetooth function broken.
T: Bus=02 Lev=01 Prnt=01 Port=05 Cnt=02 Dev#= 5 Spd=12 MxCh= 0
D: Ver= 1.10 Cls=e0(wlcon) Sub=01 Prot=01 MxPS=64 #Cfgs= 1
P: Vendor=13d3 ProdID=3362 Rev=00.02
S: Manufacturer=Atheros Communications
S: Product=Bluetooth USB Host Controller
S: SerialNumber=Alaska Day 2006
C: #Ifs= 2 Cfg#= 1 Atr=e0 MxPwr=100mA
I: If#= 0 Alt= 0 #EPs= 3 Cls=e0(wlcon) Sub=01 Prot=01 Driver=btusb
I: If#= 1 Alt= 0 #EPs= 2 Cls=e0(wlcon) Sub=01 Prot=01 Driver=btusb
The error is:
usb 2-6: device not accepting address 7, error -62
usb usb2-port6: unable to enumerate USB device
It is caused by adapter's connected port is mapped to xHC
controller, but the xHCI is not supported by the usb device.
The output of 'sudo lspci -nnxxx -s 00:14.0':
00:14.0 USB controller [0c03]: Intel Corporation 8 Series USB xHCI HC [8086:9c31] (rev 04)
00: 86 80 31 9c 06 04 90 02 04 30 03 0c 00 00 00 00
10: 04 00 a0 f7 00 00 00 00 00 00 00 00 00 00 00 00
20: 00 00 00 00 00 00 00 00 00 00 00 00 43 10 1f 20
30: 00 00 00 00 70 00 00 00 00 00 00 00 0b 01 00 00
40: fd 01 36 80 89 c6 0f 80 00 00 00 00 00 00 00 00
50: 5f 2e ce 0f 00 00 00 00 00 00 00 00 00 00 00 00
60: 30 20 00 00 00 00 00 00 00 00 00 00 00 00 00 00
70: 01 80 c2 c1 08 00 00 00 00 00 00 00 00 00 00 00
80: 05 00 87 00 0c a0 e0 fe 00 00 00 00 a1 41 00 00
90: 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
a0: 00 01 04 00 00 00 00 00 00 00 00 00 00 00 00 00
b0: 0f 00 03 00 00 00 00 00 00 00 00 00 00 00 00 00
c0: 03 c0 30 00 00 00 00 00 03 0c 00 00 00 00 00 00
d0: f9 01 00 00 f9 01 00 00 0f 00 00 00 0f 00 00 00
e0: 00 08 00 00 00 00 00 00 00 00 00 00 d8 d8 00 00
f0: 00 00 00 00 00 00 00 00 b1 0f 04 08 00 00 00 00
By referencing Intel Platform Controller Hub(PCH) datasheet,
the xHC USB 2.0 Port Routing(XUSB2PR) at offset 0xD0-0xD3h
decides the setting of mapping the port to EHCI controller or
xHC controller. And the port mapped to xHC will enable xHCI
during bus resume.
The setting of disabling bluetooth adapter's connected port is
0x000001D9. The value can be obtained by few times 1 bit flip
operation. The suited configuration should have the 'lsusb -t'
result with bluetooth using ehci:
/: Bus 03.Port 1: Dev 1, Class=root_hub, Driver=xhci_hcd/4p, 5000M
/: Bus 02.Port 1: Dev 1, Class=root_hub, Driver=xhci_hcd/9p, 480M
|__ Port 5: Dev 2, If 0, Class=Video, Driver=uvcvideo, 480M
|__ Port 5: Dev 2, If 1, Class=Video, Driver=uvcvideo, 480M
/: Bus 01.Port 1: Dev 1, Class=root_hub, Driver=ehci-pci/2p, 480M
|__ Port 1: Dev 2, If 0, Class=Hub, Driver=hub/8p, 480M
|__ Port 6: Dev 3, If 0, Class=Wireless, Driver=btusb, 12M
|__ Port 6: Dev 3, If 1, Class=Wireless, Driver=btusb, 12M
Signed-off-by: Kai-Chuan Hsieh <kai.chiuan@gmail.com>
Acked-by: Corentin Chary <corentin.chary@gmail.com>
Reviewed-by: Andy Shevchenko <andy.shevchenko@gmail.com>
[andy: resolve merge conflict in asus-wmi.h]
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2016-09-01 23:55:55 +08:00
|
|
|
if (asus->driver->quirks->xusb2pr)
|
|
|
|
asus_wmi_set_xusb2pr(asus);
|
|
|
|
|
2015-06-16 22:27:58 +08:00
|
|
|
if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
|
2011-02-26 17:20:31 +08:00
|
|
|
err = asus_wmi_backlight_init(asus);
|
2011-02-06 20:28:39 +08:00
|
|
|
if (err && err != -ENODEV)
|
2010-11-29 15:14:05 +08:00
|
|
|
goto fail_backlight;
|
2019-06-12 15:02:02 +08:00
|
|
|
} else if (asus->driver->quirks->wmi_backlight_set_devstate)
|
platform/x86: asus-wmi: Tell the EC the OS will handle the display off hotkey
In the past, Asus firmwares would change the panel backlight directly
through the EC when the display off hotkey (Fn+F7) was pressed, and
only notify the OS of such change, with 0x33 when the LCD was ON and
0x34 when the LCD was OFF. These are currently mapped to
KEY_DISPLAYTOGGLE and KEY_DISPLAY_OFF, respectively.
Most recently the EC on Asus most machines lost ability to toggle the
LCD backlight directly, but unless the OS informs the firmware it is
going to handle the display toggle hotkey events, the firmware still
tries change the brightness through the EC, to no effect. The end result
is a long list (at Endless we counted 11) of Asus laptop models where
the display toggle hotkey does not perform any action. Our firmware
engineers contacts at Asus were surprised that there were still machines
out there with the old behavior.
Calling WMNB(ASUS_WMI_DEVID_BACKLIGHT==0x00050011, 2) on the _WDG device
tells the firmware that it should let the OS handle the display toggle
event, in which case it will simply notify the OS of a key press with
0x35, as shown by the DSDT excerpts bellow.
Scope (_SB)
{
(...)
Device (ATKD)
{
(...)
Name (_WDG, Buffer (0x28)
{
/* 0000 */ 0xD0, 0x5E, 0x84, 0x97, 0x6D, 0x4E, 0xDE, 0x11,
/* 0008 */ 0x8A, 0x39, 0x08, 0x00, 0x20, 0x0C, 0x9A, 0x66,
/* 0010 */ 0x4E, 0x42, 0x01, 0x02, 0x35, 0xBB, 0x3C, 0x0B,
/* 0018 */ 0xC2, 0xE3, 0xED, 0x45, 0x91, 0xC2, 0x4C, 0x5A,
/* 0020 */ 0x6D, 0x19, 0x5D, 0x1C, 0xFF, 0x00, 0x01, 0x08
})
Method (WMNB, 3, Serialized)
{
CreateDWordField (Arg2, Zero, IIA0)
CreateDWordField (Arg2, 0x04, IIA1)
Local0 = (Arg1 & 0xFFFFFFFF)
(...)
If ((Local0 == 0x53564544))
{
(...)
If ((IIA0 == 0x00050011))
{
If ((IIA1 == 0x02))
{
^^PCI0.SBRG.EC0.SPIN (0x72, One)
^^PCI0.SBRG.EC0.BLCT = One
}
Return (One)
}
}
(...)
}
(...)
}
(...)
}
(...)
Scope (_SB.PCI0.SBRG.EC0)
{
(...)
Name (BLCT, Zero)
(...)
Method (_Q10, 0, NotSerialized) // _Qxx: EC Query
{
If ((BLCT == Zero))
{
Local0 = One
Local0 = RPIN (0x72)
Local0 ^= One
SPIN (0x72, Local0)
If (ATKP)
{
Local0 = (0x34 - Local0)
^^^^ATKD.IANE (Local0)
}
}
ElseIf ((BLCT == One))
{
If (ATKP)
{
^^^^ATKD.IANE (0x35)
}
}
}
(...)
}
Signed-off-by: João Paulo Rechi Vita <jprvita@endlessm.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
2018-11-01 08:21:26 +08:00
|
|
|
err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT, 2, NULL);
|
2010-04-11 09:27:19 +08:00
|
|
|
|
2019-04-18 14:46:48 +08:00
|
|
|
if (asus_wmi_has_fnlock_key(asus)) {
|
|
|
|
asus->fnlock_locked = true;
|
|
|
|
asus_wmi_fnlock_update(asus);
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
status = wmi_install_notify_handler(asus->driver->event_guid,
|
|
|
|
asus_wmi_notify, asus);
|
2010-04-11 09:27:19 +08:00
|
|
|
if (ACPI_FAILURE(status)) {
|
2011-02-26 17:20:31 +08:00
|
|
|
pr_err("Unable to register notify handler - %d\n", status);
|
2010-04-11 09:27:19 +08:00
|
|
|
err = -ENODEV;
|
2010-11-29 15:14:05 +08:00
|
|
|
goto fail_wmi_handler;
|
2010-04-11 09:27:19 +08:00
|
|
|
}
|
|
|
|
|
2019-09-10 01:31:28 +08:00
|
|
|
asus_wmi_battery_init(asus);
|
|
|
|
|
2019-06-12 20:12:52 +08:00
|
|
|
asus_wmi_debugfs_init(asus);
|
2010-11-29 15:14:09 +08:00
|
|
|
|
2011-02-06 20:28:33 +08:00
|
|
|
return 0;
|
2010-04-11 09:27:19 +08:00
|
|
|
|
2010-11-29 15:14:05 +08:00
|
|
|
fail_wmi_handler:
|
2011-02-26 17:20:31 +08:00
|
|
|
asus_wmi_backlight_exit(asus);
|
2010-11-29 15:14:05 +08:00
|
|
|
fail_backlight:
|
2011-02-26 17:20:31 +08:00
|
|
|
asus_wmi_rfkill_exit(asus);
|
2010-11-29 15:14:07 +08:00
|
|
|
fail_rfkill:
|
2011-02-26 17:20:31 +08:00
|
|
|
asus_wmi_led_exit(asus);
|
2010-11-29 15:14:06 +08:00
|
|
|
fail_leds:
|
2011-02-26 17:20:42 +08:00
|
|
|
fail_hwmon:
|
2011-02-26 17:20:31 +08:00
|
|
|
asus_wmi_input_exit(asus);
|
2010-11-29 15:14:05 +08:00
|
|
|
fail_input:
|
2019-05-15 03:07:05 +08:00
|
|
|
asus_wmi_sysfs_exit(asus->platform_device);
|
|
|
|
fail_sysfs:
|
2019-07-17 13:10:58 +08:00
|
|
|
fail_fan_boost_mode:
|
2010-11-29 15:14:05 +08:00
|
|
|
fail_platform:
|
2011-02-26 17:20:31 +08:00
|
|
|
kfree(asus);
|
2011-02-06 20:28:33 +08:00
|
|
|
return err;
|
2010-04-11 09:27:19 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_wmi_remove(struct platform_device *device)
|
2010-04-11 09:27:19 +08:00
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi *asus;
|
|
|
|
|
|
|
|
asus = platform_get_drvdata(device);
|
|
|
|
wmi_remove_notify_handler(asus->driver->event_guid);
|
|
|
|
asus_wmi_backlight_exit(asus);
|
|
|
|
asus_wmi_input_exit(asus);
|
|
|
|
asus_wmi_led_exit(asus);
|
|
|
|
asus_wmi_rfkill_exit(asus);
|
|
|
|
asus_wmi_debugfs_exit(asus);
|
2019-05-15 03:07:05 +08:00
|
|
|
asus_wmi_sysfs_exit(asus->platform_device);
|
2019-07-29 16:27:37 +08:00
|
|
|
asus_fan_set_auto(asus);
|
2019-09-10 01:31:28 +08:00
|
|
|
asus_wmi_battery_exit(asus);
|
2011-02-26 17:20:31 +08:00
|
|
|
|
|
|
|
kfree(asus);
|
2010-04-11 09:27:19 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* Platform driver - hibernate/resume callbacks *******************************/
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_hotk_thaw(struct device *device)
|
2011-02-06 20:28:32 +08:00
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi *asus = dev_get_drvdata(device);
|
2011-02-06 20:28:32 +08:00
|
|
|
|
2011-02-26 17:20:33 +08:00
|
|
|
if (asus->wlan.rfkill) {
|
2011-02-06 20:28:32 +08:00
|
|
|
bool wlan;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Work around bios bug - acpi _PTS turns off the wireless led
|
|
|
|
* during suspend. Normally it restores it on resume, but
|
|
|
|
* we should kick it ourselves in case hibernation is aborted.
|
|
|
|
*/
|
2011-02-26 17:20:36 +08:00
|
|
|
wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
|
2011-02-26 17:20:31 +08:00
|
|
|
asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
|
2011-02-06 20:28:32 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-09-14 17:16:30 +08:00
|
|
|
static int asus_hotk_resume(struct device *device)
|
|
|
|
{
|
|
|
|
struct asus_wmi *asus = dev_get_drvdata(device);
|
|
|
|
|
|
|
|
if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
|
2018-09-27 16:50:09 +08:00
|
|
|
kbd_led_update(asus);
|
2015-09-14 17:16:30 +08:00
|
|
|
|
2019-04-18 14:46:48 +08:00
|
|
|
if (asus_wmi_has_fnlock_key(asus))
|
|
|
|
asus_wmi_fnlock_update(asus);
|
2015-09-14 17:16:30 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_hotk_restore(struct device *device)
|
2011-02-06 20:28:32 +08:00
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct asus_wmi *asus = dev_get_drvdata(device);
|
2011-02-06 20:28:32 +08:00
|
|
|
int bl;
|
|
|
|
|
|
|
|
/* Refresh both wlan rfkill state and pci hotplug */
|
2011-02-26 17:20:33 +08:00
|
|
|
if (asus->wlan.rfkill)
|
2011-02-26 17:20:31 +08:00
|
|
|
asus_rfkill_hotplug(asus);
|
2011-02-06 20:28:32 +08:00
|
|
|
|
2011-02-26 17:20:33 +08:00
|
|
|
if (asus->bluetooth.rfkill) {
|
2011-02-26 17:20:36 +08:00
|
|
|
bl = !asus_wmi_get_devstate_simple(asus,
|
|
|
|
ASUS_WMI_DEVID_BLUETOOTH);
|
2011-02-26 17:20:33 +08:00
|
|
|
rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
|
2011-02-06 20:28:37 +08:00
|
|
|
}
|
2011-02-26 17:20:33 +08:00
|
|
|
if (asus->wimax.rfkill) {
|
2011-02-26 17:20:36 +08:00
|
|
|
bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
|
2011-02-26 17:20:33 +08:00
|
|
|
rfkill_set_sw_state(asus->wimax.rfkill, bl);
|
2011-02-06 20:28:37 +08:00
|
|
|
}
|
2011-02-26 17:20:33 +08:00
|
|
|
if (asus->wwan3g.rfkill) {
|
2011-02-26 17:20:36 +08:00
|
|
|
bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
|
2011-02-26 17:20:33 +08:00
|
|
|
rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
|
2011-02-06 20:28:32 +08:00
|
|
|
}
|
2011-07-01 17:34:40 +08:00
|
|
|
if (asus->gps.rfkill) {
|
|
|
|
bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS);
|
|
|
|
rfkill_set_sw_state(asus->gps.rfkill, bl);
|
|
|
|
}
|
2011-07-01 17:34:41 +08:00
|
|
|
if (asus->uwb.rfkill) {
|
|
|
|
bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB);
|
|
|
|
rfkill_set_sw_state(asus->uwb.rfkill, bl);
|
|
|
|
}
|
2015-09-14 17:16:30 +08:00
|
|
|
if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
|
2018-09-27 16:50:09 +08:00
|
|
|
kbd_led_update(asus);
|
2011-02-06 20:28:32 +08:00
|
|
|
|
2019-04-18 14:46:48 +08:00
|
|
|
if (asus_wmi_has_fnlock_key(asus))
|
|
|
|
asus_wmi_fnlock_update(asus);
|
2011-02-06 20:28:32 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static const struct dev_pm_ops asus_pm_ops = {
|
|
|
|
.thaw = asus_hotk_thaw,
|
|
|
|
.restore = asus_hotk_restore,
|
2015-09-14 17:16:30 +08:00
|
|
|
.resume = asus_hotk_resume,
|
2010-04-11 09:27:19 +08:00
|
|
|
};
|
|
|
|
|
2019-05-15 03:04:48 +08:00
|
|
|
/* Registration ***************************************************************/
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static int asus_wmi_probe(struct platform_device *pdev)
|
2010-11-29 15:14:14 +08:00
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
|
|
|
|
struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
|
|
|
|
int ret;
|
2010-11-29 15:14:14 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
|
2019-01-21 21:24:36 +08:00
|
|
|
pr_warn("ASUS Management GUID not found\n");
|
2010-03-21 10:26:34 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
|
2019-01-21 21:24:36 +08:00
|
|
|
pr_warn("ASUS Event GUID not found\n");
|
2010-11-29 15:14:14 +08:00
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
if (wdrv->probe) {
|
|
|
|
ret = wdrv->probe(pdev);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return asus_wmi_add(pdev);
|
2011-02-06 20:28:33 +08:00
|
|
|
}
|
2010-04-11 09:27:19 +08:00
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static bool used;
|
2010-03-21 10:26:34 +08:00
|
|
|
|
2011-07-01 17:34:32 +08:00
|
|
|
int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
|
2011-02-06 20:28:33 +08:00
|
|
|
{
|
2011-02-26 17:20:31 +08:00
|
|
|
struct platform_driver *platform_driver;
|
|
|
|
struct platform_device *platform_device;
|
|
|
|
|
|
|
|
if (used)
|
|
|
|
return -EBUSY;
|
|
|
|
|
|
|
|
platform_driver = &driver->platform_driver;
|
|
|
|
platform_driver->remove = asus_wmi_remove;
|
|
|
|
platform_driver->driver.owner = driver->owner;
|
|
|
|
platform_driver->driver.name = driver->name;
|
|
|
|
platform_driver->driver.pm = &asus_pm_ops;
|
|
|
|
|
|
|
|
platform_device = platform_create_bundle(platform_driver,
|
|
|
|
asus_wmi_probe,
|
2011-02-06 20:28:33 +08:00
|
|
|
NULL, 0, NULL, 0);
|
|
|
|
if (IS_ERR(platform_device))
|
|
|
|
return PTR_ERR(platform_device);
|
2011-02-26 17:20:31 +08:00
|
|
|
|
|
|
|
used = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
|
|
|
|
|
|
|
|
void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
|
|
|
|
{
|
|
|
|
platform_device_unregister(driver->platform_device);
|
|
|
|
platform_driver_unregister(&driver->platform_driver);
|
|
|
|
used = false;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
|
|
|
|
|
|
|
|
static int __init asus_wmi_init(void)
|
|
|
|
{
|
2013-05-23 02:32:10 +08:00
|
|
|
pr_info("ASUS WMI generic driver loaded\n");
|
2010-03-21 10:26:34 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
static void __exit asus_wmi_exit(void)
|
2010-03-21 10:26:34 +08:00
|
|
|
{
|
2013-05-23 02:32:10 +08:00
|
|
|
pr_info("ASUS WMI generic driver unloaded\n");
|
2010-03-21 10:26:34 +08:00
|
|
|
}
|
|
|
|
|
2011-02-26 17:20:31 +08:00
|
|
|
module_init(asus_wmi_init);
|
|
|
|
module_exit(asus_wmi_exit);
|