drivers/platform/x86/asus-wmi.c

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