1/*
   2 * Asus PC WMI hotkey driver
   3 *
   4 * Copyright(C) 2010 Intel Corporation.
   5 * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
   6 *
   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
  27#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  28
  29#include <linux/kernel.h>
  30#include <linux/module.h>
 
 
 
 
 
 
  31#include <linux/init.h>
  32#include <linux/types.h>
  33#include <linux/slab.h>
  34#include <linux/input.h>
  35#include <linux/input/sparse-keymap.h>
  36#include <linux/fb.h>
  37#include <linux/backlight.h>
  38#include <linux/leds.h>
  39#include <linux/rfkill.h>
 
  40#include <linux/pci.h>
  41#include <linux/pci_hotplug.h>
  42#include <linux/hwmon.h>
  43#include <linux/hwmon-sysfs.h>
  44#include <linux/debugfs.h>
  45#include <linux/seq_file.h>
  46#include <linux/platform_device.h>
  47#include <linux/thermal.h>
  48#include <linux/acpi.h>
  49#include <linux/dmi.h>
 
 
 
 
 
 
  50#include <acpi/video.h>
  51
  52#include "asus-wmi.h"
  53
  54MODULE_AUTHOR("Corentin Chary <corentin.chary@gmail.com>, "
  55	      "Yong Wang <yong.y.wang@intel.com>");
  56MODULE_DESCRIPTION("Asus Generic WMI Driver");
  57MODULE_LICENSE("GPL");
  58
 
 
 
  59#define to_asus_wmi_driver(pdrv)					\
  60	(container_of((pdrv), struct asus_wmi_driver, platform_driver))
  61
  62#define ASUS_WMI_MGMT_GUID	"97845ED0-4E6D-11DE-8A39-0800200C9A66"
  63
  64#define NOTIFY_BRNUP_MIN		0x11
  65#define NOTIFY_BRNUP_MAX		0x1f
  66#define NOTIFY_BRNDOWN_MIN		0x20
  67#define NOTIFY_BRNDOWN_MAX		0x2e
 
 
  68#define NOTIFY_KBD_BRTUP		0xc4
  69#define NOTIFY_KBD_BRTDWN		0xc5
 
 
 
 
 
  70
  71/* WMI Methods */
  72#define ASUS_WMI_METHODID_SPEC	        0x43455053 /* BIOS SPECification */
  73#define ASUS_WMI_METHODID_SFBD		0x44424653 /* Set First Boot Device */
  74#define ASUS_WMI_METHODID_GLCD		0x44434C47 /* Get LCD status */
  75#define ASUS_WMI_METHODID_GPID		0x44495047 /* Get Panel ID?? (Resol) */
  76#define ASUS_WMI_METHODID_QMOD		0x444F4D51 /* Quiet MODe */
  77#define ASUS_WMI_METHODID_SPLV		0x4C425053 /* Set Panel Light Value */
  78#define ASUS_WMI_METHODID_AGFN		0x4E464741 /* FaN? */
  79#define ASUS_WMI_METHODID_SFUN		0x4E554653 /* FUNCtionalities */
  80#define ASUS_WMI_METHODID_SDSP		0x50534453 /* Set DiSPlay output */
  81#define ASUS_WMI_METHODID_GDSP		0x50534447 /* Get DiSPlay output */
  82#define ASUS_WMI_METHODID_DEVP		0x50564544 /* DEVice Policy */
  83#define ASUS_WMI_METHODID_OSVR		0x5256534F /* OS VeRsion */
  84#define ASUS_WMI_METHODID_DSTS		0x53544344 /* Device STatuS */
  85#define ASUS_WMI_METHODID_DSTS2		0x53545344 /* Device STatuS #2*/
  86#define ASUS_WMI_METHODID_BSTS		0x53545342 /* Bios STatuS ? */
  87#define ASUS_WMI_METHODID_DEVS		0x53564544 /* DEVice Set */
  88#define ASUS_WMI_METHODID_CFVS		0x53564643 /* CPU Frequency Volt Set */
  89#define ASUS_WMI_METHODID_KBFT		0x5446424B /* KeyBoard FilTer */
  90#define ASUS_WMI_METHODID_INIT		0x54494E49 /* INITialize */
  91#define ASUS_WMI_METHODID_HKEY		0x59454B48 /* Hot KEY ?? */
  92
  93#define ASUS_WMI_UNSUPPORTED_METHOD	0xFFFFFFFE
  94
  95/* Wireless */
  96#define ASUS_WMI_DEVID_HW_SWITCH	0x00010001
  97#define ASUS_WMI_DEVID_WIRELESS_LED	0x00010002
  98#define ASUS_WMI_DEVID_CWAP		0x00010003
  99#define ASUS_WMI_DEVID_WLAN		0x00010011
 100#define ASUS_WMI_DEVID_WLAN_LED		0x00010012
 101#define ASUS_WMI_DEVID_BLUETOOTH	0x00010013
 102#define ASUS_WMI_DEVID_GPS		0x00010015
 103#define ASUS_WMI_DEVID_WIMAX		0x00010017
 104#define ASUS_WMI_DEVID_WWAN3G		0x00010019
 105#define ASUS_WMI_DEVID_UWB		0x00010021
 106
 107/* Leds */
 108/* 0x000200XX and 0x000400XX */
 109#define ASUS_WMI_DEVID_LED1		0x00020011
 110#define ASUS_WMI_DEVID_LED2		0x00020012
 111#define ASUS_WMI_DEVID_LED3		0x00020013
 112#define ASUS_WMI_DEVID_LED4		0x00020014
 113#define ASUS_WMI_DEVID_LED5		0x00020015
 114#define ASUS_WMI_DEVID_LED6		0x00020016
 115
 116/* Backlight and Brightness */
 117#define ASUS_WMI_DEVID_ALS_ENABLE	0x00050001 /* Ambient Light Sensor */
 118#define ASUS_WMI_DEVID_BACKLIGHT	0x00050011
 119#define ASUS_WMI_DEVID_BRIGHTNESS	0x00050012
 120#define ASUS_WMI_DEVID_KBD_BACKLIGHT	0x00050021
 121#define ASUS_WMI_DEVID_LIGHT_SENSOR	0x00050022 /* ?? */
 122
 123/* Misc */
 124#define ASUS_WMI_DEVID_CAMERA		0x00060013
 125
 126/* Storage */
 127#define ASUS_WMI_DEVID_CARDREADER	0x00080013
 128
 129/* Input */
 130#define ASUS_WMI_DEVID_TOUCHPAD		0x00100011
 131#define ASUS_WMI_DEVID_TOUCHPAD_LED	0x00100012
 132
 133/* Fan, Thermal */
 134#define ASUS_WMI_DEVID_THERMAL_CTRL	0x00110011
 135#define ASUS_WMI_DEVID_FAN_CTRL		0x00110012
 136
 137/* Power */
 138#define ASUS_WMI_DEVID_PROCESSOR_STATE	0x00120012
 139
 140/* Deep S3 / Resume on LID open */
 141#define ASUS_WMI_DEVID_LID_RESUME	0x00120031
 142
 143/* DSTS masks */
 144#define ASUS_WMI_DSTS_STATUS_BIT	0x00000001
 145#define ASUS_WMI_DSTS_UNKNOWN_BIT	0x00000002
 146#define ASUS_WMI_DSTS_PRESENCE_BIT	0x00010000
 147#define ASUS_WMI_DSTS_USER_BIT		0x00020000
 148#define ASUS_WMI_DSTS_BIOS_BIT		0x00040000
 149#define ASUS_WMI_DSTS_BRIGHTNESS_MASK	0x000000FF
 150#define ASUS_WMI_DSTS_MAX_BRIGTH_MASK	0x0000FF00
 151
 
 
 152#define ASUS_FAN_DESC			"cpu_fan"
 153#define ASUS_FAN_MFUN			0x13
 154#define ASUS_FAN_SFUN_READ		0x06
 155#define ASUS_FAN_SFUN_WRITE		0x07
 
 
 
 156#define ASUS_FAN_CTRL_MANUAL		1
 157#define ASUS_FAN_CTRL_AUTO		2
 158
 
 
 
 
 
 
 
 
 
 
 
 159#define USB_INTEL_XUSB2PR		0xD0
 160#define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI	0x9c31
 161
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 162static const char * const ashs_ids[] = { "ATK4001", "ATK4002", NULL };
 163
 
 
 
 
 
 
 
 
 
 
 
 
 164struct bios_args {
 165	u32 arg0;
 166	u32 arg1;
 
 
 
 
 167} __packed;
 168
 169/*
 170 * Struct that's used for all methods called via AGFN. Naming is
 171 * identically to the AML code.
 172 */
 173struct agfn_args {
 174	u16 mfun; /* probably "Multi-function" to be called */
 175	u16 sfun; /* probably "Sub-function" to be called */
 176	u16 len;  /* size of the hole struct, including subfunction fields */
 177	u8 stas;  /* not used by now */
 178	u8 err;   /* zero on success */
 179} __packed;
 180
 181/* struct used for calling fan read and write methods */
 182struct fan_args {
 183	struct agfn_args agfn;	/* common fields */
 184	u8 fan;			/* fan number: 0: set auto mode 1: 1st fan */
 185	u32 speed;		/* read: RPM/100 - write: 0-255 */
 186} __packed;
 187
 188/*
 189 * <platform>/    - debugfs root directory
 190 *   dev_id      - current dev_id
 191 *   ctrl_param  - current ctrl_param
 192 *   method_id   - current method_id
 193 *   devs        - call DEVS(dev_id, ctrl_param) and print result
 194 *   dsts        - call DSTS(dev_id)  and print result
 195 *   call        - call method_id(dev_id, ctrl_param) and print result
 196 */
 197struct asus_wmi_debug {
 198	struct dentry *root;
 199	u32 method_id;
 200	u32 dev_id;
 201	u32 ctrl_param;
 202};
 203
 204struct asus_rfkill {
 205	struct asus_wmi *asus;
 206	struct rfkill *rfkill;
 207	u32 dev_id;
 208};
 209
 
 
 
 
 
 
 
 
 
 
 
 
 
 210struct asus_wmi {
 211	int dsts_id;
 212	int spec;
 213	int sfun;
 214
 215	struct input_dev *inputdev;
 216	struct backlight_device *backlight_device;
 
 217	struct platform_device *platform_device;
 218
 219	struct led_classdev wlan_led;
 220	int wlan_led_wk;
 221	struct led_classdev tpd_led;
 222	int tpd_led_wk;
 223	struct led_classdev kbd_led;
 224	int kbd_led_wk;
 
 
 
 225	struct workqueue_struct *led_workqueue;
 226	struct work_struct tpd_led_work;
 227	struct work_struct kbd_led_work;
 228	struct work_struct wlan_led_work;
 
 229
 230	struct asus_rfkill wlan;
 231	struct asus_rfkill bluetooth;
 232	struct asus_rfkill wimax;
 233	struct asus_rfkill wwan3g;
 234	struct asus_rfkill gps;
 235	struct asus_rfkill uwb;
 236
 237	bool asus_hwmon_fan_manual_mode;
 238	int asus_hwmon_num_fans;
 239	int asus_hwmon_pwm;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 240
 241	struct hotplug_slot *hotplug_slot;
 
 
 
 242	struct mutex hotplug_lock;
 243	struct mutex wmi_lock;
 244	struct workqueue_struct *hotplug_workqueue;
 245	struct work_struct hotplug_work;
 246
 
 
 
 
 
 247	struct asus_wmi_debug debug;
 248
 249	struct asus_wmi_driver *driver;
 250};
 251
 252static int asus_wmi_input_init(struct asus_wmi *asus)
 
 
 
 253{
 254	int err;
 
 
 
 
 
 
 
 
 
 255
 256	asus->inputdev = input_allocate_device();
 257	if (!asus->inputdev)
 258		return -ENOMEM;
 259
 260	asus->inputdev->name = asus->driver->input_name;
 261	asus->inputdev->phys = asus->driver->input_phys;
 262	asus->inputdev->id.bustype = BUS_HOST;
 263	asus->inputdev->dev.parent = &asus->platform_device->dev;
 264	set_bit(EV_REP, asus->inputdev->evbit);
 265
 266	err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
 267	if (err)
 268		goto err_free_dev;
 269
 270	err = input_register_device(asus->inputdev);
 271	if (err)
 272		goto err_free_keymap;
 273
 274	return 0;
 275
 276err_free_keymap:
 277	sparse_keymap_free(asus->inputdev);
 278err_free_dev:
 279	input_free_device(asus->inputdev);
 280	return err;
 281}
 282
 283static void asus_wmi_input_exit(struct asus_wmi *asus)
 284{
 285	if (asus->inputdev) {
 286		sparse_keymap_free(asus->inputdev);
 287		input_unregister_device(asus->inputdev);
 288	}
 289
 290	asus->inputdev = NULL;
 291}
 
 292
 293static int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
 294				    u32 *retval)
 295{
 296	struct bios_args args = {
 297		.arg0 = arg0,
 298		.arg1 = arg1,
 
 
 
 299	};
 300	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
 301	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
 302	acpi_status status;
 303	union acpi_object *obj;
 304	u32 tmp = 0;
 305
 306	status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1, method_id,
 307				     &input, &output);
 308
 309	if (ACPI_FAILURE(status))
 310		goto exit;
 311
 312	obj = (union acpi_object *)output.pointer;
 313	if (obj && obj->type == ACPI_TYPE_INTEGER)
 314		tmp = (u32) obj->integer.value;
 315
 316	if (retval)
 317		*retval = tmp;
 318
 319	kfree(obj);
 320
 321exit:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 322	if (ACPI_FAILURE(status))
 323		return -EIO;
 324
 325	if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
 326		return -ENODEV;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 327
 328	return 0;
 329}
 330
 331static int asus_wmi_evaluate_method_agfn(const struct acpi_buffer args)
 332{
 333	struct acpi_buffer input;
 334	u64 phys_addr;
 335	u32 retval;
 336	u32 status = -1;
 337
 338	/*
 339	 * Copy to dma capable address otherwise memory corruption occurs as
 340	 * bios has to be able to access it.
 341	 */
 342	input.pointer = kzalloc(args.length, GFP_DMA | GFP_KERNEL);
 343	input.length = args.length;
 344	if (!input.pointer)
 345		return -ENOMEM;
 346	phys_addr = virt_to_phys(input.pointer);
 347	memcpy(input.pointer, args.pointer, args.length);
 348
 349	status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_AGFN,
 350					phys_addr, 0, &retval);
 351	if (!status)
 352		memcpy(args.pointer, input.pointer, args.length);
 353
 354	kfree(input.pointer);
 355	if (status)
 356		return -ENXIO;
 357
 358	return retval;
 359}
 360
 361static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
 362{
 363	return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
 
 
 
 
 
 
 
 
 
 
 364}
 365
 366static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
 367				 u32 *retval)
 368{
 369	return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
 370					ctrl_param, retval);
 371}
 372
 373/* Helper for special devices with magic return codes */
 374static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
 375				      u32 dev_id, u32 mask)
 376{
 377	u32 retval = 0;
 378	int err;
 379
 380	err = asus_wmi_get_devstate(asus, dev_id, &retval);
 381
 382	if (err < 0)
 383		return err;
 384
 385	if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
 386		return -ENODEV;
 387
 388	if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
 389		if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
 390			return -ENODEV;
 391	}
 392
 393	return retval & mask;
 394}
 395
 396static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
 397{
 398	return asus_wmi_get_devstate_bits(asus, dev_id,
 399					  ASUS_WMI_DSTS_STATUS_BIT);
 400}
 401
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 402/*
 403 * LEDs
 
 
 
 404 */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 405/*
 406 * These functions actually update the LED's, and are called from a
 407 * workqueue. By doing this as separate work rather than when the LED
 408 * subsystem asks, we avoid messing with the Asus ACPI stuff during a
 409 * potentially bad time, such as a timer interrupt.
 410 */
 411static void tpd_led_update(struct work_struct *work)
 412{
 413	int ctrl_param;
 414	struct asus_wmi *asus;
 415
 416	asus = container_of(work, struct asus_wmi, tpd_led_work);
 417
 418	ctrl_param = asus->tpd_led_wk;
 419	asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
 420}
 421
 422static void tpd_led_set(struct led_classdev *led_cdev,
 423			enum led_brightness value)
 424{
 425	struct asus_wmi *asus;
 426
 427	asus = container_of(led_cdev, struct asus_wmi, tpd_led);
 428
 429	asus->tpd_led_wk = !!value;
 430	queue_work(asus->led_workqueue, &asus->tpd_led_work);
 431}
 432
 433static int read_tpd_led_state(struct asus_wmi *asus)
 434{
 435	return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
 436}
 437
 438static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
 439{
 440	struct asus_wmi *asus;
 441
 442	asus = container_of(led_cdev, struct asus_wmi, tpd_led);
 443
 444	return read_tpd_led_state(asus);
 445}
 446
 447static void kbd_led_update(struct work_struct *work)
 448{
 449	int ctrl_param = 0;
 450	struct asus_wmi *asus;
 451
 452	asus = container_of(work, struct asus_wmi, kbd_led_work);
 453
 454	/*
 455	 * bits 0-2: level
 456	 * bit 7: light on/off
 457	 */
 458	if (asus->kbd_led_wk > 0)
 459		ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
 460
 
 461	asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
 462}
 463
 464static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
 465{
 466	int retval;
 467
 468	/*
 469	 * bits 0-2: level
 470	 * bit 7: light on/off
 471	 * bit 8-10: environment (0: dark, 1: normal, 2: light)
 472	 * bit 17: status unknown
 473	 */
 474	retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
 475					    0xFFFF);
 476
 477	/* Unknown status is considered as off */
 478	if (retval == 0x8000)
 479		retval = 0;
 480
 481	if (retval >= 0) {
 482		if (level)
 483			*level = retval & 0x7F;
 484		if (env)
 485			*env = (retval >> 8) & 0x7F;
 486		retval = 0;
 487	}
 488
 489	return retval;
 
 
 
 
 490}
 491
 492static void kbd_led_set(struct led_classdev *led_cdev,
 493			enum led_brightness value)
 494{
 495	struct asus_wmi *asus;
 
 496
 497	asus = container_of(led_cdev, struct asus_wmi, kbd_led);
 
 498
 499	if (value > asus->kbd_led.max_brightness)
 500		value = asus->kbd_led.max_brightness;
 501	else if (value < 0)
 502		value = 0;
 503
 504	asus->kbd_led_wk = value;
 505	queue_work(asus->led_workqueue, &asus->kbd_led_work);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 506}
 507
 508static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
 509{
 510	struct asus_wmi *asus;
 511	int retval, value;
 512
 513	asus = container_of(led_cdev, struct asus_wmi, kbd_led);
 514
 515	retval = kbd_led_read(asus, &value, NULL);
 516
 517	if (retval < 0)
 518		return retval;
 519
 520	return value;
 521}
 522
 523static int wlan_led_unknown_state(struct asus_wmi *asus)
 524{
 525	u32 result;
 526
 527	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
 528
 529	return result & ASUS_WMI_DSTS_UNKNOWN_BIT;
 530}
 531
 532static int wlan_led_presence(struct asus_wmi *asus)
 533{
 534	u32 result;
 535
 536	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
 537
 538	return result & ASUS_WMI_DSTS_PRESENCE_BIT;
 539}
 540
 541static void wlan_led_update(struct work_struct *work)
 542{
 543	int ctrl_param;
 544	struct asus_wmi *asus;
 545
 546	asus = container_of(work, struct asus_wmi, wlan_led_work);
 547
 548	ctrl_param = asus->wlan_led_wk;
 549	asus_wmi_set_devstate(ASUS_WMI_DEVID_WIRELESS_LED, ctrl_param, NULL);
 550}
 551
 552static void wlan_led_set(struct led_classdev *led_cdev,
 553			 enum led_brightness value)
 554{
 555	struct asus_wmi *asus;
 556
 557	asus = container_of(led_cdev, struct asus_wmi, wlan_led);
 558
 559	asus->wlan_led_wk = !!value;
 560	queue_work(asus->led_workqueue, &asus->wlan_led_work);
 561}
 562
 563static enum led_brightness wlan_led_get(struct led_classdev *led_cdev)
 564{
 565	struct asus_wmi *asus;
 566	u32 result;
 567
 568	asus = container_of(led_cdev, struct asus_wmi, wlan_led);
 569	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
 570
 571	return result & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
 572}
 573
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 574static void asus_wmi_led_exit(struct asus_wmi *asus)
 575{
 576	if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
 577		led_classdev_unregister(&asus->kbd_led);
 578	if (!IS_ERR_OR_NULL(asus->tpd_led.dev))
 579		led_classdev_unregister(&asus->tpd_led);
 580	if (!IS_ERR_OR_NULL(asus->wlan_led.dev))
 581		led_classdev_unregister(&asus->wlan_led);
 582	if (asus->led_workqueue)
 583		destroy_workqueue(asus->led_workqueue);
 584}
 585
 586static int asus_wmi_led_init(struct asus_wmi *asus)
 587{
 588	int rv = 0, led_val;
 
 
 
 
 
 589
 590	asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
 591	if (!asus->led_workqueue)
 592		return -ENOMEM;
 593
 594	if (read_tpd_led_state(asus) >= 0) {
 595		INIT_WORK(&asus->tpd_led_work, tpd_led_update);
 596
 597		asus->tpd_led.name = "asus::touchpad";
 598		asus->tpd_led.brightness_set = tpd_led_set;
 599		asus->tpd_led.brightness_get = tpd_led_get;
 600		asus->tpd_led.max_brightness = 1;
 601
 602		rv = led_classdev_register(&asus->platform_device->dev,
 603					   &asus->tpd_led);
 604		if (rv)
 605			goto error;
 606	}
 607
 608	led_val = kbd_led_read(asus, NULL, NULL);
 609	if (led_val >= 0) {
 610		INIT_WORK(&asus->kbd_led_work, kbd_led_update);
 611
 612		asus->kbd_led_wk = led_val;
 613		asus->kbd_led.name = "asus::kbd_backlight";
 
 614		asus->kbd_led.brightness_set = kbd_led_set;
 615		asus->kbd_led.brightness_get = kbd_led_get;
 616		asus->kbd_led.max_brightness = 3;
 617
 
 
 
 618		rv = led_classdev_register(&asus->platform_device->dev,
 619					   &asus->kbd_led);
 620		if (rv)
 621			goto error;
 622	}
 623
 624	if (wlan_led_presence(asus) && (asus->driver->quirks->wapf > 0)) {
 
 625		INIT_WORK(&asus->wlan_led_work, wlan_led_update);
 626
 627		asus->wlan_led.name = "asus::wlan";
 628		asus->wlan_led.brightness_set = wlan_led_set;
 629		if (!wlan_led_unknown_state(asus))
 630			asus->wlan_led.brightness_get = wlan_led_get;
 631		asus->wlan_led.flags = LED_CORE_SUSPENDRESUME;
 632		asus->wlan_led.max_brightness = 1;
 633		asus->wlan_led.default_trigger = "asus-wlan";
 634
 635		rv = led_classdev_register(&asus->platform_device->dev,
 636					   &asus->wlan_led);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 637	}
 638
 639error:
 640	if (rv)
 641		asus_wmi_led_exit(asus);
 642
 643	return rv;
 644}
 645
 
 646
 647/*
 648 * PCI hotplug (for wlan rfkill)
 649 */
 650static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
 651{
 652	int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
 653
 654	if (result < 0)
 655		return false;
 656	return !result;
 657}
 658
 659static void asus_rfkill_hotplug(struct asus_wmi *asus)
 660{
 661	struct pci_dev *dev;
 662	struct pci_bus *bus;
 663	bool blocked;
 664	bool absent;
 665	u32 l;
 666
 667	mutex_lock(&asus->wmi_lock);
 668	blocked = asus_wlan_rfkill_blocked(asus);
 669	mutex_unlock(&asus->wmi_lock);
 670
 671	mutex_lock(&asus->hotplug_lock);
 672	pci_lock_rescan_remove();
 673
 674	if (asus->wlan.rfkill)
 675		rfkill_set_sw_state(asus->wlan.rfkill, blocked);
 676
 677	if (asus->hotplug_slot) {
 678		bus = pci_find_bus(0, 1);
 679		if (!bus) {
 680			pr_warn("Unable to find PCI bus 1?\n");
 681			goto out_unlock;
 682		}
 683
 684		if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
 685			pr_err("Unable to read PCI config space?\n");
 686			goto out_unlock;
 687		}
 688		absent = (l == 0xffffffff);
 689
 690		if (blocked != absent) {
 691			pr_warn("BIOS says wireless lan is %s, "
 692				"but the pci device is %s\n",
 693				blocked ? "blocked" : "unblocked",
 694				absent ? "absent" : "present");
 695			pr_warn("skipped wireless hotplug as probably "
 696				"inappropriate for this model\n");
 697			goto out_unlock;
 698		}
 699
 700		if (!blocked) {
 701			dev = pci_get_slot(bus, 0);
 702			if (dev) {
 703				/* Device already present */
 704				pci_dev_put(dev);
 705				goto out_unlock;
 706			}
 707			dev = pci_scan_single_device(bus, 0);
 708			if (dev) {
 709				pci_bus_assign_resources(bus);
 710				pci_bus_add_device(dev);
 711			}
 712		} else {
 713			dev = pci_get_slot(bus, 0);
 714			if (dev) {
 715				pci_stop_and_remove_bus_device(dev);
 716				pci_dev_put(dev);
 717			}
 718		}
 719	}
 720
 721out_unlock:
 722	pci_unlock_rescan_remove();
 723	mutex_unlock(&asus->hotplug_lock);
 724}
 725
 726static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
 727{
 728	struct asus_wmi *asus = data;
 729
 730	if (event != ACPI_NOTIFY_BUS_CHECK)
 731		return;
 732
 733	/*
 734	 * We can't call directly asus_rfkill_hotplug because most
 735	 * of the time WMBC is still being executed and not reetrant.
 736	 * There is currently no way to tell ACPICA that  we want this
 737	 * method to be serialized, we schedule a asus_rfkill_hotplug
 738	 * call later, in a safer context.
 739	 */
 740	queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
 741}
 742
 743static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
 744{
 745	acpi_status status;
 746	acpi_handle handle;
 747
 748	status = acpi_get_handle(NULL, node, &handle);
 749
 750	if (ACPI_SUCCESS(status)) {
 751		status = acpi_install_notify_handler(handle,
 752						     ACPI_SYSTEM_NOTIFY,
 753						     asus_rfkill_notify, asus);
 754		if (ACPI_FAILURE(status))
 755			pr_warn("Failed to register notify on %s\n", node);
 756	} else
 757		return -ENODEV;
 758
 
 
 
 
 
 759	return 0;
 760}
 761
 762static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
 763{
 764	acpi_status status = AE_OK;
 765	acpi_handle handle;
 766
 767	status = acpi_get_handle(NULL, node, &handle);
 
 
 768
 769	if (ACPI_SUCCESS(status)) {
 770		status = acpi_remove_notify_handler(handle,
 771						    ACPI_SYSTEM_NOTIFY,
 772						    asus_rfkill_notify);
 773		if (ACPI_FAILURE(status))
 774			pr_err("Error removing rfkill notify handler %s\n",
 775			       node);
 776	}
 777}
 778
 779static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
 780				   u8 *value)
 781{
 782	struct asus_wmi *asus = hotplug_slot->private;
 
 783	int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
 784
 785	if (result < 0)
 786		return result;
 787
 788	*value = !!result;
 789	return 0;
 790}
 791
 792static void asus_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
 793{
 794	kfree(hotplug_slot->info);
 795	kfree(hotplug_slot);
 796}
 797
 798static struct hotplug_slot_ops asus_hotplug_slot_ops = {
 799	.owner = THIS_MODULE,
 800	.get_adapter_status = asus_get_adapter_status,
 801	.get_power_status = asus_get_adapter_status,
 802};
 803
 804static void asus_hotplug_work(struct work_struct *work)
 805{
 806	struct asus_wmi *asus;
 807
 808	asus = container_of(work, struct asus_wmi, hotplug_work);
 809	asus_rfkill_hotplug(asus);
 810}
 811
 812static int asus_setup_pci_hotplug(struct asus_wmi *asus)
 813{
 814	int ret = -ENOMEM;
 815	struct pci_bus *bus = pci_find_bus(0, 1);
 816
 817	if (!bus) {
 818		pr_err("Unable to find wifi PCI bus\n");
 819		return -ENODEV;
 820	}
 821
 822	asus->hotplug_workqueue =
 823	    create_singlethread_workqueue("hotplug_workqueue");
 824	if (!asus->hotplug_workqueue)
 825		goto error_workqueue;
 826
 827	INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
 828
 829	asus->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
 830	if (!asus->hotplug_slot)
 831		goto error_slot;
 832
 833	asus->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
 834					   GFP_KERNEL);
 835	if (!asus->hotplug_slot->info)
 836		goto error_info;
 837
 838	asus->hotplug_slot->private = asus;
 839	asus->hotplug_slot->release = &asus_cleanup_pci_hotplug;
 840	asus->hotplug_slot->ops = &asus_hotplug_slot_ops;
 841	asus_get_adapter_status(asus->hotplug_slot,
 842				&asus->hotplug_slot->info->adapter_status);
 843
 844	ret = pci_hp_register(asus->hotplug_slot, bus, 0, "asus-wifi");
 845	if (ret) {
 846		pr_err("Unable to register hotplug slot - %d\n", ret);
 847		goto error_register;
 848	}
 849
 850	return 0;
 851
 852error_register:
 853	kfree(asus->hotplug_slot->info);
 854error_info:
 855	kfree(asus->hotplug_slot);
 856	asus->hotplug_slot = NULL;
 857error_slot:
 858	destroy_workqueue(asus->hotplug_workqueue);
 859error_workqueue:
 860	return ret;
 861}
 862
 863/*
 864 * Rfkill devices
 865 */
 866static int asus_rfkill_set(void *data, bool blocked)
 867{
 868	struct asus_rfkill *priv = data;
 869	u32 ctrl_param = !blocked;
 870	u32 dev_id = priv->dev_id;
 871
 872	/*
 873	 * If the user bit is set, BIOS can't set and record the wlan status,
 874	 * it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
 875	 * while we query the wlan status through WMI(ASUS_WMI_DEVID_WLAN).
 876	 * So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
 877	 * while setting the wlan status through WMI.
 878	 * This is also the behavior that windows app will do.
 879	 */
 880	if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
 881	     priv->asus->driver->wlan_ctrl_by_user)
 882		dev_id = ASUS_WMI_DEVID_WLAN_LED;
 883
 884	return asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
 885}
 886
 887static void asus_rfkill_query(struct rfkill *rfkill, void *data)
 888{
 889	struct asus_rfkill *priv = data;
 890	int result;
 891
 892	result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
 893
 894	if (result < 0)
 895		return;
 896
 897	rfkill_set_sw_state(priv->rfkill, !result);
 898}
 899
 900static int asus_rfkill_wlan_set(void *data, bool blocked)
 901{
 902	struct asus_rfkill *priv = data;
 903	struct asus_wmi *asus = priv->asus;
 904	int ret;
 905
 906	/*
 907	 * This handler is enabled only if hotplug is enabled.
 908	 * In this case, the asus_wmi_set_devstate() will
 909	 * trigger a wmi notification and we need to wait
 910	 * this call to finish before being able to call
 911	 * any wmi method
 912	 */
 913	mutex_lock(&asus->wmi_lock);
 914	ret = asus_rfkill_set(data, blocked);
 915	mutex_unlock(&asus->wmi_lock);
 916	return ret;
 917}
 918
 919static const struct rfkill_ops asus_rfkill_wlan_ops = {
 920	.set_block = asus_rfkill_wlan_set,
 921	.query = asus_rfkill_query,
 922};
 923
 924static const struct rfkill_ops asus_rfkill_ops = {
 925	.set_block = asus_rfkill_set,
 926	.query = asus_rfkill_query,
 927};
 928
 929static int asus_new_rfkill(struct asus_wmi *asus,
 930			   struct asus_rfkill *arfkill,
 931			   const char *name, enum rfkill_type type, int dev_id)
 932{
 933	int result = asus_wmi_get_devstate_simple(asus, dev_id);
 934	struct rfkill **rfkill = &arfkill->rfkill;
 935
 936	if (result < 0)
 937		return result;
 938
 939	arfkill->dev_id = dev_id;
 940	arfkill->asus = asus;
 941
 942	if (dev_id == ASUS_WMI_DEVID_WLAN &&
 943	    asus->driver->quirks->hotplug_wireless)
 944		*rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
 945				       &asus_rfkill_wlan_ops, arfkill);
 946	else
 947		*rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
 948				       &asus_rfkill_ops, arfkill);
 949
 950	if (!*rfkill)
 951		return -EINVAL;
 952
 953	if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
 954			(asus->driver->quirks->wapf > 0))
 955		rfkill_set_led_trigger_name(*rfkill, "asus-wlan");
 956
 957	rfkill_init_sw_state(*rfkill, !result);
 958	result = rfkill_register(*rfkill);
 959	if (result) {
 960		rfkill_destroy(*rfkill);
 961		*rfkill = NULL;
 962		return result;
 963	}
 964	return 0;
 965}
 966
 967static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
 968{
 
 
 
 969	asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
 970	asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
 971	asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
 972	if (asus->wlan.rfkill) {
 973		rfkill_unregister(asus->wlan.rfkill);
 974		rfkill_destroy(asus->wlan.rfkill);
 975		asus->wlan.rfkill = NULL;
 976	}
 977	/*
 978	 * Refresh pci hotplug in case the rfkill state was changed after
 979	 * asus_unregister_rfkill_notifier()
 980	 */
 981	asus_rfkill_hotplug(asus);
 982	if (asus->hotplug_slot)
 983		pci_hp_deregister(asus->hotplug_slot);
 984	if (asus->hotplug_workqueue)
 985		destroy_workqueue(asus->hotplug_workqueue);
 986
 987	if (asus->bluetooth.rfkill) {
 988		rfkill_unregister(asus->bluetooth.rfkill);
 989		rfkill_destroy(asus->bluetooth.rfkill);
 990		asus->bluetooth.rfkill = NULL;
 991	}
 992	if (asus->wimax.rfkill) {
 993		rfkill_unregister(asus->wimax.rfkill);
 994		rfkill_destroy(asus->wimax.rfkill);
 995		asus->wimax.rfkill = NULL;
 996	}
 997	if (asus->wwan3g.rfkill) {
 998		rfkill_unregister(asus->wwan3g.rfkill);
 999		rfkill_destroy(asus->wwan3g.rfkill);
1000		asus->wwan3g.rfkill = NULL;
1001	}
1002	if (asus->gps.rfkill) {
1003		rfkill_unregister(asus->gps.rfkill);
1004		rfkill_destroy(asus->gps.rfkill);
1005		asus->gps.rfkill = NULL;
1006	}
1007	if (asus->uwb.rfkill) {
1008		rfkill_unregister(asus->uwb.rfkill);
1009		rfkill_destroy(asus->uwb.rfkill);
1010		asus->uwb.rfkill = NULL;
1011	}
1012}
1013
1014static int asus_wmi_rfkill_init(struct asus_wmi *asus)
1015{
1016	int result = 0;
1017
1018	mutex_init(&asus->hotplug_lock);
1019	mutex_init(&asus->wmi_lock);
1020
1021	result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
1022				 RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
1023
1024	if (result && result != -ENODEV)
1025		goto exit;
1026
1027	result = asus_new_rfkill(asus, &asus->bluetooth,
1028				 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
1029				 ASUS_WMI_DEVID_BLUETOOTH);
1030
1031	if (result && result != -ENODEV)
1032		goto exit;
1033
1034	result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
1035				 RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
1036
1037	if (result && result != -ENODEV)
1038		goto exit;
1039
1040	result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
1041				 RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
1042
1043	if (result && result != -ENODEV)
1044		goto exit;
1045
1046	result = asus_new_rfkill(asus, &asus->gps, "asus-gps",
1047				 RFKILL_TYPE_GPS, ASUS_WMI_DEVID_GPS);
1048
1049	if (result && result != -ENODEV)
1050		goto exit;
1051
1052	result = asus_new_rfkill(asus, &asus->uwb, "asus-uwb",
1053				 RFKILL_TYPE_UWB, ASUS_WMI_DEVID_UWB);
1054
1055	if (result && result != -ENODEV)
1056		goto exit;
1057
1058	if (!asus->driver->quirks->hotplug_wireless)
1059		goto exit;
1060
1061	result = asus_setup_pci_hotplug(asus);
1062	/*
1063	 * If we get -EBUSY then something else is handling the PCI hotplug -
1064	 * don't fail in this case
1065	 */
1066	if (result == -EBUSY)
1067		result = 0;
1068
1069	asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
1070	asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
1071	asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
1072	/*
1073	 * Refresh pci hotplug in case the rfkill state was changed during
1074	 * setup.
1075	 */
1076	asus_rfkill_hotplug(asus);
1077
1078exit:
1079	if (result && result != -ENODEV)
1080		asus_wmi_rfkill_exit(asus);
1081
1082	if (result == -ENODEV)
1083		result = 0;
1084
1085	return result;
1086}
1087
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1088static void asus_wmi_set_xusb2pr(struct asus_wmi *asus)
1089{
1090	struct pci_dev *xhci_pdev;
1091	u32 orig_ports_available;
1092	u32 ports_available = asus->driver->quirks->xusb2pr;
1093
1094	xhci_pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
1095			PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI,
1096			NULL);
1097
1098	if (!xhci_pdev)
1099		return;
1100
1101	pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
1102				&orig_ports_available);
1103
1104	pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
1105				cpu_to_le32(ports_available));
1106
 
 
1107	pr_info("set USB_INTEL_XUSB2PR old: 0x%04x, new: 0x%04x\n",
1108			orig_ports_available, ports_available);
1109}
1110
1111/*
1112 * Hwmon device
 
1113 */
1114static int asus_hwmon_agfn_fan_speed_read(struct asus_wmi *asus, int fan,
 
 
 
 
 
 
 
1115					  int *speed)
1116{
1117	struct fan_args args = {
1118		.agfn.len = sizeof(args),
1119		.agfn.mfun = ASUS_FAN_MFUN,
1120		.agfn.sfun = ASUS_FAN_SFUN_READ,
1121		.fan = fan,
1122		.speed = 0,
1123	};
1124	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1125	int status;
1126
1127	if (fan != 1)
1128		return -EINVAL;
1129
1130	status = asus_wmi_evaluate_method_agfn(input);
1131
1132	if (status || args.agfn.err)
1133		return -ENXIO;
1134
1135	if (speed)
1136		*speed = args.speed;
1137
1138	return 0;
1139}
1140
1141static int asus_hwmon_agfn_fan_speed_write(struct asus_wmi *asus, int fan,
1142				     int *speed)
1143{
1144	struct fan_args args = {
1145		.agfn.len = sizeof(args),
1146		.agfn.mfun = ASUS_FAN_MFUN,
1147		.agfn.sfun = ASUS_FAN_SFUN_WRITE,
1148		.fan = fan,
1149		.speed = speed ?  *speed : 0,
1150	};
1151	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1152	int status;
1153
1154	/* 1: for setting 1st fan's speed 0: setting auto mode */
1155	if (fan != 1 && fan != 0)
1156		return -EINVAL;
1157
1158	status = asus_wmi_evaluate_method_agfn(input);
1159
1160	if (status || args.agfn.err)
1161		return -ENXIO;
1162
1163	if (speed && fan == 1)
1164		asus->asus_hwmon_pwm = *speed;
1165
1166	return 0;
1167}
1168
1169/*
1170 * Check if we can read the speed of one fan. If true we assume we can also
1171 * control it.
1172 */
1173static int asus_hwmon_get_fan_number(struct asus_wmi *asus, int *num_fans)
1174{
1175	int status;
1176	int speed = 0;
 
1177
1178	*num_fans = 0;
 
 
1179
1180	status = asus_hwmon_agfn_fan_speed_read(asus, 1, &speed);
1181	if (!status)
1182		*num_fans = 1;
1183
1184	return 0;
 
 
 
 
 
 
 
 
 
1185}
1186
1187static int asus_hwmon_fan_set_auto(struct asus_wmi *asus)
1188{
1189	int status;
 
1190
1191	status = asus_hwmon_agfn_fan_speed_write(asus, 0, NULL);
1192	if (status)
1193		return -ENXIO;
1194
1195	asus->asus_hwmon_fan_manual_mode = false;
1196
1197	return 0;
1198}
1199
1200static int asus_hwmon_fan_rpm_show(struct device *dev, int fan)
1201{
1202	struct asus_wmi *asus = dev_get_drvdata(dev);
1203	int value;
1204	int ret;
1205
1206	/* no speed readable on manual mode */
1207	if (asus->asus_hwmon_fan_manual_mode)
1208		return -ENXIO;
1209
1210	ret = asus_hwmon_agfn_fan_speed_read(asus, fan+1, &value);
1211	if (ret) {
1212		pr_warn("reading fan speed failed: %d\n", ret);
1213		return -ENXIO;
1214	}
1215
1216	return value;
1217}
1218
1219static void asus_hwmon_pwm_show(struct asus_wmi *asus, int fan, int *value)
1220{
1221	int err;
 
 
1222
1223	if (asus->asus_hwmon_pwm >= 0) {
1224		*value = asus->asus_hwmon_pwm;
1225		return;
1226	}
1227
1228	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, value);
1229	if (err < 0)
1230		return;
1231
1232	*value &= 0xFF;
1233
1234	if (*value == 1) /* Low Speed */
1235		*value = 85;
1236	else if (*value == 2)
1237		*value = 170;
1238	else if (*value == 3)
1239		*value = 255;
1240	else if (*value) {
1241		pr_err("Unknown fan speed %#x\n", *value);
1242		*value = -1;
1243	}
1244}
1245
1246static ssize_t pwm1_show(struct device *dev,
1247			       struct device_attribute *attr,
1248			       char *buf)
1249{
1250	struct asus_wmi *asus = dev_get_drvdata(dev);
 
1251	int value;
1252
1253	asus_hwmon_pwm_show(asus, 0, &value);
 
 
1254
1255	return sprintf(buf, "%d\n", value);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1256}
1257
1258static ssize_t pwm1_store(struct device *dev,
1259				     struct device_attribute *attr,
1260				     const char *buf, size_t count) {
1261	struct asus_wmi *asus = dev_get_drvdata(dev);
1262	int value;
1263	int state;
1264	int ret;
1265
1266	ret = kstrtouint(buf, 10, &value);
1267
1268	if (ret)
1269		return ret;
1270
1271	value = clamp(value, 0, 255);
1272
1273	state = asus_hwmon_agfn_fan_speed_write(asus, 1, &value);
1274	if (state)
1275		pr_warn("Setting fan speed failed: %d\n", state);
1276	else
1277		asus->asus_hwmon_fan_manual_mode = true;
1278
1279	return count;
1280}
1281
1282static ssize_t fan1_input_show(struct device *dev,
1283					struct device_attribute *attr,
1284					char *buf)
1285{
1286	int value = asus_hwmon_fan_rpm_show(dev, 0);
 
 
 
 
 
 
 
 
 
1287
1288	return sprintf(buf, "%d\n", value < 0 ? -1 : value*100);
 
1289
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1290}
1291
1292static ssize_t pwm1_enable_show(struct device *dev,
1293						 struct device_attribute *attr,
1294						 char *buf)
1295{
1296	struct asus_wmi *asus = dev_get_drvdata(dev);
1297
1298	if (asus->asus_hwmon_fan_manual_mode)
1299		return sprintf(buf, "%d\n", ASUS_FAN_CTRL_MANUAL);
1300
1301	return sprintf(buf, "%d\n", ASUS_FAN_CTRL_AUTO);
 
 
 
 
 
 
1302}
1303
1304static ssize_t pwm1_enable_store(struct device *dev,
1305						  struct device_attribute *attr,
1306						  const char *buf, size_t count)
1307{
1308	struct asus_wmi *asus = dev_get_drvdata(dev);
1309	int status = 0;
1310	int state;
 
1311	int ret;
 
1312
1313	ret = kstrtouint(buf, 10, &state);
1314
1315	if (ret)
1316		return ret;
1317
1318	if (state == ASUS_FAN_CTRL_MANUAL)
1319		asus->asus_hwmon_fan_manual_mode = true;
1320	else
1321		status = asus_hwmon_fan_set_auto(asus);
 
 
 
 
 
 
 
1322
1323	if (status)
1324		return status;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1325
1326	return count;
1327}
1328
1329static ssize_t fan1_label_show(struct device *dev,
1330					  struct device_attribute *attr,
1331					  char *buf)
1332{
1333	return sprintf(buf, "%s\n", ASUS_FAN_DESC);
1334}
1335
1336static ssize_t asus_hwmon_temp1(struct device *dev,
1337				struct device_attribute *attr,
1338				char *buf)
1339{
1340	struct asus_wmi *asus = dev_get_drvdata(dev);
1341	u32 value;
1342	int err;
1343
1344	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_THERMAL_CTRL, &value);
1345
1346	if (err < 0)
1347		return err;
1348
1349	value = DECI_KELVIN_TO_CELSIUS((value & 0xFFFF)) * 1000;
 
 
1350
1351	return sprintf(buf, "%d\n", value);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1352}
1353
1354/* Fan1 */
1355static DEVICE_ATTR_RW(pwm1);
1356static DEVICE_ATTR_RW(pwm1_enable);
1357static DEVICE_ATTR_RO(fan1_input);
1358static DEVICE_ATTR_RO(fan1_label);
 
 
 
 
 
 
 
 
1359
1360/* Temperature */
1361static DEVICE_ATTR(temp1_input, S_IRUGO, asus_hwmon_temp1, NULL);
1362
1363static struct attribute *hwmon_attributes[] = {
1364	&dev_attr_pwm1.attr,
1365	&dev_attr_pwm1_enable.attr,
 
 
1366	&dev_attr_fan1_input.attr,
1367	&dev_attr_fan1_label.attr,
 
 
 
 
1368
1369	&dev_attr_temp1_input.attr,
1370	NULL
1371};
1372
1373static umode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
1374					  struct attribute *attr, int idx)
1375{
1376	struct device *dev = container_of(kobj, struct device, kobj);
1377	struct platform_device *pdev = to_platform_device(dev->parent);
1378	struct asus_wmi *asus = platform_get_drvdata(pdev);
1379	int dev_id = -1;
1380	int fan_attr = -1;
1381	u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
1382	bool ok = true;
1383
1384	if (attr == &dev_attr_pwm1.attr)
1385		dev_id = ASUS_WMI_DEVID_FAN_CTRL;
1386	else if (attr == &dev_attr_temp1_input.attr)
1387		dev_id = ASUS_WMI_DEVID_THERMAL_CTRL;
1388
1389
1390	if (attr == &dev_attr_fan1_input.attr
 
 
1391	    || attr == &dev_attr_fan1_label.attr
1392	    || attr == &dev_attr_pwm1.attr
1393	    || attr == &dev_attr_pwm1_enable.attr) {
1394		fan_attr = 1;
1395	}
1396
1397	if (dev_id != -1) {
1398		int err = asus_wmi_get_devstate(asus, dev_id, &value);
 
 
 
 
 
 
 
 
 
 
 
1399
1400		if (err < 0 && fan_attr == -1)
1401			return 0; /* can't return negative here */
1402	}
1403
1404	if (dev_id == ASUS_WMI_DEVID_FAN_CTRL) {
1405		/*
1406		 * We need to find a better way, probably using sfun,
1407		 * bits or spec ...
1408		 * Currently we disable it if:
1409		 * - ASUS_WMI_UNSUPPORTED_METHOD is returned
1410		 * - reverved bits are non-zero
1411		 * - sfun and presence bit are not set
1412		 */
1413		if (value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
1414		    || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)))
1415			ok = false;
1416		else
1417			ok = fan_attr <= asus->asus_hwmon_num_fans;
1418	} else if (dev_id == ASUS_WMI_DEVID_THERMAL_CTRL) {
1419		/* If value is zero, something is clearly wrong */
1420		if (!value)
1421			ok = false;
1422	} else if (fan_attr <= asus->asus_hwmon_num_fans && fan_attr != -1) {
1423		ok = true;
1424	} else {
1425		ok = false;
1426	}
1427
1428	return ok ? attr->mode : 0;
1429}
1430
1431static struct attribute_group hwmon_attribute_group = {
1432	.is_visible = asus_hwmon_sysfs_is_visible,
1433	.attrs = hwmon_attributes
1434};
1435__ATTRIBUTE_GROUPS(hwmon_attribute);
1436
1437static int asus_wmi_hwmon_init(struct asus_wmi *asus)
1438{
 
1439	struct device *hwmon;
1440
1441	hwmon = hwmon_device_register_with_groups(&asus->platform_device->dev,
1442						  "asus", asus,
1443						  hwmon_attribute_groups);
1444	if (IS_ERR(hwmon)) {
1445		pr_err("Could not register asus hwmon device\n");
1446		return PTR_ERR(hwmon);
1447	}
1448	return 0;
1449}
1450
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1451/*
1452 * Backlight
1453 */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1454static int read_backlight_power(struct asus_wmi *asus)
1455{
1456	int ret;
 
1457	if (asus->driver->quirks->store_backlight_power)
1458		ret = !asus->driver->panel_power;
1459	else
1460		ret = asus_wmi_get_devstate_simple(asus,
1461						   ASUS_WMI_DEVID_BACKLIGHT);
1462
1463	if (ret < 0)
1464		return ret;
1465
1466	return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
1467}
1468
1469static int read_brightness_max(struct asus_wmi *asus)
1470{
1471	u32 retval;
1472	int err;
1473
1474	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1475
1476	if (err < 0)
1477		return err;
1478
1479	retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
1480	retval >>= 8;
1481
1482	if (!retval)
1483		return -ENODEV;
1484
1485	return retval;
1486}
1487
1488static int read_brightness(struct backlight_device *bd)
1489{
1490	struct asus_wmi *asus = bl_get_data(bd);
1491	u32 retval;
1492	int err;
1493
1494	err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1495
1496	if (err < 0)
1497		return err;
1498
1499	return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
1500}
1501
1502static u32 get_scalar_command(struct backlight_device *bd)
1503{
1504	struct asus_wmi *asus = bl_get_data(bd);
1505	u32 ctrl_param = 0;
1506
1507	if ((asus->driver->brightness < bd->props.brightness) ||
1508	    bd->props.brightness == bd->props.max_brightness)
1509		ctrl_param = 0x00008001;
1510	else if ((asus->driver->brightness > bd->props.brightness) ||
1511		 bd->props.brightness == 0)
1512		ctrl_param = 0x00008000;
1513
1514	asus->driver->brightness = bd->props.brightness;
1515
1516	return ctrl_param;
1517}
1518
1519static int update_bl_status(struct backlight_device *bd)
1520{
1521	struct asus_wmi *asus = bl_get_data(bd);
1522	u32 ctrl_param;
1523	int power, err = 0;
1524
1525	power = read_backlight_power(asus);
1526	if (power != -ENODEV && bd->props.power != power) {
1527		ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
1528		err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
1529					    ctrl_param, NULL);
1530		if (asus->driver->quirks->store_backlight_power)
1531			asus->driver->panel_power = bd->props.power;
1532
1533		/* When using scalar brightness, updating the brightness
1534		 * will mess with the backlight power */
1535		if (asus->driver->quirks->scalar_panel_brightness)
1536			return err;
1537	}
1538
1539	if (asus->driver->quirks->scalar_panel_brightness)
1540		ctrl_param = get_scalar_command(bd);
1541	else
1542		ctrl_param = bd->props.brightness;
1543
1544	err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
1545				    ctrl_param, NULL);
1546
1547	return err;
1548}
1549
1550static const struct backlight_ops asus_wmi_bl_ops = {
1551	.get_brightness = read_brightness,
1552	.update_status = update_bl_status,
1553};
1554
1555static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
1556{
1557	struct backlight_device *bd = asus->backlight_device;
1558	int old = bd->props.brightness;
1559	int new = old;
1560
1561	if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1562		new = code - NOTIFY_BRNUP_MIN + 1;
1563	else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
1564		new = code - NOTIFY_BRNDOWN_MIN;
1565
1566	bd->props.brightness = new;
1567	backlight_update_status(bd);
1568	backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1569
1570	return old;
1571}
1572
1573static int asus_wmi_backlight_init(struct asus_wmi *asus)
1574{
1575	struct backlight_device *bd;
1576	struct backlight_properties props;
1577	int max;
1578	int power;
1579
1580	max = read_brightness_max(asus);
1581	if (max < 0)
1582		return max;
1583
1584	power = read_backlight_power(asus);
1585
1586	if (power == -ENODEV)
1587		power = FB_BLANK_UNBLANK;
1588	else if (power < 0)
1589		return power;
1590
1591	memset(&props, 0, sizeof(struct backlight_properties));
1592	props.type = BACKLIGHT_PLATFORM;
1593	props.max_brightness = max;
1594	bd = backlight_device_register(asus->driver->name,
1595				       &asus->platform_device->dev, asus,
1596				       &asus_wmi_bl_ops, &props);
1597	if (IS_ERR(bd)) {
1598		pr_err("Could not register backlight device\n");
1599		return PTR_ERR(bd);
1600	}
1601
1602	asus->backlight_device = bd;
1603
1604	if (asus->driver->quirks->store_backlight_power)
1605		asus->driver->panel_power = power;
1606
1607	bd->props.brightness = read_brightness(bd);
1608	bd->props.power = power;
1609	backlight_update_status(bd);
1610
1611	asus->driver->brightness = bd->props.brightness;
1612
1613	return 0;
1614}
1615
1616static void asus_wmi_backlight_exit(struct asus_wmi *asus)
1617{
1618	backlight_device_unregister(asus->backlight_device);
1619
1620	asus->backlight_device = NULL;
1621}
1622
1623static int is_display_toggle(int code)
1624{
1625	/* display toggle keys */
1626	if ((code >= 0x61 && code <= 0x67) ||
1627	    (code >= 0x8c && code <= 0x93) ||
1628	    (code >= 0xa0 && code <= 0xa7) ||
1629	    (code >= 0xd0 && code <= 0xd5))
1630		return 1;
1631
1632	return 0;
1633}
1634
1635static void asus_wmi_notify(u32 value, void *context)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1636{
1637	struct asus_wmi *asus = context;
1638	struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
1639	union acpi_object *obj;
1640	acpi_status status;
1641	int code;
1642	int orig_code;
1643	unsigned int key_value = 1;
1644	bool autorelease = 1;
1645
1646	status = wmi_get_event_data(value, &response);
1647	if (status != AE_OK) {
1648		pr_err("bad event status 0x%x\n", status);
1649		return;
 
1650	}
1651
1652	obj = (union acpi_object *)response.pointer;
1653
1654	if (!obj || obj->type != ACPI_TYPE_INTEGER)
1655		goto exit;
 
 
 
 
 
 
1656
1657	code = obj->integer.value;
1658	orig_code = code;
 
 
1659
1660	if (asus->driver->key_filter) {
1661		asus->driver->key_filter(asus->driver, &code, &key_value,
1662					 &autorelease);
1663		if (code == ASUS_WMI_KEY_IGNORE)
1664			goto exit;
1665	}
1666
1667	if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1668		code = ASUS_WMI_BRN_UP;
1669	else if (code >= NOTIFY_BRNDOWN_MIN &&
1670		 code <= NOTIFY_BRNDOWN_MAX)
1671		code = ASUS_WMI_BRN_DOWN;
1672
1673	if (code == ASUS_WMI_BRN_DOWN || code == ASUS_WMI_BRN_UP) {
1674		if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
1675			asus_wmi_backlight_notify(asus, orig_code);
1676			goto exit;
1677		}
1678	}
1679
1680	if (is_display_toggle(code) &&
1681	    asus->driver->quirks->no_display_toggle)
1682		goto exit;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1683
1684	if (!sparse_keymap_report_event(asus->inputdev, code,
1685					key_value, autorelease))
1686		pr_info("Unknown key %x pressed\n", code);
1687
1688exit:
1689	kfree(obj);
1690}
1691
1692/*
1693 * Sys helpers
1694 */
1695static int parse_arg(const char *buf, unsigned long count, int *val)
1696{
1697	if (!count)
1698		return 0;
1699	if (sscanf(buf, "%i", val) != 1)
1700		return -EINVAL;
1701	return count;
 
 
 
 
1702}
1703
 
 
1704static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
1705			     const char *buf, size_t count)
1706{
1707	u32 retval;
1708	int rv, err, value;
1709
1710	value = asus_wmi_get_devstate_simple(asus, devid);
1711	if (value < 0)
1712		return value;
1713
1714	rv = parse_arg(buf, count, &value);
1715	err = asus_wmi_set_devstate(devid, value, &retval);
 
1716
 
1717	if (err < 0)
1718		return err;
1719
1720	return rv;
1721}
1722
1723static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
1724{
1725	int value = asus_wmi_get_devstate_simple(asus, devid);
1726
1727	if (value < 0)
1728		return value;
1729
1730	return sprintf(buf, "%d\n", value);
1731}
1732
1733#define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm)			\
1734	static ssize_t show_##_name(struct device *dev,			\
1735				    struct device_attribute *attr,	\
1736				    char *buf)				\
1737	{								\
1738		struct asus_wmi *asus = dev_get_drvdata(dev);		\
1739									\
1740		return show_sys_wmi(asus, _cm, buf);			\
1741	}								\
1742	static ssize_t store_##_name(struct device *dev,		\
1743				     struct device_attribute *attr,	\
1744				     const char *buf, size_t count)	\
1745	{								\
1746		struct asus_wmi *asus = dev_get_drvdata(dev);		\
1747									\
1748		return store_sys_wmi(asus, _cm, buf, count);		\
1749	}								\
1750	static struct device_attribute dev_attr_##_name = {		\
1751		.attr = {						\
1752			.name = __stringify(_name),			\
1753			.mode = _mode },				\
1754		.show   = show_##_name,					\
1755		.store  = store_##_name,				\
1756	}
1757
1758ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
1759ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
1760ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
1761ASUS_WMI_CREATE_DEVICE_ATTR(lid_resume, 0644, ASUS_WMI_DEVID_LID_RESUME);
1762ASUS_WMI_CREATE_DEVICE_ATTR(als_enable, 0644, ASUS_WMI_DEVID_ALS_ENABLE);
1763
1764static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
1765			   const char *buf, size_t count)
1766{
1767	int value, rv;
1768
1769	if (!count || sscanf(buf, "%i", &value) != 1)
1770		return -EINVAL;
 
 
1771	if (value < 0 || value > 2)
1772		return -EINVAL;
1773
1774	rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
1775	if (rv < 0)
1776		return rv;
1777
1778	return count;
1779}
1780
1781static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
1782
1783static struct attribute *platform_attributes[] = {
1784	&dev_attr_cpufv.attr,
1785	&dev_attr_camera.attr,
1786	&dev_attr_cardr.attr,
1787	&dev_attr_touchpad.attr,
 
 
 
 
 
1788	&dev_attr_lid_resume.attr,
1789	&dev_attr_als_enable.attr,
 
 
 
 
 
 
 
 
 
 
 
1790	NULL
1791};
1792
1793static umode_t asus_sysfs_is_visible(struct kobject *kobj,
1794				    struct attribute *attr, int idx)
1795{
1796	struct device *dev = container_of(kobj, struct device, kobj);
1797	struct platform_device *pdev = to_platform_device(dev);
1798	struct asus_wmi *asus = platform_get_drvdata(pdev);
1799	bool ok = true;
1800	int devid = -1;
1801
1802	if (attr == &dev_attr_camera.attr)
1803		devid = ASUS_WMI_DEVID_CAMERA;
1804	else if (attr == &dev_attr_cardr.attr)
1805		devid = ASUS_WMI_DEVID_CARDREADER;
1806	else if (attr == &dev_attr_touchpad.attr)
1807		devid = ASUS_WMI_DEVID_TOUCHPAD;
1808	else if (attr == &dev_attr_lid_resume.attr)
1809		devid = ASUS_WMI_DEVID_LID_RESUME;
1810	else if (attr == &dev_attr_als_enable.attr)
1811		devid = ASUS_WMI_DEVID_ALS_ENABLE;
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1812
1813	if (devid != -1)
1814		ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
1815
1816	return ok ? attr->mode : 0;
1817}
1818
1819static struct attribute_group platform_attribute_group = {
1820	.is_visible = asus_sysfs_is_visible,
1821	.attrs = platform_attributes
1822};
1823
1824static void asus_wmi_sysfs_exit(struct platform_device *device)
1825{
1826	sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
1827}
1828
1829static int asus_wmi_sysfs_init(struct platform_device *device)
1830{
1831	return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
1832}
1833
1834/*
1835 * Platform device
1836 */
1837static int asus_wmi_platform_init(struct asus_wmi *asus)
1838{
 
 
1839	int rv;
1840
1841	/* INIT enable hotkeys on some models */
1842	if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
1843		pr_info("Initialization: %#x\n", rv);
1844
1845	/* We don't know yet what to do with this version... */
1846	if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
1847		pr_info("BIOS WMI version: %d.%d\n", rv >> 16, rv & 0xFF);
1848		asus->spec = rv;
1849	}
1850
1851	/*
1852	 * The SFUN method probably allows the original driver to get the list
1853	 * of features supported by a given model. For now, 0x0100 or 0x0800
1854	 * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
1855	 * The significance of others is yet to be found.
1856	 */
1857	if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
1858		pr_info("SFUN value: %#x\n", rv);
1859		asus->sfun = rv;
1860	}
1861
1862	/*
1863	 * Eee PC and Notebooks seems to have different method_id for DSTS,
1864	 * but it may also be related to the BIOS's SPEC.
1865	 * Note, on most Eeepc, there is no way to check if a method exist
1866	 * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
1867	 * but once again, SPEC may probably be used for that kind of things.
 
 
 
 
 
 
1868	 */
1869	if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, 0, 0, NULL))
 
 
 
 
 
 
 
 
1870		asus->dsts_id = ASUS_WMI_METHODID_DSTS;
1871	else
1872		asus->dsts_id = ASUS_WMI_METHODID_DSTS2;
1873
1874	/* CWAP allow to define the behavior of the Fn+F2 key,
1875	 * this method doesn't seems to be present on Eee PCs */
1876	if (asus->driver->quirks->wapf >= 0)
1877		asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP,
1878				      asus->driver->quirks->wapf, NULL);
1879
1880	return asus_wmi_sysfs_init(asus->platform_device);
1881}
1882
1883static void asus_wmi_platform_exit(struct asus_wmi *asus)
1884{
1885	asus_wmi_sysfs_exit(asus->platform_device);
1886}
1887
1888/*
1889 * debugfs
1890 */
1891struct asus_wmi_debugfs_node {
1892	struct asus_wmi *asus;
1893	char *name;
1894	int (*show) (struct seq_file *m, void *data);
1895};
1896
1897static int show_dsts(struct seq_file *m, void *data)
1898{
1899	struct asus_wmi *asus = m->private;
1900	int err;
1901	u32 retval = -1;
1902
1903	err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
1904
1905	if (err < 0)
1906		return err;
1907
1908	seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
1909
1910	return 0;
1911}
1912
1913static int show_devs(struct seq_file *m, void *data)
1914{
1915	struct asus_wmi *asus = m->private;
1916	int err;
1917	u32 retval = -1;
1918
1919	err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
1920				    &retval);
1921
1922	if (err < 0)
1923		return err;
1924
1925	seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
1926		   asus->debug.ctrl_param, retval);
1927
1928	return 0;
1929}
1930
1931static int show_call(struct seq_file *m, void *data)
1932{
1933	struct asus_wmi *asus = m->private;
1934	struct bios_args args = {
1935		.arg0 = asus->debug.dev_id,
1936		.arg1 = asus->debug.ctrl_param,
1937	};
1938	struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1939	struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
1940	union acpi_object *obj;
1941	acpi_status status;
1942
1943	status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
1944				     1, asus->debug.method_id,
1945				     &input, &output);
1946
1947	if (ACPI_FAILURE(status))
1948		return -EIO;
1949
1950	obj = (union acpi_object *)output.pointer;
1951	if (obj && obj->type == ACPI_TYPE_INTEGER)
1952		seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
1953			   asus->debug.dev_id, asus->debug.ctrl_param,
1954			   (u32) obj->integer.value);
1955	else
1956		seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
1957			   asus->debug.dev_id, asus->debug.ctrl_param,
1958			   obj ? obj->type : -1);
1959
1960	kfree(obj);
1961
1962	return 0;
1963}
1964
1965static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
1966	{NULL, "devs", show_devs},
1967	{NULL, "dsts", show_dsts},
1968	{NULL, "call", show_call},
1969};
1970
1971static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
1972{
1973	struct asus_wmi_debugfs_node *node = inode->i_private;
1974
1975	return single_open(file, node->show, node->asus);
1976}
1977
1978static const struct file_operations asus_wmi_debugfs_io_ops = {
1979	.owner = THIS_MODULE,
1980	.open = asus_wmi_debugfs_open,
1981	.read = seq_read,
1982	.llseek = seq_lseek,
1983	.release = single_release,
1984};
1985
1986static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
1987{
1988	debugfs_remove_recursive(asus->debug.root);
1989}
1990
1991static int asus_wmi_debugfs_init(struct asus_wmi *asus)
1992{
1993	struct dentry *dent;
1994	int i;
1995
1996	asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
1997	if (!asus->debug.root) {
1998		pr_err("failed to create debugfs directory\n");
1999		goto error_debugfs;
2000	}
2001
2002	dent = debugfs_create_x32("method_id", S_IRUGO | S_IWUSR,
2003				  asus->debug.root, &asus->debug.method_id);
2004	if (!dent)
2005		goto error_debugfs;
2006
2007	dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
2008				  asus->debug.root, &asus->debug.dev_id);
2009	if (!dent)
2010		goto error_debugfs;
2011
2012	dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR,
2013				  asus->debug.root, &asus->debug.ctrl_param);
2014	if (!dent)
2015		goto error_debugfs;
2016
2017	for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
2018		struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
2019
2020		node->asus = asus;
2021		dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
2022					   asus->debug.root, node,
2023					   &asus_wmi_debugfs_io_ops);
2024		if (!dent) {
2025			pr_err("failed to create debug file: %s\n", node->name);
2026			goto error_debugfs;
2027		}
2028	}
2029
2030	return 0;
 
2031
2032error_debugfs:
2033	asus_wmi_debugfs_exit(asus);
2034	return -ENOMEM;
2035}
2036
2037static int asus_wmi_fan_init(struct asus_wmi *asus)
2038{
2039	int status;
2040
2041	asus->asus_hwmon_pwm = -1;
2042	asus->asus_hwmon_num_fans = -1;
2043	asus->asus_hwmon_fan_manual_mode = false;
2044
2045	status = asus_hwmon_get_fan_number(asus, &asus->asus_hwmon_num_fans);
2046	if (status) {
2047		asus->asus_hwmon_num_fans = 0;
2048		pr_warn("Could not determine number of fans: %d\n", status);
2049		return -ENXIO;
2050	}
2051
2052	pr_info("Number of fans: %d\n", asus->asus_hwmon_num_fans);
2053	return 0;
2054}
2055
2056static bool ashs_present(void)
2057{
2058	int i = 0;
2059	while (ashs_ids[i]) {
2060		if (acpi_dev_found(ashs_ids[i++]))
2061			return true;
2062	}
2063	return false;
2064}
2065
2066/*
2067 * WMI Driver
2068 */
2069static int asus_wmi_add(struct platform_device *pdev)
2070{
2071	struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
2072	struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
2073	struct asus_wmi *asus;
2074	const char *chassis_type;
2075	acpi_status status;
2076	int err;
2077	u32 result;
2078
2079	asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
2080	if (!asus)
2081		return -ENOMEM;
2082
2083	asus->driver = wdrv;
2084	asus->platform_device = pdev;
2085	wdrv->platform_device = pdev;
2086	platform_set_drvdata(asus->platform_device, asus);
2087
2088	if (wdrv->detect_quirks)
2089		wdrv->detect_quirks(asus->driver);
2090
2091	err = asus_wmi_platform_init(asus);
2092	if (err)
2093		goto fail_platform;
2094
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2095	err = asus_wmi_input_init(asus);
2096	if (err)
2097		goto fail_input;
2098
2099	err = asus_wmi_fan_init(asus); /* probably no problems on error */
2100	asus_hwmon_fan_set_auto(asus);
2101
2102	err = asus_wmi_hwmon_init(asus);
2103	if (err)
2104		goto fail_hwmon;
2105
 
 
 
 
2106	err = asus_wmi_led_init(asus);
2107	if (err)
2108		goto fail_leds;
2109
2110	asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result);
2111	if (result & (ASUS_WMI_DSTS_PRESENCE_BIT | ASUS_WMI_DSTS_USER_BIT))
2112		asus->driver->wlan_ctrl_by_user = 1;
2113
2114	if (asus->driver->wlan_ctrl_by_user && ashs_present())
2115		asus->driver->quirks->no_rfkill = 1;
2116
2117	if (!asus->driver->quirks->no_rfkill) {
2118		err = asus_wmi_rfkill_init(asus);
2119		if (err)
2120			goto fail_rfkill;
2121	}
2122
2123	/* Some Asus desktop boards export an acpi-video backlight interface,
2124	   stop this from showing up */
2125	chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE);
2126	if (chassis_type && !strcmp(chassis_type, "3"))
2127		acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
2128
2129	if (asus->driver->quirks->wmi_backlight_power)
2130		acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
2131
2132	if (asus->driver->quirks->wmi_backlight_native)
2133		acpi_video_set_dmi_backlight_type(acpi_backlight_native);
2134
2135	if (asus->driver->quirks->xusb2pr)
2136		asus_wmi_set_xusb2pr(asus);
2137
2138	if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
2139		err = asus_wmi_backlight_init(asus);
2140		if (err && err != -ENODEV)
2141			goto fail_backlight;
 
 
 
 
 
 
 
 
 
 
 
 
2142	}
2143
2144	status = wmi_install_notify_handler(asus->driver->event_guid,
2145					    asus_wmi_notify, asus);
2146	if (ACPI_FAILURE(status)) {
2147		pr_err("Unable to register notify handler - %d\n", status);
2148		err = -ENODEV;
2149		goto fail_wmi_handler;
2150	}
2151
2152	err = asus_wmi_debugfs_init(asus);
2153	if (err)
2154		goto fail_debugfs;
 
 
 
 
 
 
2155
2156	return 0;
2157
2158fail_debugfs:
2159	wmi_remove_notify_handler(asus->driver->event_guid);
2160fail_wmi_handler:
2161	asus_wmi_backlight_exit(asus);
2162fail_backlight:
2163	asus_wmi_rfkill_exit(asus);
 
 
2164fail_rfkill:
2165	asus_wmi_led_exit(asus);
2166fail_leds:
2167fail_hwmon:
2168	asus_wmi_input_exit(asus);
2169fail_input:
2170	asus_wmi_platform_exit(asus);
 
 
 
 
 
 
 
2171fail_platform:
2172	kfree(asus);
2173	return err;
2174}
2175
2176static int asus_wmi_remove(struct platform_device *device)
2177{
2178	struct asus_wmi *asus;
2179
2180	asus = platform_get_drvdata(device);
 
 
2181	wmi_remove_notify_handler(asus->driver->event_guid);
2182	asus_wmi_backlight_exit(asus);
 
2183	asus_wmi_input_exit(asus);
2184	asus_wmi_led_exit(asus);
2185	asus_wmi_rfkill_exit(asus);
2186	asus_wmi_debugfs_exit(asus);
2187	asus_wmi_platform_exit(asus);
2188	asus_hwmon_fan_set_auto(asus);
 
 
 
 
 
2189
2190	kfree(asus);
2191	return 0;
2192}
2193
2194/*
2195 * Platform driver - hibernate/resume callbacks
2196 */
2197static int asus_hotk_thaw(struct device *device)
2198{
2199	struct asus_wmi *asus = dev_get_drvdata(device);
2200
2201	if (asus->wlan.rfkill) {
2202		bool wlan;
2203
2204		/*
2205		 * Work around bios bug - acpi _PTS turns off the wireless led
2206		 * during suspend.  Normally it restores it on resume, but
2207		 * we should kick it ourselves in case hibernation is aborted.
2208		 */
2209		wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
2210		asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
2211	}
2212
2213	return 0;
2214}
2215
2216static int asus_hotk_resume(struct device *device)
2217{
2218	struct asus_wmi *asus = dev_get_drvdata(device);
2219
2220	if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
2221		queue_work(asus->led_workqueue, &asus->kbd_led_work);
 
 
 
 
 
2222
2223	return 0;
2224}
2225
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2226static int asus_hotk_restore(struct device *device)
2227{
2228	struct asus_wmi *asus = dev_get_drvdata(device);
2229	int bl;
2230
2231	/* Refresh both wlan rfkill state and pci hotplug */
2232	if (asus->wlan.rfkill)
2233		asus_rfkill_hotplug(asus);
2234
2235	if (asus->bluetooth.rfkill) {
2236		bl = !asus_wmi_get_devstate_simple(asus,
2237						   ASUS_WMI_DEVID_BLUETOOTH);
2238		rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
2239	}
2240	if (asus->wimax.rfkill) {
2241		bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
2242		rfkill_set_sw_state(asus->wimax.rfkill, bl);
2243	}
2244	if (asus->wwan3g.rfkill) {
2245		bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
2246		rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
2247	}
2248	if (asus->gps.rfkill) {
2249		bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS);
2250		rfkill_set_sw_state(asus->gps.rfkill, bl);
2251	}
2252	if (asus->uwb.rfkill) {
2253		bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB);
2254		rfkill_set_sw_state(asus->uwb.rfkill, bl);
2255	}
2256	if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
2257		queue_work(asus->led_workqueue, &asus->kbd_led_work);
 
 
 
2258
 
2259	return 0;
2260}
2261
2262static const struct dev_pm_ops asus_pm_ops = {
2263	.thaw = asus_hotk_thaw,
2264	.restore = asus_hotk_restore,
2265	.resume = asus_hotk_resume,
 
 
2266};
2267
 
 
2268static int asus_wmi_probe(struct platform_device *pdev)
2269{
2270	struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
2271	struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
2272	int ret;
2273
2274	if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
2275		pr_warn("Management GUID not found\n");
2276		return -ENODEV;
2277	}
2278
2279	if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
2280		pr_warn("Event GUID not found\n");
2281		return -ENODEV;
2282	}
2283
2284	if (wdrv->probe) {
2285		ret = wdrv->probe(pdev);
2286		if (ret)
2287			return ret;
2288	}
2289
2290	return asus_wmi_add(pdev);
2291}
2292
2293static bool used;
2294
2295int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
2296{
2297	struct platform_driver *platform_driver;
2298	struct platform_device *platform_device;
2299
2300	if (used)
2301		return -EBUSY;
2302
2303	platform_driver = &driver->platform_driver;
2304	platform_driver->remove = asus_wmi_remove;
2305	platform_driver->driver.owner = driver->owner;
2306	platform_driver->driver.name = driver->name;
2307	platform_driver->driver.pm = &asus_pm_ops;
2308
2309	platform_device = platform_create_bundle(platform_driver,
2310						 asus_wmi_probe,
2311						 NULL, 0, NULL, 0);
2312	if (IS_ERR(platform_device))
2313		return PTR_ERR(platform_device);
2314
2315	used = true;
2316	return 0;
2317}
2318EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
2319
2320void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
2321{
2322	platform_device_unregister(driver->platform_device);
2323	platform_driver_unregister(&driver->platform_driver);
2324	used = false;
2325}
2326EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
2327
2328static int __init asus_wmi_init(void)
2329{
2330	if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
2331		pr_info("Asus Management GUID not found\n");
2332		return -ENODEV;
2333	}
2334
2335	pr_info("ASUS WMI generic driver loaded\n");
2336	return 0;
2337}
2338
2339static void __exit asus_wmi_exit(void)
2340{
2341	pr_info("ASUS WMI generic driver unloaded\n");
2342}
2343
2344module_init(asus_wmi_init);
2345module_exit(asus_wmi_exit);