blob: a96630d5234674353790275695b4668198d1d402 [file] [log] [blame]
Yong Wangee027e42010-03-21 10:26:34 +08001/*
Corentin Charye12e6d92011-02-26 10:20:31 +01002 * Asus PC WMI hotkey driver
Yong Wangee027e42010-03-21 10:26:34 +08003 *
4 * Copyright(C) 2010 Intel Corporation.
Corentin Chary57ab7da2011-02-26 10:20:32 +01005 * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
Yong Wangee027e42010-03-21 10:26:34 +08006 *
7 * Portions based on wistron_btns.c:
8 * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
9 * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
10 * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 2 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 */
26
Yong Wang81248882010-04-11 09:26:33 +080027#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
28
Yong Wangee027e42010-03-21 10:26:34 +080029#include <linux/kernel.h>
30#include <linux/module.h>
31#include <linux/init.h>
32#include <linux/types.h>
Tejun Heoa32f3922010-04-05 11:37:59 +090033#include <linux/slab.h>
Yong Wangee027e42010-03-21 10:26:34 +080034#include <linux/input.h>
35#include <linux/input/sparse-keymap.h>
Yong Wang3d7b1652010-04-11 09:27:54 +080036#include <linux/fb.h>
37#include <linux/backlight.h>
Corentin Chary084fca62010-11-29 08:14:06 +010038#include <linux/leds.h>
Corentin Charyba48fdb2010-11-29 08:14:07 +010039#include <linux/rfkill.h>
Corentin Charyafa7c882011-02-06 13:28:28 +010040#include <linux/pci.h>
41#include <linux/pci_hotplug.h>
Corentin Charye07babd2011-02-26 10:20:42 +010042#include <linux/hwmon.h>
43#include <linux/hwmon-sysfs.h>
Corentin Chary8c1b2d82010-11-29 08:14:09 +010044#include <linux/debugfs.h>
45#include <linux/seq_file.h>
Yong Wang45f2c692010-04-11 09:27:19 +080046#include <linux/platform_device.h>
Corentin Chary6118b8a2011-07-01 11:34:36 +020047#include <linux/thermal.h>
Lv Zheng8b484632013-12-03 08:49:16 +080048#include <linux/acpi.h>
Hans de Goeded8c66f62014-07-08 10:47:21 +020049#include <linux/dmi.h>
AceLan Kao272c77d2012-06-13 09:32:06 +020050#include <acpi/video.h>
Yong Wangee027e42010-03-21 10:26:34 +080051
Corentin Charye12e6d92011-02-26 10:20:31 +010052#include "asus-wmi.h"
Yong Wang45f2c692010-04-11 09:27:19 +080053
Corentin Chary5909c652012-12-17 16:00:05 -080054MODULE_AUTHOR("Corentin Chary <corentin.chary@gmail.com>, "
Corentin Charye12e6d92011-02-26 10:20:31 +010055 "Yong Wang <yong.y.wang@intel.com>");
56MODULE_DESCRIPTION("Asus Generic WMI Driver");
Yong Wangee027e42010-03-21 10:26:34 +080057MODULE_LICENSE("GPL");
58
Corentin Charye12e6d92011-02-26 10:20:31 +010059#define to_asus_wmi_driver(pdrv) \
60 (container_of((pdrv), struct asus_wmi_driver, platform_driver))
Yong Wangee027e42010-03-21 10:26:34 +080061
Corentin Charye12e6d92011-02-26 10:20:31 +010062#define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
Yong Wangee027e42010-03-21 10:26:34 +080063
Corentin Chary33e0e6f2011-02-06 13:28:34 +010064#define NOTIFY_BRNUP_MIN 0x11
65#define NOTIFY_BRNUP_MAX 0x1f
66#define NOTIFY_BRNDOWN_MIN 0x20
67#define NOTIFY_BRNDOWN_MAX 0x2e
Corentin Charye9809c02011-07-01 11:34:31 +020068#define NOTIFY_KBD_BRTUP 0xc4
69#define NOTIFY_KBD_BRTDWN 0xc5
Yong Wangee027e42010-03-21 10:26:34 +080070
Corentin Chary43815942011-02-06 13:28:43 +010071/* WMI Methods */
Corentin Chary2f686b52011-02-26 10:20:41 +010072#define ASUS_WMI_METHODID_SPEC 0x43455053 /* BIOS SPECification */
73#define ASUS_WMI_METHODID_SFBD 0x44424653 /* Set First Boot Device */
74#define ASUS_WMI_METHODID_GLCD 0x44434C47 /* Get LCD status */
75#define ASUS_WMI_METHODID_GPID 0x44495047 /* Get Panel ID?? (Resol) */
76#define ASUS_WMI_METHODID_QMOD 0x444F4D51 /* Quiet MODe */
77#define ASUS_WMI_METHODID_SPLV 0x4C425053 /* Set Panel Light Value */
Kast Bernd53e755c2015-05-13 16:24:16 +020078#define ASUS_WMI_METHODID_AGFN 0x4E464741 /* FaN? */
Corentin Chary2f686b52011-02-26 10:20:41 +010079#define ASUS_WMI_METHODID_SFUN 0x4E554653 /* FUNCtionalities */
80#define ASUS_WMI_METHODID_SDSP 0x50534453 /* Set DiSPlay output */
81#define ASUS_WMI_METHODID_GDSP 0x50534447 /* Get DiSPlay output */
82#define ASUS_WMI_METHODID_DEVP 0x50564544 /* DEVice Policy */
83#define ASUS_WMI_METHODID_OSVR 0x5256534F /* OS VeRsion */
84#define ASUS_WMI_METHODID_DSTS 0x53544344 /* Device STatuS */
85#define ASUS_WMI_METHODID_DSTS2 0x53545344 /* Device STatuS #2*/
86#define ASUS_WMI_METHODID_BSTS 0x53545342 /* Bios STatuS ? */
87#define ASUS_WMI_METHODID_DEVS 0x53564544 /* DEVice Set */
88#define ASUS_WMI_METHODID_CFVS 0x53564643 /* CPU Frequency Volt Set */
89#define ASUS_WMI_METHODID_KBFT 0x5446424B /* KeyBoard FilTer */
90#define ASUS_WMI_METHODID_INIT 0x54494E49 /* INITialize */
91#define ASUS_WMI_METHODID_HKEY 0x59454B48 /* Hot KEY ?? */
Yong Wang3d7b1652010-04-11 09:27:54 +080092
Corentin Charyd33da3b2011-02-26 10:20:35 +010093#define ASUS_WMI_UNSUPPORTED_METHOD 0xFFFFFFFE
94
Corentin Chary43815942011-02-06 13:28:43 +010095/* Wireless */
Corentin Chary2f686b52011-02-26 10:20:41 +010096#define ASUS_WMI_DEVID_HW_SWITCH 0x00010001
97#define ASUS_WMI_DEVID_WIRELESS_LED 0x00010002
Corentin Chary79ec1172011-07-01 11:34:35 +020098#define ASUS_WMI_DEVID_CWAP 0x00010003
Corentin Charye12e6d92011-02-26 10:20:31 +010099#define ASUS_WMI_DEVID_WLAN 0x00010011
AceLan Kaoa50bd122012-07-26 17:13:31 +0800100#define ASUS_WMI_DEVID_WLAN_LED 0x00010012
Corentin Charye12e6d92011-02-26 10:20:31 +0100101#define ASUS_WMI_DEVID_BLUETOOTH 0x00010013
Corentin Chary2f686b52011-02-26 10:20:41 +0100102#define ASUS_WMI_DEVID_GPS 0x00010015
Corentin Charye12e6d92011-02-26 10:20:31 +0100103#define ASUS_WMI_DEVID_WIMAX 0x00010017
104#define ASUS_WMI_DEVID_WWAN3G 0x00010019
Corentin Chary2f686b52011-02-26 10:20:41 +0100105#define ASUS_WMI_DEVID_UWB 0x00010021
106
107/* Leds */
108/* 0x000200XX and 0x000400XX */
Corentin Chary79ec1172011-07-01 11:34:35 +0200109#define ASUS_WMI_DEVID_LED1 0x00020011
110#define ASUS_WMI_DEVID_LED2 0x00020012
111#define ASUS_WMI_DEVID_LED3 0x00020013
112#define ASUS_WMI_DEVID_LED4 0x00020014
113#define ASUS_WMI_DEVID_LED5 0x00020015
114#define ASUS_WMI_DEVID_LED6 0x00020016
Corentin Chary43815942011-02-06 13:28:43 +0100115
116/* Backlight and Brightness */
Corentin Charye12e6d92011-02-26 10:20:31 +0100117#define ASUS_WMI_DEVID_BACKLIGHT 0x00050011
118#define ASUS_WMI_DEVID_BRIGHTNESS 0x00050012
Corentin Chary2f686b52011-02-26 10:20:41 +0100119#define ASUS_WMI_DEVID_KBD_BACKLIGHT 0x00050021
120#define ASUS_WMI_DEVID_LIGHT_SENSOR 0x00050022 /* ?? */
Corentin Chary43815942011-02-06 13:28:43 +0100121
122/* Misc */
Corentin Charye12e6d92011-02-26 10:20:31 +0100123#define ASUS_WMI_DEVID_CAMERA 0x00060013
Corentin Chary43815942011-02-06 13:28:43 +0100124
125/* Storage */
Corentin Charye12e6d92011-02-26 10:20:31 +0100126#define ASUS_WMI_DEVID_CARDREADER 0x00080013
Corentin Chary43815942011-02-06 13:28:43 +0100127
128/* Input */
Corentin Chary57ab7da2011-02-26 10:20:32 +0100129#define ASUS_WMI_DEVID_TOUCHPAD 0x00100011
Corentin Charye12e6d92011-02-26 10:20:31 +0100130#define ASUS_WMI_DEVID_TOUCHPAD_LED 0x00100012
Yong Wang3d7b1652010-04-11 09:27:54 +0800131
Corentin Chary2f686b52011-02-26 10:20:41 +0100132/* Fan, Thermal */
133#define ASUS_WMI_DEVID_THERMAL_CTRL 0x00110011
134#define ASUS_WMI_DEVID_FAN_CTRL 0x00110012
135
136/* Power */
137#define ASUS_WMI_DEVID_PROCESSOR_STATE 0x00120012
138
AceLan Kaoc0b91b62012-06-13 09:32:07 +0200139/* Deep S3 / Resume on LID open */
140#define ASUS_WMI_DEVID_LID_RESUME 0x00120031
141
Corentin Chary43815942011-02-06 13:28:43 +0100142/* DSTS masks */
Corentin Charye12e6d92011-02-26 10:20:31 +0100143#define ASUS_WMI_DSTS_STATUS_BIT 0x00000001
Corentin Charya75fe0d2011-02-26 10:20:34 +0100144#define ASUS_WMI_DSTS_UNKNOWN_BIT 0x00000002
Corentin Charye12e6d92011-02-26 10:20:31 +0100145#define ASUS_WMI_DSTS_PRESENCE_BIT 0x00010000
Corentin Chary2f686b52011-02-26 10:20:41 +0100146#define ASUS_WMI_DSTS_USER_BIT 0x00020000
147#define ASUS_WMI_DSTS_BIOS_BIT 0x00040000
Corentin Charye12e6d92011-02-26 10:20:31 +0100148#define ASUS_WMI_DSTS_BRIGHTNESS_MASK 0x000000FF
149#define ASUS_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
Yong Wangee027e42010-03-21 10:26:34 +0800150
Kast Bernd53e755c2015-05-13 16:24:16 +0200151#define ASUS_FAN_DESC "cpu_fan"
152#define ASUS_FAN_MFUN 0x13
153#define ASUS_FAN_SFUN_READ 0x06
154#define ASUS_FAN_SFUN_WRITE 0x07
155#define ASUS_FAN_CTRL_MANUAL 1
156#define ASUS_FAN_CTRL_AUTO 2
157
Yong Wang3d7b1652010-04-11 09:27:54 +0800158struct bios_args {
Corentin Charyd33da3b2011-02-26 10:20:35 +0100159 u32 arg0;
160 u32 arg1;
161} __packed;
Yong Wang3d7b1652010-04-11 09:27:54 +0800162
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100163/*
Kast Bernd53e755c2015-05-13 16:24:16 +0200164 * Struct that's used for all methods called via AGFN. Naming is
165 * identically to the AML code.
166 */
167struct agfn_args {
168 u16 mfun; /* probably "Multi-function" to be called */
169 u16 sfun; /* probably "Sub-function" to be called */
170 u16 len; /* size of the hole struct, including subfunction fields */
171 u8 stas; /* not used by now */
172 u8 err; /* zero on success */
173} __packed;
174
175/* struct used for calling fan read and write methods */
176struct fan_args {
177 struct agfn_args agfn; /* common fields */
178 u8 fan; /* fan number: 0: set auto mode 1: 1st fan */
179 u32 speed; /* read: RPM/100 - write: 0-255 */
180} __packed;
181
182/*
Corentin Charye12e6d92011-02-26 10:20:31 +0100183 * <platform>/ - debugfs root directory
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100184 * dev_id - current dev_id
185 * ctrl_param - current ctrl_param
Corentin Charyef343492011-02-26 10:20:39 +0100186 * method_id - current method_id
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100187 * devs - call DEVS(dev_id, ctrl_param) and print result
188 * dsts - call DSTS(dev_id) and print result
Corentin Charyef343492011-02-26 10:20:39 +0100189 * call - call method_id(dev_id, ctrl_param) and print result
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100190 */
Corentin Charye12e6d92011-02-26 10:20:31 +0100191struct asus_wmi_debug {
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100192 struct dentry *root;
Corentin Charyef343492011-02-26 10:20:39 +0100193 u32 method_id;
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100194 u32 dev_id;
195 u32 ctrl_param;
196};
197
Corentin Charya7ce3f02011-02-26 10:20:33 +0100198struct asus_rfkill {
199 struct asus_wmi *asus;
200 struct rfkill *rfkill;
201 u32 dev_id;
202};
203
Corentin Charye12e6d92011-02-26 10:20:31 +0100204struct asus_wmi {
Corentin Chary1d070f82011-02-26 10:20:36 +0100205 int dsts_id;
Corentin Chary46dbca82011-02-26 10:20:38 +0100206 int spec;
207 int sfun;
Corentin Chary1d070f82011-02-26 10:20:36 +0100208
Yong Wang81248882010-04-11 09:26:33 +0800209 struct input_dev *inputdev;
Yong Wang3d7b1652010-04-11 09:27:54 +0800210 struct backlight_device *backlight_device;
Corentin Chary27c136c2010-11-29 08:14:05 +0100211 struct platform_device *platform_device;
Corentin Chary084fca62010-11-29 08:14:06 +0100212
AceLan Kao6cae06e2012-07-27 16:51:59 +0800213 struct led_classdev wlan_led;
214 int wlan_led_wk;
Corentin Chary084fca62010-11-29 08:14:06 +0100215 struct led_classdev tpd_led;
216 int tpd_led_wk;
Corentin Charye9809c02011-07-01 11:34:31 +0200217 struct led_classdev kbd_led;
218 int kbd_led_wk;
Corentin Chary084fca62010-11-29 08:14:06 +0100219 struct workqueue_struct *led_workqueue;
220 struct work_struct tpd_led_work;
Corentin Charye9809c02011-07-01 11:34:31 +0200221 struct work_struct kbd_led_work;
AceLan Kao6cae06e2012-07-27 16:51:59 +0800222 struct work_struct wlan_led_work;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100223
Corentin Charya7ce3f02011-02-26 10:20:33 +0100224 struct asus_rfkill wlan;
225 struct asus_rfkill bluetooth;
226 struct asus_rfkill wimax;
227 struct asus_rfkill wwan3g;
Corentin Chary43be8bd2011-07-01 11:34:40 +0200228 struct asus_rfkill gps;
Corentin Charya912d322011-07-01 11:34:41 +0200229 struct asus_rfkill uwb;
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100230
Kast Bernd53e755c2015-05-13 16:24:16 +0200231 bool asus_hwmon_fan_manual_mode;
232 int asus_hwmon_num_fans;
233 int asus_hwmon_pwm;
234
Corentin Charyafa7c882011-02-06 13:28:28 +0100235 struct hotplug_slot *hotplug_slot;
236 struct mutex hotplug_lock;
Corentin Chary279f8f92011-02-06 13:28:29 +0100237 struct mutex wmi_lock;
238 struct workqueue_struct *hotplug_workqueue;
239 struct work_struct hotplug_work;
Corentin Charyafa7c882011-02-06 13:28:28 +0100240
Corentin Charye12e6d92011-02-26 10:20:31 +0100241 struct asus_wmi_debug debug;
242
243 struct asus_wmi_driver *driver;
Yong Wang81248882010-04-11 09:26:33 +0800244};
245
Corentin Charye12e6d92011-02-26 10:20:31 +0100246static int asus_wmi_input_init(struct asus_wmi *asus)
Yong Wangee027e42010-03-21 10:26:34 +0800247{
248 int err;
249
Corentin Charye12e6d92011-02-26 10:20:31 +0100250 asus->inputdev = input_allocate_device();
251 if (!asus->inputdev)
Yong Wangee027e42010-03-21 10:26:34 +0800252 return -ENOMEM;
253
Corentin Chary58a9f392011-03-30 16:32:32 +0200254 asus->inputdev->name = asus->driver->input_name;
255 asus->inputdev->phys = asus->driver->input_phys;
Corentin Charye12e6d92011-02-26 10:20:31 +0100256 asus->inputdev->id.bustype = BUS_HOST;
257 asus->inputdev->dev.parent = &asus->platform_device->dev;
Seth Forshee39bbde02011-07-04 09:49:20 +0200258 set_bit(EV_REP, asus->inputdev->evbit);
Yong Wangee027e42010-03-21 10:26:34 +0800259
Corentin Charye12e6d92011-02-26 10:20:31 +0100260 err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
Yong Wangee027e42010-03-21 10:26:34 +0800261 if (err)
262 goto err_free_dev;
263
Corentin Charye12e6d92011-02-26 10:20:31 +0100264 err = input_register_device(asus->inputdev);
Yong Wangee027e42010-03-21 10:26:34 +0800265 if (err)
266 goto err_free_keymap;
267
268 return 0;
269
270err_free_keymap:
Corentin Charye12e6d92011-02-26 10:20:31 +0100271 sparse_keymap_free(asus->inputdev);
Yong Wangee027e42010-03-21 10:26:34 +0800272err_free_dev:
Corentin Charye12e6d92011-02-26 10:20:31 +0100273 input_free_device(asus->inputdev);
Yong Wangee027e42010-03-21 10:26:34 +0800274 return err;
275}
276
Corentin Charye12e6d92011-02-26 10:20:31 +0100277static void asus_wmi_input_exit(struct asus_wmi *asus)
Yong Wang81248882010-04-11 09:26:33 +0800278{
Corentin Charye12e6d92011-02-26 10:20:31 +0100279 if (asus->inputdev) {
280 sparse_keymap_free(asus->inputdev);
281 input_unregister_device(asus->inputdev);
Yong Wang81248882010-04-11 09:26:33 +0800282 }
283
Corentin Charye12e6d92011-02-26 10:20:31 +0100284 asus->inputdev = NULL;
Yong Wang81248882010-04-11 09:26:33 +0800285}
286
Corentin Charyd33da3b2011-02-26 10:20:35 +0100287static int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
288 u32 *retval)
Yong Wang3d7b1652010-04-11 09:27:54 +0800289{
Corentin Charyd33da3b2011-02-26 10:20:35 +0100290 struct bios_args args = {
291 .arg0 = arg0,
292 .arg1 = arg1,
293 };
294 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
Yong Wang3d7b1652010-04-11 09:27:54 +0800295 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
Yong Wang3d7b1652010-04-11 09:27:54 +0800296 acpi_status status;
Corentin Charyd33da3b2011-02-26 10:20:35 +0100297 union acpi_object *obj;
Rickard Strandqvist8ad3be1e2014-06-01 14:58:52 +0200298 u32 tmp = 0;
Yong Wang3d7b1652010-04-11 09:27:54 +0800299
Corentin Charyd33da3b2011-02-26 10:20:35 +0100300 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1, method_id,
Corentin Charyafa7c882011-02-06 13:28:28 +0100301 &input, &output);
Yong Wang3d7b1652010-04-11 09:27:54 +0800302
303 if (ACPI_FAILURE(status))
Corentin Charyd33da3b2011-02-26 10:20:35 +0100304 goto exit;
Yong Wang3d7b1652010-04-11 09:27:54 +0800305
306 obj = (union acpi_object *)output.pointer;
307 if (obj && obj->type == ACPI_TYPE_INTEGER)
Corentin Charye12e6d92011-02-26 10:20:31 +0100308 tmp = (u32) obj->integer.value;
Yong Wang3d7b1652010-04-11 09:27:54 +0800309
Corentin Chary2a3f0062010-11-29 08:14:10 +0100310 if (retval)
311 *retval = tmp;
Yong Wang3d7b1652010-04-11 09:27:54 +0800312
313 kfree(obj);
314
Corentin Charyd33da3b2011-02-26 10:20:35 +0100315exit:
316 if (ACPI_FAILURE(status))
317 return -EIO;
Yong Wang3d7b1652010-04-11 09:27:54 +0800318
Corentin Charyd33da3b2011-02-26 10:20:35 +0100319 if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
320 return -ENODEV;
321
322 return 0;
Yong Wang3d7b1652010-04-11 09:27:54 +0800323}
324
Kast Bernd53e755c2015-05-13 16:24:16 +0200325static int asus_wmi_evaluate_method_agfn(const struct acpi_buffer args)
326{
327 struct acpi_buffer input;
328 u64 phys_addr;
329 u32 retval;
330 u32 status = -1;
331
332 /*
333 * Copy to dma capable address otherwise memory corruption occurs as
334 * bios has to be able to access it.
335 */
336 input.pointer = kzalloc(args.length, GFP_DMA | GFP_KERNEL);
337 input.length = args.length;
338 if (!input.pointer)
339 return -ENOMEM;
340 phys_addr = virt_to_phys(input.pointer);
341 memcpy(input.pointer, args.pointer, args.length);
342
343 status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_AGFN,
344 phys_addr, 0, &retval);
345 if (!status)
346 memcpy(args.pointer, input.pointer, args.length);
347
348 kfree(input.pointer);
349 if (status)
350 return -ENXIO;
351
352 return retval;
353}
354
Corentin Chary1d070f82011-02-26 10:20:36 +0100355static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
Corentin Charyd33da3b2011-02-26 10:20:35 +0100356{
Corentin Chary1d070f82011-02-26 10:20:36 +0100357 return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
Corentin Charyd33da3b2011-02-26 10:20:35 +0100358}
359
360static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
Corentin Chary1d070f82011-02-26 10:20:36 +0100361 u32 *retval)
Yong Wang3d7b1652010-04-11 09:27:54 +0800362{
Corentin Charyd33da3b2011-02-26 10:20:35 +0100363 return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
364 ctrl_param, retval);
Yong Wang3d7b1652010-04-11 09:27:54 +0800365}
366
Corentin Chary5c956382011-02-06 13:28:31 +0100367/* Helper for special devices with magic return codes */
Corentin Chary1d070f82011-02-26 10:20:36 +0100368static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
369 u32 dev_id, u32 mask)
Corentin Chary5c956382011-02-06 13:28:31 +0100370{
371 u32 retval = 0;
Corentin Charyd33da3b2011-02-26 10:20:35 +0100372 int err;
Corentin Chary5c956382011-02-06 13:28:31 +0100373
Corentin Chary1d070f82011-02-26 10:20:36 +0100374 err = asus_wmi_get_devstate(asus, dev_id, &retval);
Corentin Chary5c956382011-02-06 13:28:31 +0100375
Corentin Charyd33da3b2011-02-26 10:20:35 +0100376 if (err < 0)
377 return err;
Corentin Chary5c956382011-02-06 13:28:31 +0100378
Corentin Charye12e6d92011-02-26 10:20:31 +0100379 if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
Corentin Chary5c956382011-02-06 13:28:31 +0100380 return -ENODEV;
381
Corentin Charya75fe0d2011-02-26 10:20:34 +0100382 if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
383 if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
384 return -ENODEV;
385 }
386
Corentin Charyb7187262011-02-06 13:28:39 +0100387 return retval & mask;
388}
389
Corentin Chary1d070f82011-02-26 10:20:36 +0100390static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
Corentin Charyb7187262011-02-06 13:28:39 +0100391{
Corentin Chary1d070f82011-02-26 10:20:36 +0100392 return asus_wmi_get_devstate_bits(asus, dev_id,
393 ASUS_WMI_DSTS_STATUS_BIT);
Corentin Chary5c956382011-02-06 13:28:31 +0100394}
395
Corentin Chary084fca62010-11-29 08:14:06 +0100396/*
397 * LEDs
398 */
399/*
400 * These functions actually update the LED's, and are called from a
401 * workqueue. By doing this as separate work rather than when the LED
Corentin Charye12e6d92011-02-26 10:20:31 +0100402 * subsystem asks, we avoid messing with the Asus ACPI stuff during a
Corentin Chary084fca62010-11-29 08:14:06 +0100403 * potentially bad time, such as a timer interrupt.
404 */
405static void tpd_led_update(struct work_struct *work)
406{
407 int ctrl_param;
Corentin Charye12e6d92011-02-26 10:20:31 +0100408 struct asus_wmi *asus;
Corentin Chary084fca62010-11-29 08:14:06 +0100409
Corentin Charye12e6d92011-02-26 10:20:31 +0100410 asus = container_of(work, struct asus_wmi, tpd_led_work);
Corentin Chary084fca62010-11-29 08:14:06 +0100411
Corentin Charye12e6d92011-02-26 10:20:31 +0100412 ctrl_param = asus->tpd_led_wk;
413 asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
Corentin Chary084fca62010-11-29 08:14:06 +0100414}
415
416static void tpd_led_set(struct led_classdev *led_cdev,
417 enum led_brightness value)
418{
Corentin Charye12e6d92011-02-26 10:20:31 +0100419 struct asus_wmi *asus;
Corentin Chary084fca62010-11-29 08:14:06 +0100420
Corentin Charye12e6d92011-02-26 10:20:31 +0100421 asus = container_of(led_cdev, struct asus_wmi, tpd_led);
Corentin Chary084fca62010-11-29 08:14:06 +0100422
Corentin Charye12e6d92011-02-26 10:20:31 +0100423 asus->tpd_led_wk = !!value;
424 queue_work(asus->led_workqueue, &asus->tpd_led_work);
Corentin Chary084fca62010-11-29 08:14:06 +0100425}
426
Corentin Charye12e6d92011-02-26 10:20:31 +0100427static int read_tpd_led_state(struct asus_wmi *asus)
Corentin Chary084fca62010-11-29 08:14:06 +0100428{
Corentin Chary1d070f82011-02-26 10:20:36 +0100429 return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
Corentin Chary084fca62010-11-29 08:14:06 +0100430}
431
432static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
433{
Corentin Charye12e6d92011-02-26 10:20:31 +0100434 struct asus_wmi *asus;
Corentin Chary084fca62010-11-29 08:14:06 +0100435
Corentin Charye12e6d92011-02-26 10:20:31 +0100436 asus = container_of(led_cdev, struct asus_wmi, tpd_led);
Corentin Chary084fca62010-11-29 08:14:06 +0100437
Corentin Charye12e6d92011-02-26 10:20:31 +0100438 return read_tpd_led_state(asus);
Corentin Chary084fca62010-11-29 08:14:06 +0100439}
440
Corentin Charye9809c02011-07-01 11:34:31 +0200441static void kbd_led_update(struct work_struct *work)
Corentin Chary084fca62010-11-29 08:14:06 +0100442{
Corentin Charye9809c02011-07-01 11:34:31 +0200443 int ctrl_param = 0;
444 struct asus_wmi *asus;
Corentin Chary084fca62010-11-29 08:14:06 +0100445
Corentin Charye9809c02011-07-01 11:34:31 +0200446 asus = container_of(work, struct asus_wmi, kbd_led_work);
Corentin Chary084fca62010-11-29 08:14:06 +0100447
Corentin Charye9809c02011-07-01 11:34:31 +0200448 /*
449 * bits 0-2: level
450 * bit 7: light on/off
451 */
452 if (asus->kbd_led_wk > 0)
453 ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
Corentin Chary084fca62010-11-29 08:14:06 +0100454
Corentin Charye9809c02011-07-01 11:34:31 +0200455 asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
456}
Corentin Chary084fca62010-11-29 08:14:06 +0100457
Corentin Charye9809c02011-07-01 11:34:31 +0200458static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
459{
460 int retval;
461
462 /*
463 * bits 0-2: level
464 * bit 7: light on/off
465 * bit 8-10: environment (0: dark, 1: normal, 2: light)
466 * bit 17: status unknown
467 */
468 retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
469 0xFFFF);
470
Corentin Charyaf965e92011-07-01 11:34:34 +0200471 /* Unknown status is considered as off */
Corentin Charye9809c02011-07-01 11:34:31 +0200472 if (retval == 0x8000)
Corentin Charyaf965e92011-07-01 11:34:34 +0200473 retval = 0;
Corentin Charye9809c02011-07-01 11:34:31 +0200474
475 if (retval >= 0) {
476 if (level)
Corentin Charyc09b2232012-03-20 09:53:04 +0100477 *level = retval & 0x7F;
Corentin Charye9809c02011-07-01 11:34:31 +0200478 if (env)
479 *env = (retval >> 8) & 0x7F;
480 retval = 0;
Corentin Chary084fca62010-11-29 08:14:06 +0100481 }
482
Corentin Charye9809c02011-07-01 11:34:31 +0200483 return retval;
484}
485
486static void kbd_led_set(struct led_classdev *led_cdev,
487 enum led_brightness value)
488{
489 struct asus_wmi *asus;
490
491 asus = container_of(led_cdev, struct asus_wmi, kbd_led);
492
493 if (value > asus->kbd_led.max_brightness)
494 value = asus->kbd_led.max_brightness;
495 else if (value < 0)
496 value = 0;
497
498 asus->kbd_led_wk = value;
499 queue_work(asus->led_workqueue, &asus->kbd_led_work);
500}
501
502static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
503{
504 struct asus_wmi *asus;
505 int retval, value;
506
507 asus = container_of(led_cdev, struct asus_wmi, kbd_led);
508
509 retval = kbd_led_read(asus, &value, NULL);
510
511 if (retval < 0)
512 return retval;
513
514 return value;
Corentin Chary084fca62010-11-29 08:14:06 +0100515}
516
AceLan Kao6cae06e2012-07-27 16:51:59 +0800517static int wlan_led_unknown_state(struct asus_wmi *asus)
518{
519 u32 result;
520
521 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
522
523 return result & ASUS_WMI_DSTS_UNKNOWN_BIT;
524}
525
526static int wlan_led_presence(struct asus_wmi *asus)
527{
528 u32 result;
529
530 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
531
532 return result & ASUS_WMI_DSTS_PRESENCE_BIT;
533}
534
535static void wlan_led_update(struct work_struct *work)
536{
537 int ctrl_param;
538 struct asus_wmi *asus;
539
540 asus = container_of(work, struct asus_wmi, wlan_led_work);
541
542 ctrl_param = asus->wlan_led_wk;
543 asus_wmi_set_devstate(ASUS_WMI_DEVID_WIRELESS_LED, ctrl_param, NULL);
544}
545
546static void wlan_led_set(struct led_classdev *led_cdev,
547 enum led_brightness value)
548{
549 struct asus_wmi *asus;
550
551 asus = container_of(led_cdev, struct asus_wmi, wlan_led);
552
553 asus->wlan_led_wk = !!value;
554 queue_work(asus->led_workqueue, &asus->wlan_led_work);
555}
556
557static enum led_brightness wlan_led_get(struct led_classdev *led_cdev)
558{
559 struct asus_wmi *asus;
560 u32 result;
561
562 asus = container_of(led_cdev, struct asus_wmi, wlan_led);
563 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
564
565 return result & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
566}
567
Corentin Charye12e6d92011-02-26 10:20:31 +0100568static void asus_wmi_led_exit(struct asus_wmi *asus)
Corentin Chary084fca62010-11-29 08:14:06 +0100569{
Axel Line9298022011-08-08 17:16:01 +0800570 if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
571 led_classdev_unregister(&asus->kbd_led);
572 if (!IS_ERR_OR_NULL(asus->tpd_led.dev))
Corentin Charye12e6d92011-02-26 10:20:31 +0100573 led_classdev_unregister(&asus->tpd_led);
AceLan Kao6cae06e2012-07-27 16:51:59 +0800574 if (!IS_ERR_OR_NULL(asus->wlan_led.dev))
575 led_classdev_unregister(&asus->wlan_led);
Corentin Charye12e6d92011-02-26 10:20:31 +0100576 if (asus->led_workqueue)
577 destroy_workqueue(asus->led_workqueue);
Corentin Chary084fca62010-11-29 08:14:06 +0100578}
579
Corentin Charye9809c02011-07-01 11:34:31 +0200580static int asus_wmi_led_init(struct asus_wmi *asus)
581{
Oleksij Rempel30734042015-09-14 11:16:30 +0200582 int rv = 0, led_val;
Corentin Charye9809c02011-07-01 11:34:31 +0200583
584 asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
585 if (!asus->led_workqueue)
586 return -ENOMEM;
587
588 if (read_tpd_led_state(asus) >= 0) {
589 INIT_WORK(&asus->tpd_led_work, tpd_led_update);
590
591 asus->tpd_led.name = "asus::touchpad";
592 asus->tpd_led.brightness_set = tpd_led_set;
593 asus->tpd_led.brightness_get = tpd_led_get;
594 asus->tpd_led.max_brightness = 1;
595
596 rv = led_classdev_register(&asus->platform_device->dev,
597 &asus->tpd_led);
598 if (rv)
599 goto error;
600 }
601
Oleksij Rempel30734042015-09-14 11:16:30 +0200602 led_val = kbd_led_read(asus, NULL, NULL);
603 if (led_val >= 0) {
Corentin Charye9809c02011-07-01 11:34:31 +0200604 INIT_WORK(&asus->kbd_led_work, kbd_led_update);
605
Oleksij Rempel30734042015-09-14 11:16:30 +0200606 asus->kbd_led_wk = led_val;
Corentin Charye9809c02011-07-01 11:34:31 +0200607 asus->kbd_led.name = "asus::kbd_backlight";
608 asus->kbd_led.brightness_set = kbd_led_set;
609 asus->kbd_led.brightness_get = kbd_led_get;
610 asus->kbd_led.max_brightness = 3;
611
612 rv = led_classdev_register(&asus->platform_device->dev,
613 &asus->kbd_led);
AceLan Kao6cae06e2012-07-27 16:51:59 +0800614 if (rv)
615 goto error;
616 }
617
AceLan Kaof5156232014-07-09 16:18:18 +0800618 if (wlan_led_presence(asus) && (asus->driver->quirks->wapf > 0)) {
AceLan Kao6cae06e2012-07-27 16:51:59 +0800619 INIT_WORK(&asus->wlan_led_work, wlan_led_update);
620
621 asus->wlan_led.name = "asus::wlan";
622 asus->wlan_led.brightness_set = wlan_led_set;
623 if (!wlan_led_unknown_state(asus))
624 asus->wlan_led.brightness_get = wlan_led_get;
625 asus->wlan_led.flags = LED_CORE_SUSPENDRESUME;
626 asus->wlan_led.max_brightness = 1;
627 asus->wlan_led.default_trigger = "asus-wlan";
628
629 rv = led_classdev_register(&asus->platform_device->dev,
630 &asus->wlan_led);
Corentin Charye9809c02011-07-01 11:34:31 +0200631 }
632
633error:
634 if (rv)
635 asus_wmi_led_exit(asus);
636
637 return rv;
638}
639
640
Corentin Chary084fca62010-11-29 08:14:06 +0100641/*
Corentin Charyafa7c882011-02-06 13:28:28 +0100642 * PCI hotplug (for wlan rfkill)
643 */
Corentin Charye12e6d92011-02-26 10:20:31 +0100644static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
Corentin Charyafa7c882011-02-06 13:28:28 +0100645{
Corentin Chary1d070f82011-02-26 10:20:36 +0100646 int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
Corentin Charyafa7c882011-02-06 13:28:28 +0100647
Corentin Chary5c956382011-02-06 13:28:31 +0100648 if (result < 0)
Corentin Charyafa7c882011-02-06 13:28:28 +0100649 return false;
Corentin Chary5c956382011-02-06 13:28:31 +0100650 return !result;
Corentin Charyafa7c882011-02-06 13:28:28 +0100651}
652
Corentin Charye12e6d92011-02-26 10:20:31 +0100653static void asus_rfkill_hotplug(struct asus_wmi *asus)
Corentin Charyafa7c882011-02-06 13:28:28 +0100654{
655 struct pci_dev *dev;
656 struct pci_bus *bus;
Corentin Chary279f8f92011-02-06 13:28:29 +0100657 bool blocked;
Corentin Charyafa7c882011-02-06 13:28:28 +0100658 bool absent;
659 u32 l;
660
Corentin Charye12e6d92011-02-26 10:20:31 +0100661 mutex_lock(&asus->wmi_lock);
662 blocked = asus_wlan_rfkill_blocked(asus);
663 mutex_unlock(&asus->wmi_lock);
Corentin Charyafa7c882011-02-06 13:28:28 +0100664
Corentin Charye12e6d92011-02-26 10:20:31 +0100665 mutex_lock(&asus->hotplug_lock);
Rafael J. Wysocki8b9ec1d2014-01-10 15:27:08 +0100666 pci_lock_rescan_remove();
Corentin Charyafa7c882011-02-06 13:28:28 +0100667
Corentin Charya7ce3f02011-02-26 10:20:33 +0100668 if (asus->wlan.rfkill)
669 rfkill_set_sw_state(asus->wlan.rfkill, blocked);
Corentin Chary279f8f92011-02-06 13:28:29 +0100670
Corentin Charye12e6d92011-02-26 10:20:31 +0100671 if (asus->hotplug_slot) {
Corentin Charyafa7c882011-02-06 13:28:28 +0100672 bus = pci_find_bus(0, 1);
673 if (!bus) {
Joe Perches5ad77dc2011-03-29 15:21:35 -0700674 pr_warn("Unable to find PCI bus 1?\n");
Corentin Charyafa7c882011-02-06 13:28:28 +0100675 goto out_unlock;
676 }
677
678 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
679 pr_err("Unable to read PCI config space?\n");
680 goto out_unlock;
681 }
682 absent = (l == 0xffffffff);
683
684 if (blocked != absent) {
Joe Perches5ad77dc2011-03-29 15:21:35 -0700685 pr_warn("BIOS says wireless lan is %s, "
686 "but the pci device is %s\n",
687 blocked ? "blocked" : "unblocked",
688 absent ? "absent" : "present");
689 pr_warn("skipped wireless hotplug as probably "
690 "inappropriate for this model\n");
Corentin Charyafa7c882011-02-06 13:28:28 +0100691 goto out_unlock;
692 }
693
694 if (!blocked) {
695 dev = pci_get_slot(bus, 0);
696 if (dev) {
697 /* Device already present */
698 pci_dev_put(dev);
699 goto out_unlock;
700 }
701 dev = pci_scan_single_device(bus, 0);
702 if (dev) {
703 pci_bus_assign_resources(bus);
Yijing Wangc893d132014-05-30 11:01:03 +0800704 pci_bus_add_device(dev);
Corentin Charyafa7c882011-02-06 13:28:28 +0100705 }
706 } else {
707 dev = pci_get_slot(bus, 0);
708 if (dev) {
Yinghai Lu210647a2012-02-25 13:54:20 -0800709 pci_stop_and_remove_bus_device(dev);
Corentin Charyafa7c882011-02-06 13:28:28 +0100710 pci_dev_put(dev);
711 }
712 }
713 }
714
715out_unlock:
Rafael J. Wysocki8b9ec1d2014-01-10 15:27:08 +0100716 pci_unlock_rescan_remove();
Corentin Charye12e6d92011-02-26 10:20:31 +0100717 mutex_unlock(&asus->hotplug_lock);
Corentin Charyafa7c882011-02-06 13:28:28 +0100718}
719
Corentin Charye12e6d92011-02-26 10:20:31 +0100720static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
Corentin Charyafa7c882011-02-06 13:28:28 +0100721{
Corentin Charye12e6d92011-02-26 10:20:31 +0100722 struct asus_wmi *asus = data;
Corentin Charyafa7c882011-02-06 13:28:28 +0100723
724 if (event != ACPI_NOTIFY_BUS_CHECK)
725 return;
726
Corentin Chary279f8f92011-02-06 13:28:29 +0100727 /*
Corentin Charye12e6d92011-02-26 10:20:31 +0100728 * We can't call directly asus_rfkill_hotplug because most
Corentin Chary279f8f92011-02-06 13:28:29 +0100729 * of the time WMBC is still being executed and not reetrant.
730 * There is currently no way to tell ACPICA that we want this
Corentin Charye12e6d92011-02-26 10:20:31 +0100731 * method to be serialized, we schedule a asus_rfkill_hotplug
Corentin Chary279f8f92011-02-06 13:28:29 +0100732 * call later, in a safer context.
733 */
Corentin Charye12e6d92011-02-26 10:20:31 +0100734 queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
Corentin Charyafa7c882011-02-06 13:28:28 +0100735}
736
Corentin Charye12e6d92011-02-26 10:20:31 +0100737static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
Corentin Charyafa7c882011-02-06 13:28:28 +0100738{
739 acpi_status status;
740 acpi_handle handle;
741
742 status = acpi_get_handle(NULL, node, &handle);
743
744 if (ACPI_SUCCESS(status)) {
745 status = acpi_install_notify_handler(handle,
746 ACPI_SYSTEM_NOTIFY,
Corentin Charye12e6d92011-02-26 10:20:31 +0100747 asus_rfkill_notify, asus);
Corentin Charyafa7c882011-02-06 13:28:28 +0100748 if (ACPI_FAILURE(status))
Joe Perches5ad77dc2011-03-29 15:21:35 -0700749 pr_warn("Failed to register notify on %s\n", node);
Corentin Charyafa7c882011-02-06 13:28:28 +0100750 } else
751 return -ENODEV;
752
753 return 0;
754}
755
Corentin Charye12e6d92011-02-26 10:20:31 +0100756static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
Corentin Charyafa7c882011-02-06 13:28:28 +0100757{
758 acpi_status status = AE_OK;
759 acpi_handle handle;
760
761 status = acpi_get_handle(NULL, node, &handle);
762
763 if (ACPI_SUCCESS(status)) {
764 status = acpi_remove_notify_handler(handle,
Corentin Charye12e6d92011-02-26 10:20:31 +0100765 ACPI_SYSTEM_NOTIFY,
766 asus_rfkill_notify);
Corentin Charyafa7c882011-02-06 13:28:28 +0100767 if (ACPI_FAILURE(status))
768 pr_err("Error removing rfkill notify handler %s\n",
Corentin Charye12e6d92011-02-26 10:20:31 +0100769 node);
Corentin Charyafa7c882011-02-06 13:28:28 +0100770 }
771}
772
Corentin Charye12e6d92011-02-26 10:20:31 +0100773static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
774 u8 *value)
Corentin Charyafa7c882011-02-06 13:28:28 +0100775{
Corentin Chary1d070f82011-02-26 10:20:36 +0100776 struct asus_wmi *asus = hotplug_slot->private;
777 int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
Corentin Charyafa7c882011-02-06 13:28:28 +0100778
Corentin Chary5c956382011-02-06 13:28:31 +0100779 if (result < 0)
780 return result;
Corentin Charyafa7c882011-02-06 13:28:28 +0100781
Corentin Chary5c956382011-02-06 13:28:31 +0100782 *value = !!result;
Corentin Charyafa7c882011-02-06 13:28:28 +0100783 return 0;
784}
785
Corentin Charye12e6d92011-02-26 10:20:31 +0100786static void asus_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
Corentin Charyafa7c882011-02-06 13:28:28 +0100787{
788 kfree(hotplug_slot->info);
789 kfree(hotplug_slot);
790}
791
Corentin Charye12e6d92011-02-26 10:20:31 +0100792static struct hotplug_slot_ops asus_hotplug_slot_ops = {
Corentin Charyafa7c882011-02-06 13:28:28 +0100793 .owner = THIS_MODULE,
Corentin Charye12e6d92011-02-26 10:20:31 +0100794 .get_adapter_status = asus_get_adapter_status,
795 .get_power_status = asus_get_adapter_status,
Corentin Charyafa7c882011-02-06 13:28:28 +0100796};
797
Corentin Charye12e6d92011-02-26 10:20:31 +0100798static void asus_hotplug_work(struct work_struct *work)
Corentin Chary279f8f92011-02-06 13:28:29 +0100799{
Corentin Charye12e6d92011-02-26 10:20:31 +0100800 struct asus_wmi *asus;
Corentin Chary279f8f92011-02-06 13:28:29 +0100801
Corentin Charye12e6d92011-02-26 10:20:31 +0100802 asus = container_of(work, struct asus_wmi, hotplug_work);
803 asus_rfkill_hotplug(asus);
Corentin Chary279f8f92011-02-06 13:28:29 +0100804}
805
Corentin Charye12e6d92011-02-26 10:20:31 +0100806static int asus_setup_pci_hotplug(struct asus_wmi *asus)
Corentin Charyafa7c882011-02-06 13:28:28 +0100807{
808 int ret = -ENOMEM;
809 struct pci_bus *bus = pci_find_bus(0, 1);
810
811 if (!bus) {
812 pr_err("Unable to find wifi PCI bus\n");
813 return -ENODEV;
814 }
815
Corentin Charye12e6d92011-02-26 10:20:31 +0100816 asus->hotplug_workqueue =
817 create_singlethread_workqueue("hotplug_workqueue");
818 if (!asus->hotplug_workqueue)
Corentin Chary279f8f92011-02-06 13:28:29 +0100819 goto error_workqueue;
820
Corentin Charye12e6d92011-02-26 10:20:31 +0100821 INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
Corentin Chary279f8f92011-02-06 13:28:29 +0100822
Corentin Charye12e6d92011-02-26 10:20:31 +0100823 asus->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
824 if (!asus->hotplug_slot)
Corentin Charyafa7c882011-02-06 13:28:28 +0100825 goto error_slot;
826
Corentin Charye12e6d92011-02-26 10:20:31 +0100827 asus->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
828 GFP_KERNEL);
829 if (!asus->hotplug_slot->info)
Corentin Charyafa7c882011-02-06 13:28:28 +0100830 goto error_info;
831
Corentin Charye12e6d92011-02-26 10:20:31 +0100832 asus->hotplug_slot->private = asus;
833 asus->hotplug_slot->release = &asus_cleanup_pci_hotplug;
834 asus->hotplug_slot->ops = &asus_hotplug_slot_ops;
835 asus_get_adapter_status(asus->hotplug_slot,
836 &asus->hotplug_slot->info->adapter_status);
Corentin Charyafa7c882011-02-06 13:28:28 +0100837
Corentin Charye12e6d92011-02-26 10:20:31 +0100838 ret = pci_hp_register(asus->hotplug_slot, bus, 0, "asus-wifi");
Corentin Charyafa7c882011-02-06 13:28:28 +0100839 if (ret) {
840 pr_err("Unable to register hotplug slot - %d\n", ret);
841 goto error_register;
842 }
843
844 return 0;
845
846error_register:
Corentin Charye12e6d92011-02-26 10:20:31 +0100847 kfree(asus->hotplug_slot->info);
Corentin Charyafa7c882011-02-06 13:28:28 +0100848error_info:
Corentin Charye12e6d92011-02-26 10:20:31 +0100849 kfree(asus->hotplug_slot);
850 asus->hotplug_slot = NULL;
Corentin Charyafa7c882011-02-06 13:28:28 +0100851error_slot:
Corentin Charye12e6d92011-02-26 10:20:31 +0100852 destroy_workqueue(asus->hotplug_workqueue);
Corentin Chary279f8f92011-02-06 13:28:29 +0100853error_workqueue:
Corentin Charyafa7c882011-02-06 13:28:28 +0100854 return ret;
855}
856
857/*
Corentin Charyba48fdb2010-11-29 08:14:07 +0100858 * Rfkill devices
859 */
Corentin Charye12e6d92011-02-26 10:20:31 +0100860static int asus_rfkill_set(void *data, bool blocked)
Corentin Charyba48fdb2010-11-29 08:14:07 +0100861{
Corentin Charya7ce3f02011-02-26 10:20:33 +0100862 struct asus_rfkill *priv = data;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100863 u32 ctrl_param = !blocked;
AceLan Kaoa50bd122012-07-26 17:13:31 +0800864 u32 dev_id = priv->dev_id;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100865
AceLan Kaoa50bd122012-07-26 17:13:31 +0800866 /*
867 * If the user bit is set, BIOS can't set and record the wlan status,
868 * it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
869 * while we query the wlan status through WMI(ASUS_WMI_DEVID_WLAN).
870 * So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
871 * while setting the wlan status through WMI.
872 * This is also the behavior that windows app will do.
873 */
874 if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
875 priv->asus->driver->wlan_ctrl_by_user)
876 dev_id = ASUS_WMI_DEVID_WLAN_LED;
877
878 return asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100879}
880
Corentin Charye12e6d92011-02-26 10:20:31 +0100881static void asus_rfkill_query(struct rfkill *rfkill, void *data)
Corentin Charyba48fdb2010-11-29 08:14:07 +0100882{
Corentin Charya7ce3f02011-02-26 10:20:33 +0100883 struct asus_rfkill *priv = data;
Corentin Chary5c956382011-02-06 13:28:31 +0100884 int result;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100885
Corentin Chary1d070f82011-02-26 10:20:36 +0100886 result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100887
Corentin Chary5c956382011-02-06 13:28:31 +0100888 if (result < 0)
Corentin Charye12e6d92011-02-26 10:20:31 +0100889 return;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100890
Corentin Charya7ce3f02011-02-26 10:20:33 +0100891 rfkill_set_sw_state(priv->rfkill, !result);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100892}
893
Corentin Charye12e6d92011-02-26 10:20:31 +0100894static int asus_rfkill_wlan_set(void *data, bool blocked)
Corentin Chary279f8f92011-02-06 13:28:29 +0100895{
Corentin Charya7ce3f02011-02-26 10:20:33 +0100896 struct asus_rfkill *priv = data;
897 struct asus_wmi *asus = priv->asus;
Corentin Chary279f8f92011-02-06 13:28:29 +0100898 int ret;
899
900 /*
901 * This handler is enabled only if hotplug is enabled.
Corentin Charye12e6d92011-02-26 10:20:31 +0100902 * In this case, the asus_wmi_set_devstate() will
Corentin Chary279f8f92011-02-06 13:28:29 +0100903 * trigger a wmi notification and we need to wait
904 * this call to finish before being able to call
905 * any wmi method
906 */
Corentin Charye12e6d92011-02-26 10:20:31 +0100907 mutex_lock(&asus->wmi_lock);
Corentin Charya7ce3f02011-02-26 10:20:33 +0100908 ret = asus_rfkill_set(data, blocked);
Corentin Charye12e6d92011-02-26 10:20:31 +0100909 mutex_unlock(&asus->wmi_lock);
Corentin Chary279f8f92011-02-06 13:28:29 +0100910 return ret;
911}
912
Corentin Charye12e6d92011-02-26 10:20:31 +0100913static const struct rfkill_ops asus_rfkill_wlan_ops = {
914 .set_block = asus_rfkill_wlan_set,
Corentin Charya7ce3f02011-02-26 10:20:33 +0100915 .query = asus_rfkill_query,
Corentin Chary279f8f92011-02-06 13:28:29 +0100916};
917
Corentin Charye12e6d92011-02-26 10:20:31 +0100918static const struct rfkill_ops asus_rfkill_ops = {
919 .set_block = asus_rfkill_set,
920 .query = asus_rfkill_query,
Corentin Charyba48fdb2010-11-29 08:14:07 +0100921};
922
Corentin Charye12e6d92011-02-26 10:20:31 +0100923static int asus_new_rfkill(struct asus_wmi *asus,
Corentin Charya7ce3f02011-02-26 10:20:33 +0100924 struct asus_rfkill *arfkill,
Corentin Charye12e6d92011-02-26 10:20:31 +0100925 const char *name, enum rfkill_type type, int dev_id)
Corentin Charyba48fdb2010-11-29 08:14:07 +0100926{
Corentin Chary1d070f82011-02-26 10:20:36 +0100927 int result = asus_wmi_get_devstate_simple(asus, dev_id);
Corentin Charya7ce3f02011-02-26 10:20:33 +0100928 struct rfkill **rfkill = &arfkill->rfkill;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100929
Corentin Chary5c956382011-02-06 13:28:31 +0100930 if (result < 0)
931 return result;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100932
Corentin Charya7ce3f02011-02-26 10:20:33 +0100933 arfkill->dev_id = dev_id;
934 arfkill->asus = asus;
935
AceLan Kaoc87992d2012-03-20 09:53:08 +0100936 if (dev_id == ASUS_WMI_DEVID_WLAN &&
937 asus->driver->quirks->hotplug_wireless)
Corentin Charye12e6d92011-02-26 10:20:31 +0100938 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
Corentin Charya7ce3f02011-02-26 10:20:33 +0100939 &asus_rfkill_wlan_ops, arfkill);
Corentin Chary279f8f92011-02-06 13:28:29 +0100940 else
Corentin Charye12e6d92011-02-26 10:20:31 +0100941 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
Corentin Charya7ce3f02011-02-26 10:20:33 +0100942 &asus_rfkill_ops, arfkill);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100943
944 if (!*rfkill)
945 return -EINVAL;
946
AceLan Kaoe8f56c82013-05-30 10:31:50 +0800947 if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
AceLan Kaof5156232014-07-09 16:18:18 +0800948 (asus->driver->quirks->wapf > 0))
AceLan Kao6cae06e2012-07-27 16:51:59 +0800949 rfkill_set_led_trigger_name(*rfkill, "asus-wlan");
950
Corentin Chary5c956382011-02-06 13:28:31 +0100951 rfkill_init_sw_state(*rfkill, !result);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100952 result = rfkill_register(*rfkill);
953 if (result) {
954 rfkill_destroy(*rfkill);
955 *rfkill = NULL;
956 return result;
957 }
958 return 0;
959}
960
Corentin Charye12e6d92011-02-26 10:20:31 +0100961static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
Corentin Charyba48fdb2010-11-29 08:14:07 +0100962{
Corentin Charye12e6d92011-02-26 10:20:31 +0100963 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
964 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
965 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
Corentin Charya7ce3f02011-02-26 10:20:33 +0100966 if (asus->wlan.rfkill) {
967 rfkill_unregister(asus->wlan.rfkill);
968 rfkill_destroy(asus->wlan.rfkill);
969 asus->wlan.rfkill = NULL;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100970 }
Corentin Charyafa7c882011-02-06 13:28:28 +0100971 /*
972 * Refresh pci hotplug in case the rfkill state was changed after
Corentin Charye12e6d92011-02-26 10:20:31 +0100973 * asus_unregister_rfkill_notifier()
Corentin Charyafa7c882011-02-06 13:28:28 +0100974 */
Corentin Charye12e6d92011-02-26 10:20:31 +0100975 asus_rfkill_hotplug(asus);
976 if (asus->hotplug_slot)
977 pci_hp_deregister(asus->hotplug_slot);
978 if (asus->hotplug_workqueue)
979 destroy_workqueue(asus->hotplug_workqueue);
Corentin Charyafa7c882011-02-06 13:28:28 +0100980
Corentin Charya7ce3f02011-02-26 10:20:33 +0100981 if (asus->bluetooth.rfkill) {
982 rfkill_unregister(asus->bluetooth.rfkill);
983 rfkill_destroy(asus->bluetooth.rfkill);
984 asus->bluetooth.rfkill = NULL;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100985 }
Corentin Charya7ce3f02011-02-26 10:20:33 +0100986 if (asus->wimax.rfkill) {
987 rfkill_unregister(asus->wimax.rfkill);
988 rfkill_destroy(asus->wimax.rfkill);
989 asus->wimax.rfkill = NULL;
Corentin Chary2e9e1592011-02-06 13:28:37 +0100990 }
Corentin Charya7ce3f02011-02-26 10:20:33 +0100991 if (asus->wwan3g.rfkill) {
992 rfkill_unregister(asus->wwan3g.rfkill);
993 rfkill_destroy(asus->wwan3g.rfkill);
994 asus->wwan3g.rfkill = NULL;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100995 }
Corentin Chary43be8bd2011-07-01 11:34:40 +0200996 if (asus->gps.rfkill) {
997 rfkill_unregister(asus->gps.rfkill);
998 rfkill_destroy(asus->gps.rfkill);
999 asus->gps.rfkill = NULL;
1000 }
Corentin Charya912d322011-07-01 11:34:41 +02001001 if (asus->uwb.rfkill) {
1002 rfkill_unregister(asus->uwb.rfkill);
1003 rfkill_destroy(asus->uwb.rfkill);
1004 asus->uwb.rfkill = NULL;
1005 }
Corentin Charyba48fdb2010-11-29 08:14:07 +01001006}
1007
Corentin Charye12e6d92011-02-26 10:20:31 +01001008static int asus_wmi_rfkill_init(struct asus_wmi *asus)
Corentin Charyba48fdb2010-11-29 08:14:07 +01001009{
1010 int result = 0;
1011
Corentin Charye12e6d92011-02-26 10:20:31 +01001012 mutex_init(&asus->hotplug_lock);
1013 mutex_init(&asus->wmi_lock);
Corentin Charyafa7c882011-02-06 13:28:28 +01001014
Corentin Charya7ce3f02011-02-26 10:20:33 +01001015 result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
1016 RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
Corentin Charyba48fdb2010-11-29 08:14:07 +01001017
1018 if (result && result != -ENODEV)
1019 goto exit;
1020
Corentin Charya7ce3f02011-02-26 10:20:33 +01001021 result = asus_new_rfkill(asus, &asus->bluetooth,
Corentin Charye12e6d92011-02-26 10:20:31 +01001022 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
1023 ASUS_WMI_DEVID_BLUETOOTH);
Corentin Charyba48fdb2010-11-29 08:14:07 +01001024
1025 if (result && result != -ENODEV)
1026 goto exit;
1027
Corentin Charya7ce3f02011-02-26 10:20:33 +01001028 result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
1029 RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
Corentin Chary2e9e1592011-02-06 13:28:37 +01001030
1031 if (result && result != -ENODEV)
1032 goto exit;
1033
Corentin Charya7ce3f02011-02-26 10:20:33 +01001034 result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
1035 RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
Corentin Charyba48fdb2010-11-29 08:14:07 +01001036
1037 if (result && result != -ENODEV)
1038 goto exit;
1039
Corentin Chary43be8bd2011-07-01 11:34:40 +02001040 result = asus_new_rfkill(asus, &asus->gps, "asus-gps",
1041 RFKILL_TYPE_GPS, ASUS_WMI_DEVID_GPS);
1042
1043 if (result && result != -ENODEV)
1044 goto exit;
1045
Corentin Charya912d322011-07-01 11:34:41 +02001046 result = asus_new_rfkill(asus, &asus->uwb, "asus-uwb",
1047 RFKILL_TYPE_UWB, ASUS_WMI_DEVID_UWB);
1048
1049 if (result && result != -ENODEV)
1050 goto exit;
1051
AceLan Kaoc87992d2012-03-20 09:53:08 +01001052 if (!asus->driver->quirks->hotplug_wireless)
Corentin Charyc14d4b82011-02-06 13:28:40 +01001053 goto exit;
1054
Corentin Charye12e6d92011-02-26 10:20:31 +01001055 result = asus_setup_pci_hotplug(asus);
Corentin Charyafa7c882011-02-06 13:28:28 +01001056 /*
1057 * If we get -EBUSY then something else is handling the PCI hotplug -
1058 * don't fail in this case
1059 */
1060 if (result == -EBUSY)
1061 result = 0;
1062
Corentin Charye12e6d92011-02-26 10:20:31 +01001063 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
1064 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
1065 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
Corentin Charyafa7c882011-02-06 13:28:28 +01001066 /*
1067 * Refresh pci hotplug in case the rfkill state was changed during
1068 * setup.
1069 */
Corentin Charye12e6d92011-02-26 10:20:31 +01001070 asus_rfkill_hotplug(asus);
Corentin Charyafa7c882011-02-06 13:28:28 +01001071
Corentin Charyba48fdb2010-11-29 08:14:07 +01001072exit:
1073 if (result && result != -ENODEV)
Corentin Charye12e6d92011-02-26 10:20:31 +01001074 asus_wmi_rfkill_exit(asus);
Corentin Charyba48fdb2010-11-29 08:14:07 +01001075
1076 if (result == -ENODEV)
1077 result = 0;
1078
1079 return result;
1080}
1081
1082/*
Corentin Charye07babd2011-02-26 10:20:42 +01001083 * Hwmon device
1084 */
Kast Bernd53e755c2015-05-13 16:24:16 +02001085static int asus_hwmon_agfn_fan_speed_read(struct asus_wmi *asus, int fan,
1086 int *speed)
1087{
1088 struct fan_args args = {
1089 .agfn.len = sizeof(args),
1090 .agfn.mfun = ASUS_FAN_MFUN,
1091 .agfn.sfun = ASUS_FAN_SFUN_READ,
1092 .fan = fan,
1093 .speed = 0,
1094 };
1095 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1096 int status;
1097
1098 if (fan != 1)
1099 return -EINVAL;
1100
1101 status = asus_wmi_evaluate_method_agfn(input);
1102
1103 if (status || args.agfn.err)
1104 return -ENXIO;
1105
1106 if (speed)
1107 *speed = args.speed;
1108
1109 return 0;
1110}
1111
1112static int asus_hwmon_agfn_fan_speed_write(struct asus_wmi *asus, int fan,
1113 int *speed)
1114{
1115 struct fan_args args = {
1116 .agfn.len = sizeof(args),
1117 .agfn.mfun = ASUS_FAN_MFUN,
1118 .agfn.sfun = ASUS_FAN_SFUN_WRITE,
1119 .fan = fan,
1120 .speed = speed ? *speed : 0,
1121 };
1122 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1123 int status;
1124
1125 /* 1: for setting 1st fan's speed 0: setting auto mode */
1126 if (fan != 1 && fan != 0)
1127 return -EINVAL;
1128
1129 status = asus_wmi_evaluate_method_agfn(input);
1130
1131 if (status || args.agfn.err)
1132 return -ENXIO;
1133
1134 if (speed && fan == 1)
1135 asus->asus_hwmon_pwm = *speed;
1136
1137 return 0;
1138}
1139
1140/*
1141 * Check if we can read the speed of one fan. If true we assume we can also
1142 * control it.
1143 */
1144static int asus_hwmon_get_fan_number(struct asus_wmi *asus, int *num_fans)
1145{
1146 int status;
1147 int speed = 0;
1148
1149 *num_fans = 0;
1150
1151 status = asus_hwmon_agfn_fan_speed_read(asus, 1, &speed);
1152 if (!status)
1153 *num_fans = 1;
1154
1155 return 0;
1156}
1157
1158static int asus_hwmon_fan_set_auto(struct asus_wmi *asus)
1159{
1160 int status;
1161
1162 status = asus_hwmon_agfn_fan_speed_write(asus, 0, NULL);
1163 if (status)
1164 return -ENXIO;
1165
1166 asus->asus_hwmon_fan_manual_mode = false;
1167
1168 return 0;
1169}
1170
1171static int asus_hwmon_fan_rpm_show(struct device *dev, int fan)
1172{
1173 struct asus_wmi *asus = dev_get_drvdata(dev);
1174 int value;
1175 int ret;
1176
1177 /* no speed readable on manual mode */
1178 if (asus->asus_hwmon_fan_manual_mode)
1179 return -ENXIO;
1180
1181 ret = asus_hwmon_agfn_fan_speed_read(asus, fan+1, &value);
1182 if (ret) {
1183 pr_warn("reading fan speed failed: %d\n", ret);
1184 return -ENXIO;
1185 }
1186
1187 return value;
1188}
1189
1190static void asus_hwmon_pwm_show(struct asus_wmi *asus, int fan, int *value)
1191{
1192 int err;
1193
1194 if (asus->asus_hwmon_pwm >= 0) {
1195 *value = asus->asus_hwmon_pwm;
1196 return;
1197 }
1198
1199 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, value);
1200 if (err < 0)
1201 return;
1202
1203 *value &= 0xFF;
1204
1205 if (*value == 1) /* Low Speed */
1206 *value = 85;
1207 else if (*value == 2)
1208 *value = 170;
1209 else if (*value == 3)
1210 *value = 255;
1211 else if (*value) {
1212 pr_err("Unknown fan speed %#x\n", *value);
1213 *value = -1;
1214 }
1215}
1216
1217static ssize_t pwm1_show(struct device *dev,
Corentin Chary49979d02011-07-01 11:34:26 +02001218 struct device_attribute *attr,
1219 char *buf)
Corentin Charye07babd2011-02-26 10:20:42 +01001220{
1221 struct asus_wmi *asus = dev_get_drvdata(dev);
Kast Bernd53e755c2015-05-13 16:24:16 +02001222 int value;
Corentin Charye07babd2011-02-26 10:20:42 +01001223
Kast Bernd53e755c2015-05-13 16:24:16 +02001224 asus_hwmon_pwm_show(asus, 0, &value);
Corentin Charye07babd2011-02-26 10:20:42 +01001225
1226 return sprintf(buf, "%d\n", value);
1227}
1228
Kast Bernd53e755c2015-05-13 16:24:16 +02001229static ssize_t pwm1_store(struct device *dev,
1230 struct device_attribute *attr,
1231 const char *buf, size_t count) {
1232 struct asus_wmi *asus = dev_get_drvdata(dev);
1233 int value;
1234 int state;
1235 int ret;
1236
1237 ret = kstrtouint(buf, 10, &value);
1238
1239 if (ret)
1240 return ret;
1241
1242 value = clamp(value, 0, 255);
1243
1244 state = asus_hwmon_agfn_fan_speed_write(asus, 1, &value);
1245 if (state)
1246 pr_warn("Setting fan speed failed: %d\n", state);
1247 else
1248 asus->asus_hwmon_fan_manual_mode = true;
1249
1250 return count;
1251}
1252
1253static ssize_t fan1_input_show(struct device *dev,
1254 struct device_attribute *attr,
1255 char *buf)
1256{
1257 int value = asus_hwmon_fan_rpm_show(dev, 0);
1258
1259 return sprintf(buf, "%d\n", value < 0 ? -1 : value*100);
1260
1261}
1262
1263static ssize_t pwm1_enable_show(struct device *dev,
1264 struct device_attribute *attr,
1265 char *buf)
1266{
1267 struct asus_wmi *asus = dev_get_drvdata(dev);
1268
1269 if (asus->asus_hwmon_fan_manual_mode)
1270 return sprintf(buf, "%d\n", ASUS_FAN_CTRL_MANUAL);
1271
1272 return sprintf(buf, "%d\n", ASUS_FAN_CTRL_AUTO);
1273}
1274
1275static ssize_t pwm1_enable_store(struct device *dev,
1276 struct device_attribute *attr,
1277 const char *buf, size_t count)
1278{
1279 struct asus_wmi *asus = dev_get_drvdata(dev);
1280 int status = 0;
1281 int state;
1282 int ret;
1283
1284 ret = kstrtouint(buf, 10, &state);
1285
1286 if (ret)
1287 return ret;
1288
1289 if (state == ASUS_FAN_CTRL_MANUAL)
1290 asus->asus_hwmon_fan_manual_mode = true;
1291 else
1292 status = asus_hwmon_fan_set_auto(asus);
1293
1294 if (status)
1295 return status;
1296
1297 return count;
1298}
1299
1300static ssize_t fan1_label_show(struct device *dev,
1301 struct device_attribute *attr,
1302 char *buf)
1303{
1304 return sprintf(buf, "%s\n", ASUS_FAN_DESC);
1305}
1306
Corentin Chary6118b8a2011-07-01 11:34:36 +02001307static ssize_t asus_hwmon_temp1(struct device *dev,
1308 struct device_attribute *attr,
1309 char *buf)
1310{
1311 struct asus_wmi *asus = dev_get_drvdata(dev);
1312 u32 value;
1313 int err;
1314
1315 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_THERMAL_CTRL, &value);
1316
1317 if (err < 0)
1318 return err;
1319
Rasmus Villemoese866a2e2015-10-01 23:45:31 +02001320 value = DECI_KELVIN_TO_CELSIUS((value & 0xFFFF)) * 1000;
Corentin Chary6118b8a2011-07-01 11:34:36 +02001321
1322 return sprintf(buf, "%d\n", value);
1323}
1324
Kast Bernd53e755c2015-05-13 16:24:16 +02001325/* Fan1 */
1326static DEVICE_ATTR_RW(pwm1);
1327static DEVICE_ATTR_RW(pwm1_enable);
1328static DEVICE_ATTR_RO(fan1_input);
1329static DEVICE_ATTR_RO(fan1_label);
1330
1331/* Temperature */
Guenter Roeck50a639f2013-11-23 11:03:17 -08001332static DEVICE_ATTR(temp1_input, S_IRUGO, asus_hwmon_temp1, NULL);
Corentin Charye07babd2011-02-26 10:20:42 +01001333
1334static struct attribute *hwmon_attributes[] = {
Guenter Roeck50a639f2013-11-23 11:03:17 -08001335 &dev_attr_pwm1.attr,
Kast Bernd53e755c2015-05-13 16:24:16 +02001336 &dev_attr_pwm1_enable.attr,
1337 &dev_attr_fan1_input.attr,
1338 &dev_attr_fan1_label.attr,
1339
Guenter Roeck50a639f2013-11-23 11:03:17 -08001340 &dev_attr_temp1_input.attr,
Corentin Charye07babd2011-02-26 10:20:42 +01001341 NULL
1342};
1343
Al Viro587a1f12011-07-23 23:11:19 -04001344static umode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
Corentin Charye02431d2011-07-01 11:34:37 +02001345 struct attribute *attr, int idx)
Corentin Charye07babd2011-02-26 10:20:42 +01001346{
1347 struct device *dev = container_of(kobj, struct device, kobj);
1348 struct platform_device *pdev = to_platform_device(dev->parent);
1349 struct asus_wmi *asus = platform_get_drvdata(pdev);
Corentin Charye07babd2011-02-26 10:20:42 +01001350 int dev_id = -1;
Kast Bernd53e755c2015-05-13 16:24:16 +02001351 int fan_attr = -1;
Corentin Charye07babd2011-02-26 10:20:42 +01001352 u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
Kast Bernd53e755c2015-05-13 16:24:16 +02001353 bool ok = true;
Corentin Charye07babd2011-02-26 10:20:42 +01001354
Guenter Roeck50a639f2013-11-23 11:03:17 -08001355 if (attr == &dev_attr_pwm1.attr)
Corentin Charye07babd2011-02-26 10:20:42 +01001356 dev_id = ASUS_WMI_DEVID_FAN_CTRL;
Guenter Roeck50a639f2013-11-23 11:03:17 -08001357 else if (attr == &dev_attr_temp1_input.attr)
Corentin Charye02431d2011-07-01 11:34:37 +02001358 dev_id = ASUS_WMI_DEVID_THERMAL_CTRL;
Corentin Charye07babd2011-02-26 10:20:42 +01001359
Kast Bernd53e755c2015-05-13 16:24:16 +02001360
1361 if (attr == &dev_attr_fan1_input.attr
1362 || attr == &dev_attr_fan1_label.attr
1363 || attr == &dev_attr_pwm1.attr
1364 || attr == &dev_attr_pwm1_enable.attr) {
1365 fan_attr = 1;
1366 }
1367
Corentin Charye07babd2011-02-26 10:20:42 +01001368 if (dev_id != -1) {
1369 int err = asus_wmi_get_devstate(asus, dev_id, &value);
1370
Kast Bernd53e755c2015-05-13 16:24:16 +02001371 if (err < 0 && fan_attr == -1)
Al Viroe772aed2011-07-23 20:59:40 -04001372 return 0; /* can't return negative here */
Corentin Charye07babd2011-02-26 10:20:42 +01001373 }
1374
1375 if (dev_id == ASUS_WMI_DEVID_FAN_CTRL) {
1376 /*
1377 * We need to find a better way, probably using sfun,
1378 * bits or spec ...
1379 * Currently we disable it if:
1380 * - ASUS_WMI_UNSUPPORTED_METHOD is returned
1381 * - reverved bits are non-zero
1382 * - sfun and presence bit are not set
1383 */
Corentin Chary49979d02011-07-01 11:34:26 +02001384 if (value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
Corentin Charye07babd2011-02-26 10:20:42 +01001385 || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)))
1386 ok = false;
Kast Bernd53e755c2015-05-13 16:24:16 +02001387 else
1388 ok = fan_attr <= asus->asus_hwmon_num_fans;
Corentin Charye02431d2011-07-01 11:34:37 +02001389 } else if (dev_id == ASUS_WMI_DEVID_THERMAL_CTRL) {
1390 /* If value is zero, something is clearly wrong */
Kast Bernd53e755c2015-05-13 16:24:16 +02001391 if (!value)
Corentin Charye02431d2011-07-01 11:34:37 +02001392 ok = false;
Kast Bernd53e755c2015-05-13 16:24:16 +02001393 } else if (fan_attr <= asus->asus_hwmon_num_fans && fan_attr != -1) {
1394 ok = true;
1395 } else {
1396 ok = false;
Corentin Charye07babd2011-02-26 10:20:42 +01001397 }
1398
1399 return ok ? attr->mode : 0;
1400}
1401
1402static struct attribute_group hwmon_attribute_group = {
1403 .is_visible = asus_hwmon_sysfs_is_visible,
1404 .attrs = hwmon_attributes
1405};
Guenter Roeck50a639f2013-11-23 11:03:17 -08001406__ATTRIBUTE_GROUPS(hwmon_attribute);
Corentin Charye07babd2011-02-26 10:20:42 +01001407
1408static int asus_wmi_hwmon_init(struct asus_wmi *asus)
1409{
1410 struct device *hwmon;
Corentin Charye07babd2011-02-26 10:20:42 +01001411
Guenter Roeck50a639f2013-11-23 11:03:17 -08001412 hwmon = hwmon_device_register_with_groups(&asus->platform_device->dev,
1413 "asus", asus,
1414 hwmon_attribute_groups);
Corentin Charye07babd2011-02-26 10:20:42 +01001415 if (IS_ERR(hwmon)) {
1416 pr_err("Could not register asus hwmon device\n");
1417 return PTR_ERR(hwmon);
1418 }
Guenter Roeck50a639f2013-11-23 11:03:17 -08001419 return 0;
Corentin Charye07babd2011-02-26 10:20:42 +01001420}
1421
1422/*
Corentin Chary084fca62010-11-29 08:14:06 +01001423 * Backlight
1424 */
Corentin Chary1d070f82011-02-26 10:20:36 +01001425static int read_backlight_power(struct asus_wmi *asus)
Corentin Charyb7187262011-02-06 13:28:39 +01001426{
AceLan Kao6e0044b2012-03-20 09:53:09 +01001427 int ret;
1428 if (asus->driver->quirks->store_backlight_power)
1429 ret = !asus->driver->panel_power;
1430 else
1431 ret = asus_wmi_get_devstate_simple(asus,
1432 ASUS_WMI_DEVID_BACKLIGHT);
Corentin Charyb7187262011-02-06 13:28:39 +01001433
1434 if (ret < 0)
1435 return ret;
1436
1437 return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
1438}
1439
Corentin Chary8fbea012011-02-26 10:20:37 +01001440static int read_brightness_max(struct asus_wmi *asus)
1441{
1442 u32 retval;
1443 int err;
1444
1445 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1446
1447 if (err < 0)
1448 return err;
1449
1450 retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
1451 retval >>= 8;
1452
1453 if (!retval)
1454 return -ENODEV;
1455
1456 return retval;
1457}
1458
Yong Wang3d7b1652010-04-11 09:27:54 +08001459static int read_brightness(struct backlight_device *bd)
1460{
Corentin Chary1d070f82011-02-26 10:20:36 +01001461 struct asus_wmi *asus = bl_get_data(bd);
Dan Carpenter0986f252011-03-15 10:06:23 +03001462 u32 retval;
1463 int err;
Yong Wang3d7b1652010-04-11 09:27:54 +08001464
Corentin Chary1d070f82011-02-26 10:20:36 +01001465 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
Yong Wang3d7b1652010-04-11 09:27:54 +08001466
Corentin Charyd33da3b2011-02-26 10:20:35 +01001467 if (err < 0)
1468 return err;
1469
1470 return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
Yong Wang3d7b1652010-04-11 09:27:54 +08001471}
1472
AceLan Kaoc87992d2012-03-20 09:53:08 +01001473static u32 get_scalar_command(struct backlight_device *bd)
1474{
1475 struct asus_wmi *asus = bl_get_data(bd);
1476 u32 ctrl_param = 0;
1477
1478 if ((asus->driver->brightness < bd->props.brightness) ||
1479 bd->props.brightness == bd->props.max_brightness)
1480 ctrl_param = 0x00008001;
1481 else if ((asus->driver->brightness > bd->props.brightness) ||
1482 bd->props.brightness == 0)
1483 ctrl_param = 0x00008000;
1484
1485 asus->driver->brightness = bd->props.brightness;
1486
1487 return ctrl_param;
1488}
1489
Yong Wang3d7b1652010-04-11 09:27:54 +08001490static int update_bl_status(struct backlight_device *bd)
1491{
Corentin Chary1d070f82011-02-26 10:20:36 +01001492 struct asus_wmi *asus = bl_get_data(bd);
Corentin Charydfed65d2010-11-29 08:14:12 +01001493 u32 ctrl_param;
AceLan Kao6e0044b2012-03-20 09:53:09 +01001494 int power, err = 0;
Corentin Charyb7187262011-02-06 13:28:39 +01001495
Corentin Chary1d070f82011-02-26 10:20:36 +01001496 power = read_backlight_power(asus);
Corentin Charyb7187262011-02-06 13:28:39 +01001497 if (power != -ENODEV && bd->props.power != power) {
1498 ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
Corentin Charyd33da3b2011-02-26 10:20:35 +01001499 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
1500 ctrl_param, NULL);
AceLan Kao6e0044b2012-03-20 09:53:09 +01001501 if (asus->driver->quirks->store_backlight_power)
1502 asus->driver->panel_power = bd->props.power;
AceLan Kao6e0044b2012-03-20 09:53:09 +01001503
Corentin Charyade28ab2012-03-20 09:53:14 +01001504 /* When using scalar brightness, updating the brightness
1505 * will mess with the backlight power */
1506 if (asus->driver->quirks->scalar_panel_brightness)
1507 return err;
Corentin Charyb7187262011-02-06 13:28:39 +01001508 }
Corentin Charyade28ab2012-03-20 09:53:14 +01001509
1510 if (asus->driver->quirks->scalar_panel_brightness)
1511 ctrl_param = get_scalar_command(bd);
1512 else
1513 ctrl_param = bd->props.brightness;
1514
1515 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
1516 ctrl_param, NULL);
1517
Corentin Chary8fbea012011-02-26 10:20:37 +01001518 return err;
Yong Wang3d7b1652010-04-11 09:27:54 +08001519}
1520
Corentin Charye12e6d92011-02-26 10:20:31 +01001521static const struct backlight_ops asus_wmi_bl_ops = {
Yong Wang3d7b1652010-04-11 09:27:54 +08001522 .get_brightness = read_brightness,
1523 .update_status = update_bl_status,
1524};
1525
Corentin Charye12e6d92011-02-26 10:20:31 +01001526static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
Yong Wang3d7b1652010-04-11 09:27:54 +08001527{
Corentin Charye12e6d92011-02-26 10:20:31 +01001528 struct backlight_device *bd = asus->backlight_device;
Yong Wang3d7b1652010-04-11 09:27:54 +08001529 int old = bd->props.brightness;
Daniel Mackb7670ed2010-05-19 12:37:01 +02001530 int new = old;
Yong Wang3d7b1652010-04-11 09:27:54 +08001531
1532 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1533 new = code - NOTIFY_BRNUP_MIN + 1;
1534 else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
1535 new = code - NOTIFY_BRNDOWN_MIN;
1536
1537 bd->props.brightness = new;
1538 backlight_update_status(bd);
1539 backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1540
1541 return old;
1542}
1543
Corentin Charye12e6d92011-02-26 10:20:31 +01001544static int asus_wmi_backlight_init(struct asus_wmi *asus)
Yong Wang3d7b1652010-04-11 09:27:54 +08001545{
1546 struct backlight_device *bd;
1547 struct backlight_properties props;
Corentin Charyb7187262011-02-06 13:28:39 +01001548 int max;
1549 int power;
1550
Corentin Chary8fbea012011-02-26 10:20:37 +01001551 max = read_brightness_max(asus);
Hans de Goede86ac27352014-07-08 10:47:22 +02001552 if (max < 0)
Corentin Chary8fbea012011-02-26 10:20:37 +01001553 return max;
1554
1555 power = read_backlight_power(asus);
1556
Corentin Charyb7187262011-02-06 13:28:39 +01001557 if (power == -ENODEV)
1558 power = FB_BLANK_UNBLANK;
Corentin Chary8fbea012011-02-26 10:20:37 +01001559 else if (power < 0)
1560 return power;
Yong Wang3d7b1652010-04-11 09:27:54 +08001561
1562 memset(&props, 0, sizeof(struct backlight_properties));
Axel Lin60cfa092011-06-29 11:43:30 +08001563 props.type = BACKLIGHT_PLATFORM;
Corentin Charyb7187262011-02-06 13:28:39 +01001564 props.max_brightness = max;
Corentin Charye12e6d92011-02-26 10:20:31 +01001565 bd = backlight_device_register(asus->driver->name,
1566 &asus->platform_device->dev, asus,
1567 &asus_wmi_bl_ops, &props);
Yong Wang3d7b1652010-04-11 09:27:54 +08001568 if (IS_ERR(bd)) {
1569 pr_err("Could not register backlight device\n");
1570 return PTR_ERR(bd);
1571 }
1572
Corentin Charye12e6d92011-02-26 10:20:31 +01001573 asus->backlight_device = bd;
Yong Wang3d7b1652010-04-11 09:27:54 +08001574
AceLan Kao6e0044b2012-03-20 09:53:09 +01001575 if (asus->driver->quirks->store_backlight_power)
1576 asus->driver->panel_power = power;
1577
Yong Wang3d7b1652010-04-11 09:27:54 +08001578 bd->props.brightness = read_brightness(bd);
Corentin Charyb7187262011-02-06 13:28:39 +01001579 bd->props.power = power;
Yong Wang3d7b1652010-04-11 09:27:54 +08001580 backlight_update_status(bd);
1581
AceLan Kaoc87992d2012-03-20 09:53:08 +01001582 asus->driver->brightness = bd->props.brightness;
1583
Yong Wang3d7b1652010-04-11 09:27:54 +08001584 return 0;
1585}
1586
Corentin Charye12e6d92011-02-26 10:20:31 +01001587static void asus_wmi_backlight_exit(struct asus_wmi *asus)
Yong Wang3d7b1652010-04-11 09:27:54 +08001588{
Markus Elfring00981812014-11-24 20:30:29 +01001589 backlight_device_unregister(asus->backlight_device);
Yong Wang3d7b1652010-04-11 09:27:54 +08001590
Corentin Charye12e6d92011-02-26 10:20:31 +01001591 asus->backlight_device = NULL;
Yong Wang3d7b1652010-04-11 09:27:54 +08001592}
1593
AceLan Kaoa2a96f02012-10-03 11:26:31 +02001594static int is_display_toggle(int code)
1595{
1596 /* display toggle keys */
1597 if ((code >= 0x61 && code <= 0x67) ||
1598 (code >= 0x8c && code <= 0x93) ||
1599 (code >= 0xa0 && code <= 0xa7) ||
1600 (code >= 0xd0 && code <= 0xd5))
1601 return 1;
1602
1603 return 0;
1604}
1605
Corentin Charye12e6d92011-02-26 10:20:31 +01001606static void asus_wmi_notify(u32 value, void *context)
Yong Wang3d7b1652010-04-11 09:27:54 +08001607{
Corentin Charye12e6d92011-02-26 10:20:31 +01001608 struct asus_wmi *asus = context;
Yong Wang3d7b1652010-04-11 09:27:54 +08001609 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
1610 union acpi_object *obj;
1611 acpi_status status;
1612 int code;
1613 int orig_code;
Seth Forsheec4453f62011-07-01 11:34:27 +02001614 unsigned int key_value = 1;
1615 bool autorelease = 1;
Yong Wang3d7b1652010-04-11 09:27:54 +08001616
1617 status = wmi_get_event_data(value, &response);
1618 if (status != AE_OK) {
1619 pr_err("bad event status 0x%x\n", status);
1620 return;
1621 }
1622
1623 obj = (union acpi_object *)response.pointer;
1624
Corentin Chary57ab7da2011-02-26 10:20:32 +01001625 if (!obj || obj->type != ACPI_TYPE_INTEGER)
1626 goto exit;
Yong Wang3d7b1652010-04-11 09:27:54 +08001627
Corentin Chary57ab7da2011-02-26 10:20:32 +01001628 code = obj->integer.value;
1629 orig_code = code;
Yong Wang3d7b1652010-04-11 09:27:54 +08001630
Seth Forsheec4453f62011-07-01 11:34:27 +02001631 if (asus->driver->key_filter) {
1632 asus->driver->key_filter(asus->driver, &code, &key_value,
1633 &autorelease);
1634 if (code == ASUS_WMI_KEY_IGNORE)
1635 goto exit;
1636 }
1637
Corentin Chary57ab7da2011-02-26 10:20:32 +01001638 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
Corentin Chary3ba03022012-11-29 09:12:38 +01001639 code = ASUS_WMI_BRN_UP;
Corentin Chary57ab7da2011-02-26 10:20:32 +01001640 else if (code >= NOTIFY_BRNDOWN_MIN &&
1641 code <= NOTIFY_BRNDOWN_MAX)
Corentin Chary3ba03022012-11-29 09:12:38 +01001642 code = ASUS_WMI_BRN_DOWN;
Yong Wang3d7b1652010-04-11 09:27:54 +08001643
Corentin Chary3ba03022012-11-29 09:12:38 +01001644 if (code == ASUS_WMI_BRN_DOWN || code == ASUS_WMI_BRN_UP) {
Hans de Goede62c4aa12015-06-16 16:27:58 +02001645 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
Corentin Chary57ab7da2011-02-26 10:20:32 +01001646 asus_wmi_backlight_notify(asus, orig_code);
Corentin Chary3ba03022012-11-29 09:12:38 +01001647 goto exit;
AceLan Kaoa2a96f02012-10-03 11:26:31 +02001648 }
AceLan Kaoa2a96f02012-10-03 11:26:31 +02001649 }
1650
1651 if (is_display_toggle(code) &&
1652 asus->driver->quirks->no_display_toggle)
1653 goto exit;
1654
1655 if (!sparse_keymap_report_event(asus->inputdev, code,
1656 key_value, autorelease))
Corentin Chary57ab7da2011-02-26 10:20:32 +01001657 pr_info("Unknown key %x pressed\n", code);
Yong Wang3d7b1652010-04-11 09:27:54 +08001658
Corentin Chary57ab7da2011-02-26 10:20:32 +01001659exit:
Yong Wang3d7b1652010-04-11 09:27:54 +08001660 kfree(obj);
1661}
1662
Corentin Chary9e1565b2011-02-06 13:28:36 +01001663/*
1664 * Sys helpers
1665 */
1666static int parse_arg(const char *buf, unsigned long count, int *val)
1667{
1668 if (!count)
1669 return 0;
1670 if (sscanf(buf, "%i", val) != 1)
1671 return -EINVAL;
1672 return count;
1673}
1674
Corentin Chary1d070f82011-02-26 10:20:36 +01001675static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
1676 const char *buf, size_t count)
Corentin Chary9e1565b2011-02-06 13:28:36 +01001677{
Corentin Chary9e1565b2011-02-06 13:28:36 +01001678 u32 retval;
Corentin Charyd33da3b2011-02-26 10:20:35 +01001679 int rv, err, value;
Corentin Chary9e1565b2011-02-06 13:28:36 +01001680
Corentin Chary1d070f82011-02-26 10:20:36 +01001681 value = asus_wmi_get_devstate_simple(asus, devid);
Dan Carpenterb8298342015-11-11 01:18:16 +03001682 if (value < 0)
Corentin Chary9e1565b2011-02-06 13:28:36 +01001683 return value;
1684
1685 rv = parse_arg(buf, count, &value);
Corentin Charyd33da3b2011-02-26 10:20:35 +01001686 err = asus_wmi_set_devstate(devid, value, &retval);
Corentin Chary9e1565b2011-02-06 13:28:36 +01001687
Corentin Charyd33da3b2011-02-26 10:20:35 +01001688 if (err < 0)
1689 return err;
1690
Corentin Chary9e1565b2011-02-06 13:28:36 +01001691 return rv;
1692}
1693
Corentin Chary1d070f82011-02-26 10:20:36 +01001694static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
Corentin Chary9e1565b2011-02-06 13:28:36 +01001695{
Corentin Chary1d070f82011-02-26 10:20:36 +01001696 int value = asus_wmi_get_devstate_simple(asus, devid);
Corentin Chary9e1565b2011-02-06 13:28:36 +01001697
1698 if (value < 0)
1699 return value;
1700
1701 return sprintf(buf, "%d\n", value);
1702}
1703
Corentin Charye12e6d92011-02-26 10:20:31 +01001704#define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
Corentin Chary9e1565b2011-02-06 13:28:36 +01001705 static ssize_t show_##_name(struct device *dev, \
1706 struct device_attribute *attr, \
1707 char *buf) \
1708 { \
Corentin Chary1d070f82011-02-26 10:20:36 +01001709 struct asus_wmi *asus = dev_get_drvdata(dev); \
1710 \
1711 return show_sys_wmi(asus, _cm, buf); \
Corentin Chary9e1565b2011-02-06 13:28:36 +01001712 } \
1713 static ssize_t store_##_name(struct device *dev, \
1714 struct device_attribute *attr, \
1715 const char *buf, size_t count) \
1716 { \
Corentin Chary1d070f82011-02-26 10:20:36 +01001717 struct asus_wmi *asus = dev_get_drvdata(dev); \
1718 \
1719 return store_sys_wmi(asus, _cm, buf, count); \
Corentin Chary9e1565b2011-02-06 13:28:36 +01001720 } \
1721 static struct device_attribute dev_attr_##_name = { \
1722 .attr = { \
1723 .name = __stringify(_name), \
1724 .mode = _mode }, \
1725 .show = show_##_name, \
1726 .store = store_##_name, \
1727 }
1728
Corentin Charye12e6d92011-02-26 10:20:31 +01001729ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
1730ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
1731ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
AceLan Kaoc0b91b62012-06-13 09:32:07 +02001732ASUS_WMI_CREATE_DEVICE_ATTR(lid_resume, 0644, ASUS_WMI_DEVID_LID_RESUME);
Corentin Chary9e1565b2011-02-06 13:28:36 +01001733
Dmitry Torokhov67fa38e2010-11-03 11:14:01 -07001734static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
1735 const char *buf, size_t count)
Chris Bagwell7f80d732010-10-11 18:47:18 -05001736{
Corentin Chary3df5fda2011-07-01 11:34:38 +02001737 int value, rv;
Chris Bagwell7f80d732010-10-11 18:47:18 -05001738
1739 if (!count || sscanf(buf, "%i", &value) != 1)
1740 return -EINVAL;
1741 if (value < 0 || value > 2)
1742 return -EINVAL;
1743
Corentin Chary3df5fda2011-07-01 11:34:38 +02001744 rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
1745 if (rv < 0)
1746 return rv;
1747
1748 return count;
Chris Bagwell7f80d732010-10-11 18:47:18 -05001749}
1750
1751static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
1752
Corentin Chary4e37b422010-11-29 08:14:08 +01001753static struct attribute *platform_attributes[] = {
1754 &dev_attr_cpufv.attr,
Corentin Chary9e1565b2011-02-06 13:28:36 +01001755 &dev_attr_camera.attr,
1756 &dev_attr_cardr.attr,
Corentin Chary4615bb62011-02-06 13:28:42 +01001757 &dev_attr_touchpad.attr,
AceLan Kaoc0b91b62012-06-13 09:32:07 +02001758 &dev_attr_lid_resume.attr,
Corentin Chary4e37b422010-11-29 08:14:08 +01001759 NULL
1760};
1761
Al Viro587a1f12011-07-23 23:11:19 -04001762static umode_t asus_sysfs_is_visible(struct kobject *kobj,
Corentin Charye12e6d92011-02-26 10:20:31 +01001763 struct attribute *attr, int idx)
Corentin Chary9e1565b2011-02-06 13:28:36 +01001764{
Corentin Chary1d070f82011-02-26 10:20:36 +01001765 struct device *dev = container_of(kobj, struct device, kobj);
1766 struct platform_device *pdev = to_platform_device(dev);
1767 struct asus_wmi *asus = platform_get_drvdata(pdev);
1768 bool ok = true;
Corentin Chary9e1565b2011-02-06 13:28:36 +01001769 int devid = -1;
1770
1771 if (attr == &dev_attr_camera.attr)
Corentin Charye12e6d92011-02-26 10:20:31 +01001772 devid = ASUS_WMI_DEVID_CAMERA;
Corentin Chary9e1565b2011-02-06 13:28:36 +01001773 else if (attr == &dev_attr_cardr.attr)
Corentin Charye12e6d92011-02-26 10:20:31 +01001774 devid = ASUS_WMI_DEVID_CARDREADER;
Corentin Chary4615bb62011-02-06 13:28:42 +01001775 else if (attr == &dev_attr_touchpad.attr)
Corentin Charye12e6d92011-02-26 10:20:31 +01001776 devid = ASUS_WMI_DEVID_TOUCHPAD;
AceLan Kaoc0b91b62012-06-13 09:32:07 +02001777 else if (attr == &dev_attr_lid_resume.attr)
1778 devid = ASUS_WMI_DEVID_LID_RESUME;
Corentin Chary9e1565b2011-02-06 13:28:36 +01001779
1780 if (devid != -1)
Corentin Chary1d070f82011-02-26 10:20:36 +01001781 ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
Corentin Chary9e1565b2011-02-06 13:28:36 +01001782
Corentin Chary1d070f82011-02-26 10:20:36 +01001783 return ok ? attr->mode : 0;
Corentin Chary9e1565b2011-02-06 13:28:36 +01001784}
1785
Corentin Chary4e37b422010-11-29 08:14:08 +01001786static struct attribute_group platform_attribute_group = {
Corentin Charye12e6d92011-02-26 10:20:31 +01001787 .is_visible = asus_sysfs_is_visible,
1788 .attrs = platform_attributes
Corentin Chary4e37b422010-11-29 08:14:08 +01001789};
1790
Corentin Charye12e6d92011-02-26 10:20:31 +01001791static void asus_wmi_sysfs_exit(struct platform_device *device)
Chris Bagwell7f80d732010-10-11 18:47:18 -05001792{
Corentin Chary4e37b422010-11-29 08:14:08 +01001793 sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
Chris Bagwell7f80d732010-10-11 18:47:18 -05001794}
1795
Corentin Charye12e6d92011-02-26 10:20:31 +01001796static int asus_wmi_sysfs_init(struct platform_device *device)
Chris Bagwell7f80d732010-10-11 18:47:18 -05001797{
Corentin Chary4e37b422010-11-29 08:14:08 +01001798 return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
Chris Bagwell7f80d732010-10-11 18:47:18 -05001799}
1800
Corentin Chary27c136c2010-11-29 08:14:05 +01001801/*
1802 * Platform device
1803 */
Joe Perches39ddf3b2011-03-29 15:21:32 -07001804static int asus_wmi_platform_init(struct asus_wmi *asus)
Corentin Chary27c136c2010-11-29 08:14:05 +01001805{
Corentin Chary46dbca82011-02-26 10:20:38 +01001806 int rv;
1807
1808 /* INIT enable hotkeys on some models */
1809 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
vic0ed60652013-05-22 21:32:10 +03001810 pr_info("Initialization: %#x\n", rv);
Corentin Chary46dbca82011-02-26 10:20:38 +01001811
1812 /* We don't know yet what to do with this version... */
1813 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
vic0ed60652013-05-22 21:32:10 +03001814 pr_info("BIOS WMI version: %d.%d\n", rv >> 16, rv & 0xFF);
Corentin Chary46dbca82011-02-26 10:20:38 +01001815 asus->spec = rv;
1816 }
1817
1818 /*
1819 * The SFUN method probably allows the original driver to get the list
1820 * of features supported by a given model. For now, 0x0100 or 0x0800
1821 * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
1822 * The significance of others is yet to be found.
1823 */
1824 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
vic0ed60652013-05-22 21:32:10 +03001825 pr_info("SFUN value: %#x\n", rv);
Corentin Chary46dbca82011-02-26 10:20:38 +01001826 asus->sfun = rv;
1827 }
1828
Corentin Chary1d070f82011-02-26 10:20:36 +01001829 /*
1830 * Eee PC and Notebooks seems to have different method_id for DSTS,
1831 * but it may also be related to the BIOS's SPEC.
1832 * Note, on most Eeepc, there is no way to check if a method exist
1833 * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
1834 * but once again, SPEC may probably be used for that kind of things.
1835 */
1836 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, 0, 0, NULL))
1837 asus->dsts_id = ASUS_WMI_METHODID_DSTS;
Alex Hung63a78bb12012-06-20 11:47:35 +08001838 else
Corentin Chary1d070f82011-02-26 10:20:36 +01001839 asus->dsts_id = ASUS_WMI_METHODID_DSTS2;
1840
Corentin Charyfddbfed2011-07-01 11:34:39 +02001841 /* CWAP allow to define the behavior of the Fn+F2 key,
1842 * this method doesn't seems to be present on Eee PCs */
Corentin Chary6a2bccc2012-03-20 09:53:10 +01001843 if (asus->driver->quirks->wapf >= 0)
Corentin Charyfddbfed2011-07-01 11:34:39 +02001844 asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP,
Corentin Chary6a2bccc2012-03-20 09:53:10 +01001845 asus->driver->quirks->wapf, NULL);
Corentin Charyfddbfed2011-07-01 11:34:39 +02001846
Corentin Charye12e6d92011-02-26 10:20:31 +01001847 return asus_wmi_sysfs_init(asus->platform_device);
Corentin Chary27c136c2010-11-29 08:14:05 +01001848}
1849
Corentin Charye12e6d92011-02-26 10:20:31 +01001850static void asus_wmi_platform_exit(struct asus_wmi *asus)
Corentin Chary27c136c2010-11-29 08:14:05 +01001851{
Corentin Charye12e6d92011-02-26 10:20:31 +01001852 asus_wmi_sysfs_exit(asus->platform_device);
Corentin Chary27c136c2010-11-29 08:14:05 +01001853}
1854
1855/*
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001856 * debugfs
1857 */
Corentin Charye12e6d92011-02-26 10:20:31 +01001858struct asus_wmi_debugfs_node {
1859 struct asus_wmi *asus;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001860 char *name;
Corentin Charye12e6d92011-02-26 10:20:31 +01001861 int (*show) (struct seq_file *m, void *data);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001862};
1863
1864static int show_dsts(struct seq_file *m, void *data)
1865{
Corentin Charye12e6d92011-02-26 10:20:31 +01001866 struct asus_wmi *asus = m->private;
Corentin Charyd33da3b2011-02-26 10:20:35 +01001867 int err;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001868 u32 retval = -1;
1869
Corentin Chary1d070f82011-02-26 10:20:36 +01001870 err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001871
Corentin Charyd33da3b2011-02-26 10:20:35 +01001872 if (err < 0)
1873 return err;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001874
Corentin Charyef343492011-02-26 10:20:39 +01001875 seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001876
1877 return 0;
1878}
1879
1880static int show_devs(struct seq_file *m, void *data)
1881{
Corentin Charye12e6d92011-02-26 10:20:31 +01001882 struct asus_wmi *asus = m->private;
Corentin Charyd33da3b2011-02-26 10:20:35 +01001883 int err;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001884 u32 retval = -1;
1885
Corentin Charyd33da3b2011-02-26 10:20:35 +01001886 err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
1887 &retval);
1888
1889 if (err < 0)
1890 return err;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001891
Corentin Charyef343492011-02-26 10:20:39 +01001892 seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
Corentin Charye12e6d92011-02-26 10:20:31 +01001893 asus->debug.ctrl_param, retval);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001894
1895 return 0;
1896}
1897
Corentin Charyef343492011-02-26 10:20:39 +01001898static int show_call(struct seq_file *m, void *data)
1899{
1900 struct asus_wmi *asus = m->private;
1901 struct bios_args args = {
1902 .arg0 = asus->debug.dev_id,
1903 .arg1 = asus->debug.ctrl_param,
1904 };
1905 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1906 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
1907 union acpi_object *obj;
1908 acpi_status status;
1909
1910 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
1911 1, asus->debug.method_id,
1912 &input, &output);
1913
1914 if (ACPI_FAILURE(status))
1915 return -EIO;
1916
1917 obj = (union acpi_object *)output.pointer;
1918 if (obj && obj->type == ACPI_TYPE_INTEGER)
1919 seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
1920 asus->debug.dev_id, asus->debug.ctrl_param,
1921 (u32) obj->integer.value);
1922 else
1923 seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
1924 asus->debug.dev_id, asus->debug.ctrl_param,
Dan Carpentera1d60862011-03-15 10:07:37 +03001925 obj ? obj->type : -1);
Corentin Charyef343492011-02-26 10:20:39 +01001926
1927 kfree(obj);
1928
1929 return 0;
1930}
1931
Corentin Charye12e6d92011-02-26 10:20:31 +01001932static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
1933 {NULL, "devs", show_devs},
1934 {NULL, "dsts", show_dsts},
Corentin Charyef343492011-02-26 10:20:39 +01001935 {NULL, "call", show_call},
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001936};
1937
Corentin Charye12e6d92011-02-26 10:20:31 +01001938static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001939{
Corentin Charye12e6d92011-02-26 10:20:31 +01001940 struct asus_wmi_debugfs_node *node = inode->i_private;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001941
Corentin Charye12e6d92011-02-26 10:20:31 +01001942 return single_open(file, node->show, node->asus);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001943}
1944
Corentin Charye12e6d92011-02-26 10:20:31 +01001945static const struct file_operations asus_wmi_debugfs_io_ops = {
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001946 .owner = THIS_MODULE,
Corentin Charye12e6d92011-02-26 10:20:31 +01001947 .open = asus_wmi_debugfs_open,
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001948 .read = seq_read,
1949 .llseek = seq_lseek,
1950 .release = single_release,
1951};
1952
Corentin Charye12e6d92011-02-26 10:20:31 +01001953static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001954{
Corentin Charye12e6d92011-02-26 10:20:31 +01001955 debugfs_remove_recursive(asus->debug.root);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001956}
1957
Corentin Charye12e6d92011-02-26 10:20:31 +01001958static int asus_wmi_debugfs_init(struct asus_wmi *asus)
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001959{
1960 struct dentry *dent;
1961 int i;
1962
Corentin Charye12e6d92011-02-26 10:20:31 +01001963 asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
1964 if (!asus->debug.root) {
vic0ed60652013-05-22 21:32:10 +03001965 pr_err("failed to create debugfs directory\n");
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001966 goto error_debugfs;
1967 }
1968
Corentin Charyef343492011-02-26 10:20:39 +01001969 dent = debugfs_create_x32("method_id", S_IRUGO | S_IWUSR,
1970 asus->debug.root, &asus->debug.method_id);
1971 if (!dent)
1972 goto error_debugfs;
1973
Corentin Charye12e6d92011-02-26 10:20:31 +01001974 dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
1975 asus->debug.root, &asus->debug.dev_id);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001976 if (!dent)
1977 goto error_debugfs;
1978
Corentin Charye12e6d92011-02-26 10:20:31 +01001979 dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR,
1980 asus->debug.root, &asus->debug.ctrl_param);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001981 if (!dent)
1982 goto error_debugfs;
1983
Corentin Charye12e6d92011-02-26 10:20:31 +01001984 for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
1985 struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001986
Corentin Charye12e6d92011-02-26 10:20:31 +01001987 node->asus = asus;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001988 dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
Corentin Charye12e6d92011-02-26 10:20:31 +01001989 asus->debug.root, node,
1990 &asus_wmi_debugfs_io_ops);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001991 if (!dent) {
1992 pr_err("failed to create debug file: %s\n", node->name);
1993 goto error_debugfs;
1994 }
1995 }
1996
1997 return 0;
1998
1999error_debugfs:
Corentin Charye12e6d92011-02-26 10:20:31 +01002000 asus_wmi_debugfs_exit(asus);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01002001 return -ENOMEM;
2002}
2003
Kast Bernd53e755c2015-05-13 16:24:16 +02002004static int asus_wmi_fan_init(struct asus_wmi *asus)
2005{
2006 int status;
2007
2008 asus->asus_hwmon_pwm = -1;
2009 asus->asus_hwmon_num_fans = -1;
2010 asus->asus_hwmon_fan_manual_mode = false;
2011
2012 status = asus_hwmon_get_fan_number(asus, &asus->asus_hwmon_num_fans);
2013 if (status) {
2014 asus->asus_hwmon_num_fans = 0;
2015 pr_warn("Could not determine number of fans: %d\n", status);
2016 return -ENXIO;
2017 }
2018
2019 pr_info("Number of fans: %d\n", asus->asus_hwmon_num_fans);
2020 return 0;
2021}
2022
Corentin Chary8c1b2d82010-11-29 08:14:09 +01002023/*
Corentin Chary27c136c2010-11-29 08:14:05 +01002024 * WMI Driver
2025 */
Corentin Charye12e6d92011-02-26 10:20:31 +01002026static int asus_wmi_add(struct platform_device *pdev)
Corentin Charyafa7c882011-02-06 13:28:28 +01002027{
Corentin Charye12e6d92011-02-26 10:20:31 +01002028 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
2029 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
2030 struct asus_wmi *asus;
Hans de Goeded8c66f62014-07-08 10:47:21 +02002031 const char *chassis_type;
Yong Wangee027e42010-03-21 10:26:34 +08002032 acpi_status status;
Corentin Chary27c136c2010-11-29 08:14:05 +01002033 int err;
AceLan Kaoa50bd122012-07-26 17:13:31 +08002034 u32 result;
Yong Wangee027e42010-03-21 10:26:34 +08002035
Corentin Charye12e6d92011-02-26 10:20:31 +01002036 asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
2037 if (!asus)
Corentin Charya04ce292011-02-06 13:28:33 +01002038 return -ENOMEM;
2039
Corentin Charye12e6d92011-02-26 10:20:31 +01002040 asus->driver = wdrv;
2041 asus->platform_device = pdev;
2042 wdrv->platform_device = pdev;
2043 platform_set_drvdata(asus->platform_device, asus);
Corentin Chary27c136c2010-11-29 08:14:05 +01002044
AceLan Kaoc87992d2012-03-20 09:53:08 +01002045 if (wdrv->detect_quirks)
2046 wdrv->detect_quirks(asus->driver);
Corentin Charyafa7c882011-02-06 13:28:28 +01002047
Corentin Charye12e6d92011-02-26 10:20:31 +01002048 err = asus_wmi_platform_init(asus);
Corentin Chary27c136c2010-11-29 08:14:05 +01002049 if (err)
2050 goto fail_platform;
Yong Wang45f2c692010-04-11 09:27:19 +08002051
Corentin Charye12e6d92011-02-26 10:20:31 +01002052 err = asus_wmi_input_init(asus);
Yong Wang45f2c692010-04-11 09:27:19 +08002053 if (err)
Corentin Chary27c136c2010-11-29 08:14:05 +01002054 goto fail_input;
Yong Wang3d7b1652010-04-11 09:27:54 +08002055
Kast Bernd53e755c2015-05-13 16:24:16 +02002056 err = asus_wmi_fan_init(asus); /* probably no problems on error */
2057 asus_hwmon_fan_set_auto(asus);
2058
Corentin Charye07babd2011-02-26 10:20:42 +01002059 err = asus_wmi_hwmon_init(asus);
2060 if (err)
2061 goto fail_hwmon;
2062
Corentin Charye12e6d92011-02-26 10:20:31 +01002063 err = asus_wmi_led_init(asus);
Corentin Chary084fca62010-11-29 08:14:06 +01002064 if (err)
2065 goto fail_leds;
2066
Corentin Charye12e6d92011-02-26 10:20:31 +01002067 err = asus_wmi_rfkill_init(asus);
Corentin Charyba48fdb2010-11-29 08:14:07 +01002068 if (err)
2069 goto fail_rfkill;
2070
Hans de Goeded8c66f62014-07-08 10:47:21 +02002071 /* Some Asus desktop boards export an acpi-video backlight interface,
2072 stop this from showing up */
2073 chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE);
2074 if (chassis_type && !strcmp(chassis_type, "3"))
Hans de Goede62c4aa12015-06-16 16:27:58 +02002075 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
2076
AceLan Kao272c77d2012-06-13 09:32:06 +02002077 if (asus->driver->quirks->wmi_backlight_power)
Hans de Goede62c4aa12015-06-16 16:27:58 +02002078 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
2079
2080 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
Corentin Charye12e6d92011-02-26 10:20:31 +01002081 err = asus_wmi_backlight_init(asus);
Corentin Charyb7187262011-02-06 13:28:39 +01002082 if (err && err != -ENODEV)
Corentin Chary27c136c2010-11-29 08:14:05 +01002083 goto fail_backlight;
Hans de Goede62c4aa12015-06-16 16:27:58 +02002084 }
Yong Wang45f2c692010-04-11 09:27:19 +08002085
Corentin Charye12e6d92011-02-26 10:20:31 +01002086 status = wmi_install_notify_handler(asus->driver->event_guid,
2087 asus_wmi_notify, asus);
Yong Wang45f2c692010-04-11 09:27:19 +08002088 if (ACPI_FAILURE(status)) {
Corentin Charye12e6d92011-02-26 10:20:31 +01002089 pr_err("Unable to register notify handler - %d\n", status);
Yong Wang45f2c692010-04-11 09:27:19 +08002090 err = -ENODEV;
Corentin Chary27c136c2010-11-29 08:14:05 +01002091 goto fail_wmi_handler;
Yong Wang45f2c692010-04-11 09:27:19 +08002092 }
2093
Corentin Charye12e6d92011-02-26 10:20:31 +01002094 err = asus_wmi_debugfs_init(asus);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01002095 if (err)
2096 goto fail_debugfs;
2097
AceLan Kaoa50bd122012-07-26 17:13:31 +08002098 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result);
2099 if (result & (ASUS_WMI_DSTS_PRESENCE_BIT | ASUS_WMI_DSTS_USER_BIT))
2100 asus->driver->wlan_ctrl_by_user = 1;
2101
Corentin Charya04ce292011-02-06 13:28:33 +01002102 return 0;
Yong Wang45f2c692010-04-11 09:27:19 +08002103
Corentin Chary8c1b2d82010-11-29 08:14:09 +01002104fail_debugfs:
Corentin Charye12e6d92011-02-26 10:20:31 +01002105 wmi_remove_notify_handler(asus->driver->event_guid);
Corentin Chary27c136c2010-11-29 08:14:05 +01002106fail_wmi_handler:
Corentin Charye12e6d92011-02-26 10:20:31 +01002107 asus_wmi_backlight_exit(asus);
Corentin Chary27c136c2010-11-29 08:14:05 +01002108fail_backlight:
Corentin Charye12e6d92011-02-26 10:20:31 +01002109 asus_wmi_rfkill_exit(asus);
Corentin Charyba48fdb2010-11-29 08:14:07 +01002110fail_rfkill:
Corentin Charye12e6d92011-02-26 10:20:31 +01002111 asus_wmi_led_exit(asus);
Corentin Chary084fca62010-11-29 08:14:06 +01002112fail_leds:
Corentin Charye07babd2011-02-26 10:20:42 +01002113fail_hwmon:
Corentin Charye12e6d92011-02-26 10:20:31 +01002114 asus_wmi_input_exit(asus);
Corentin Chary27c136c2010-11-29 08:14:05 +01002115fail_input:
Corentin Charye12e6d92011-02-26 10:20:31 +01002116 asus_wmi_platform_exit(asus);
Corentin Chary27c136c2010-11-29 08:14:05 +01002117fail_platform:
Corentin Charye12e6d92011-02-26 10:20:31 +01002118 kfree(asus);
Corentin Charya04ce292011-02-06 13:28:33 +01002119 return err;
Yong Wang45f2c692010-04-11 09:27:19 +08002120}
2121
Corentin Charye12e6d92011-02-26 10:20:31 +01002122static int asus_wmi_remove(struct platform_device *device)
Yong Wang45f2c692010-04-11 09:27:19 +08002123{
Corentin Charye12e6d92011-02-26 10:20:31 +01002124 struct asus_wmi *asus;
Yong Wang45f2c692010-04-11 09:27:19 +08002125
Corentin Charye12e6d92011-02-26 10:20:31 +01002126 asus = platform_get_drvdata(device);
2127 wmi_remove_notify_handler(asus->driver->event_guid);
2128 asus_wmi_backlight_exit(asus);
2129 asus_wmi_input_exit(asus);
2130 asus_wmi_led_exit(asus);
2131 asus_wmi_rfkill_exit(asus);
2132 asus_wmi_debugfs_exit(asus);
2133 asus_wmi_platform_exit(asus);
Kast Bernd53e755c2015-05-13 16:24:16 +02002134 asus_hwmon_fan_set_auto(asus);
Yong Wang45f2c692010-04-11 09:27:19 +08002135
Corentin Charye12e6d92011-02-26 10:20:31 +01002136 kfree(asus);
Yong Wang45f2c692010-04-11 09:27:19 +08002137 return 0;
2138}
2139
Corentin Chary0773d7f2011-02-06 13:28:32 +01002140/*
2141 * Platform driver - hibernate/resume callbacks
2142 */
Corentin Charye12e6d92011-02-26 10:20:31 +01002143static int asus_hotk_thaw(struct device *device)
Corentin Chary0773d7f2011-02-06 13:28:32 +01002144{
Corentin Charye12e6d92011-02-26 10:20:31 +01002145 struct asus_wmi *asus = dev_get_drvdata(device);
Corentin Chary0773d7f2011-02-06 13:28:32 +01002146
Corentin Charya7ce3f02011-02-26 10:20:33 +01002147 if (asus->wlan.rfkill) {
Corentin Chary0773d7f2011-02-06 13:28:32 +01002148 bool wlan;
2149
2150 /*
2151 * Work around bios bug - acpi _PTS turns off the wireless led
2152 * during suspend. Normally it restores it on resume, but
2153 * we should kick it ourselves in case hibernation is aborted.
2154 */
Corentin Chary1d070f82011-02-26 10:20:36 +01002155 wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
Corentin Charye12e6d92011-02-26 10:20:31 +01002156 asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
Corentin Chary0773d7f2011-02-06 13:28:32 +01002157 }
2158
2159 return 0;
2160}
2161
Oleksij Rempel30734042015-09-14 11:16:30 +02002162static int asus_hotk_resume(struct device *device)
2163{
2164 struct asus_wmi *asus = dev_get_drvdata(device);
2165
2166 if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
2167 queue_work(asus->led_workqueue, &asus->kbd_led_work);
2168
2169 return 0;
2170}
2171
Corentin Charye12e6d92011-02-26 10:20:31 +01002172static int asus_hotk_restore(struct device *device)
Corentin Chary0773d7f2011-02-06 13:28:32 +01002173{
Corentin Charye12e6d92011-02-26 10:20:31 +01002174 struct asus_wmi *asus = dev_get_drvdata(device);
Corentin Chary0773d7f2011-02-06 13:28:32 +01002175 int bl;
2176
2177 /* Refresh both wlan rfkill state and pci hotplug */
Corentin Charya7ce3f02011-02-26 10:20:33 +01002178 if (asus->wlan.rfkill)
Corentin Charye12e6d92011-02-26 10:20:31 +01002179 asus_rfkill_hotplug(asus);
Corentin Chary0773d7f2011-02-06 13:28:32 +01002180
Corentin Charya7ce3f02011-02-26 10:20:33 +01002181 if (asus->bluetooth.rfkill) {
Corentin Chary1d070f82011-02-26 10:20:36 +01002182 bl = !asus_wmi_get_devstate_simple(asus,
2183 ASUS_WMI_DEVID_BLUETOOTH);
Corentin Charya7ce3f02011-02-26 10:20:33 +01002184 rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
Corentin Chary2e9e1592011-02-06 13:28:37 +01002185 }
Corentin Charya7ce3f02011-02-26 10:20:33 +01002186 if (asus->wimax.rfkill) {
Corentin Chary1d070f82011-02-26 10:20:36 +01002187 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
Corentin Charya7ce3f02011-02-26 10:20:33 +01002188 rfkill_set_sw_state(asus->wimax.rfkill, bl);
Corentin Chary2e9e1592011-02-06 13:28:37 +01002189 }
Corentin Charya7ce3f02011-02-26 10:20:33 +01002190 if (asus->wwan3g.rfkill) {
Corentin Chary1d070f82011-02-26 10:20:36 +01002191 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
Corentin Charya7ce3f02011-02-26 10:20:33 +01002192 rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
Corentin Chary0773d7f2011-02-06 13:28:32 +01002193 }
Corentin Chary43be8bd2011-07-01 11:34:40 +02002194 if (asus->gps.rfkill) {
2195 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS);
2196 rfkill_set_sw_state(asus->gps.rfkill, bl);
2197 }
Corentin Charya912d322011-07-01 11:34:41 +02002198 if (asus->uwb.rfkill) {
2199 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB);
2200 rfkill_set_sw_state(asus->uwb.rfkill, bl);
2201 }
Oleksij Rempel30734042015-09-14 11:16:30 +02002202 if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
2203 queue_work(asus->led_workqueue, &asus->kbd_led_work);
Corentin Chary0773d7f2011-02-06 13:28:32 +01002204
2205 return 0;
2206}
2207
Corentin Charye12e6d92011-02-26 10:20:31 +01002208static const struct dev_pm_ops asus_pm_ops = {
2209 .thaw = asus_hotk_thaw,
2210 .restore = asus_hotk_restore,
Oleksij Rempel30734042015-09-14 11:16:30 +02002211 .resume = asus_hotk_resume,
Corentin Chary0773d7f2011-02-06 13:28:32 +01002212};
2213
Corentin Charye12e6d92011-02-26 10:20:31 +01002214static int asus_wmi_probe(struct platform_device *pdev)
Corentin Charyd358cb52010-11-29 08:14:14 +01002215{
Corentin Charye12e6d92011-02-26 10:20:31 +01002216 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
2217 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
2218 int ret;
Corentin Charyd358cb52010-11-29 08:14:14 +01002219
Corentin Charye12e6d92011-02-26 10:20:31 +01002220 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
Joe Perches5ad77dc2011-03-29 15:21:35 -07002221 pr_warn("Management GUID not found\n");
Yong Wangee027e42010-03-21 10:26:34 +08002222 return -ENODEV;
2223 }
2224
Corentin Charye12e6d92011-02-26 10:20:31 +01002225 if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
Joe Perches5ad77dc2011-03-29 15:21:35 -07002226 pr_warn("Event GUID not found\n");
Corentin Charyd358cb52010-11-29 08:14:14 +01002227 return -ENODEV;
2228 }
2229
Corentin Charye12e6d92011-02-26 10:20:31 +01002230 if (wdrv->probe) {
2231 ret = wdrv->probe(pdev);
2232 if (ret)
2233 return ret;
2234 }
2235
2236 return asus_wmi_add(pdev);
Corentin Charya04ce292011-02-06 13:28:33 +01002237}
Yong Wangee027e42010-03-21 10:26:34 +08002238
Corentin Charye12e6d92011-02-26 10:20:31 +01002239static bool used;
Yong Wangee027e42010-03-21 10:26:34 +08002240
Corentin Chary8fe8c252011-07-01 11:34:32 +02002241int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
Corentin Charya04ce292011-02-06 13:28:33 +01002242{
Corentin Charye12e6d92011-02-26 10:20:31 +01002243 struct platform_driver *platform_driver;
2244 struct platform_device *platform_device;
2245
2246 if (used)
2247 return -EBUSY;
2248
2249 platform_driver = &driver->platform_driver;
2250 platform_driver->remove = asus_wmi_remove;
2251 platform_driver->driver.owner = driver->owner;
2252 platform_driver->driver.name = driver->name;
2253 platform_driver->driver.pm = &asus_pm_ops;
2254
2255 platform_device = platform_create_bundle(platform_driver,
2256 asus_wmi_probe,
Corentin Charya04ce292011-02-06 13:28:33 +01002257 NULL, 0, NULL, 0);
2258 if (IS_ERR(platform_device))
2259 return PTR_ERR(platform_device);
Corentin Charye12e6d92011-02-26 10:20:31 +01002260
2261 used = true;
2262 return 0;
2263}
2264EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
2265
2266void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
2267{
2268 platform_device_unregister(driver->platform_device);
2269 platform_driver_unregister(&driver->platform_driver);
2270 used = false;
2271}
2272EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
2273
2274static int __init asus_wmi_init(void)
2275{
2276 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
vic0ed60652013-05-22 21:32:10 +03002277 pr_info("Asus Management GUID not found\n");
Corentin Charye12e6d92011-02-26 10:20:31 +01002278 return -ENODEV;
2279 }
2280
vic0ed60652013-05-22 21:32:10 +03002281 pr_info("ASUS WMI generic driver loaded\n");
Yong Wangee027e42010-03-21 10:26:34 +08002282 return 0;
2283}
2284
Corentin Charye12e6d92011-02-26 10:20:31 +01002285static void __exit asus_wmi_exit(void)
Yong Wangee027e42010-03-21 10:26:34 +08002286{
vic0ed60652013-05-22 21:32:10 +03002287 pr_info("ASUS WMI generic driver unloaded\n");
Yong Wangee027e42010-03-21 10:26:34 +08002288}
2289
Corentin Charye12e6d92011-02-26 10:20:31 +01002290module_init(asus_wmi_init);
2291module_exit(asus_wmi_exit);