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