blob: 95cba9ebf6c08ddab129840447367fb0e83aea9e [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>
Yong Wangee027e42010-03-21 10:26:34 +080048#include <acpi/acpi_bus.h>
49#include <acpi/acpi_drivers.h>
50
Corentin Charye12e6d92011-02-26 10:20:31 +010051#include "asus-wmi.h"
Yong Wang45f2c692010-04-11 09:27:19 +080052
Corentin Charye12e6d92011-02-26 10:20:31 +010053MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>, "
54 "Yong Wang <yong.y.wang@intel.com>");
55MODULE_DESCRIPTION("Asus Generic WMI Driver");
Yong Wangee027e42010-03-21 10:26:34 +080056MODULE_LICENSE("GPL");
57
Corentin Charye12e6d92011-02-26 10:20:31 +010058#define to_platform_driver(drv) \
59 (container_of((drv), struct platform_driver, driver))
Corentin Charyd358cb52010-11-29 08:14:14 +010060
Corentin Charye12e6d92011-02-26 10:20:31 +010061#define to_asus_wmi_driver(pdrv) \
62 (container_of((pdrv), struct asus_wmi_driver, platform_driver))
Yong Wangee027e42010-03-21 10:26:34 +080063
Corentin Charye12e6d92011-02-26 10:20:31 +010064#define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66"
Yong Wangee027e42010-03-21 10:26:34 +080065
Corentin Chary33e0e6f2011-02-06 13:28:34 +010066#define NOTIFY_BRNUP_MIN 0x11
67#define NOTIFY_BRNUP_MAX 0x1f
68#define NOTIFY_BRNDOWN_MIN 0x20
69#define NOTIFY_BRNDOWN_MAX 0x2e
Corentin Charye9809c02011-07-01 11:34:31 +020070#define NOTIFY_KBD_BRTUP 0xc4
71#define NOTIFY_KBD_BRTDWN 0xc5
Yong Wangee027e42010-03-21 10:26:34 +080072
Corentin Chary43815942011-02-06 13:28:43 +010073/* WMI Methods */
Corentin Chary2f686b52011-02-26 10:20:41 +010074#define ASUS_WMI_METHODID_SPEC 0x43455053 /* BIOS SPECification */
75#define ASUS_WMI_METHODID_SFBD 0x44424653 /* Set First Boot Device */
76#define ASUS_WMI_METHODID_GLCD 0x44434C47 /* Get LCD status */
77#define ASUS_WMI_METHODID_GPID 0x44495047 /* Get Panel ID?? (Resol) */
78#define ASUS_WMI_METHODID_QMOD 0x444F4D51 /* Quiet MODe */
79#define ASUS_WMI_METHODID_SPLV 0x4C425053 /* Set Panel Light Value */
80#define ASUS_WMI_METHODID_SFUN 0x4E554653 /* FUNCtionalities */
81#define ASUS_WMI_METHODID_SDSP 0x50534453 /* Set DiSPlay output */
82#define ASUS_WMI_METHODID_GDSP 0x50534447 /* Get DiSPlay output */
83#define ASUS_WMI_METHODID_DEVP 0x50564544 /* DEVice Policy */
84#define ASUS_WMI_METHODID_OSVR 0x5256534F /* OS VeRsion */
85#define ASUS_WMI_METHODID_DSTS 0x53544344 /* Device STatuS */
86#define ASUS_WMI_METHODID_DSTS2 0x53545344 /* Device STatuS #2*/
87#define ASUS_WMI_METHODID_BSTS 0x53545342 /* Bios STatuS ? */
88#define ASUS_WMI_METHODID_DEVS 0x53564544 /* DEVice Set */
89#define ASUS_WMI_METHODID_CFVS 0x53564643 /* CPU Frequency Volt Set */
90#define ASUS_WMI_METHODID_KBFT 0x5446424B /* KeyBoard FilTer */
91#define ASUS_WMI_METHODID_INIT 0x54494E49 /* INITialize */
92#define ASUS_WMI_METHODID_HKEY 0x59454B48 /* Hot KEY ?? */
Yong Wang3d7b1652010-04-11 09:27:54 +080093
Corentin Charyd33da3b2011-02-26 10:20:35 +010094#define ASUS_WMI_UNSUPPORTED_METHOD 0xFFFFFFFE
95
Corentin Chary43815942011-02-06 13:28:43 +010096/* Wireless */
Corentin Chary2f686b52011-02-26 10:20:41 +010097#define ASUS_WMI_DEVID_HW_SWITCH 0x00010001
98#define ASUS_WMI_DEVID_WIRELESS_LED 0x00010002
Corentin Chary79ec1172011-07-01 11:34:35 +020099#define ASUS_WMI_DEVID_CWAP 0x00010003
Corentin Charye12e6d92011-02-26 10:20:31 +0100100#define ASUS_WMI_DEVID_WLAN 0x00010011
101#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
Corentin Chary43815942011-02-06 13:28:43 +0100139/* DSTS masks */
Corentin Charye12e6d92011-02-26 10:20:31 +0100140#define ASUS_WMI_DSTS_STATUS_BIT 0x00000001
Corentin Charya75fe0d2011-02-26 10:20:34 +0100141#define ASUS_WMI_DSTS_UNKNOWN_BIT 0x00000002
Corentin Charye12e6d92011-02-26 10:20:31 +0100142#define ASUS_WMI_DSTS_PRESENCE_BIT 0x00010000
Corentin Chary2f686b52011-02-26 10:20:41 +0100143#define ASUS_WMI_DSTS_USER_BIT 0x00020000
144#define ASUS_WMI_DSTS_BIOS_BIT 0x00040000
Corentin Charye12e6d92011-02-26 10:20:31 +0100145#define ASUS_WMI_DSTS_BRIGHTNESS_MASK 0x000000FF
146#define ASUS_WMI_DSTS_MAX_BRIGTH_MASK 0x0000FF00
Yong Wangee027e42010-03-21 10:26:34 +0800147
Yong Wang3d7b1652010-04-11 09:27:54 +0800148struct bios_args {
Corentin Charyd33da3b2011-02-26 10:20:35 +0100149 u32 arg0;
150 u32 arg1;
151} __packed;
Yong Wang3d7b1652010-04-11 09:27:54 +0800152
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100153/*
Corentin Charye12e6d92011-02-26 10:20:31 +0100154 * <platform>/ - debugfs root directory
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100155 * dev_id - current dev_id
156 * ctrl_param - current ctrl_param
Corentin Charyef343492011-02-26 10:20:39 +0100157 * method_id - current method_id
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100158 * devs - call DEVS(dev_id, ctrl_param) and print result
159 * dsts - call DSTS(dev_id) and print result
Corentin Charyef343492011-02-26 10:20:39 +0100160 * call - call method_id(dev_id, ctrl_param) and print result
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100161 */
Corentin Charye12e6d92011-02-26 10:20:31 +0100162struct asus_wmi_debug {
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100163 struct dentry *root;
Corentin Charyef343492011-02-26 10:20:39 +0100164 u32 method_id;
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100165 u32 dev_id;
166 u32 ctrl_param;
167};
168
Corentin Charya7ce3f02011-02-26 10:20:33 +0100169struct asus_rfkill {
170 struct asus_wmi *asus;
171 struct rfkill *rfkill;
172 u32 dev_id;
173};
174
Corentin Charye12e6d92011-02-26 10:20:31 +0100175struct asus_wmi {
Corentin Chary1d070f82011-02-26 10:20:36 +0100176 int dsts_id;
Corentin Chary46dbca82011-02-26 10:20:38 +0100177 int spec;
178 int sfun;
Corentin Chary1d070f82011-02-26 10:20:36 +0100179
Yong Wang81248882010-04-11 09:26:33 +0800180 struct input_dev *inputdev;
Yong Wang3d7b1652010-04-11 09:27:54 +0800181 struct backlight_device *backlight_device;
Corentin Charye07babd2011-02-26 10:20:42 +0100182 struct device *hwmon_device;
Corentin Chary27c136c2010-11-29 08:14:05 +0100183 struct platform_device *platform_device;
Corentin Chary084fca62010-11-29 08:14:06 +0100184
185 struct led_classdev tpd_led;
186 int tpd_led_wk;
Corentin Charye9809c02011-07-01 11:34:31 +0200187 struct led_classdev kbd_led;
188 int kbd_led_wk;
Corentin Chary084fca62010-11-29 08:14:06 +0100189 struct workqueue_struct *led_workqueue;
190 struct work_struct tpd_led_work;
Corentin Charye9809c02011-07-01 11:34:31 +0200191 struct work_struct kbd_led_work;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100192
Corentin Charya7ce3f02011-02-26 10:20:33 +0100193 struct asus_rfkill wlan;
194 struct asus_rfkill bluetooth;
195 struct asus_rfkill wimax;
196 struct asus_rfkill wwan3g;
Corentin Chary43be8bd2011-07-01 11:34:40 +0200197 struct asus_rfkill gps;
Corentin Charya912d322011-07-01 11:34:41 +0200198 struct asus_rfkill uwb;
Corentin Chary8c1b2d82010-11-29 08:14:09 +0100199
Corentin Charyafa7c882011-02-06 13:28:28 +0100200 struct hotplug_slot *hotplug_slot;
201 struct mutex hotplug_lock;
Corentin Chary279f8f92011-02-06 13:28:29 +0100202 struct mutex wmi_lock;
203 struct workqueue_struct *hotplug_workqueue;
204 struct work_struct hotplug_work;
Corentin Charyafa7c882011-02-06 13:28:28 +0100205
Corentin Charye12e6d92011-02-26 10:20:31 +0100206 struct asus_wmi_debug debug;
207
208 struct asus_wmi_driver *driver;
Yong Wang81248882010-04-11 09:26:33 +0800209};
210
Corentin Charye12e6d92011-02-26 10:20:31 +0100211static int asus_wmi_input_init(struct asus_wmi *asus)
Yong Wangee027e42010-03-21 10:26:34 +0800212{
213 int err;
214
Corentin Charye12e6d92011-02-26 10:20:31 +0100215 asus->inputdev = input_allocate_device();
216 if (!asus->inputdev)
Yong Wangee027e42010-03-21 10:26:34 +0800217 return -ENOMEM;
218
Corentin Chary58a9f392011-03-30 16:32:32 +0200219 asus->inputdev->name = asus->driver->input_name;
220 asus->inputdev->phys = asus->driver->input_phys;
Corentin Charye12e6d92011-02-26 10:20:31 +0100221 asus->inputdev->id.bustype = BUS_HOST;
222 asus->inputdev->dev.parent = &asus->platform_device->dev;
Seth Forshee39bbde02011-07-04 09:49:20 +0200223 set_bit(EV_REP, asus->inputdev->evbit);
Yong Wangee027e42010-03-21 10:26:34 +0800224
Corentin Charye12e6d92011-02-26 10:20:31 +0100225 err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
Yong Wangee027e42010-03-21 10:26:34 +0800226 if (err)
227 goto err_free_dev;
228
Corentin Charye12e6d92011-02-26 10:20:31 +0100229 err = input_register_device(asus->inputdev);
Yong Wangee027e42010-03-21 10:26:34 +0800230 if (err)
231 goto err_free_keymap;
232
233 return 0;
234
235err_free_keymap:
Corentin Charye12e6d92011-02-26 10:20:31 +0100236 sparse_keymap_free(asus->inputdev);
Yong Wangee027e42010-03-21 10:26:34 +0800237err_free_dev:
Corentin Charye12e6d92011-02-26 10:20:31 +0100238 input_free_device(asus->inputdev);
Yong Wangee027e42010-03-21 10:26:34 +0800239 return err;
240}
241
Corentin Charye12e6d92011-02-26 10:20:31 +0100242static void asus_wmi_input_exit(struct asus_wmi *asus)
Yong Wang81248882010-04-11 09:26:33 +0800243{
Corentin Charye12e6d92011-02-26 10:20:31 +0100244 if (asus->inputdev) {
245 sparse_keymap_free(asus->inputdev);
246 input_unregister_device(asus->inputdev);
Yong Wang81248882010-04-11 09:26:33 +0800247 }
248
Corentin Charye12e6d92011-02-26 10:20:31 +0100249 asus->inputdev = NULL;
Yong Wang81248882010-04-11 09:26:33 +0800250}
251
Corentin Charyd33da3b2011-02-26 10:20:35 +0100252static int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
253 u32 *retval)
Yong Wang3d7b1652010-04-11 09:27:54 +0800254{
Corentin Charyd33da3b2011-02-26 10:20:35 +0100255 struct bios_args args = {
256 .arg0 = arg0,
257 .arg1 = arg1,
258 };
259 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
Yong Wang3d7b1652010-04-11 09:27:54 +0800260 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
Yong Wang3d7b1652010-04-11 09:27:54 +0800261 acpi_status status;
Corentin Charyd33da3b2011-02-26 10:20:35 +0100262 union acpi_object *obj;
Yong Wang3d7b1652010-04-11 09:27:54 +0800263 u32 tmp;
264
Corentin Charyd33da3b2011-02-26 10:20:35 +0100265 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1, method_id,
Corentin Charyafa7c882011-02-06 13:28:28 +0100266 &input, &output);
Yong Wang3d7b1652010-04-11 09:27:54 +0800267
268 if (ACPI_FAILURE(status))
Corentin Charyd33da3b2011-02-26 10:20:35 +0100269 goto exit;
Yong Wang3d7b1652010-04-11 09:27:54 +0800270
271 obj = (union acpi_object *)output.pointer;
272 if (obj && obj->type == ACPI_TYPE_INTEGER)
Corentin Charye12e6d92011-02-26 10:20:31 +0100273 tmp = (u32) obj->integer.value;
Yong Wang3d7b1652010-04-11 09:27:54 +0800274 else
275 tmp = 0;
276
Corentin Chary2a3f0062010-11-29 08:14:10 +0100277 if (retval)
278 *retval = tmp;
Yong Wang3d7b1652010-04-11 09:27:54 +0800279
280 kfree(obj);
281
Corentin Charyd33da3b2011-02-26 10:20:35 +0100282exit:
283 if (ACPI_FAILURE(status))
284 return -EIO;
Yong Wang3d7b1652010-04-11 09:27:54 +0800285
Corentin Charyd33da3b2011-02-26 10:20:35 +0100286 if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
287 return -ENODEV;
288
289 return 0;
Yong Wang3d7b1652010-04-11 09:27:54 +0800290}
291
Corentin Chary1d070f82011-02-26 10:20:36 +0100292static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
Corentin Charyd33da3b2011-02-26 10:20:35 +0100293{
Corentin Chary1d070f82011-02-26 10:20:36 +0100294 return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
Corentin Charyd33da3b2011-02-26 10:20:35 +0100295}
296
297static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
Corentin Chary1d070f82011-02-26 10:20:36 +0100298 u32 *retval)
Yong Wang3d7b1652010-04-11 09:27:54 +0800299{
Corentin Charyd33da3b2011-02-26 10:20:35 +0100300 return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
301 ctrl_param, retval);
Yong Wang3d7b1652010-04-11 09:27:54 +0800302}
303
Corentin Chary5c956382011-02-06 13:28:31 +0100304/* Helper for special devices with magic return codes */
Corentin Chary1d070f82011-02-26 10:20:36 +0100305static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
306 u32 dev_id, u32 mask)
Corentin Chary5c956382011-02-06 13:28:31 +0100307{
308 u32 retval = 0;
Corentin Charyd33da3b2011-02-26 10:20:35 +0100309 int err;
Corentin Chary5c956382011-02-06 13:28:31 +0100310
Corentin Chary1d070f82011-02-26 10:20:36 +0100311 err = asus_wmi_get_devstate(asus, dev_id, &retval);
Corentin Chary5c956382011-02-06 13:28:31 +0100312
Corentin Charyd33da3b2011-02-26 10:20:35 +0100313 if (err < 0)
314 return err;
Corentin Chary5c956382011-02-06 13:28:31 +0100315
Corentin Charye12e6d92011-02-26 10:20:31 +0100316 if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
Corentin Chary5c956382011-02-06 13:28:31 +0100317 return -ENODEV;
318
Corentin Charya75fe0d2011-02-26 10:20:34 +0100319 if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
320 if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
321 return -ENODEV;
322 }
323
Corentin Charyb7187262011-02-06 13:28:39 +0100324 return retval & mask;
325}
326
Corentin Chary1d070f82011-02-26 10:20:36 +0100327static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
Corentin Charyb7187262011-02-06 13:28:39 +0100328{
Corentin Chary1d070f82011-02-26 10:20:36 +0100329 return asus_wmi_get_devstate_bits(asus, dev_id,
330 ASUS_WMI_DSTS_STATUS_BIT);
Corentin Chary5c956382011-02-06 13:28:31 +0100331}
332
Corentin Chary084fca62010-11-29 08:14:06 +0100333/*
334 * LEDs
335 */
336/*
337 * These functions actually update the LED's, and are called from a
338 * workqueue. By doing this as separate work rather than when the LED
Corentin Charye12e6d92011-02-26 10:20:31 +0100339 * subsystem asks, we avoid messing with the Asus ACPI stuff during a
Corentin Chary084fca62010-11-29 08:14:06 +0100340 * potentially bad time, such as a timer interrupt.
341 */
342static void tpd_led_update(struct work_struct *work)
343{
344 int ctrl_param;
Corentin Charye12e6d92011-02-26 10:20:31 +0100345 struct asus_wmi *asus;
Corentin Chary084fca62010-11-29 08:14:06 +0100346
Corentin Charye12e6d92011-02-26 10:20:31 +0100347 asus = container_of(work, struct asus_wmi, tpd_led_work);
Corentin Chary084fca62010-11-29 08:14:06 +0100348
Corentin Charye12e6d92011-02-26 10:20:31 +0100349 ctrl_param = asus->tpd_led_wk;
350 asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
Corentin Chary084fca62010-11-29 08:14:06 +0100351}
352
353static void tpd_led_set(struct led_classdev *led_cdev,
354 enum led_brightness value)
355{
Corentin Charye12e6d92011-02-26 10:20:31 +0100356 struct asus_wmi *asus;
Corentin Chary084fca62010-11-29 08:14:06 +0100357
Corentin Charye12e6d92011-02-26 10:20:31 +0100358 asus = container_of(led_cdev, struct asus_wmi, tpd_led);
Corentin Chary084fca62010-11-29 08:14:06 +0100359
Corentin Charye12e6d92011-02-26 10:20:31 +0100360 asus->tpd_led_wk = !!value;
361 queue_work(asus->led_workqueue, &asus->tpd_led_work);
Corentin Chary084fca62010-11-29 08:14:06 +0100362}
363
Corentin Charye12e6d92011-02-26 10:20:31 +0100364static int read_tpd_led_state(struct asus_wmi *asus)
Corentin Chary084fca62010-11-29 08:14:06 +0100365{
Corentin Chary1d070f82011-02-26 10:20:36 +0100366 return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
Corentin Chary084fca62010-11-29 08:14:06 +0100367}
368
369static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
370{
Corentin Charye12e6d92011-02-26 10:20:31 +0100371 struct asus_wmi *asus;
Corentin Chary084fca62010-11-29 08:14:06 +0100372
Corentin Charye12e6d92011-02-26 10:20:31 +0100373 asus = container_of(led_cdev, struct asus_wmi, tpd_led);
Corentin Chary084fca62010-11-29 08:14:06 +0100374
Corentin Charye12e6d92011-02-26 10:20:31 +0100375 return read_tpd_led_state(asus);
Corentin Chary084fca62010-11-29 08:14:06 +0100376}
377
Corentin Charye9809c02011-07-01 11:34:31 +0200378static void kbd_led_update(struct work_struct *work)
Corentin Chary084fca62010-11-29 08:14:06 +0100379{
Corentin Charye9809c02011-07-01 11:34:31 +0200380 int ctrl_param = 0;
381 struct asus_wmi *asus;
Corentin Chary084fca62010-11-29 08:14:06 +0100382
Corentin Charye9809c02011-07-01 11:34:31 +0200383 asus = container_of(work, struct asus_wmi, kbd_led_work);
Corentin Chary084fca62010-11-29 08:14:06 +0100384
Corentin Charye9809c02011-07-01 11:34:31 +0200385 /*
386 * bits 0-2: level
387 * bit 7: light on/off
388 */
389 if (asus->kbd_led_wk > 0)
390 ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
Corentin Chary084fca62010-11-29 08:14:06 +0100391
Corentin Charye9809c02011-07-01 11:34:31 +0200392 asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
393}
Corentin Chary084fca62010-11-29 08:14:06 +0100394
Corentin Charye9809c02011-07-01 11:34:31 +0200395static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
396{
397 int retval;
398
399 /*
400 * bits 0-2: level
401 * bit 7: light on/off
402 * bit 8-10: environment (0: dark, 1: normal, 2: light)
403 * bit 17: status unknown
404 */
405 retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
406 0xFFFF);
407
Corentin Charyaf965e92011-07-01 11:34:34 +0200408 /* Unknown status is considered as off */
Corentin Charye9809c02011-07-01 11:34:31 +0200409 if (retval == 0x8000)
Corentin Charyaf965e92011-07-01 11:34:34 +0200410 retval = 0;
Corentin Charye9809c02011-07-01 11:34:31 +0200411
412 if (retval >= 0) {
413 if (level)
414 *level = retval & 0x80 ? retval & 0x7F : 0;
415 if (env)
416 *env = (retval >> 8) & 0x7F;
417 retval = 0;
Corentin Chary084fca62010-11-29 08:14:06 +0100418 }
419
Corentin Charye9809c02011-07-01 11:34:31 +0200420 return retval;
421}
422
423static void kbd_led_set(struct led_classdev *led_cdev,
424 enum led_brightness value)
425{
426 struct asus_wmi *asus;
427
428 asus = container_of(led_cdev, struct asus_wmi, kbd_led);
429
430 if (value > asus->kbd_led.max_brightness)
431 value = asus->kbd_led.max_brightness;
432 else if (value < 0)
433 value = 0;
434
435 asus->kbd_led_wk = value;
436 queue_work(asus->led_workqueue, &asus->kbd_led_work);
437}
438
439static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
440{
441 struct asus_wmi *asus;
442 int retval, value;
443
444 asus = container_of(led_cdev, struct asus_wmi, kbd_led);
445
446 retval = kbd_led_read(asus, &value, NULL);
447
448 if (retval < 0)
449 return retval;
450
451 return value;
Corentin Chary084fca62010-11-29 08:14:06 +0100452}
453
Corentin Charye12e6d92011-02-26 10:20:31 +0100454static void asus_wmi_led_exit(struct asus_wmi *asus)
Corentin Chary084fca62010-11-29 08:14:06 +0100455{
Corentin Charye12e6d92011-02-26 10:20:31 +0100456 if (asus->tpd_led.dev)
457 led_classdev_unregister(&asus->tpd_led);
458 if (asus->led_workqueue)
459 destroy_workqueue(asus->led_workqueue);
Corentin Chary084fca62010-11-29 08:14:06 +0100460}
461
Corentin Charye9809c02011-07-01 11:34:31 +0200462static int asus_wmi_led_init(struct asus_wmi *asus)
463{
464 int rv = 0;
465
466 asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
467 if (!asus->led_workqueue)
468 return -ENOMEM;
469
470 if (read_tpd_led_state(asus) >= 0) {
471 INIT_WORK(&asus->tpd_led_work, tpd_led_update);
472
473 asus->tpd_led.name = "asus::touchpad";
474 asus->tpd_led.brightness_set = tpd_led_set;
475 asus->tpd_led.brightness_get = tpd_led_get;
476 asus->tpd_led.max_brightness = 1;
477
478 rv = led_classdev_register(&asus->platform_device->dev,
479 &asus->tpd_led);
480 if (rv)
481 goto error;
482 }
483
484 if (kbd_led_read(asus, NULL, NULL) >= 0) {
485 INIT_WORK(&asus->kbd_led_work, kbd_led_update);
486
487 asus->kbd_led.name = "asus::kbd_backlight";
488 asus->kbd_led.brightness_set = kbd_led_set;
489 asus->kbd_led.brightness_get = kbd_led_get;
490 asus->kbd_led.max_brightness = 3;
491
492 rv = led_classdev_register(&asus->platform_device->dev,
493 &asus->kbd_led);
494 }
495
496error:
497 if (rv)
498 asus_wmi_led_exit(asus);
499
500 return rv;
501}
502
503
Corentin Chary084fca62010-11-29 08:14:06 +0100504/*
Corentin Charyafa7c882011-02-06 13:28:28 +0100505 * PCI hotplug (for wlan rfkill)
506 */
Corentin Charye12e6d92011-02-26 10:20:31 +0100507static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
Corentin Charyafa7c882011-02-06 13:28:28 +0100508{
Corentin Chary1d070f82011-02-26 10:20:36 +0100509 int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
Corentin Charyafa7c882011-02-06 13:28:28 +0100510
Corentin Chary5c956382011-02-06 13:28:31 +0100511 if (result < 0)
Corentin Charyafa7c882011-02-06 13:28:28 +0100512 return false;
Corentin Chary5c956382011-02-06 13:28:31 +0100513 return !result;
Corentin Charyafa7c882011-02-06 13:28:28 +0100514}
515
Corentin Charye12e6d92011-02-26 10:20:31 +0100516static void asus_rfkill_hotplug(struct asus_wmi *asus)
Corentin Charyafa7c882011-02-06 13:28:28 +0100517{
518 struct pci_dev *dev;
519 struct pci_bus *bus;
Corentin Chary279f8f92011-02-06 13:28:29 +0100520 bool blocked;
Corentin Charyafa7c882011-02-06 13:28:28 +0100521 bool absent;
522 u32 l;
523
Corentin Charye12e6d92011-02-26 10:20:31 +0100524 mutex_lock(&asus->wmi_lock);
525 blocked = asus_wlan_rfkill_blocked(asus);
526 mutex_unlock(&asus->wmi_lock);
Corentin Charyafa7c882011-02-06 13:28:28 +0100527
Corentin Charye12e6d92011-02-26 10:20:31 +0100528 mutex_lock(&asus->hotplug_lock);
Corentin Charyafa7c882011-02-06 13:28:28 +0100529
Corentin Charya7ce3f02011-02-26 10:20:33 +0100530 if (asus->wlan.rfkill)
531 rfkill_set_sw_state(asus->wlan.rfkill, blocked);
Corentin Chary279f8f92011-02-06 13:28:29 +0100532
Corentin Charye12e6d92011-02-26 10:20:31 +0100533 if (asus->hotplug_slot) {
Corentin Charyafa7c882011-02-06 13:28:28 +0100534 bus = pci_find_bus(0, 1);
535 if (!bus) {
Joe Perches5ad77dc2011-03-29 15:21:35 -0700536 pr_warn("Unable to find PCI bus 1?\n");
Corentin Charyafa7c882011-02-06 13:28:28 +0100537 goto out_unlock;
538 }
539
540 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
541 pr_err("Unable to read PCI config space?\n");
542 goto out_unlock;
543 }
544 absent = (l == 0xffffffff);
545
546 if (blocked != absent) {
Joe Perches5ad77dc2011-03-29 15:21:35 -0700547 pr_warn("BIOS says wireless lan is %s, "
548 "but the pci device is %s\n",
549 blocked ? "blocked" : "unblocked",
550 absent ? "absent" : "present");
551 pr_warn("skipped wireless hotplug as probably "
552 "inappropriate for this model\n");
Corentin Charyafa7c882011-02-06 13:28:28 +0100553 goto out_unlock;
554 }
555
556 if (!blocked) {
557 dev = pci_get_slot(bus, 0);
558 if (dev) {
559 /* Device already present */
560 pci_dev_put(dev);
561 goto out_unlock;
562 }
563 dev = pci_scan_single_device(bus, 0);
564 if (dev) {
565 pci_bus_assign_resources(bus);
566 if (pci_bus_add_device(dev))
567 pr_err("Unable to hotplug wifi\n");
568 }
569 } else {
570 dev = pci_get_slot(bus, 0);
571 if (dev) {
572 pci_remove_bus_device(dev);
573 pci_dev_put(dev);
574 }
575 }
576 }
577
578out_unlock:
Corentin Charye12e6d92011-02-26 10:20:31 +0100579 mutex_unlock(&asus->hotplug_lock);
Corentin Charyafa7c882011-02-06 13:28:28 +0100580}
581
Corentin Charye12e6d92011-02-26 10:20:31 +0100582static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
Corentin Charyafa7c882011-02-06 13:28:28 +0100583{
Corentin Charye12e6d92011-02-26 10:20:31 +0100584 struct asus_wmi *asus = data;
Corentin Charyafa7c882011-02-06 13:28:28 +0100585
586 if (event != ACPI_NOTIFY_BUS_CHECK)
587 return;
588
Corentin Chary279f8f92011-02-06 13:28:29 +0100589 /*
Corentin Charye12e6d92011-02-26 10:20:31 +0100590 * We can't call directly asus_rfkill_hotplug because most
Corentin Chary279f8f92011-02-06 13:28:29 +0100591 * of the time WMBC is still being executed and not reetrant.
592 * There is currently no way to tell ACPICA that we want this
Corentin Charye12e6d92011-02-26 10:20:31 +0100593 * method to be serialized, we schedule a asus_rfkill_hotplug
Corentin Chary279f8f92011-02-06 13:28:29 +0100594 * call later, in a safer context.
595 */
Corentin Charye12e6d92011-02-26 10:20:31 +0100596 queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
Corentin Charyafa7c882011-02-06 13:28:28 +0100597}
598
Corentin Charye12e6d92011-02-26 10:20:31 +0100599static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
Corentin Charyafa7c882011-02-06 13:28:28 +0100600{
601 acpi_status status;
602 acpi_handle handle;
603
604 status = acpi_get_handle(NULL, node, &handle);
605
606 if (ACPI_SUCCESS(status)) {
607 status = acpi_install_notify_handler(handle,
608 ACPI_SYSTEM_NOTIFY,
Corentin Charye12e6d92011-02-26 10:20:31 +0100609 asus_rfkill_notify, asus);
Corentin Charyafa7c882011-02-06 13:28:28 +0100610 if (ACPI_FAILURE(status))
Joe Perches5ad77dc2011-03-29 15:21:35 -0700611 pr_warn("Failed to register notify on %s\n", node);
Corentin Charyafa7c882011-02-06 13:28:28 +0100612 } else
613 return -ENODEV;
614
615 return 0;
616}
617
Corentin Charye12e6d92011-02-26 10:20:31 +0100618static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
Corentin Charyafa7c882011-02-06 13:28:28 +0100619{
620 acpi_status status = AE_OK;
621 acpi_handle handle;
622
623 status = acpi_get_handle(NULL, node, &handle);
624
625 if (ACPI_SUCCESS(status)) {
626 status = acpi_remove_notify_handler(handle,
Corentin Charye12e6d92011-02-26 10:20:31 +0100627 ACPI_SYSTEM_NOTIFY,
628 asus_rfkill_notify);
Corentin Charyafa7c882011-02-06 13:28:28 +0100629 if (ACPI_FAILURE(status))
630 pr_err("Error removing rfkill notify handler %s\n",
Corentin Charye12e6d92011-02-26 10:20:31 +0100631 node);
Corentin Charyafa7c882011-02-06 13:28:28 +0100632 }
633}
634
Corentin Charye12e6d92011-02-26 10:20:31 +0100635static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
636 u8 *value)
Corentin Charyafa7c882011-02-06 13:28:28 +0100637{
Corentin Chary1d070f82011-02-26 10:20:36 +0100638 struct asus_wmi *asus = hotplug_slot->private;
639 int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
Corentin Charyafa7c882011-02-06 13:28:28 +0100640
Corentin Chary5c956382011-02-06 13:28:31 +0100641 if (result < 0)
642 return result;
Corentin Charyafa7c882011-02-06 13:28:28 +0100643
Corentin Chary5c956382011-02-06 13:28:31 +0100644 *value = !!result;
Corentin Charyafa7c882011-02-06 13:28:28 +0100645 return 0;
646}
647
Corentin Charye12e6d92011-02-26 10:20:31 +0100648static void asus_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
Corentin Charyafa7c882011-02-06 13:28:28 +0100649{
650 kfree(hotplug_slot->info);
651 kfree(hotplug_slot);
652}
653
Corentin Charye12e6d92011-02-26 10:20:31 +0100654static struct hotplug_slot_ops asus_hotplug_slot_ops = {
Corentin Charyafa7c882011-02-06 13:28:28 +0100655 .owner = THIS_MODULE,
Corentin Charye12e6d92011-02-26 10:20:31 +0100656 .get_adapter_status = asus_get_adapter_status,
657 .get_power_status = asus_get_adapter_status,
Corentin Charyafa7c882011-02-06 13:28:28 +0100658};
659
Corentin Charye12e6d92011-02-26 10:20:31 +0100660static void asus_hotplug_work(struct work_struct *work)
Corentin Chary279f8f92011-02-06 13:28:29 +0100661{
Corentin Charye12e6d92011-02-26 10:20:31 +0100662 struct asus_wmi *asus;
Corentin Chary279f8f92011-02-06 13:28:29 +0100663
Corentin Charye12e6d92011-02-26 10:20:31 +0100664 asus = container_of(work, struct asus_wmi, hotplug_work);
665 asus_rfkill_hotplug(asus);
Corentin Chary279f8f92011-02-06 13:28:29 +0100666}
667
Corentin Charye12e6d92011-02-26 10:20:31 +0100668static int asus_setup_pci_hotplug(struct asus_wmi *asus)
Corentin Charyafa7c882011-02-06 13:28:28 +0100669{
670 int ret = -ENOMEM;
671 struct pci_bus *bus = pci_find_bus(0, 1);
672
673 if (!bus) {
674 pr_err("Unable to find wifi PCI bus\n");
675 return -ENODEV;
676 }
677
Corentin Charye12e6d92011-02-26 10:20:31 +0100678 asus->hotplug_workqueue =
679 create_singlethread_workqueue("hotplug_workqueue");
680 if (!asus->hotplug_workqueue)
Corentin Chary279f8f92011-02-06 13:28:29 +0100681 goto error_workqueue;
682
Corentin Charye12e6d92011-02-26 10:20:31 +0100683 INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
Corentin Chary279f8f92011-02-06 13:28:29 +0100684
Corentin Charye12e6d92011-02-26 10:20:31 +0100685 asus->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
686 if (!asus->hotplug_slot)
Corentin Charyafa7c882011-02-06 13:28:28 +0100687 goto error_slot;
688
Corentin Charye12e6d92011-02-26 10:20:31 +0100689 asus->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
690 GFP_KERNEL);
691 if (!asus->hotplug_slot->info)
Corentin Charyafa7c882011-02-06 13:28:28 +0100692 goto error_info;
693
Corentin Charye12e6d92011-02-26 10:20:31 +0100694 asus->hotplug_slot->private = asus;
695 asus->hotplug_slot->release = &asus_cleanup_pci_hotplug;
696 asus->hotplug_slot->ops = &asus_hotplug_slot_ops;
697 asus_get_adapter_status(asus->hotplug_slot,
698 &asus->hotplug_slot->info->adapter_status);
Corentin Charyafa7c882011-02-06 13:28:28 +0100699
Corentin Charye12e6d92011-02-26 10:20:31 +0100700 ret = pci_hp_register(asus->hotplug_slot, bus, 0, "asus-wifi");
Corentin Charyafa7c882011-02-06 13:28:28 +0100701 if (ret) {
702 pr_err("Unable to register hotplug slot - %d\n", ret);
703 goto error_register;
704 }
705
706 return 0;
707
708error_register:
Corentin Charye12e6d92011-02-26 10:20:31 +0100709 kfree(asus->hotplug_slot->info);
Corentin Charyafa7c882011-02-06 13:28:28 +0100710error_info:
Corentin Charye12e6d92011-02-26 10:20:31 +0100711 kfree(asus->hotplug_slot);
712 asus->hotplug_slot = NULL;
Corentin Charyafa7c882011-02-06 13:28:28 +0100713error_slot:
Corentin Charye12e6d92011-02-26 10:20:31 +0100714 destroy_workqueue(asus->hotplug_workqueue);
Corentin Chary279f8f92011-02-06 13:28:29 +0100715error_workqueue:
Corentin Charyafa7c882011-02-06 13:28:28 +0100716 return ret;
717}
718
719/*
Corentin Charyba48fdb2010-11-29 08:14:07 +0100720 * Rfkill devices
721 */
Corentin Charye12e6d92011-02-26 10:20:31 +0100722static int asus_rfkill_set(void *data, bool blocked)
Corentin Charyba48fdb2010-11-29 08:14:07 +0100723{
Corentin Charya7ce3f02011-02-26 10:20:33 +0100724 struct asus_rfkill *priv = data;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100725 u32 ctrl_param = !blocked;
726
Corentin Charyd33da3b2011-02-26 10:20:35 +0100727 return asus_wmi_set_devstate(priv->dev_id, ctrl_param, NULL);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100728}
729
Corentin Charye12e6d92011-02-26 10:20:31 +0100730static void asus_rfkill_query(struct rfkill *rfkill, void *data)
Corentin Charyba48fdb2010-11-29 08:14:07 +0100731{
Corentin Charya7ce3f02011-02-26 10:20:33 +0100732 struct asus_rfkill *priv = data;
Corentin Chary5c956382011-02-06 13:28:31 +0100733 int result;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100734
Corentin Chary1d070f82011-02-26 10:20:36 +0100735 result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100736
Corentin Chary5c956382011-02-06 13:28:31 +0100737 if (result < 0)
Corentin Charye12e6d92011-02-26 10:20:31 +0100738 return;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100739
Corentin Charya7ce3f02011-02-26 10:20:33 +0100740 rfkill_set_sw_state(priv->rfkill, !result);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100741}
742
Corentin Charye12e6d92011-02-26 10:20:31 +0100743static int asus_rfkill_wlan_set(void *data, bool blocked)
Corentin Chary279f8f92011-02-06 13:28:29 +0100744{
Corentin Charya7ce3f02011-02-26 10:20:33 +0100745 struct asus_rfkill *priv = data;
746 struct asus_wmi *asus = priv->asus;
Corentin Chary279f8f92011-02-06 13:28:29 +0100747 int ret;
748
749 /*
750 * This handler is enabled only if hotplug is enabled.
Corentin Charye12e6d92011-02-26 10:20:31 +0100751 * In this case, the asus_wmi_set_devstate() will
Corentin Chary279f8f92011-02-06 13:28:29 +0100752 * trigger a wmi notification and we need to wait
753 * this call to finish before being able to call
754 * any wmi method
755 */
Corentin Charye12e6d92011-02-26 10:20:31 +0100756 mutex_lock(&asus->wmi_lock);
Corentin Charya7ce3f02011-02-26 10:20:33 +0100757 ret = asus_rfkill_set(data, blocked);
Corentin Charye12e6d92011-02-26 10:20:31 +0100758 mutex_unlock(&asus->wmi_lock);
Corentin Chary279f8f92011-02-06 13:28:29 +0100759 return ret;
760}
761
Corentin Charye12e6d92011-02-26 10:20:31 +0100762static const struct rfkill_ops asus_rfkill_wlan_ops = {
763 .set_block = asus_rfkill_wlan_set,
Corentin Charya7ce3f02011-02-26 10:20:33 +0100764 .query = asus_rfkill_query,
Corentin Chary279f8f92011-02-06 13:28:29 +0100765};
766
Corentin Charye12e6d92011-02-26 10:20:31 +0100767static const struct rfkill_ops asus_rfkill_ops = {
768 .set_block = asus_rfkill_set,
769 .query = asus_rfkill_query,
Corentin Charyba48fdb2010-11-29 08:14:07 +0100770};
771
Corentin Charye12e6d92011-02-26 10:20:31 +0100772static int asus_new_rfkill(struct asus_wmi *asus,
Corentin Charya7ce3f02011-02-26 10:20:33 +0100773 struct asus_rfkill *arfkill,
Corentin Charye12e6d92011-02-26 10:20:31 +0100774 const char *name, enum rfkill_type type, int dev_id)
Corentin Charyba48fdb2010-11-29 08:14:07 +0100775{
Corentin Chary1d070f82011-02-26 10:20:36 +0100776 int result = asus_wmi_get_devstate_simple(asus, dev_id);
Corentin Charya7ce3f02011-02-26 10:20:33 +0100777 struct rfkill **rfkill = &arfkill->rfkill;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100778
Corentin Chary5c956382011-02-06 13:28:31 +0100779 if (result < 0)
780 return result;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100781
Corentin Charya7ce3f02011-02-26 10:20:33 +0100782 arfkill->dev_id = dev_id;
783 arfkill->asus = asus;
784
Corentin Charye12e6d92011-02-26 10:20:31 +0100785 if (dev_id == ASUS_WMI_DEVID_WLAN && asus->driver->hotplug_wireless)
786 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
Corentin Charya7ce3f02011-02-26 10:20:33 +0100787 &asus_rfkill_wlan_ops, arfkill);
Corentin Chary279f8f92011-02-06 13:28:29 +0100788 else
Corentin Charye12e6d92011-02-26 10:20:31 +0100789 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
Corentin Charya7ce3f02011-02-26 10:20:33 +0100790 &asus_rfkill_ops, arfkill);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100791
792 if (!*rfkill)
793 return -EINVAL;
794
Corentin Chary5c956382011-02-06 13:28:31 +0100795 rfkill_init_sw_state(*rfkill, !result);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100796 result = rfkill_register(*rfkill);
797 if (result) {
798 rfkill_destroy(*rfkill);
799 *rfkill = NULL;
800 return result;
801 }
802 return 0;
803}
804
Corentin Charye12e6d92011-02-26 10:20:31 +0100805static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
Corentin Charyba48fdb2010-11-29 08:14:07 +0100806{
Corentin Charye12e6d92011-02-26 10:20:31 +0100807 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
808 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
809 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
Corentin Charya7ce3f02011-02-26 10:20:33 +0100810 if (asus->wlan.rfkill) {
811 rfkill_unregister(asus->wlan.rfkill);
812 rfkill_destroy(asus->wlan.rfkill);
813 asus->wlan.rfkill = NULL;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100814 }
Corentin Charyafa7c882011-02-06 13:28:28 +0100815 /*
816 * Refresh pci hotplug in case the rfkill state was changed after
Corentin Charye12e6d92011-02-26 10:20:31 +0100817 * asus_unregister_rfkill_notifier()
Corentin Charyafa7c882011-02-06 13:28:28 +0100818 */
Corentin Charye12e6d92011-02-26 10:20:31 +0100819 asus_rfkill_hotplug(asus);
820 if (asus->hotplug_slot)
821 pci_hp_deregister(asus->hotplug_slot);
822 if (asus->hotplug_workqueue)
823 destroy_workqueue(asus->hotplug_workqueue);
Corentin Charyafa7c882011-02-06 13:28:28 +0100824
Corentin Charya7ce3f02011-02-26 10:20:33 +0100825 if (asus->bluetooth.rfkill) {
826 rfkill_unregister(asus->bluetooth.rfkill);
827 rfkill_destroy(asus->bluetooth.rfkill);
828 asus->bluetooth.rfkill = NULL;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100829 }
Corentin Charya7ce3f02011-02-26 10:20:33 +0100830 if (asus->wimax.rfkill) {
831 rfkill_unregister(asus->wimax.rfkill);
832 rfkill_destroy(asus->wimax.rfkill);
833 asus->wimax.rfkill = NULL;
Corentin Chary2e9e1592011-02-06 13:28:37 +0100834 }
Corentin Charya7ce3f02011-02-26 10:20:33 +0100835 if (asus->wwan3g.rfkill) {
836 rfkill_unregister(asus->wwan3g.rfkill);
837 rfkill_destroy(asus->wwan3g.rfkill);
838 asus->wwan3g.rfkill = NULL;
Corentin Charyba48fdb2010-11-29 08:14:07 +0100839 }
Corentin Chary43be8bd2011-07-01 11:34:40 +0200840 if (asus->gps.rfkill) {
841 rfkill_unregister(asus->gps.rfkill);
842 rfkill_destroy(asus->gps.rfkill);
843 asus->gps.rfkill = NULL;
844 }
Corentin Charya912d322011-07-01 11:34:41 +0200845 if (asus->uwb.rfkill) {
846 rfkill_unregister(asus->uwb.rfkill);
847 rfkill_destroy(asus->uwb.rfkill);
848 asus->uwb.rfkill = NULL;
849 }
Corentin Charyba48fdb2010-11-29 08:14:07 +0100850}
851
Corentin Charye12e6d92011-02-26 10:20:31 +0100852static int asus_wmi_rfkill_init(struct asus_wmi *asus)
Corentin Charyba48fdb2010-11-29 08:14:07 +0100853{
854 int result = 0;
855
Corentin Charye12e6d92011-02-26 10:20:31 +0100856 mutex_init(&asus->hotplug_lock);
857 mutex_init(&asus->wmi_lock);
Corentin Charyafa7c882011-02-06 13:28:28 +0100858
Corentin Charya7ce3f02011-02-26 10:20:33 +0100859 result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
860 RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100861
862 if (result && result != -ENODEV)
863 goto exit;
864
Corentin Charya7ce3f02011-02-26 10:20:33 +0100865 result = asus_new_rfkill(asus, &asus->bluetooth,
Corentin Charye12e6d92011-02-26 10:20:31 +0100866 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
867 ASUS_WMI_DEVID_BLUETOOTH);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100868
869 if (result && result != -ENODEV)
870 goto exit;
871
Corentin Charya7ce3f02011-02-26 10:20:33 +0100872 result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
873 RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
Corentin Chary2e9e1592011-02-06 13:28:37 +0100874
875 if (result && result != -ENODEV)
876 goto exit;
877
Corentin Charya7ce3f02011-02-26 10:20:33 +0100878 result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
879 RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100880
881 if (result && result != -ENODEV)
882 goto exit;
883
Corentin Chary43be8bd2011-07-01 11:34:40 +0200884 result = asus_new_rfkill(asus, &asus->gps, "asus-gps",
885 RFKILL_TYPE_GPS, ASUS_WMI_DEVID_GPS);
886
887 if (result && result != -ENODEV)
888 goto exit;
889
Corentin Charya912d322011-07-01 11:34:41 +0200890 result = asus_new_rfkill(asus, &asus->uwb, "asus-uwb",
891 RFKILL_TYPE_UWB, ASUS_WMI_DEVID_UWB);
892
893 if (result && result != -ENODEV)
894 goto exit;
895
Corentin Charye12e6d92011-02-26 10:20:31 +0100896 if (!asus->driver->hotplug_wireless)
Corentin Charyc14d4b82011-02-06 13:28:40 +0100897 goto exit;
898
Corentin Charye12e6d92011-02-26 10:20:31 +0100899 result = asus_setup_pci_hotplug(asus);
Corentin Charyafa7c882011-02-06 13:28:28 +0100900 /*
901 * If we get -EBUSY then something else is handling the PCI hotplug -
902 * don't fail in this case
903 */
904 if (result == -EBUSY)
905 result = 0;
906
Corentin Charye12e6d92011-02-26 10:20:31 +0100907 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
908 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
909 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
Corentin Charyafa7c882011-02-06 13:28:28 +0100910 /*
911 * Refresh pci hotplug in case the rfkill state was changed during
912 * setup.
913 */
Corentin Charye12e6d92011-02-26 10:20:31 +0100914 asus_rfkill_hotplug(asus);
Corentin Charyafa7c882011-02-06 13:28:28 +0100915
Corentin Charyba48fdb2010-11-29 08:14:07 +0100916exit:
917 if (result && result != -ENODEV)
Corentin Charye12e6d92011-02-26 10:20:31 +0100918 asus_wmi_rfkill_exit(asus);
Corentin Charyba48fdb2010-11-29 08:14:07 +0100919
920 if (result == -ENODEV)
921 result = 0;
922
923 return result;
924}
925
926/*
Corentin Charye07babd2011-02-26 10:20:42 +0100927 * Hwmon device
928 */
929static ssize_t asus_hwmon_pwm1(struct device *dev,
Corentin Chary49979d02011-07-01 11:34:26 +0200930 struct device_attribute *attr,
931 char *buf)
Corentin Charye07babd2011-02-26 10:20:42 +0100932{
933 struct asus_wmi *asus = dev_get_drvdata(dev);
934 u32 value;
935 int err;
936
937 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
938
939 if (err < 0)
940 return err;
941
Corentin Chary49979d02011-07-01 11:34:26 +0200942 value &= 0xFF;
Corentin Charye07babd2011-02-26 10:20:42 +0100943
944 if (value == 1) /* Low Speed */
945 value = 85;
946 else if (value == 2)
947 value = 170;
948 else if (value == 3)
949 value = 255;
950 else if (value != 0) {
951 pr_err("Unknown fan speed %#x", value);
952 value = -1;
953 }
954
955 return sprintf(buf, "%d\n", value);
956}
957
Corentin Chary6118b8a2011-07-01 11:34:36 +0200958static ssize_t asus_hwmon_temp1(struct device *dev,
959 struct device_attribute *attr,
960 char *buf)
961{
962 struct asus_wmi *asus = dev_get_drvdata(dev);
963 u32 value;
964 int err;
965
966 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_THERMAL_CTRL, &value);
967
968 if (err < 0)
969 return err;
970
971 value = KELVIN_TO_CELSIUS((value & 0xFFFF)) * 1000;
972
973 return sprintf(buf, "%d\n", value);
974}
975
Corentin Charye07babd2011-02-26 10:20:42 +0100976static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO, asus_hwmon_pwm1, NULL, 0);
Corentin Chary6118b8a2011-07-01 11:34:36 +0200977static SENSOR_DEVICE_ATTR(temp1_input, S_IRUGO, asus_hwmon_temp1, NULL, 0);
Corentin Charye07babd2011-02-26 10:20:42 +0100978
979static ssize_t
980show_name(struct device *dev, struct device_attribute *attr, char *buf)
981{
982 return sprintf(buf, "asus\n");
983}
984static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
985
986static struct attribute *hwmon_attributes[] = {
987 &sensor_dev_attr_pwm1.dev_attr.attr,
Corentin Chary6118b8a2011-07-01 11:34:36 +0200988 &sensor_dev_attr_temp1_input.dev_attr.attr,
Corentin Charye07babd2011-02-26 10:20:42 +0100989 &sensor_dev_attr_name.dev_attr.attr,
990 NULL
991};
992
993static mode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
Corentin Charye02431d2011-07-01 11:34:37 +0200994 struct attribute *attr, int idx)
Corentin Charye07babd2011-02-26 10:20:42 +0100995{
996 struct device *dev = container_of(kobj, struct device, kobj);
997 struct platform_device *pdev = to_platform_device(dev->parent);
998 struct asus_wmi *asus = platform_get_drvdata(pdev);
999 bool ok = true;
1000 int dev_id = -1;
1001 u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
1002
1003 if (attr == &sensor_dev_attr_pwm1.dev_attr.attr)
1004 dev_id = ASUS_WMI_DEVID_FAN_CTRL;
Corentin Charye02431d2011-07-01 11:34:37 +02001005 else if (attr == &sensor_dev_attr_temp1_input.dev_attr.attr)
1006 dev_id = ASUS_WMI_DEVID_THERMAL_CTRL;
Corentin Charye07babd2011-02-26 10:20:42 +01001007
1008 if (dev_id != -1) {
1009 int err = asus_wmi_get_devstate(asus, dev_id, &value);
1010
1011 if (err < 0)
Al Viroe772aed2011-07-23 20:59:40 -04001012 return 0; /* can't return negative here */
Corentin Charye07babd2011-02-26 10:20:42 +01001013 }
1014
1015 if (dev_id == ASUS_WMI_DEVID_FAN_CTRL) {
1016 /*
1017 * We need to find a better way, probably using sfun,
1018 * bits or spec ...
1019 * Currently we disable it if:
1020 * - ASUS_WMI_UNSUPPORTED_METHOD is returned
1021 * - reverved bits are non-zero
1022 * - sfun and presence bit are not set
1023 */
Corentin Chary49979d02011-07-01 11:34:26 +02001024 if (value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
Corentin Charye07babd2011-02-26 10:20:42 +01001025 || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)))
1026 ok = false;
Corentin Charye02431d2011-07-01 11:34:37 +02001027 } else if (dev_id == ASUS_WMI_DEVID_THERMAL_CTRL) {
1028 /* If value is zero, something is clearly wrong */
1029 if (value == 0)
1030 ok = false;
Corentin Charye07babd2011-02-26 10:20:42 +01001031 }
1032
1033 return ok ? attr->mode : 0;
1034}
1035
1036static struct attribute_group hwmon_attribute_group = {
1037 .is_visible = asus_hwmon_sysfs_is_visible,
1038 .attrs = hwmon_attributes
1039};
1040
1041static void asus_wmi_hwmon_exit(struct asus_wmi *asus)
1042{
1043 struct device *hwmon;
1044
1045 hwmon = asus->hwmon_device;
1046 if (!hwmon)
1047 return;
1048 sysfs_remove_group(&hwmon->kobj, &hwmon_attribute_group);
1049 hwmon_device_unregister(hwmon);
1050 asus->hwmon_device = NULL;
1051}
1052
1053static int asus_wmi_hwmon_init(struct asus_wmi *asus)
1054{
1055 struct device *hwmon;
1056 int result;
1057
1058 hwmon = hwmon_device_register(&asus->platform_device->dev);
1059 if (IS_ERR(hwmon)) {
1060 pr_err("Could not register asus hwmon device\n");
1061 return PTR_ERR(hwmon);
1062 }
Corentin Chary49979d02011-07-01 11:34:26 +02001063 dev_set_drvdata(hwmon, asus);
Corentin Charye07babd2011-02-26 10:20:42 +01001064 asus->hwmon_device = hwmon;
1065 result = sysfs_create_group(&hwmon->kobj, &hwmon_attribute_group);
1066 if (result)
1067 asus_wmi_hwmon_exit(asus);
1068 return result;
1069}
1070
1071/*
Corentin Chary084fca62010-11-29 08:14:06 +01001072 * Backlight
1073 */
Corentin Chary1d070f82011-02-26 10:20:36 +01001074static int read_backlight_power(struct asus_wmi *asus)
Corentin Charyb7187262011-02-06 13:28:39 +01001075{
Corentin Chary1d070f82011-02-26 10:20:36 +01001076 int ret = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_BACKLIGHT);
Corentin Charyb7187262011-02-06 13:28:39 +01001077
1078 if (ret < 0)
1079 return ret;
1080
1081 return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
1082}
1083
Corentin Chary8fbea012011-02-26 10:20:37 +01001084static int read_brightness_max(struct asus_wmi *asus)
1085{
1086 u32 retval;
1087 int err;
1088
1089 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1090
1091 if (err < 0)
1092 return err;
1093
1094 retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
1095 retval >>= 8;
1096
1097 if (!retval)
1098 return -ENODEV;
1099
1100 return retval;
1101}
1102
Yong Wang3d7b1652010-04-11 09:27:54 +08001103static int read_brightness(struct backlight_device *bd)
1104{
Corentin Chary1d070f82011-02-26 10:20:36 +01001105 struct asus_wmi *asus = bl_get_data(bd);
Dan Carpenter0986f252011-03-15 10:06:23 +03001106 u32 retval;
1107 int err;
Yong Wang3d7b1652010-04-11 09:27:54 +08001108
Corentin Chary1d070f82011-02-26 10:20:36 +01001109 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
Yong Wang3d7b1652010-04-11 09:27:54 +08001110
Corentin Charyd33da3b2011-02-26 10:20:35 +01001111 if (err < 0)
1112 return err;
1113
1114 return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
Yong Wang3d7b1652010-04-11 09:27:54 +08001115}
1116
1117static int update_bl_status(struct backlight_device *bd)
1118{
Corentin Chary1d070f82011-02-26 10:20:36 +01001119 struct asus_wmi *asus = bl_get_data(bd);
Corentin Charydfed65d2010-11-29 08:14:12 +01001120 u32 ctrl_param;
Corentin Charyd33da3b2011-02-26 10:20:35 +01001121 int power, err;
Yong Wang3d7b1652010-04-11 09:27:54 +08001122
1123 ctrl_param = bd->props.brightness;
1124
Corentin Charyd33da3b2011-02-26 10:20:35 +01001125 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
1126 ctrl_param, NULL);
Yong Wang3d7b1652010-04-11 09:27:54 +08001127
Corentin Charyd33da3b2011-02-26 10:20:35 +01001128 if (err < 0)
1129 return err;
Corentin Charyb7187262011-02-06 13:28:39 +01001130
Corentin Chary1d070f82011-02-26 10:20:36 +01001131 power = read_backlight_power(asus);
Corentin Charyb7187262011-02-06 13:28:39 +01001132 if (power != -ENODEV && bd->props.power != power) {
1133 ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
Corentin Charyd33da3b2011-02-26 10:20:35 +01001134 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
1135 ctrl_param, NULL);
Corentin Charyb7187262011-02-06 13:28:39 +01001136 }
Corentin Chary8fbea012011-02-26 10:20:37 +01001137 return err;
Yong Wang3d7b1652010-04-11 09:27:54 +08001138}
1139
Corentin Charye12e6d92011-02-26 10:20:31 +01001140static const struct backlight_ops asus_wmi_bl_ops = {
Yong Wang3d7b1652010-04-11 09:27:54 +08001141 .get_brightness = read_brightness,
1142 .update_status = update_bl_status,
1143};
1144
Corentin Charye12e6d92011-02-26 10:20:31 +01001145static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
Yong Wang3d7b1652010-04-11 09:27:54 +08001146{
Corentin Charye12e6d92011-02-26 10:20:31 +01001147 struct backlight_device *bd = asus->backlight_device;
Yong Wang3d7b1652010-04-11 09:27:54 +08001148 int old = bd->props.brightness;
Daniel Mackb7670ed2010-05-19 12:37:01 +02001149 int new = old;
Yong Wang3d7b1652010-04-11 09:27:54 +08001150
1151 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1152 new = code - NOTIFY_BRNUP_MIN + 1;
1153 else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
1154 new = code - NOTIFY_BRNDOWN_MIN;
1155
1156 bd->props.brightness = new;
1157 backlight_update_status(bd);
1158 backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1159
1160 return old;
1161}
1162
Corentin Charye12e6d92011-02-26 10:20:31 +01001163static int asus_wmi_backlight_init(struct asus_wmi *asus)
Yong Wang3d7b1652010-04-11 09:27:54 +08001164{
1165 struct backlight_device *bd;
1166 struct backlight_properties props;
Corentin Charyb7187262011-02-06 13:28:39 +01001167 int max;
1168 int power;
1169
Corentin Chary8fbea012011-02-26 10:20:37 +01001170 max = read_brightness_max(asus);
Corentin Charyb7187262011-02-06 13:28:39 +01001171
Corentin Charyb7187262011-02-06 13:28:39 +01001172 if (max == -ENODEV)
1173 max = 0;
Corentin Chary8fbea012011-02-26 10:20:37 +01001174 else if (max < 0)
1175 return max;
1176
1177 power = read_backlight_power(asus);
1178
Corentin Charyb7187262011-02-06 13:28:39 +01001179 if (power == -ENODEV)
1180 power = FB_BLANK_UNBLANK;
Corentin Chary8fbea012011-02-26 10:20:37 +01001181 else if (power < 0)
1182 return power;
Yong Wang3d7b1652010-04-11 09:27:54 +08001183
1184 memset(&props, 0, sizeof(struct backlight_properties));
Axel Lin60cfa092011-06-29 11:43:30 +08001185 props.type = BACKLIGHT_PLATFORM;
Corentin Charyb7187262011-02-06 13:28:39 +01001186 props.max_brightness = max;
Corentin Charye12e6d92011-02-26 10:20:31 +01001187 bd = backlight_device_register(asus->driver->name,
1188 &asus->platform_device->dev, asus,
1189 &asus_wmi_bl_ops, &props);
Yong Wang3d7b1652010-04-11 09:27:54 +08001190 if (IS_ERR(bd)) {
1191 pr_err("Could not register backlight device\n");
1192 return PTR_ERR(bd);
1193 }
1194
Corentin Charye12e6d92011-02-26 10:20:31 +01001195 asus->backlight_device = bd;
Yong Wang3d7b1652010-04-11 09:27:54 +08001196
1197 bd->props.brightness = read_brightness(bd);
Corentin Charyb7187262011-02-06 13:28:39 +01001198 bd->props.power = power;
Yong Wang3d7b1652010-04-11 09:27:54 +08001199 backlight_update_status(bd);
1200
1201 return 0;
1202}
1203
Corentin Charye12e6d92011-02-26 10:20:31 +01001204static void asus_wmi_backlight_exit(struct asus_wmi *asus)
Yong Wang3d7b1652010-04-11 09:27:54 +08001205{
Corentin Charye12e6d92011-02-26 10:20:31 +01001206 if (asus->backlight_device)
1207 backlight_device_unregister(asus->backlight_device);
Yong Wang3d7b1652010-04-11 09:27:54 +08001208
Corentin Charye12e6d92011-02-26 10:20:31 +01001209 asus->backlight_device = NULL;
Yong Wang3d7b1652010-04-11 09:27:54 +08001210}
1211
Corentin Charye12e6d92011-02-26 10:20:31 +01001212static void asus_wmi_notify(u32 value, void *context)
Yong Wang3d7b1652010-04-11 09:27:54 +08001213{
Corentin Charye12e6d92011-02-26 10:20:31 +01001214 struct asus_wmi *asus = context;
Yong Wang3d7b1652010-04-11 09:27:54 +08001215 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
1216 union acpi_object *obj;
1217 acpi_status status;
1218 int code;
1219 int orig_code;
Seth Forsheec4453f62011-07-01 11:34:27 +02001220 unsigned int key_value = 1;
1221 bool autorelease = 1;
Yong Wang3d7b1652010-04-11 09:27:54 +08001222
1223 status = wmi_get_event_data(value, &response);
1224 if (status != AE_OK) {
1225 pr_err("bad event status 0x%x\n", status);
1226 return;
1227 }
1228
1229 obj = (union acpi_object *)response.pointer;
1230
Corentin Chary57ab7da2011-02-26 10:20:32 +01001231 if (!obj || obj->type != ACPI_TYPE_INTEGER)
1232 goto exit;
Yong Wang3d7b1652010-04-11 09:27:54 +08001233
Corentin Chary57ab7da2011-02-26 10:20:32 +01001234 code = obj->integer.value;
1235 orig_code = code;
Yong Wang3d7b1652010-04-11 09:27:54 +08001236
Seth Forsheec4453f62011-07-01 11:34:27 +02001237 if (asus->driver->key_filter) {
1238 asus->driver->key_filter(asus->driver, &code, &key_value,
1239 &autorelease);
1240 if (code == ASUS_WMI_KEY_IGNORE)
1241 goto exit;
1242 }
1243
Corentin Chary57ab7da2011-02-26 10:20:32 +01001244 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1245 code = NOTIFY_BRNUP_MIN;
1246 else if (code >= NOTIFY_BRNDOWN_MIN &&
1247 code <= NOTIFY_BRNDOWN_MAX)
1248 code = NOTIFY_BRNDOWN_MIN;
Yong Wang3d7b1652010-04-11 09:27:54 +08001249
Corentin Chary57ab7da2011-02-26 10:20:32 +01001250 if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
1251 if (!acpi_video_backlight_support())
1252 asus_wmi_backlight_notify(asus, orig_code);
Seth Forsheec4453f62011-07-01 11:34:27 +02001253 } else if (!sparse_keymap_report_event(asus->inputdev, code,
1254 key_value, autorelease))
Corentin Chary57ab7da2011-02-26 10:20:32 +01001255 pr_info("Unknown key %x pressed\n", code);
Yong Wang3d7b1652010-04-11 09:27:54 +08001256
Corentin Chary57ab7da2011-02-26 10:20:32 +01001257exit:
Yong Wang3d7b1652010-04-11 09:27:54 +08001258 kfree(obj);
1259}
1260
Corentin Chary9e1565b2011-02-06 13:28:36 +01001261/*
1262 * Sys helpers
1263 */
1264static int parse_arg(const char *buf, unsigned long count, int *val)
1265{
1266 if (!count)
1267 return 0;
1268 if (sscanf(buf, "%i", val) != 1)
1269 return -EINVAL;
1270 return count;
1271}
1272
Corentin Chary1d070f82011-02-26 10:20:36 +01001273static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
1274 const char *buf, size_t count)
Corentin Chary9e1565b2011-02-06 13:28:36 +01001275{
Corentin Chary9e1565b2011-02-06 13:28:36 +01001276 u32 retval;
Corentin Charyd33da3b2011-02-26 10:20:35 +01001277 int rv, err, value;
Corentin Chary9e1565b2011-02-06 13:28:36 +01001278
Corentin Chary1d070f82011-02-26 10:20:36 +01001279 value = asus_wmi_get_devstate_simple(asus, devid);
Corentin Charye12e6d92011-02-26 10:20:31 +01001280 if (value == -ENODEV) /* Check device presence */
Corentin Chary9e1565b2011-02-06 13:28:36 +01001281 return value;
1282
1283 rv = parse_arg(buf, count, &value);
Corentin Charyd33da3b2011-02-26 10:20:35 +01001284 err = asus_wmi_set_devstate(devid, value, &retval);
Corentin Chary9e1565b2011-02-06 13:28:36 +01001285
Corentin Charyd33da3b2011-02-26 10:20:35 +01001286 if (err < 0)
1287 return err;
1288
Corentin Chary9e1565b2011-02-06 13:28:36 +01001289 return rv;
1290}
1291
Corentin Chary1d070f82011-02-26 10:20:36 +01001292static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
Corentin Chary9e1565b2011-02-06 13:28:36 +01001293{
Corentin Chary1d070f82011-02-26 10:20:36 +01001294 int value = asus_wmi_get_devstate_simple(asus, devid);
Corentin Chary9e1565b2011-02-06 13:28:36 +01001295
1296 if (value < 0)
1297 return value;
1298
1299 return sprintf(buf, "%d\n", value);
1300}
1301
Corentin Charye12e6d92011-02-26 10:20:31 +01001302#define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \
Corentin Chary9e1565b2011-02-06 13:28:36 +01001303 static ssize_t show_##_name(struct device *dev, \
1304 struct device_attribute *attr, \
1305 char *buf) \
1306 { \
Corentin Chary1d070f82011-02-26 10:20:36 +01001307 struct asus_wmi *asus = dev_get_drvdata(dev); \
1308 \
1309 return show_sys_wmi(asus, _cm, buf); \
Corentin Chary9e1565b2011-02-06 13:28:36 +01001310 } \
1311 static ssize_t store_##_name(struct device *dev, \
1312 struct device_attribute *attr, \
1313 const char *buf, size_t count) \
1314 { \
Corentin Chary1d070f82011-02-26 10:20:36 +01001315 struct asus_wmi *asus = dev_get_drvdata(dev); \
1316 \
1317 return store_sys_wmi(asus, _cm, buf, count); \
Corentin Chary9e1565b2011-02-06 13:28:36 +01001318 } \
1319 static struct device_attribute dev_attr_##_name = { \
1320 .attr = { \
1321 .name = __stringify(_name), \
1322 .mode = _mode }, \
1323 .show = show_##_name, \
1324 .store = store_##_name, \
1325 }
1326
Corentin Charye12e6d92011-02-26 10:20:31 +01001327ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
1328ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
1329ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
Corentin Chary9e1565b2011-02-06 13:28:36 +01001330
Dmitry Torokhov67fa38e2010-11-03 11:14:01 -07001331static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
1332 const char *buf, size_t count)
Chris Bagwell7f80d732010-10-11 18:47:18 -05001333{
Corentin Chary3df5fda2011-07-01 11:34:38 +02001334 int value, rv;
Chris Bagwell7f80d732010-10-11 18:47:18 -05001335
1336 if (!count || sscanf(buf, "%i", &value) != 1)
1337 return -EINVAL;
1338 if (value < 0 || value > 2)
1339 return -EINVAL;
1340
Corentin Chary3df5fda2011-07-01 11:34:38 +02001341 rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
1342 if (rv < 0)
1343 return rv;
1344
1345 return count;
Chris Bagwell7f80d732010-10-11 18:47:18 -05001346}
1347
1348static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
1349
Corentin Chary4e37b422010-11-29 08:14:08 +01001350static struct attribute *platform_attributes[] = {
1351 &dev_attr_cpufv.attr,
Corentin Chary9e1565b2011-02-06 13:28:36 +01001352 &dev_attr_camera.attr,
1353 &dev_attr_cardr.attr,
Corentin Chary4615bb62011-02-06 13:28:42 +01001354 &dev_attr_touchpad.attr,
Corentin Chary4e37b422010-11-29 08:14:08 +01001355 NULL
1356};
1357
Corentin Charye12e6d92011-02-26 10:20:31 +01001358static mode_t asus_sysfs_is_visible(struct kobject *kobj,
1359 struct attribute *attr, int idx)
Corentin Chary9e1565b2011-02-06 13:28:36 +01001360{
Corentin Chary1d070f82011-02-26 10:20:36 +01001361 struct device *dev = container_of(kobj, struct device, kobj);
1362 struct platform_device *pdev = to_platform_device(dev);
1363 struct asus_wmi *asus = platform_get_drvdata(pdev);
1364 bool ok = true;
Corentin Chary9e1565b2011-02-06 13:28:36 +01001365 int devid = -1;
1366
1367 if (attr == &dev_attr_camera.attr)
Corentin Charye12e6d92011-02-26 10:20:31 +01001368 devid = ASUS_WMI_DEVID_CAMERA;
Corentin Chary9e1565b2011-02-06 13:28:36 +01001369 else if (attr == &dev_attr_cardr.attr)
Corentin Charye12e6d92011-02-26 10:20:31 +01001370 devid = ASUS_WMI_DEVID_CARDREADER;
Corentin Chary4615bb62011-02-06 13:28:42 +01001371 else if (attr == &dev_attr_touchpad.attr)
Corentin Charye12e6d92011-02-26 10:20:31 +01001372 devid = ASUS_WMI_DEVID_TOUCHPAD;
Corentin Chary9e1565b2011-02-06 13:28:36 +01001373
1374 if (devid != -1)
Corentin Chary1d070f82011-02-26 10:20:36 +01001375 ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
Corentin Chary9e1565b2011-02-06 13:28:36 +01001376
Corentin Chary1d070f82011-02-26 10:20:36 +01001377 return ok ? attr->mode : 0;
Corentin Chary9e1565b2011-02-06 13:28:36 +01001378}
1379
Corentin Chary4e37b422010-11-29 08:14:08 +01001380static struct attribute_group platform_attribute_group = {
Corentin Charye12e6d92011-02-26 10:20:31 +01001381 .is_visible = asus_sysfs_is_visible,
1382 .attrs = platform_attributes
Corentin Chary4e37b422010-11-29 08:14:08 +01001383};
1384
Corentin Charye12e6d92011-02-26 10:20:31 +01001385static void asus_wmi_sysfs_exit(struct platform_device *device)
Chris Bagwell7f80d732010-10-11 18:47:18 -05001386{
Corentin Chary4e37b422010-11-29 08:14:08 +01001387 sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
Chris Bagwell7f80d732010-10-11 18:47:18 -05001388}
1389
Corentin Charye12e6d92011-02-26 10:20:31 +01001390static int asus_wmi_sysfs_init(struct platform_device *device)
Chris Bagwell7f80d732010-10-11 18:47:18 -05001391{
Corentin Chary4e37b422010-11-29 08:14:08 +01001392 return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
Chris Bagwell7f80d732010-10-11 18:47:18 -05001393}
1394
Corentin Chary27c136c2010-11-29 08:14:05 +01001395/*
1396 * Platform device
1397 */
Joe Perches39ddf3b2011-03-29 15:21:32 -07001398static int asus_wmi_platform_init(struct asus_wmi *asus)
Corentin Chary27c136c2010-11-29 08:14:05 +01001399{
Corentin Chary46dbca82011-02-26 10:20:38 +01001400 int rv;
1401
1402 /* INIT enable hotkeys on some models */
1403 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
1404 pr_info("Initialization: %#x", rv);
1405
1406 /* We don't know yet what to do with this version... */
1407 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
Corentin Chary57d5c8e2011-07-01 11:34:30 +02001408 pr_info("BIOS WMI version: %d.%d", rv >> 16, rv & 0xFF);
Corentin Chary46dbca82011-02-26 10:20:38 +01001409 asus->spec = rv;
1410 }
1411
1412 /*
1413 * The SFUN method probably allows the original driver to get the list
1414 * of features supported by a given model. For now, 0x0100 or 0x0800
1415 * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
1416 * The significance of others is yet to be found.
1417 */
1418 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
1419 pr_info("SFUN value: %#x", rv);
1420 asus->sfun = rv;
1421 }
1422
Corentin Chary1d070f82011-02-26 10:20:36 +01001423 /*
1424 * Eee PC and Notebooks seems to have different method_id for DSTS,
1425 * but it may also be related to the BIOS's SPEC.
1426 * Note, on most Eeepc, there is no way to check if a method exist
1427 * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
1428 * but once again, SPEC may probably be used for that kind of things.
1429 */
1430 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, 0, 0, NULL))
1431 asus->dsts_id = ASUS_WMI_METHODID_DSTS;
1432 else if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS2, 0, 0, NULL))
1433 asus->dsts_id = ASUS_WMI_METHODID_DSTS2;
1434
1435 if (!asus->dsts_id) {
1436 pr_err("Can't find DSTS");
1437 return -ENODEV;
1438 }
1439
Corentin Charyfddbfed2011-07-01 11:34:39 +02001440 /* CWAP allow to define the behavior of the Fn+F2 key,
1441 * this method doesn't seems to be present on Eee PCs */
1442 if (asus->driver->wapf >= 0)
1443 asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP,
1444 asus->driver->wapf, NULL);
1445
Corentin Charye12e6d92011-02-26 10:20:31 +01001446 return asus_wmi_sysfs_init(asus->platform_device);
Corentin Chary27c136c2010-11-29 08:14:05 +01001447}
1448
Corentin Charye12e6d92011-02-26 10:20:31 +01001449static void asus_wmi_platform_exit(struct asus_wmi *asus)
Corentin Chary27c136c2010-11-29 08:14:05 +01001450{
Corentin Charye12e6d92011-02-26 10:20:31 +01001451 asus_wmi_sysfs_exit(asus->platform_device);
Corentin Chary27c136c2010-11-29 08:14:05 +01001452}
1453
1454/*
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001455 * debugfs
1456 */
Corentin Charye12e6d92011-02-26 10:20:31 +01001457struct asus_wmi_debugfs_node {
1458 struct asus_wmi *asus;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001459 char *name;
Corentin Charye12e6d92011-02-26 10:20:31 +01001460 int (*show) (struct seq_file *m, void *data);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001461};
1462
1463static int show_dsts(struct seq_file *m, void *data)
1464{
Corentin Charye12e6d92011-02-26 10:20:31 +01001465 struct asus_wmi *asus = m->private;
Corentin Charyd33da3b2011-02-26 10:20:35 +01001466 int err;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001467 u32 retval = -1;
1468
Corentin Chary1d070f82011-02-26 10:20:36 +01001469 err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001470
Corentin Charyd33da3b2011-02-26 10:20:35 +01001471 if (err < 0)
1472 return err;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001473
Corentin Charyef343492011-02-26 10:20:39 +01001474 seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001475
1476 return 0;
1477}
1478
1479static int show_devs(struct seq_file *m, void *data)
1480{
Corentin Charye12e6d92011-02-26 10:20:31 +01001481 struct asus_wmi *asus = m->private;
Corentin Charyd33da3b2011-02-26 10:20:35 +01001482 int err;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001483 u32 retval = -1;
1484
Corentin Charyd33da3b2011-02-26 10:20:35 +01001485 err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
1486 &retval);
1487
1488 if (err < 0)
1489 return err;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001490
Corentin Charyef343492011-02-26 10:20:39 +01001491 seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
Corentin Charye12e6d92011-02-26 10:20:31 +01001492 asus->debug.ctrl_param, retval);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001493
1494 return 0;
1495}
1496
Corentin Charyef343492011-02-26 10:20:39 +01001497static int show_call(struct seq_file *m, void *data)
1498{
1499 struct asus_wmi *asus = m->private;
1500 struct bios_args args = {
1501 .arg0 = asus->debug.dev_id,
1502 .arg1 = asus->debug.ctrl_param,
1503 };
1504 struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1505 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
1506 union acpi_object *obj;
1507 acpi_status status;
1508
1509 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
1510 1, asus->debug.method_id,
1511 &input, &output);
1512
1513 if (ACPI_FAILURE(status))
1514 return -EIO;
1515
1516 obj = (union acpi_object *)output.pointer;
1517 if (obj && obj->type == ACPI_TYPE_INTEGER)
1518 seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
1519 asus->debug.dev_id, asus->debug.ctrl_param,
1520 (u32) obj->integer.value);
1521 else
1522 seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
1523 asus->debug.dev_id, asus->debug.ctrl_param,
Dan Carpentera1d60862011-03-15 10:07:37 +03001524 obj ? obj->type : -1);
Corentin Charyef343492011-02-26 10:20:39 +01001525
1526 kfree(obj);
1527
1528 return 0;
1529}
1530
Corentin Charye12e6d92011-02-26 10:20:31 +01001531static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
1532 {NULL, "devs", show_devs},
1533 {NULL, "dsts", show_dsts},
Corentin Charyef343492011-02-26 10:20:39 +01001534 {NULL, "call", show_call},
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001535};
1536
Corentin Charye12e6d92011-02-26 10:20:31 +01001537static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001538{
Corentin Charye12e6d92011-02-26 10:20:31 +01001539 struct asus_wmi_debugfs_node *node = inode->i_private;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001540
Corentin Charye12e6d92011-02-26 10:20:31 +01001541 return single_open(file, node->show, node->asus);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001542}
1543
Corentin Charye12e6d92011-02-26 10:20:31 +01001544static const struct file_operations asus_wmi_debugfs_io_ops = {
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001545 .owner = THIS_MODULE,
Corentin Charye12e6d92011-02-26 10:20:31 +01001546 .open = asus_wmi_debugfs_open,
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001547 .read = seq_read,
1548 .llseek = seq_lseek,
1549 .release = single_release,
1550};
1551
Corentin Charye12e6d92011-02-26 10:20:31 +01001552static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001553{
Corentin Charye12e6d92011-02-26 10:20:31 +01001554 debugfs_remove_recursive(asus->debug.root);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001555}
1556
Corentin Charye12e6d92011-02-26 10:20:31 +01001557static int asus_wmi_debugfs_init(struct asus_wmi *asus)
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001558{
1559 struct dentry *dent;
1560 int i;
1561
Corentin Charye12e6d92011-02-26 10:20:31 +01001562 asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
1563 if (!asus->debug.root) {
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001564 pr_err("failed to create debugfs directory");
1565 goto error_debugfs;
1566 }
1567
Corentin Charyef343492011-02-26 10:20:39 +01001568 dent = debugfs_create_x32("method_id", S_IRUGO | S_IWUSR,
1569 asus->debug.root, &asus->debug.method_id);
1570 if (!dent)
1571 goto error_debugfs;
1572
Corentin Charye12e6d92011-02-26 10:20:31 +01001573 dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
1574 asus->debug.root, &asus->debug.dev_id);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001575 if (!dent)
1576 goto error_debugfs;
1577
Corentin Charye12e6d92011-02-26 10:20:31 +01001578 dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR,
1579 asus->debug.root, &asus->debug.ctrl_param);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001580 if (!dent)
1581 goto error_debugfs;
1582
Corentin Charye12e6d92011-02-26 10:20:31 +01001583 for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
1584 struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001585
Corentin Charye12e6d92011-02-26 10:20:31 +01001586 node->asus = asus;
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001587 dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
Corentin Charye12e6d92011-02-26 10:20:31 +01001588 asus->debug.root, node,
1589 &asus_wmi_debugfs_io_ops);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001590 if (!dent) {
1591 pr_err("failed to create debug file: %s\n", node->name);
1592 goto error_debugfs;
1593 }
1594 }
1595
1596 return 0;
1597
1598error_debugfs:
Corentin Charye12e6d92011-02-26 10:20:31 +01001599 asus_wmi_debugfs_exit(asus);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001600 return -ENOMEM;
1601}
1602
1603/*
Corentin Chary27c136c2010-11-29 08:14:05 +01001604 * WMI Driver
1605 */
Corentin Charye12e6d92011-02-26 10:20:31 +01001606static int asus_wmi_add(struct platform_device *pdev)
Corentin Charyafa7c882011-02-06 13:28:28 +01001607{
Corentin Charye12e6d92011-02-26 10:20:31 +01001608 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
1609 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
1610 struct asus_wmi *asus;
Yong Wangee027e42010-03-21 10:26:34 +08001611 acpi_status status;
Corentin Chary27c136c2010-11-29 08:14:05 +01001612 int err;
Yong Wangee027e42010-03-21 10:26:34 +08001613
Corentin Charye12e6d92011-02-26 10:20:31 +01001614 asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
1615 if (!asus)
Corentin Charya04ce292011-02-06 13:28:33 +01001616 return -ENOMEM;
1617
Corentin Charye12e6d92011-02-26 10:20:31 +01001618 asus->driver = wdrv;
1619 asus->platform_device = pdev;
1620 wdrv->platform_device = pdev;
1621 platform_set_drvdata(asus->platform_device, asus);
Corentin Chary27c136c2010-11-29 08:14:05 +01001622
Corentin Charye12e6d92011-02-26 10:20:31 +01001623 if (wdrv->quirks)
1624 wdrv->quirks(asus->driver);
Corentin Charyafa7c882011-02-06 13:28:28 +01001625
Corentin Charye12e6d92011-02-26 10:20:31 +01001626 err = asus_wmi_platform_init(asus);
Corentin Chary27c136c2010-11-29 08:14:05 +01001627 if (err)
1628 goto fail_platform;
Yong Wang45f2c692010-04-11 09:27:19 +08001629
Corentin Charye12e6d92011-02-26 10:20:31 +01001630 err = asus_wmi_input_init(asus);
Yong Wang45f2c692010-04-11 09:27:19 +08001631 if (err)
Corentin Chary27c136c2010-11-29 08:14:05 +01001632 goto fail_input;
Yong Wang3d7b1652010-04-11 09:27:54 +08001633
Corentin Charye07babd2011-02-26 10:20:42 +01001634 err = asus_wmi_hwmon_init(asus);
1635 if (err)
1636 goto fail_hwmon;
1637
Corentin Charye12e6d92011-02-26 10:20:31 +01001638 err = asus_wmi_led_init(asus);
Corentin Chary084fca62010-11-29 08:14:06 +01001639 if (err)
1640 goto fail_leds;
1641
Corentin Charye12e6d92011-02-26 10:20:31 +01001642 err = asus_wmi_rfkill_init(asus);
Corentin Charyba48fdb2010-11-29 08:14:07 +01001643 if (err)
1644 goto fail_rfkill;
1645
Yong Wang3d7b1652010-04-11 09:27:54 +08001646 if (!acpi_video_backlight_support()) {
Corentin Charye12e6d92011-02-26 10:20:31 +01001647 err = asus_wmi_backlight_init(asus);
Corentin Charyb7187262011-02-06 13:28:39 +01001648 if (err && err != -ENODEV)
Corentin Chary27c136c2010-11-29 08:14:05 +01001649 goto fail_backlight;
Yong Wang3d7b1652010-04-11 09:27:54 +08001650 } else
1651 pr_info("Backlight controlled by ACPI video driver\n");
Yong Wang45f2c692010-04-11 09:27:19 +08001652
Corentin Charye12e6d92011-02-26 10:20:31 +01001653 status = wmi_install_notify_handler(asus->driver->event_guid,
1654 asus_wmi_notify, asus);
Yong Wang45f2c692010-04-11 09:27:19 +08001655 if (ACPI_FAILURE(status)) {
Corentin Charye12e6d92011-02-26 10:20:31 +01001656 pr_err("Unable to register notify handler - %d\n", status);
Yong Wang45f2c692010-04-11 09:27:19 +08001657 err = -ENODEV;
Corentin Chary27c136c2010-11-29 08:14:05 +01001658 goto fail_wmi_handler;
Yong Wang45f2c692010-04-11 09:27:19 +08001659 }
1660
Corentin Charye12e6d92011-02-26 10:20:31 +01001661 err = asus_wmi_debugfs_init(asus);
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001662 if (err)
1663 goto fail_debugfs;
1664
Corentin Charya04ce292011-02-06 13:28:33 +01001665 return 0;
Yong Wang45f2c692010-04-11 09:27:19 +08001666
Corentin Chary8c1b2d82010-11-29 08:14:09 +01001667fail_debugfs:
Corentin Charye12e6d92011-02-26 10:20:31 +01001668 wmi_remove_notify_handler(asus->driver->event_guid);
Corentin Chary27c136c2010-11-29 08:14:05 +01001669fail_wmi_handler:
Corentin Charye12e6d92011-02-26 10:20:31 +01001670 asus_wmi_backlight_exit(asus);
Corentin Chary27c136c2010-11-29 08:14:05 +01001671fail_backlight:
Corentin Charye12e6d92011-02-26 10:20:31 +01001672 asus_wmi_rfkill_exit(asus);
Corentin Charyba48fdb2010-11-29 08:14:07 +01001673fail_rfkill:
Corentin Charye12e6d92011-02-26 10:20:31 +01001674 asus_wmi_led_exit(asus);
Corentin Chary084fca62010-11-29 08:14:06 +01001675fail_leds:
Corentin Charye07babd2011-02-26 10:20:42 +01001676 asus_wmi_hwmon_exit(asus);
1677fail_hwmon:
Corentin Charye12e6d92011-02-26 10:20:31 +01001678 asus_wmi_input_exit(asus);
Corentin Chary27c136c2010-11-29 08:14:05 +01001679fail_input:
Corentin Charye12e6d92011-02-26 10:20:31 +01001680 asus_wmi_platform_exit(asus);
Corentin Chary27c136c2010-11-29 08:14:05 +01001681fail_platform:
Corentin Charye12e6d92011-02-26 10:20:31 +01001682 kfree(asus);
Corentin Charya04ce292011-02-06 13:28:33 +01001683 return err;
Yong Wang45f2c692010-04-11 09:27:19 +08001684}
1685
Corentin Charye12e6d92011-02-26 10:20:31 +01001686static int asus_wmi_remove(struct platform_device *device)
Yong Wang45f2c692010-04-11 09:27:19 +08001687{
Corentin Charye12e6d92011-02-26 10:20:31 +01001688 struct asus_wmi *asus;
Yong Wang45f2c692010-04-11 09:27:19 +08001689
Corentin Charye12e6d92011-02-26 10:20:31 +01001690 asus = platform_get_drvdata(device);
1691 wmi_remove_notify_handler(asus->driver->event_guid);
1692 asus_wmi_backlight_exit(asus);
1693 asus_wmi_input_exit(asus);
Corentin Charye07babd2011-02-26 10:20:42 +01001694 asus_wmi_hwmon_exit(asus);
Corentin Charye12e6d92011-02-26 10:20:31 +01001695 asus_wmi_led_exit(asus);
1696 asus_wmi_rfkill_exit(asus);
1697 asus_wmi_debugfs_exit(asus);
1698 asus_wmi_platform_exit(asus);
Yong Wang45f2c692010-04-11 09:27:19 +08001699
Corentin Charye12e6d92011-02-26 10:20:31 +01001700 kfree(asus);
Yong Wang45f2c692010-04-11 09:27:19 +08001701 return 0;
1702}
1703
Corentin Chary0773d7f2011-02-06 13:28:32 +01001704/*
1705 * Platform driver - hibernate/resume callbacks
1706 */
Corentin Charye12e6d92011-02-26 10:20:31 +01001707static int asus_hotk_thaw(struct device *device)
Corentin Chary0773d7f2011-02-06 13:28:32 +01001708{
Corentin Charye12e6d92011-02-26 10:20:31 +01001709 struct asus_wmi *asus = dev_get_drvdata(device);
Corentin Chary0773d7f2011-02-06 13:28:32 +01001710
Corentin Charya7ce3f02011-02-26 10:20:33 +01001711 if (asus->wlan.rfkill) {
Corentin Chary0773d7f2011-02-06 13:28:32 +01001712 bool wlan;
1713
1714 /*
1715 * Work around bios bug - acpi _PTS turns off the wireless led
1716 * during suspend. Normally it restores it on resume, but
1717 * we should kick it ourselves in case hibernation is aborted.
1718 */
Corentin Chary1d070f82011-02-26 10:20:36 +01001719 wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
Corentin Charye12e6d92011-02-26 10:20:31 +01001720 asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
Corentin Chary0773d7f2011-02-06 13:28:32 +01001721 }
1722
1723 return 0;
1724}
1725
Corentin Charye12e6d92011-02-26 10:20:31 +01001726static int asus_hotk_restore(struct device *device)
Corentin Chary0773d7f2011-02-06 13:28:32 +01001727{
Corentin Charye12e6d92011-02-26 10:20:31 +01001728 struct asus_wmi *asus = dev_get_drvdata(device);
Corentin Chary0773d7f2011-02-06 13:28:32 +01001729 int bl;
1730
1731 /* Refresh both wlan rfkill state and pci hotplug */
Corentin Charya7ce3f02011-02-26 10:20:33 +01001732 if (asus->wlan.rfkill)
Corentin Charye12e6d92011-02-26 10:20:31 +01001733 asus_rfkill_hotplug(asus);
Corentin Chary0773d7f2011-02-06 13:28:32 +01001734
Corentin Charya7ce3f02011-02-26 10:20:33 +01001735 if (asus->bluetooth.rfkill) {
Corentin Chary1d070f82011-02-26 10:20:36 +01001736 bl = !asus_wmi_get_devstate_simple(asus,
1737 ASUS_WMI_DEVID_BLUETOOTH);
Corentin Charya7ce3f02011-02-26 10:20:33 +01001738 rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
Corentin Chary2e9e1592011-02-06 13:28:37 +01001739 }
Corentin Charya7ce3f02011-02-26 10:20:33 +01001740 if (asus->wimax.rfkill) {
Corentin Chary1d070f82011-02-26 10:20:36 +01001741 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
Corentin Charya7ce3f02011-02-26 10:20:33 +01001742 rfkill_set_sw_state(asus->wimax.rfkill, bl);
Corentin Chary2e9e1592011-02-06 13:28:37 +01001743 }
Corentin Charya7ce3f02011-02-26 10:20:33 +01001744 if (asus->wwan3g.rfkill) {
Corentin Chary1d070f82011-02-26 10:20:36 +01001745 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
Corentin Charya7ce3f02011-02-26 10:20:33 +01001746 rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
Corentin Chary0773d7f2011-02-06 13:28:32 +01001747 }
Corentin Chary43be8bd2011-07-01 11:34:40 +02001748 if (asus->gps.rfkill) {
1749 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS);
1750 rfkill_set_sw_state(asus->gps.rfkill, bl);
1751 }
Corentin Charya912d322011-07-01 11:34:41 +02001752 if (asus->uwb.rfkill) {
1753 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB);
1754 rfkill_set_sw_state(asus->uwb.rfkill, bl);
1755 }
Corentin Chary0773d7f2011-02-06 13:28:32 +01001756
1757 return 0;
1758}
1759
Corentin Charye12e6d92011-02-26 10:20:31 +01001760static const struct dev_pm_ops asus_pm_ops = {
1761 .thaw = asus_hotk_thaw,
1762 .restore = asus_hotk_restore,
Corentin Chary0773d7f2011-02-06 13:28:32 +01001763};
1764
Corentin Charye12e6d92011-02-26 10:20:31 +01001765static int asus_wmi_probe(struct platform_device *pdev)
Corentin Charyd358cb52010-11-29 08:14:14 +01001766{
Corentin Charye12e6d92011-02-26 10:20:31 +01001767 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
1768 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
1769 int ret;
Corentin Charyd358cb52010-11-29 08:14:14 +01001770
Corentin Charye12e6d92011-02-26 10:20:31 +01001771 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
Joe Perches5ad77dc2011-03-29 15:21:35 -07001772 pr_warn("Management GUID not found\n");
Yong Wangee027e42010-03-21 10:26:34 +08001773 return -ENODEV;
1774 }
1775
Corentin Charye12e6d92011-02-26 10:20:31 +01001776 if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
Joe Perches5ad77dc2011-03-29 15:21:35 -07001777 pr_warn("Event GUID not found\n");
Corentin Charyd358cb52010-11-29 08:14:14 +01001778 return -ENODEV;
1779 }
1780
Corentin Charye12e6d92011-02-26 10:20:31 +01001781 if (wdrv->probe) {
1782 ret = wdrv->probe(pdev);
1783 if (ret)
1784 return ret;
1785 }
1786
1787 return asus_wmi_add(pdev);
Corentin Charya04ce292011-02-06 13:28:33 +01001788}
Yong Wangee027e42010-03-21 10:26:34 +08001789
Corentin Charye12e6d92011-02-26 10:20:31 +01001790static bool used;
Yong Wangee027e42010-03-21 10:26:34 +08001791
Corentin Chary8fe8c252011-07-01 11:34:32 +02001792int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
Corentin Charya04ce292011-02-06 13:28:33 +01001793{
Corentin Charye12e6d92011-02-26 10:20:31 +01001794 struct platform_driver *platform_driver;
1795 struct platform_device *platform_device;
1796
1797 if (used)
1798 return -EBUSY;
1799
1800 platform_driver = &driver->platform_driver;
1801 platform_driver->remove = asus_wmi_remove;
1802 platform_driver->driver.owner = driver->owner;
1803 platform_driver->driver.name = driver->name;
1804 platform_driver->driver.pm = &asus_pm_ops;
1805
1806 platform_device = platform_create_bundle(platform_driver,
1807 asus_wmi_probe,
Corentin Charya04ce292011-02-06 13:28:33 +01001808 NULL, 0, NULL, 0);
1809 if (IS_ERR(platform_device))
1810 return PTR_ERR(platform_device);
Corentin Charye12e6d92011-02-26 10:20:31 +01001811
1812 used = true;
1813 return 0;
1814}
1815EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
1816
1817void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
1818{
1819 platform_device_unregister(driver->platform_device);
1820 platform_driver_unregister(&driver->platform_driver);
1821 used = false;
1822}
1823EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
1824
1825static int __init asus_wmi_init(void)
1826{
1827 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
1828 pr_info("Asus Management GUID not found");
1829 return -ENODEV;
1830 }
1831
1832 pr_info("ASUS WMI generic driver loaded");
Yong Wangee027e42010-03-21 10:26:34 +08001833 return 0;
1834}
1835
Corentin Charye12e6d92011-02-26 10:20:31 +01001836static void __exit asus_wmi_exit(void)
Yong Wangee027e42010-03-21 10:26:34 +08001837{
Corentin Charye12e6d92011-02-26 10:20:31 +01001838 pr_info("ASUS WMI generic driver unloaded");
Yong Wangee027e42010-03-21 10:26:34 +08001839}
1840
Corentin Charye12e6d92011-02-26 10:20:31 +01001841module_init(asus_wmi_init);
1842module_exit(asus_wmi_exit);