drivers/platform/x86/asus-wmi.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Asus PC WMI hotkey driver
   4  *
   5  * Copyright(C) 2010 Intel Corporation.
   6  * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
   7  *
   8  * Portions based on wistron_btns.c:
   9  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
  10  * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
  11  * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
  12  */
  13
  14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  15
  16 #include <linux/kernel.h>
  17 #include <linux/module.h>
  18 #include <linux/init.h>
  19 #include <linux/types.h>
  20 #include <linux/slab.h>
  21 #include <linux/input.h>
  22 #include <linux/input/sparse-keymap.h>
  23 #include <linux/fb.h>
  24 #include <linux/backlight.h>
  25 #include <linux/leds.h>
  26 #include <linux/rfkill.h>
  27 #include <linux/pci.h>
  28 #include <linux/pci_hotplug.h>
  29 #include <linux/power_supply.h>
  30 #include <linux/hwmon.h>
  31 #include <linux/hwmon-sysfs.h>
  32 #include <linux/debugfs.h>
  33 #include <linux/seq_file.h>
  34 #include <linux/platform_data/x86/asus-wmi.h>
  35 #include <linux/platform_device.h>
  36 #include <linux/acpi.h>
  37 #include <linux/dmi.h>
  38 #include <linux/units.h>
  39
  40 #include <acpi/battery.h>
  41 #include <acpi/video.h>
  42
  43 #include "asus-wmi.h"
  44
  45 MODULE_AUTHOR("Corentin Chary <corentin.chary@gmail.com>, "
  46               "Yong Wang <yong.y.wang@intel.com>");
  47 MODULE_DESCRIPTION("Asus Generic WMI Driver");
  48 MODULE_LICENSE("GPL");
  49
  50 #define to_asus_wmi_driver(pdrv)                                        \
  51         (container_of((pdrv), struct asus_wmi_driver, platform_driver))
  52
  53 #define ASUS_WMI_MGMT_GUID      "97845ED0-4E6D-11DE-8A39-0800200C9A66"
  54
  55 #define NOTIFY_BRNUP_MIN                0x11
  56 #define NOTIFY_BRNUP_MAX                0x1f
  57 #define NOTIFY_BRNDOWN_MIN              0x20
  58 #define NOTIFY_BRNDOWN_MAX              0x2e
  59 #define NOTIFY_FNLOCK_TOGGLE            0x4e
  60 #define NOTIFY_KBD_DOCK_CHANGE          0x75
  61 #define NOTIFY_KBD_BRTUP                0xc4
  62 #define NOTIFY_KBD_BRTDWN               0xc5
  63 #define NOTIFY_KBD_BRTTOGGLE            0xc7
  64 #define NOTIFY_KBD_FBM                  0x99
  65 #define NOTIFY_KBD_TTP                  0xae
  66 #define NOTIFY_LID_FLIP                 0xfa
  67
  68 #define ASUS_WMI_FNLOCK_BIOS_DISABLED   BIT(0)
  69
  70 #define ASUS_FAN_DESC                   "cpu_fan"
  71 #define ASUS_FAN_MFUN                   0x13
  72 #define ASUS_FAN_SFUN_READ              0x06
  73 #define ASUS_FAN_SFUN_WRITE             0x07
  74
  75 /* Based on standard hwmon pwmX_enable values */
  76 #define ASUS_FAN_CTRL_FULLSPEED         0
  77 #define ASUS_FAN_CTRL_MANUAL            1
  78 #define ASUS_FAN_CTRL_AUTO              2
  79
  80 #define ASUS_FAN_BOOST_MODE_NORMAL              0
  81 #define ASUS_FAN_BOOST_MODE_OVERBOOST           1
  82 #define ASUS_FAN_BOOST_MODE_OVERBOOST_MASK      0x01
  83 #define ASUS_FAN_BOOST_MODE_SILENT              2
  84 #define ASUS_FAN_BOOST_MODE_SILENT_MASK         0x02
  85 #define ASUS_FAN_BOOST_MODES_MASK               0x03
  86
  87 #define ASUS_THROTTLE_THERMAL_POLICY_DEFAULT    0
  88 #define ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST  1
  89 #define ASUS_THROTTLE_THERMAL_POLICY_SILENT     2
  90
  91 #define USB_INTEL_XUSB2PR               0xD0
  92 #define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI   0x9c31
  93
  94 #define ASUS_ACPI_UID_ASUSWMI           "ASUSWMI"
  95 #define ASUS_ACPI_UID_ATK               "ATK"
  96
  97 #define WMI_EVENT_QUEUE_SIZE            0x10
  98 #define WMI_EVENT_QUEUE_END             0x1
  99 #define WMI_EVENT_MASK                  0xFFFF
 100 /* The WMI hotkey event value is always the same. */
 101 #define WMI_EVENT_VALUE_ATK             0xFF
 102
 103 #define WMI_EVENT_MASK                  0xFFFF
 104
 105 static const char * const ashs_ids[] = { "ATK4001", "ATK4002", NULL };
 106
 107 static bool ashs_present(void)
 108 {
 109         int i = 0;
 110         while (ashs_ids[i]) {
 111                 if (acpi_dev_found(ashs_ids[i++]))
 112                         return true;
 113         }
 114         return false;
 115 }
 116
 117 struct bios_args {
 118         u32 arg0;
 119         u32 arg1;
 120         u32 arg2; /* At least TUF Gaming series uses 3 dword input buffer. */
 121         u32 arg4;
 122         u32 arg5;
 123 } __packed;
 124
 125 /*
 126  * Struct that's used for all methods called via AGFN. Naming is
 127  * identically to the AML code.
 128  */
 129 struct agfn_args {
 130         u16 mfun; /* probably "Multi-function" to be called */
 131         u16 sfun; /* probably "Sub-function" to be called */
 132         u16 len;  /* size of the hole struct, including subfunction fields */
 133         u8 stas;  /* not used by now */
 134         u8 err;   /* zero on success */
 135 } __packed;
 136
 137 /* struct used for calling fan read and write methods */
 138 struct agfn_fan_args {
 139         struct agfn_args agfn;  /* common fields */
 140         u8 fan;                 /* fan number: 0: set auto mode 1: 1st fan */
 141         u32 speed;              /* read: RPM/100 - write: 0-255 */
 142 } __packed;
 143
 144 /*
 145  * <platform>/    - debugfs root directory
 146  *   dev_id      - current dev_id
 147  *   ctrl_param  - current ctrl_param
 148  *   method_id   - current method_id
 149  *   devs        - call DEVS(dev_id, ctrl_param) and print result
 150  *   dsts        - call DSTS(dev_id)  and print result
 151  *   call        - call method_id(dev_id, ctrl_param) and print result
 152  */
 153 struct asus_wmi_debug {
 154         struct dentry *root;
 155         u32 method_id;
 156         u32 dev_id;
 157         u32 ctrl_param;
 158 };
 159
 160 struct asus_rfkill {
 161         struct asus_wmi *asus;
 162         struct rfkill *rfkill;
 163         u32 dev_id;
 164 };
 165
 166 enum fan_type {
 167         FAN_TYPE_NONE = 0,
 168         FAN_TYPE_AGFN,          /* deprecated on newer platforms */
 169         FAN_TYPE_SPEC83,        /* starting in Spec 8.3, use CPU_FAN_CTRL */
 170 };
 171
 172 struct asus_wmi {
 173         int dsts_id;
 174         int spec;
 175         int sfun;
 176         bool wmi_event_queue;
 177
 178         struct input_dev *inputdev;
 179         struct backlight_device *backlight_device;
 180         struct platform_device *platform_device;
 181
 182         struct led_classdev wlan_led;
 183         int wlan_led_wk;
 184         struct led_classdev tpd_led;
 185         int tpd_led_wk;
 186         struct led_classdev kbd_led;
 187         int kbd_led_wk;
 188         struct led_classdev lightbar_led;
 189         int lightbar_led_wk;
 190         struct workqueue_struct *led_workqueue;
 191         struct work_struct tpd_led_work;
 192         struct work_struct wlan_led_work;
 193         struct work_struct lightbar_led_work;
 194
 195         struct asus_rfkill wlan;
 196         struct asus_rfkill bluetooth;
 197         struct asus_rfkill wimax;
 198         struct asus_rfkill wwan3g;
 199         struct asus_rfkill gps;
 200         struct asus_rfkill uwb;
 201
 202         enum fan_type fan_type;
 203         int fan_pwm_mode;
 204         int agfn_pwm;
 205
 206         bool fan_boost_mode_available;
 207         u8 fan_boost_mode_mask;
 208         u8 fan_boost_mode;
 209
 210         bool throttle_thermal_policy_available;
 211         u8 throttle_thermal_policy_mode;
 212
 213         // The RSOC controls the maximum charging percentage.
 214         bool battery_rsoc_available;
 215
 216         struct hotplug_slot hotplug_slot;
 217         struct mutex hotplug_lock;
 218         struct mutex wmi_lock;
 219         struct workqueue_struct *hotplug_workqueue;
 220         struct work_struct hotplug_work;
 221
 222         bool fnlock_locked;
 223
 224         struct asus_wmi_debug debug;
 225
 226         struct asus_wmi_driver *driver;
 227 };
 228
 229 /* WMI ************************************************************************/
 230
 231 static int asus_wmi_evaluate_method3(u32 method_id,
 232                 u32 arg0, u32 arg1, u32 arg2, u32 *retval)
 233 {
 234         struct bios_args args = {
 235                 .arg0 = arg0,
 236                 .arg1 = arg1,
 237                 .arg2 = arg2,
 238         };
 239         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
 240         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
 241         acpi_status status;
 242         union acpi_object *obj;
 243         u32 tmp = 0;
 244
 245         status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
 246                                      &input, &output);
 247
 248         if (ACPI_FAILURE(status))
 249                 return -EIO;
 250
 251         obj = (union acpi_object *)output.pointer;
 252         if (obj && obj->type == ACPI_TYPE_INTEGER)
 253                 tmp = (u32) obj->integer.value;
 254
 255         if (retval)
 256                 *retval = tmp;
 257
 258         kfree(obj);
 259
 260         if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
 261                 return -ENODEV;
 262
 263         return 0;
 264 }
 265
 266 int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1, u32 *retval)
 267 {
 268         return asus_wmi_evaluate_method3(method_id, arg0, arg1, 0, retval);
 269 }
 270 EXPORT_SYMBOL_GPL(asus_wmi_evaluate_method);
 271
 272 static int asus_wmi_evaluate_method_agfn(const struct acpi_buffer args)
 273 {
 274         struct acpi_buffer input;
 275         u64 phys_addr;
 276         u32 retval;
 277         u32 status;
 278
 279         /*
 280          * Copy to dma capable address otherwise memory corruption occurs as
 281          * bios has to be able to access it.
 282          */
 283         input.pointer = kmemdup(args.pointer, args.length, GFP_DMA | GFP_KERNEL);
 284         input.length = args.length;
 285         if (!input.pointer)
 286                 return -ENOMEM;
 287         phys_addr = virt_to_phys(input.pointer);
 288
 289         status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_AGFN,
 290                                         phys_addr, 0, &retval);
 291         if (!status)
 292                 memcpy(args.pointer, input.pointer, args.length);
 293
 294         kfree(input.pointer);
 295         if (status)
 296                 return -ENXIO;
 297
 298         return retval;
 299 }
 300
 301 static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
 302 {
 303         return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
 304 }
 305
 306 static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
 307                                  u32 *retval)
 308 {
 309         return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
 310                                         ctrl_param, retval);
 311 }
 312
 313 /* Helper for special devices with magic return codes */
 314 static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
 315                                       u32 dev_id, u32 mask)
 316 {
 317         u32 retval = 0;
 318         int err;
 319
 320         err = asus_wmi_get_devstate(asus, dev_id, &retval);
 321         if (err < 0)
 322                 return err;
 323
 324         if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
 325                 return -ENODEV;
 326
 327         if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
 328                 if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
 329                         return -ENODEV;
 330         }
 331
 332         return retval & mask;
 333 }
 334
 335 static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
 336 {
 337         return asus_wmi_get_devstate_bits(asus, dev_id,
 338                                           ASUS_WMI_DSTS_STATUS_BIT);
 339 }
 340
 341 static bool asus_wmi_dev_is_present(struct asus_wmi *asus, u32 dev_id)
 342 {
 343         u32 retval;
 344         int status = asus_wmi_get_devstate(asus, dev_id, &retval);
 345
 346         return status == 0 && (retval & ASUS_WMI_DSTS_PRESENCE_BIT);
 347 }
 348
 349 /* Input **********************************************************************/
 350
 351 static int asus_wmi_input_init(struct asus_wmi *asus)
 352 {
 353         int err, result;
 354
 355         asus->inputdev = input_allocate_device();
 356         if (!asus->inputdev)
 357                 return -ENOMEM;
 358
 359         asus->inputdev->name = asus->driver->input_name;
 360         asus->inputdev->phys = asus->driver->input_phys;
 361         asus->inputdev->id.bustype = BUS_HOST;
 362         asus->inputdev->dev.parent = &asus->platform_device->dev;
 363         set_bit(EV_REP, asus->inputdev->evbit);
 364
 365         err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
 366         if (err)
 367                 goto err_free_dev;
 368
 369         if (asus->driver->quirks->use_kbd_dock_devid) {
 370                 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_KBD_DOCK);
 371                 if (result >= 0) {
 372                         input_set_capability(asus->inputdev, EV_SW, SW_TABLET_MODE);
 373                         input_report_switch(asus->inputdev, SW_TABLET_MODE, !result);
 374                 } else if (result != -ENODEV) {
 375                         pr_err("Error checking for keyboard-dock: %d\n", result);
 376                 }
 377         }
 378
 379         if (asus->driver->quirks->use_lid_flip_devid) {
 380                 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_LID_FLIP);
 381                 if (result < 0)
 382                         asus->driver->quirks->use_lid_flip_devid = 0;
 383                 if (result >= 0) {
 384                         input_set_capability(asus->inputdev, EV_SW, SW_TABLET_MODE);
 385                         input_report_switch(asus->inputdev, SW_TABLET_MODE, result);
 386                 } else if (result == -ENODEV) {
 387                         pr_err("This device has lid_flip quirk but got ENODEV checking it. This is a bug.");
 388                 } else {
 389                         pr_err("Error checking for lid-flip: %d\n", result);
 390                 }
 391         }
 392
 393         err = input_register_device(asus->inputdev);
 394         if (err)
 395                 goto err_free_dev;
 396
 397         return 0;
 398
 399 err_free_dev:
 400         input_free_device(asus->inputdev);
 401         return err;
 402 }
 403
 404 static void asus_wmi_input_exit(struct asus_wmi *asus)
 405 {
 406         if (asus->inputdev)
 407                 input_unregister_device(asus->inputdev);
 408
 409         asus->inputdev = NULL;
 410 }
 411
 412 /* Tablet mode ****************************************************************/
 413
 414 static void lid_flip_tablet_mode_get_state(struct asus_wmi *asus)
 415 {
 416         int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_LID_FLIP);
 417
 418         if (result >= 0) {
 419                 input_report_switch(asus->inputdev, SW_TABLET_MODE, result);
 420                 input_sync(asus->inputdev);
 421         }
 422 }
 423
 424 /* Battery ********************************************************************/
 425
 426 /* The battery maximum charging percentage */
 427 static int charge_end_threshold;
 428
 429 static ssize_t charge_control_end_threshold_store(struct device *dev,
 430                                                   struct device_attribute *attr,
 431                                                   const char *buf, size_t count)
 432 {
 433         int value, ret, rv;
 434
 435         ret = kstrtouint(buf, 10, &value);
 436         if (ret)
 437                 return ret;
 438
 439         if (value < 0 || value > 100)
 440                 return -EINVAL;
 441
 442         ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, value, &rv);
 443         if (ret)
 444                 return ret;
 445
 446         if (rv != 1)
 447                 return -EIO;
 448
 449         /* There isn't any method in the DSDT to read the threshold, so we
 450          * save the threshold.
 451          */
 452         charge_end_threshold = value;
 453         return count;
 454 }
 455
 456 static ssize_t charge_control_end_threshold_show(struct device *device,
 457                                                  struct device_attribute *attr,
 458                                                  char *buf)
 459 {
 460         return sprintf(buf, "%d\n", charge_end_threshold);
 461 }
 462
 463 static DEVICE_ATTR_RW(charge_control_end_threshold);
 464
 465 static int asus_wmi_battery_add(struct power_supply *battery)
 466 {
 467         /* The WMI method does not provide a way to specific a battery, so we
 468          * just assume it is the first battery.
 469          * Note: On some newer ASUS laptops (Zenbook UM431DA), the primary/first
 470          * battery is named BATT.
 471          */
 472         if (strcmp(battery->desc->name, "BAT0") != 0 &&
 473             strcmp(battery->desc->name, "BAT1") != 0 &&
 474             strcmp(battery->desc->name, "BATC") != 0 &&
 475             strcmp(battery->desc->name, "BATT") != 0)
 476                 return -ENODEV;
 477
 478         if (device_create_file(&battery->dev,
 479             &dev_attr_charge_control_end_threshold))
 480                 return -ENODEV;
 481
 482         /* The charge threshold is only reset when the system is power cycled,
 483          * and we can't get the current threshold so let set it to 100% when
 484          * a battery is added.
 485          */
 486         asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, 100, NULL);
 487         charge_end_threshold = 100;
 488
 489         return 0;
 490 }
 491
 492 static int asus_wmi_battery_remove(struct power_supply *battery)
 493 {
 494         device_remove_file(&battery->dev,
 495                            &dev_attr_charge_control_end_threshold);
 496         return 0;
 497 }
 498
 499 static struct acpi_battery_hook battery_hook = {
 500         .add_battery = asus_wmi_battery_add,
 501         .remove_battery = asus_wmi_battery_remove,
 502         .name = "ASUS Battery Extension",
 503 };
 504
 505 static void asus_wmi_battery_init(struct asus_wmi *asus)
 506 {
 507         asus->battery_rsoc_available = false;
 508         if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_RSOC)) {
 509                 asus->battery_rsoc_available = true;
 510                 battery_hook_register(&battery_hook);
 511         }
 512 }
 513
 514 static void asus_wmi_battery_exit(struct asus_wmi *asus)
 515 {
 516         if (asus->battery_rsoc_available)
 517                 battery_hook_unregister(&battery_hook);
 518 }
 519
 520 /* LEDs ***********************************************************************/
 521
 522 /*
 523  * These functions actually update the LED's, and are called from a
 524  * workqueue. By doing this as separate work rather than when the LED
 525  * subsystem asks, we avoid messing with the Asus ACPI stuff during a
 526  * potentially bad time, such as a timer interrupt.
 527  */
 528 static void tpd_led_update(struct work_struct *work)
 529 {
 530         int ctrl_param;
 531         struct asus_wmi *asus;
 532
 533         asus = container_of(work, struct asus_wmi, tpd_led_work);
 534
 535         ctrl_param = asus->tpd_led_wk;
 536         asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
 537 }
 538
 539 static void tpd_led_set(struct led_classdev *led_cdev,
 540                         enum led_brightness value)
 541 {
 542         struct asus_wmi *asus;
 543
 544         asus = container_of(led_cdev, struct asus_wmi, tpd_led);
 545
 546         asus->tpd_led_wk = !!value;
 547         queue_work(asus->led_workqueue, &asus->tpd_led_work);
 548 }
 549
 550 static int read_tpd_led_state(struct asus_wmi *asus)
 551 {
 552         return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
 553 }
 554
 555 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
 556 {
 557         struct asus_wmi *asus;
 558
 559         asus = container_of(led_cdev, struct asus_wmi, tpd_led);
 560
 561         return read_tpd_led_state(asus);
 562 }
 563
 564 static void kbd_led_update(struct asus_wmi *asus)
 565 {
 566         int ctrl_param = 0;
 567
 568         ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
 569         asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
 570 }
 571
 572 static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
 573 {
 574         int retval;
 575
 576         /*
 577          * bits 0-2: level
 578          * bit 7: light on/off
 579          * bit 8-10: environment (0: dark, 1: normal, 2: light)
 580          * bit 17: status unknown
 581          */
 582         retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
 583                                             0xFFFF);
 584
 585         /* Unknown status is considered as off */
 586         if (retval == 0x8000)
 587                 retval = 0;
 588
 589         if (retval < 0)
 590                 return retval;
 591
 592         if (level)
 593                 *level = retval & 0x7F;
 594         if (env)
 595                 *env = (retval >> 8) & 0x7F;
 596         return 0;
 597 }
 598
 599 static void do_kbd_led_set(struct led_classdev *led_cdev, int value)
 600 {
 601         struct asus_wmi *asus;
 602         int max_level;
 603
 604         asus = container_of(led_cdev, struct asus_wmi, kbd_led);
 605         max_level = asus->kbd_led.max_brightness;
 606
 607         asus->kbd_led_wk = clamp_val(value, 0, max_level);
 608         kbd_led_update(asus);
 609 }
 610
 611 static void kbd_led_set(struct led_classdev *led_cdev,
 612                         enum led_brightness value)
 613 {
 614         /* Prevent disabling keyboard backlight on module unregister */
 615         if (led_cdev->flags & LED_UNREGISTERING)
 616                 return;
 617
 618         do_kbd_led_set(led_cdev, value);
 619 }
 620
 621 static void kbd_led_set_by_kbd(struct asus_wmi *asus, enum led_brightness value)
 622 {
 623         struct led_classdev *led_cdev = &asus->kbd_led;
 624
 625         do_kbd_led_set(led_cdev, value);
 626         led_classdev_notify_brightness_hw_changed(led_cdev, asus->kbd_led_wk);
 627 }
 628
 629 static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
 630 {
 631         struct asus_wmi *asus;
 632         int retval, value;
 633
 634         asus = container_of(led_cdev, struct asus_wmi, kbd_led);
 635
 636         retval = kbd_led_read(asus, &value, NULL);
 637         if (retval < 0)
 638                 return retval;
 639
 640         return value;
 641 }
 642
 643 static int wlan_led_unknown_state(struct asus_wmi *asus)
 644 {
 645         u32 result;
 646
 647         asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
 648
 649         return result & ASUS_WMI_DSTS_UNKNOWN_BIT;
 650 }
 651
 652 static void wlan_led_update(struct work_struct *work)
 653 {
 654         int ctrl_param;
 655         struct asus_wmi *asus;
 656
 657         asus = container_of(work, struct asus_wmi, wlan_led_work);
 658
 659         ctrl_param = asus->wlan_led_wk;
 660         asus_wmi_set_devstate(ASUS_WMI_DEVID_WIRELESS_LED, ctrl_param, NULL);
 661 }
 662
 663 static void wlan_led_set(struct led_classdev *led_cdev,
 664                          enum led_brightness value)
 665 {
 666         struct asus_wmi *asus;
 667
 668         asus = container_of(led_cdev, struct asus_wmi, wlan_led);
 669
 670         asus->wlan_led_wk = !!value;
 671         queue_work(asus->led_workqueue, &asus->wlan_led_work);
 672 }
 673
 674 static enum led_brightness wlan_led_get(struct led_classdev *led_cdev)
 675 {
 676         struct asus_wmi *asus;
 677         u32 result;
 678
 679         asus = container_of(led_cdev, struct asus_wmi, wlan_led);
 680         asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
 681
 682         return result & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
 683 }
 684
 685 static void lightbar_led_update(struct work_struct *work)
 686 {
 687         struct asus_wmi *asus;
 688         int ctrl_param;
 689
 690         asus = container_of(work, struct asus_wmi, lightbar_led_work);
 691
 692         ctrl_param = asus->lightbar_led_wk;
 693         asus_wmi_set_devstate(ASUS_WMI_DEVID_LIGHTBAR, ctrl_param, NULL);
 694 }
 695
 696 static void lightbar_led_set(struct led_classdev *led_cdev,
 697                              enum led_brightness value)
 698 {
 699         struct asus_wmi *asus;
 700
 701         asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
 702
 703         asus->lightbar_led_wk = !!value;
 704         queue_work(asus->led_workqueue, &asus->lightbar_led_work);
 705 }
 706
 707 static enum led_brightness lightbar_led_get(struct led_classdev *led_cdev)
 708 {
 709         struct asus_wmi *asus;
 710         u32 result;
 711
 712         asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
 713         asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_LIGHTBAR, &result);
 714
 715         return result & ASUS_WMI_DSTS_LIGHTBAR_MASK;
 716 }
 717
 718 static void asus_wmi_led_exit(struct asus_wmi *asus)
 719 {
 720         led_classdev_unregister(&asus->kbd_led);
 721         led_classdev_unregister(&asus->tpd_led);
 722         led_classdev_unregister(&asus->wlan_led);
 723         led_classdev_unregister(&asus->lightbar_led);
 724
 725         if (asus->led_workqueue)
 726                 destroy_workqueue(asus->led_workqueue);
 727 }
 728
 729 static int asus_wmi_led_init(struct asus_wmi *asus)
 730 {
 731         int rv = 0, led_val;
 732
 733         asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
 734         if (!asus->led_workqueue)
 735                 return -ENOMEM;
 736
 737         if (read_tpd_led_state(asus) >= 0) {
 738                 INIT_WORK(&asus->tpd_led_work, tpd_led_update);
 739
 740                 asus->tpd_led.name = "asus::touchpad";
 741                 asus->tpd_led.brightness_set = tpd_led_set;
 742                 asus->tpd_led.brightness_get = tpd_led_get;
 743                 asus->tpd_led.max_brightness = 1;
 744
 745                 rv = led_classdev_register(&asus->platform_device->dev,
 746                                            &asus->tpd_led);
 747                 if (rv)
 748                         goto error;
 749         }
 750
 751         if (!kbd_led_read(asus, &led_val, NULL)) {
 752                 asus->kbd_led_wk = led_val;
 753                 asus->kbd_led.name = "asus::kbd_backlight";
 754                 asus->kbd_led.flags = LED_BRIGHT_HW_CHANGED;
 755                 asus->kbd_led.brightness_set = kbd_led_set;
 756                 asus->kbd_led.brightness_get = kbd_led_get;
 757                 asus->kbd_led.max_brightness = 3;
 758
 759                 rv = led_classdev_register(&asus->platform_device->dev,
 760                                            &asus->kbd_led);
 761                 if (rv)
 762                         goto error;
 763         }
 764
 765         if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_WIRELESS_LED)
 766                         && (asus->driver->quirks->wapf > 0)) {
 767                 INIT_WORK(&asus->wlan_led_work, wlan_led_update);
 768
 769                 asus->wlan_led.name = "asus::wlan";
 770                 asus->wlan_led.brightness_set = wlan_led_set;
 771                 if (!wlan_led_unknown_state(asus))
 772                         asus->wlan_led.brightness_get = wlan_led_get;
 773                 asus->wlan_led.flags = LED_CORE_SUSPENDRESUME;
 774                 asus->wlan_led.max_brightness = 1;
 775                 asus->wlan_led.default_trigger = "asus-wlan";
 776
 777                 rv = led_classdev_register(&asus->platform_device->dev,
 778                                            &asus->wlan_led);
 779                 if (rv)
 780                         goto error;
 781         }
 782
 783         if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_LIGHTBAR)) {
 784                 INIT_WORK(&asus->lightbar_led_work, lightbar_led_update);
 785
 786                 asus->lightbar_led.name = "asus::lightbar";
 787                 asus->lightbar_led.brightness_set = lightbar_led_set;
 788                 asus->lightbar_led.brightness_get = lightbar_led_get;
 789                 asus->lightbar_led.max_brightness = 1;
 790
 791                 rv = led_classdev_register(&asus->platform_device->dev,
 792                                            &asus->lightbar_led);
 793         }
 794
 795 error:
 796         if (rv)
 797                 asus_wmi_led_exit(asus);
 798
 799         return rv;
 800 }
 801
 802 /* RF *************************************************************************/
 803
 804 /*
 805  * PCI hotplug (for wlan rfkill)
 806  */
 807 static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
 808 {
 809         int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
 810
 811         if (result < 0)
 812                 return false;
 813         return !result;
 814 }
 815
 816 static void asus_rfkill_hotplug(struct asus_wmi *asus)
 817 {
 818         struct pci_dev *dev;
 819         struct pci_bus *bus;
 820         bool blocked;
 821         bool absent;
 822         u32 l;
 823
 824         mutex_lock(&asus->wmi_lock);
 825         blocked = asus_wlan_rfkill_blocked(asus);
 826         mutex_unlock(&asus->wmi_lock);
 827
 828         mutex_lock(&asus->hotplug_lock);
 829         pci_lock_rescan_remove();
 830
 831         if (asus->wlan.rfkill)
 832                 rfkill_set_sw_state(asus->wlan.rfkill, blocked);
 833
 834         if (asus->hotplug_slot.ops) {
 835                 bus = pci_find_bus(0, 1);
 836                 if (!bus) {
 837                         pr_warn("Unable to find PCI bus 1?\n");
 838                         goto out_unlock;
 839                 }
 840
 841                 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
 842                         pr_err("Unable to read PCI config space?\n");
 843                         goto out_unlock;
 844                 }
 845                 absent = (l == 0xffffffff);
 846
 847                 if (blocked != absent) {
 848                         pr_warn("BIOS says wireless lan is %s, "
 849                                 "but the pci device is %s\n",
 850                                 blocked ? "blocked" : "unblocked",
 851                                 absent ? "absent" : "present");
 852                         pr_warn("skipped wireless hotplug as probably "
 853                                 "inappropriate for this model\n");
 854                         goto out_unlock;
 855                 }
 856
 857                 if (!blocked) {
 858                         dev = pci_get_slot(bus, 0);
 859                         if (dev) {
 860                                 /* Device already present */
 861                                 pci_dev_put(dev);
 862                                 goto out_unlock;
 863                         }
 864                         dev = pci_scan_single_device(bus, 0);
 865                         if (dev) {
 866                                 pci_bus_assign_resources(bus);
 867                                 pci_bus_add_device(dev);
 868                         }
 869                 } else {
 870                         dev = pci_get_slot(bus, 0);
 871                         if (dev) {
 872                                 pci_stop_and_remove_bus_device(dev);
 873                                 pci_dev_put(dev);
 874                         }
 875                 }
 876         }
 877
 878 out_unlock:
 879         pci_unlock_rescan_remove();
 880         mutex_unlock(&asus->hotplug_lock);
 881 }
 882
 883 static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
 884 {
 885         struct asus_wmi *asus = data;
 886
 887         if (event != ACPI_NOTIFY_BUS_CHECK)
 888                 return;
 889
 890         /*
 891          * We can't call directly asus_rfkill_hotplug because most
 892          * of the time WMBC is still being executed and not reetrant.
 893          * There is currently no way to tell ACPICA that  we want this
 894          * method to be serialized, we schedule a asus_rfkill_hotplug
 895          * call later, in a safer context.
 896          */
 897         queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
 898 }
 899
 900 static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
 901 {
 902         acpi_status status;
 903         acpi_handle handle;
 904
 905         status = acpi_get_handle(NULL, node, &handle);
 906         if (ACPI_FAILURE(status))
 907                 return -ENODEV;
 908
 909         status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
 910                                              asus_rfkill_notify, asus);
 911         if (ACPI_FAILURE(status))
 912                 pr_warn("Failed to register notify on %s\n", node);
 913
 914         return 0;
 915 }
 916
 917 static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
 918 {
 919         acpi_status status = AE_OK;
 920         acpi_handle handle;
 921
 922         status = acpi_get_handle(NULL, node, &handle);
 923         if (ACPI_FAILURE(status))
 924                 return;
 925
 926         status = acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
 927                                             asus_rfkill_notify);
 928         if (ACPI_FAILURE(status))
 929                 pr_err("Error removing rfkill notify handler %s\n", node);
 930 }
 931
 932 static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
 933                                    u8 *value)
 934 {
 935         struct asus_wmi *asus = container_of(hotplug_slot,
 936                                              struct asus_wmi, hotplug_slot);
 937         int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
 938
 939         if (result < 0)
 940                 return result;
 941
 942         *value = !!result;
 943         return 0;
 944 }
 945
 946 static const struct hotplug_slot_ops asus_hotplug_slot_ops = {
 947         .get_adapter_status = asus_get_adapter_status,
 948         .get_power_status = asus_get_adapter_status,
 949 };
 950
 951 static void asus_hotplug_work(struct work_struct *work)
 952 {
 953         struct asus_wmi *asus;
 954
 955         asus = container_of(work, struct asus_wmi, hotplug_work);
 956         asus_rfkill_hotplug(asus);
 957 }
 958
 959 static int asus_setup_pci_hotplug(struct asus_wmi *asus)
 960 {
 961         int ret = -ENOMEM;
 962         struct pci_bus *bus = pci_find_bus(0, 1);
 963
 964         if (!bus) {
 965                 pr_err("Unable to find wifi PCI bus\n");
 966                 return -ENODEV;
 967         }
 968
 969         asus->hotplug_workqueue =
 970             create_singlethread_workqueue("hotplug_workqueue");
 971         if (!asus->hotplug_workqueue)
 972                 goto error_workqueue;
 973
 974         INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
 975
 976         asus->hotplug_slot.ops = &asus_hotplug_slot_ops;
 977
 978         ret = pci_hp_register(&asus->hotplug_slot, bus, 0, "asus-wifi");
 979         if (ret) {
 980                 pr_err("Unable to register hotplug slot - %d\n", ret);
 981                 goto error_register;
 982         }
 983
 984         return 0;
 985
 986 error_register:
 987         asus->hotplug_slot.ops = NULL;
 988         destroy_workqueue(asus->hotplug_workqueue);
 989 error_workqueue:
 990         return ret;
 991 }
 992
 993 /*
 994  * Rfkill devices
 995  */
 996 static int asus_rfkill_set(void *data, bool blocked)
 997 {
 998         struct asus_rfkill *priv = data;
 999         u32 ctrl_param = !blocked;
1000         u32 dev_id = priv->dev_id;
1001
1002         /*
1003          * If the user bit is set, BIOS can't set and record the wlan status,
1004          * it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
1005          * while we query the wlan status through WMI(ASUS_WMI_DEVID_WLAN).
1006          * So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
1007          * while setting the wlan status through WMI.
1008          * This is also the behavior that windows app will do.
1009          */
1010         if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
1011              priv->asus->driver->wlan_ctrl_by_user)
1012                 dev_id = ASUS_WMI_DEVID_WLAN_LED;
1013
1014         return asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
1015 }
1016
1017 static void asus_rfkill_query(struct rfkill *rfkill, void *data)
1018 {
1019         struct asus_rfkill *priv = data;
1020         int result;
1021
1022         result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
1023
1024         if (result < 0)
1025                 return;
1026
1027         rfkill_set_sw_state(priv->rfkill, !result);
1028 }
1029
1030 static int asus_rfkill_wlan_set(void *data, bool blocked)
1031 {
1032         struct asus_rfkill *priv = data;
1033         struct asus_wmi *asus = priv->asus;
1034         int ret;
1035
1036         /*
1037          * This handler is enabled only if hotplug is enabled.
1038          * In this case, the asus_wmi_set_devstate() will
1039          * trigger a wmi notification and we need to wait
1040          * this call to finish before being able to call
1041          * any wmi method
1042          */
1043         mutex_lock(&asus->wmi_lock);
1044         ret = asus_rfkill_set(data, blocked);
1045         mutex_unlock(&asus->wmi_lock);
1046         return ret;
1047 }
1048
1049 static const struct rfkill_ops asus_rfkill_wlan_ops = {
1050         .set_block = asus_rfkill_wlan_set,
1051         .query = asus_rfkill_query,
1052 };
1053
1054 static const struct rfkill_ops asus_rfkill_ops = {
1055         .set_block = asus_rfkill_set,
1056         .query = asus_rfkill_query,
1057 };
1058
1059 static int asus_new_rfkill(struct asus_wmi *asus,
1060                            struct asus_rfkill *arfkill,
1061                            const char *name, enum rfkill_type type, int dev_id)
1062 {
1063         int result = asus_wmi_get_devstate_simple(asus, dev_id);
1064         struct rfkill **rfkill = &arfkill->rfkill;
1065
1066         if (result < 0)
1067                 return result;
1068
1069         arfkill->dev_id = dev_id;
1070         arfkill->asus = asus;
1071
1072         if (dev_id == ASUS_WMI_DEVID_WLAN &&
1073             asus->driver->quirks->hotplug_wireless)
1074                 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
1075                                        &asus_rfkill_wlan_ops, arfkill);
1076         else
1077                 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
1078                                        &asus_rfkill_ops, arfkill);
1079
1080         if (!*rfkill)
1081                 return -EINVAL;
1082
1083         if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
1084                         (asus->driver->quirks->wapf > 0))
1085                 rfkill_set_led_trigger_name(*rfkill, "asus-wlan");
1086
1087         rfkill_init_sw_state(*rfkill, !result);
1088         result = rfkill_register(*rfkill);
1089         if (result) {
1090                 rfkill_destroy(*rfkill);
1091                 *rfkill = NULL;
1092                 return result;
1093         }
1094         return 0;
1095 }
1096
1097 static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
1098 {
1099         if (asus->driver->wlan_ctrl_by_user && ashs_present())
1100                 return;
1101
1102         asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
1103         asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
1104         asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
1105         if (asus->wlan.rfkill) {
1106                 rfkill_unregister(asus->wlan.rfkill);
1107                 rfkill_destroy(asus->wlan.rfkill);
1108                 asus->wlan.rfkill = NULL;
1109         }
1110         /*
1111          * Refresh pci hotplug in case the rfkill state was changed after
1112          * asus_unregister_rfkill_notifier()
1113          */
1114         asus_rfkill_hotplug(asus);
1115         if (asus->hotplug_slot.ops)
1116                 pci_hp_deregister(&asus->hotplug_slot);
1117         if (asus->hotplug_workqueue)
1118                 destroy_workqueue(asus->hotplug_workqueue);
1119
1120         if (asus->bluetooth.rfkill) {
1121                 rfkill_unregister(asus->bluetooth.rfkill);
1122                 rfkill_destroy(asus->bluetooth.rfkill);
1123                 asus->bluetooth.rfkill = NULL;
1124         }
1125         if (asus->wimax.rfkill) {
1126                 rfkill_unregister(asus->wimax.rfkill);
1127                 rfkill_destroy(asus->wimax.rfkill);
1128                 asus->wimax.rfkill = NULL;
1129         }
1130         if (asus->wwan3g.rfkill) {
1131                 rfkill_unregister(asus->wwan3g.rfkill);
1132                 rfkill_destroy(asus->wwan3g.rfkill);
1133                 asus->wwan3g.rfkill = NULL;
1134         }
1135         if (asus->gps.rfkill) {
1136                 rfkill_unregister(asus->gps.rfkill);
1137                 rfkill_destroy(asus->gps.rfkill);
1138                 asus->gps.rfkill = NULL;
1139         }
1140         if (asus->uwb.rfkill) {
1141                 rfkill_unregister(asus->uwb.rfkill);
1142                 rfkill_destroy(asus->uwb.rfkill);
1143                 asus->uwb.rfkill = NULL;
1144         }
1145 }
1146
1147 static int asus_wmi_rfkill_init(struct asus_wmi *asus)
1148 {
1149         int result = 0;
1150
1151         mutex_init(&asus->hotplug_lock);
1152         mutex_init(&asus->wmi_lock);
1153
1154         result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
1155                                  RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
1156
1157         if (result && result != -ENODEV)
1158                 goto exit;
1159
1160         result = asus_new_rfkill(asus, &asus->bluetooth,
1161                                  "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
1162                                  ASUS_WMI_DEVID_BLUETOOTH);
1163
1164         if (result && result != -ENODEV)
1165                 goto exit;
1166
1167         result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
1168                                  RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
1169
1170         if (result && result != -ENODEV)
1171                 goto exit;
1172
1173         result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
1174                                  RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
1175
1176         if (result && result != -ENODEV)
1177                 goto exit;
1178
1179         result = asus_new_rfkill(asus, &asus->gps, "asus-gps",
1180                                  RFKILL_TYPE_GPS, ASUS_WMI_DEVID_GPS);
1181
1182         if (result && result != -ENODEV)
1183                 goto exit;
1184
1185         result = asus_new_rfkill(asus, &asus->uwb, "asus-uwb",
1186                                  RFKILL_TYPE_UWB, ASUS_WMI_DEVID_UWB);
1187
1188         if (result && result != -ENODEV)
1189                 goto exit;
1190
1191         if (!asus->driver->quirks->hotplug_wireless)
1192                 goto exit;
1193
1194         result = asus_setup_pci_hotplug(asus);
1195         /*
1196          * If we get -EBUSY then something else is handling the PCI hotplug -
1197          * don't fail in this case
1198          */
1199         if (result == -EBUSY)
1200                 result = 0;
1201
1202         asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
1203         asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
1204         asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
1205         /*
1206          * Refresh pci hotplug in case the rfkill state was changed during
1207          * setup.
1208          */
1209         asus_rfkill_hotplug(asus);
1210
1211 exit:
1212         if (result && result != -ENODEV)
1213                 asus_wmi_rfkill_exit(asus);
1214
1215         if (result == -ENODEV)
1216                 result = 0;
1217
1218         return result;
1219 }
1220
1221 /* Quirks *********************************************************************/
1222
1223 static void asus_wmi_set_xusb2pr(struct asus_wmi *asus)
1224 {
1225         struct pci_dev *xhci_pdev;
1226         u32 orig_ports_available;
1227         u32 ports_available = asus->driver->quirks->xusb2pr;
1228
1229         xhci_pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
1230                         PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI,
1231                         NULL);
1232
1233         if (!xhci_pdev)
1234                 return;
1235
1236         pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
1237                                 &orig_ports_available);
1238
1239         pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
1240                                 cpu_to_le32(ports_available));
1241
1242         pr_info("set USB_INTEL_XUSB2PR old: 0x%04x, new: 0x%04x\n",
1243                         orig_ports_available, ports_available);
1244 }
1245
1246 /*
1247  * Some devices dont support or have borcken get_als method
1248  * but still support set method.
1249  */
1250 static void asus_wmi_set_als(void)
1251 {
1252         asus_wmi_set_devstate(ASUS_WMI_DEVID_ALS_ENABLE, 1, NULL);
1253 }
1254
1255 /* Hwmon device ***************************************************************/
1256
1257 static int asus_agfn_fan_speed_read(struct asus_wmi *asus, int fan,
1258                                           int *speed)
1259 {
1260         struct agfn_fan_args args = {
1261                 .agfn.len = sizeof(args),
1262                 .agfn.mfun = ASUS_FAN_MFUN,
1263                 .agfn.sfun = ASUS_FAN_SFUN_READ,
1264                 .fan = fan,
1265                 .speed = 0,
1266         };
1267         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1268         int status;
1269
1270         if (fan != 1)
1271                 return -EINVAL;
1272
1273         status = asus_wmi_evaluate_method_agfn(input);
1274
1275         if (status || args.agfn.err)
1276                 return -ENXIO;
1277
1278         if (speed)
1279                 *speed = args.speed;
1280
1281         return 0;
1282 }
1283
1284 static int asus_agfn_fan_speed_write(struct asus_wmi *asus, int fan,
1285                                      int *speed)
1286 {
1287         struct agfn_fan_args args = {
1288                 .agfn.len = sizeof(args),
1289                 .agfn.mfun = ASUS_FAN_MFUN,
1290                 .agfn.sfun = ASUS_FAN_SFUN_WRITE,
1291                 .fan = fan,
1292                 .speed = speed ?  *speed : 0,
1293         };
1294         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1295         int status;
1296
1297         /* 1: for setting 1st fan's speed 0: setting auto mode */
1298         if (fan != 1 && fan != 0)
1299                 return -EINVAL;
1300
1301         status = asus_wmi_evaluate_method_agfn(input);
1302
1303         if (status || args.agfn.err)
1304                 return -ENXIO;
1305
1306         if (speed && fan == 1)
1307                 asus->agfn_pwm = *speed;
1308
1309         return 0;
1310 }
1311
1312 /*
1313  * Check if we can read the speed of one fan. If true we assume we can also
1314  * control it.
1315  */
1316 static bool asus_wmi_has_agfn_fan(struct asus_wmi *asus)
1317 {
1318         int status;
1319         int speed;
1320         u32 value;
1321
1322         status = asus_agfn_fan_speed_read(asus, 1, &speed);
1323         if (status != 0)
1324                 return false;
1325
1326         status = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
1327         if (status != 0)
1328                 return false;
1329
1330         /*
1331          * We need to find a better way, probably using sfun,
1332          * bits or spec ...
1333          * Currently we disable it if:
1334          * - ASUS_WMI_UNSUPPORTED_METHOD is returned
1335          * - reverved bits are non-zero
1336          * - sfun and presence bit are not set
1337          */
1338         return !(value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
1339                  || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)));
1340 }
1341
1342 static int asus_fan_set_auto(struct asus_wmi *asus)
1343 {
1344         int status;
1345         u32 retval;
1346
1347         switch (asus->fan_type) {
1348         case FAN_TYPE_SPEC83:
1349                 status = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
1350                                                0, &retval);
1351                 if (status)
1352                         return status;
1353
1354                 if (retval != 1)
1355                         return -EIO;
1356                 break;
1357
1358         case FAN_TYPE_AGFN:
1359                 status = asus_agfn_fan_speed_write(asus, 0, NULL);
1360                 if (status)
1361                         return -ENXIO;
1362                 break;
1363
1364         default:
1365                 return -ENXIO;
1366         }
1367
1368
1369         return 0;
1370 }
1371
1372 static ssize_t pwm1_show(struct device *dev,
1373                                struct device_attribute *attr,
1374                                char *buf)
1375 {
1376         struct asus_wmi *asus = dev_get_drvdata(dev);
1377         int err;
1378         int value;
1379
1380         /* If we already set a value then just return it */
1381         if (asus->agfn_pwm >= 0)
1382                 return sprintf(buf, "%d\n", asus->agfn_pwm);
1383
1384         /*
1385          * If we haven't set already set a value through the AGFN interface,
1386          * we read a current value through the (now-deprecated) FAN_CTRL device.
1387          */
1388         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
1389         if (err < 0)
1390                 return err;
1391
1392         value &= 0xFF;
1393
1394         if (value == 1) /* Low Speed */
1395                 value = 85;
1396         else if (value == 2)
1397                 value = 170;
1398         else if (value == 3)
1399                 value = 255;
1400         else if (value) {
1401                 pr_err("Unknown fan speed %#x\n", value);
1402                 value = -1;
1403         }
1404
1405         return sprintf(buf, "%d\n", value);
1406 }
1407
1408 static ssize_t pwm1_store(struct device *dev,
1409                                      struct device_attribute *attr,
1410                                      const char *buf, size_t count) {
1411         struct asus_wmi *asus = dev_get_drvdata(dev);
1412         int value;
1413         int state;
1414         int ret;
1415
1416         ret = kstrtouint(buf, 10, &value);
1417         if (ret)
1418                 return ret;
1419
1420         value = clamp(value, 0, 255);
1421
1422         state = asus_agfn_fan_speed_write(asus, 1, &value);
1423         if (state)
1424                 pr_warn("Setting fan speed failed: %d\n", state);
1425         else
1426                 asus->fan_pwm_mode = ASUS_FAN_CTRL_MANUAL;
1427
1428         return count;
1429 }
1430
1431 static ssize_t fan1_input_show(struct device *dev,
1432                                         struct device_attribute *attr,
1433                                         char *buf)
1434 {
1435         struct asus_wmi *asus = dev_get_drvdata(dev);
1436         int value;
1437         int ret;
1438
1439         switch (asus->fan_type) {
1440         case FAN_TYPE_SPEC83:
1441                 ret = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL,
1442                                             &value);
1443                 if (ret < 0)
1444                         return ret;
1445
1446                 value &= 0xffff;
1447                 break;
1448
1449         case FAN_TYPE_AGFN:
1450                 /* no speed readable on manual mode */
1451                 if (asus->fan_pwm_mode == ASUS_FAN_CTRL_MANUAL)
1452                         return -ENXIO;
1453
1454                 ret = asus_agfn_fan_speed_read(asus, 1, &value);
1455                 if (ret) {
1456                         pr_warn("reading fan speed failed: %d\n", ret);
1457                         return -ENXIO;
1458                 }
1459                 break;
1460
1461         default:
1462                 return -ENXIO;
1463         }
1464
1465         return sprintf(buf, "%d\n", value < 0 ? -1 : value*100);
1466 }
1467
1468 static ssize_t pwm1_enable_show(struct device *dev,
1469                                                  struct device_attribute *attr,
1470                                                  char *buf)
1471 {
1472         struct asus_wmi *asus = dev_get_drvdata(dev);
1473
1474         /*
1475          * Just read back the cached pwm mode.
1476          *
1477          * For the CPU_FAN device, the spec indicates that we should be
1478          * able to read the device status and consult bit 19 to see if we
1479          * are in Full On or Automatic mode. However, this does not work
1480          * in practice on X532FL at least (the bit is always 0) and there's
1481          * also nothing in the DSDT to indicate that this behaviour exists.
1482          */
1483         return sprintf(buf, "%d\n", asus->fan_pwm_mode);
1484 }
1485
1486 static ssize_t pwm1_enable_store(struct device *dev,
1487                                                   struct device_attribute *attr,
1488                                                   const char *buf, size_t count)
1489 {
1490         struct asus_wmi *asus = dev_get_drvdata(dev);
1491         int status = 0;
1492         int state;
1493         int value;
1494         int ret;
1495         u32 retval;
1496
1497         ret = kstrtouint(buf, 10, &state);
1498         if (ret)
1499                 return ret;
1500
1501         if (asus->fan_type == FAN_TYPE_SPEC83) {
1502                 switch (state) { /* standard documented hwmon values */
1503                 case ASUS_FAN_CTRL_FULLSPEED:
1504                         value = 1;
1505                         break;
1506                 case ASUS_FAN_CTRL_AUTO:
1507                         value = 0;
1508                         break;
1509                 default:
1510                         return -EINVAL;
1511                 }
1512
1513                 ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
1514                                             value, &retval);
1515                 if (ret)
1516                         return ret;
1517
1518                 if (retval != 1)
1519                         return -EIO;
1520         } else if (asus->fan_type == FAN_TYPE_AGFN) {
1521                 switch (state) {
1522                 case ASUS_FAN_CTRL_MANUAL:
1523                         break;
1524
1525                 case ASUS_FAN_CTRL_AUTO:
1526                         status = asus_fan_set_auto(asus);
1527                         if (status)
1528                                 return status;
1529                         break;
1530
1531                 default:
1532                         return -EINVAL;
1533                 }
1534         }
1535
1536         asus->fan_pwm_mode = state;
1537         return count;
1538 }
1539
1540 static ssize_t fan1_label_show(struct device *dev,
1541                                           struct device_attribute *attr,
1542                                           char *buf)
1543 {
1544         return sprintf(buf, "%s\n", ASUS_FAN_DESC);
1545 }
1546
1547 static ssize_t asus_hwmon_temp1(struct device *dev,
1548                                 struct device_attribute *attr,
1549                                 char *buf)
1550 {
1551         struct asus_wmi *asus = dev_get_drvdata(dev);
1552         u32 value;
1553         int err;
1554
1555         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_THERMAL_CTRL, &value);
1556         if (err < 0)
1557                 return err;
1558
1559         return sprintf(buf, "%ld\n",
1560                        deci_kelvin_to_millicelsius(value & 0xFFFF));
1561 }
1562
1563 /* Fan1 */
1564 static DEVICE_ATTR_RW(pwm1);
1565 static DEVICE_ATTR_RW(pwm1_enable);
1566 static DEVICE_ATTR_RO(fan1_input);
1567 static DEVICE_ATTR_RO(fan1_label);
1568
1569 /* Temperature */
1570 static DEVICE_ATTR(temp1_input, S_IRUGO, asus_hwmon_temp1, NULL);
1571
1572 static struct attribute *hwmon_attributes[] = {
1573         &dev_attr_pwm1.attr,
1574         &dev_attr_pwm1_enable.attr,
1575         &dev_attr_fan1_input.attr,
1576         &dev_attr_fan1_label.attr,
1577
1578         &dev_attr_temp1_input.attr,
1579         NULL
1580 };
1581
1582 static umode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
1583                                           struct attribute *attr, int idx)
1584 {
1585         struct device *dev = container_of(kobj, struct device, kobj);
1586         struct asus_wmi *asus = dev_get_drvdata(dev->parent);
1587         u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
1588
1589         if (attr == &dev_attr_pwm1.attr) {
1590                 if (asus->fan_type != FAN_TYPE_AGFN)
1591                         return 0;
1592         } else if (attr == &dev_attr_fan1_input.attr
1593             || attr == &dev_attr_fan1_label.attr
1594             || attr == &dev_attr_pwm1_enable.attr) {
1595                 if (asus->fan_type == FAN_TYPE_NONE)
1596                         return 0;
1597         } else if (attr == &dev_attr_temp1_input.attr) {
1598                 int err = asus_wmi_get_devstate(asus,
1599                                                 ASUS_WMI_DEVID_THERMAL_CTRL,
1600                                                 &value);
1601
1602                 if (err < 0)
1603                         return 0; /* can't return negative here */
1604
1605                 /*
1606                  * If the temperature value in deci-Kelvin is near the absolute
1607                  * zero temperature, something is clearly wrong
1608                  */
1609                 if (value == 0 || value == 1)
1610                         return 0;
1611         }
1612
1613         return attr->mode;
1614 }
1615
1616 static const struct attribute_group hwmon_attribute_group = {
1617         .is_visible = asus_hwmon_sysfs_is_visible,
1618         .attrs = hwmon_attributes
1619 };
1620 __ATTRIBUTE_GROUPS(hwmon_attribute);
1621
1622 static int asus_wmi_hwmon_init(struct asus_wmi *asus)
1623 {
1624         struct device *dev = &asus->platform_device->dev;
1625         struct device *hwmon;
1626
1627         hwmon = devm_hwmon_device_register_with_groups(dev, "asus", asus,
1628                         hwmon_attribute_groups);
1629
1630         if (IS_ERR(hwmon)) {
1631                 pr_err("Could not register asus hwmon device\n");
1632                 return PTR_ERR(hwmon);
1633         }
1634         return 0;
1635 }
1636
1637 static int asus_wmi_fan_init(struct asus_wmi *asus)
1638 {
1639         asus->fan_type = FAN_TYPE_NONE;
1640         asus->agfn_pwm = -1;
1641
1642         if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL))
1643                 asus->fan_type = FAN_TYPE_SPEC83;
1644         else if (asus_wmi_has_agfn_fan(asus))
1645                 asus->fan_type = FAN_TYPE_AGFN;
1646
1647         if (asus->fan_type == FAN_TYPE_NONE)
1648                 return -ENODEV;
1649
1650         asus_fan_set_auto(asus);
1651         asus->fan_pwm_mode = ASUS_FAN_CTRL_AUTO;
1652         return 0;
1653 }
1654
1655 /* Fan mode *******************************************************************/
1656
1657 static int fan_boost_mode_check_present(struct asus_wmi *asus)
1658 {
1659         u32 result;
1660         int err;
1661
1662         asus->fan_boost_mode_available = false;
1663
1664         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_BOOST_MODE,
1665                                     &result);
1666         if (err) {
1667                 if (err == -ENODEV)
1668                         return 0;
1669                 else
1670                         return err;
1671         }
1672
1673         if ((result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
1674                         (result & ASUS_FAN_BOOST_MODES_MASK)) {
1675                 asus->fan_boost_mode_available = true;
1676                 asus->fan_boost_mode_mask = result & ASUS_FAN_BOOST_MODES_MASK;
1677         }
1678
1679         return 0;
1680 }
1681
1682 static int fan_boost_mode_write(struct asus_wmi *asus)
1683 {
1684         int err;
1685         u8 value;
1686         u32 retval;
1687
1688         value = asus->fan_boost_mode;
1689
1690         pr_info("Set fan boost mode: %u\n", value);
1691         err = asus_wmi_set_devstate(ASUS_WMI_DEVID_FAN_BOOST_MODE, value,
1692                                     &retval);
1693         if (err) {
1694                 pr_warn("Failed to set fan boost mode: %d\n", err);
1695                 return err;
1696         }
1697
1698         if (retval != 1) {
1699                 pr_warn("Failed to set fan boost mode (retval): 0x%x\n",
1700                         retval);
1701                 return -EIO;
1702         }
1703
1704         return 0;
1705 }
1706
1707 static int fan_boost_mode_switch_next(struct asus_wmi *asus)
1708 {
1709         u8 mask = asus->fan_boost_mode_mask;
1710
1711         if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_NORMAL) {
1712                 if (mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK)
1713                         asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_OVERBOOST;
1714                 else if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
1715                         asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
1716         } else if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
1717                 if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
1718                         asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
1719                 else
1720                         asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
1721         } else {
1722                 asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
1723         }
1724
1725         return fan_boost_mode_write(asus);
1726 }
1727
1728 static ssize_t fan_boost_mode_show(struct device *dev,
1729                                    struct device_attribute *attr, char *buf)
1730 {
1731         struct asus_wmi *asus = dev_get_drvdata(dev);
1732
1733         return scnprintf(buf, PAGE_SIZE, "%d\n", asus->fan_boost_mode);
1734 }
1735
1736 static ssize_t fan_boost_mode_store(struct device *dev,
1737                                     struct device_attribute *attr,
1738                                     const char *buf, size_t count)
1739 {
1740         int result;
1741         u8 new_mode;
1742         struct asus_wmi *asus = dev_get_drvdata(dev);
1743         u8 mask = asus->fan_boost_mode_mask;
1744
1745         result = kstrtou8(buf, 10, &new_mode);
1746         if (result < 0) {
1747                 pr_warn("Trying to store invalid value\n");
1748                 return result;
1749         }
1750
1751         if (new_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
1752                 if (!(mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK))
1753                         return -EINVAL;
1754         } else if (new_mode == ASUS_FAN_BOOST_MODE_SILENT) {
1755                 if (!(mask & ASUS_FAN_BOOST_MODE_SILENT_MASK))
1756                         return -EINVAL;
1757         } else if (new_mode != ASUS_FAN_BOOST_MODE_NORMAL) {
1758                 return -EINVAL;
1759         }
1760
1761         asus->fan_boost_mode = new_mode;
1762         fan_boost_mode_write(asus);
1763
1764         return count;
1765 }
1766
1767 // Fan boost mode: 0 - normal, 1 - overboost, 2 - silent
1768 static DEVICE_ATTR_RW(fan_boost_mode);
1769
1770 /* Throttle thermal policy ****************************************************/
1771
1772 static int throttle_thermal_policy_check_present(struct asus_wmi *asus)
1773 {
1774         u32 result;
1775         int err;
1776
1777         asus->throttle_thermal_policy_available = false;
1778
1779         err = asus_wmi_get_devstate(asus,
1780                                     ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY,
1781                                     &result);
1782         if (err) {
1783                 if (err == -ENODEV)
1784                         return 0;
1785                 return err;
1786         }
1787
1788         if (result & ASUS_WMI_DSTS_PRESENCE_BIT)
1789                 asus->throttle_thermal_policy_available = true;
1790
1791         return 0;
1792 }
1793
1794 static int throttle_thermal_policy_write(struct asus_wmi *asus)
1795 {
1796         int err;
1797         u8 value;
1798         u32 retval;
1799
1800         value = asus->throttle_thermal_policy_mode;
1801
1802         err = asus_wmi_set_devstate(ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY,
1803                                     value, &retval);
1804         if (err) {
1805                 pr_warn("Failed to set throttle thermal policy: %d\n", err);
1806                 return err;
1807         }
1808
1809         if (retval != 1) {
1810                 pr_warn("Failed to set throttle thermal policy (retval): 0x%x\n",
1811                         retval);
1812                 return -EIO;
1813         }
1814
1815         return 0;
1816 }
1817
1818 static int throttle_thermal_policy_set_default(struct asus_wmi *asus)
1819 {
1820         if (!asus->throttle_thermal_policy_available)
1821                 return 0;
1822
1823         asus->throttle_thermal_policy_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
1824         return throttle_thermal_policy_write(asus);
1825 }
1826
1827 static int throttle_thermal_policy_switch_next(struct asus_wmi *asus)
1828 {
1829         u8 new_mode = asus->throttle_thermal_policy_mode + 1;
1830
1831         if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT)
1832                 new_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
1833
1834         asus->throttle_thermal_policy_mode = new_mode;
1835         return throttle_thermal_policy_write(asus);
1836 }
1837
1838 static ssize_t throttle_thermal_policy_show(struct device *dev,
1839                                    struct device_attribute *attr, char *buf)
1840 {
1841         struct asus_wmi *asus = dev_get_drvdata(dev);
1842         u8 mode = asus->throttle_thermal_policy_mode;
1843
1844         return scnprintf(buf, PAGE_SIZE, "%d\n", mode);
1845 }
1846
1847 static ssize_t throttle_thermal_policy_store(struct device *dev,
1848                                     struct device_attribute *attr,
1849                                     const char *buf, size_t count)
1850 {
1851         int result;
1852         u8 new_mode;
1853         struct asus_wmi *asus = dev_get_drvdata(dev);
1854
1855         result = kstrtou8(buf, 10, &new_mode);
1856         if (result < 0)
1857                 return result;
1858
1859         if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT)
1860                 return -EINVAL;
1861
1862         asus->throttle_thermal_policy_mode = new_mode;
1863         throttle_thermal_policy_write(asus);
1864
1865         return count;
1866 }
1867
1868 // Throttle thermal policy: 0 - default, 1 - overboost, 2 - silent
1869 static DEVICE_ATTR_RW(throttle_thermal_policy);
1870
1871 /* Backlight ******************************************************************/
1872
1873 static int read_backlight_power(struct asus_wmi *asus)
1874 {
1875         int ret;
1876
1877         if (asus->driver->quirks->store_backlight_power)
1878                 ret = !asus->driver->panel_power;
1879         else
1880                 ret = asus_wmi_get_devstate_simple(asus,
1881                                                    ASUS_WMI_DEVID_BACKLIGHT);
1882
1883         if (ret < 0)
1884                 return ret;
1885
1886         return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
1887 }
1888
1889 static int read_brightness_max(struct asus_wmi *asus)
1890 {
1891         u32 retval;
1892         int err;
1893
1894         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1895         if (err < 0)
1896                 return err;
1897
1898         retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
1899         retval >>= 8;
1900
1901         if (!retval)
1902                 return -ENODEV;
1903
1904         return retval;
1905 }
1906
1907 static int read_brightness(struct backlight_device *bd)
1908 {
1909         struct asus_wmi *asus = bl_get_data(bd);
1910         u32 retval;
1911         int err;
1912
1913         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1914         if (err < 0)
1915                 return err;
1916
1917         return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
1918 }
1919
1920 static u32 get_scalar_command(struct backlight_device *bd)
1921 {
1922         struct asus_wmi *asus = bl_get_data(bd);
1923         u32 ctrl_param = 0;
1924
1925         if ((asus->driver->brightness < bd->props.brightness) ||
1926             bd->props.brightness == bd->props.max_brightness)
1927                 ctrl_param = 0x00008001;
1928         else if ((asus->driver->brightness > bd->props.brightness) ||
1929                  bd->props.brightness == 0)
1930                 ctrl_param = 0x00008000;
1931
1932         asus->driver->brightness = bd->props.brightness;
1933
1934         return ctrl_param;
1935 }
1936
1937 static int update_bl_status(struct backlight_device *bd)
1938 {
1939         struct asus_wmi *asus = bl_get_data(bd);
1940         u32 ctrl_param;
1941         int power, err = 0;
1942
1943         power = read_backlight_power(asus);
1944         if (power != -ENODEV && bd->props.power != power) {
1945                 ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
1946                 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
1947                                             ctrl_param, NULL);
1948                 if (asus->driver->quirks->store_backlight_power)
1949                         asus->driver->panel_power = bd->props.power;
1950
1951                 /* When using scalar brightness, updating the brightness
1952                  * will mess with the backlight power */
1953                 if (asus->driver->quirks->scalar_panel_brightness)
1954                         return err;
1955         }
1956
1957         if (asus->driver->quirks->scalar_panel_brightness)
1958                 ctrl_param = get_scalar_command(bd);
1959         else
1960                 ctrl_param = bd->props.brightness;
1961
1962         err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
1963                                     ctrl_param, NULL);
1964
1965         return err;
1966 }
1967
1968 static const struct backlight_ops asus_wmi_bl_ops = {
1969         .get_brightness = read_brightness,
1970         .update_status = update_bl_status,
1971 };
1972
1973 static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
1974 {
1975         struct backlight_device *bd = asus->backlight_device;
1976         int old = bd->props.brightness;
1977         int new = old;
1978
1979         if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1980                 new = code - NOTIFY_BRNUP_MIN + 1;
1981         else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
1982                 new = code - NOTIFY_BRNDOWN_MIN;
1983
1984         bd->props.brightness = new;
1985         backlight_update_status(bd);
1986         backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1987
1988         return old;
1989 }
1990
1991 static int asus_wmi_backlight_init(struct asus_wmi *asus)
1992 {
1993         struct backlight_device *bd;
1994         struct backlight_properties props;
1995         int max;
1996         int power;
1997
1998         max = read_brightness_max(asus);
1999         if (max < 0)
2000                 return max;
2001
2002         power = read_backlight_power(asus);
2003         if (power == -ENODEV)
2004                 power = FB_BLANK_UNBLANK;
2005         else if (power < 0)
2006                 return power;
2007
2008         memset(&props, 0, sizeof(struct backlight_properties));
2009         props.type = BACKLIGHT_PLATFORM;
2010         props.max_brightness = max;
2011         bd = backlight_device_register(asus->driver->name,
2012                                        &asus->platform_device->dev, asus,
2013                                        &asus_wmi_bl_ops, &props);
2014         if (IS_ERR(bd)) {
2015                 pr_err("Could not register backlight device\n");
2016                 return PTR_ERR(bd);
2017         }
2018
2019         asus->backlight_device = bd;
2020
2021         if (asus->driver->quirks->store_backlight_power)
2022                 asus->driver->panel_power = power;
2023
2024         bd->props.brightness = read_brightness(bd);
2025         bd->props.power = power;
2026         backlight_update_status(bd);
2027
2028         asus->driver->brightness = bd->props.brightness;
2029
2030         return 0;
2031 }
2032
2033 static void asus_wmi_backlight_exit(struct asus_wmi *asus)
2034 {
2035         backlight_device_unregister(asus->backlight_device);
2036
2037         asus->backlight_device = NULL;
2038 }
2039
2040 static int is_display_toggle(int code)
2041 {
2042         /* display toggle keys */
2043         if ((code >= 0x61 && code <= 0x67) ||
2044             (code >= 0x8c && code <= 0x93) ||
2045             (code >= 0xa0 && code <= 0xa7) ||
2046             (code >= 0xd0 && code <= 0xd5))
2047                 return 1;
2048
2049         return 0;
2050 }
2051
2052 /* Fn-lock ********************************************************************/
2053
2054 static bool asus_wmi_has_fnlock_key(struct asus_wmi *asus)
2055 {
2056         u32 result;
2057
2058         asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FNLOCK, &result);
2059
2060         return (result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
2061                 !(result & ASUS_WMI_FNLOCK_BIOS_DISABLED);
2062 }
2063
2064 static void asus_wmi_fnlock_update(struct asus_wmi *asus)
2065 {
2066         int mode = asus->fnlock_locked;
2067
2068         asus_wmi_set_devstate(ASUS_WMI_DEVID_FNLOCK, mode, NULL);
2069 }
2070
2071 /* WMI events *****************************************************************/
2072
2073 static int asus_wmi_get_event_code(u32 value)
2074 {
2075         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
2076         union acpi_object *obj;
2077         acpi_status status;
2078         int code;
2079
2080         status = wmi_get_event_data(value, &response);
2081         if (ACPI_FAILURE(status)) {
2082                 pr_warn("Failed to get WMI notify code: %s\n",
2083                                 acpi_format_exception(status));
2084                 return -EIO;
2085         }
2086
2087         obj = (union acpi_object *)response.pointer;
2088
2089         if (obj && obj->type == ACPI_TYPE_INTEGER)
2090                 code = (int)(obj->integer.value & WMI_EVENT_MASK);
2091         else
2092                 code = -EIO;
2093
2094         kfree(obj);
2095         return code;
2096 }
2097
2098 static void asus_wmi_handle_event_code(int code, struct asus_wmi *asus)
2099 {
2100         unsigned int key_value = 1;
2101         bool autorelease = 1;
2102         int result, orig_code;
2103
2104         orig_code = code;
2105
2106         if (asus->driver->key_filter) {
2107                 asus->driver->key_filter(asus->driver, &code, &key_value,
2108                                          &autorelease);
2109                 if (code == ASUS_WMI_KEY_IGNORE)
2110                         return;
2111         }
2112
2113         if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
2114                 code = ASUS_WMI_BRN_UP;
2115         else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
2116                 code = ASUS_WMI_BRN_DOWN;
2117
2118         if (code == ASUS_WMI_BRN_DOWN || code == ASUS_WMI_BRN_UP) {
2119                 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
2120                         asus_wmi_backlight_notify(asus, orig_code);
2121                         return;
2122                 }
2123         }
2124
2125         if (code == NOTIFY_KBD_BRTUP) {
2126                 kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
2127                 return;
2128         }
2129         if (code == NOTIFY_KBD_BRTDWN) {
2130                 kbd_led_set_by_kbd(asus, asus->kbd_led_wk - 1);
2131                 return;
2132         }
2133         if (code == NOTIFY_KBD_BRTTOGGLE) {
2134                 if (asus->kbd_led_wk == asus->kbd_led.max_brightness)
2135                         kbd_led_set_by_kbd(asus, 0);
2136                 else
2137                         kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
2138                 return;
2139         }
2140
2141         if (code == NOTIFY_FNLOCK_TOGGLE) {
2142                 asus->fnlock_locked = !asus->fnlock_locked;
2143                 asus_wmi_fnlock_update(asus);
2144                 return;
2145         }
2146
2147         if (asus->driver->quirks->use_kbd_dock_devid && code == NOTIFY_KBD_DOCK_CHANGE) {
2148                 result = asus_wmi_get_devstate_simple(asus,
2149                                                       ASUS_WMI_DEVID_KBD_DOCK);
2150                 if (result >= 0) {
2151                         input_report_switch(asus->inputdev, SW_TABLET_MODE,
2152                                             !result);
2153                         input_sync(asus->inputdev);
2154                 }
2155                 return;
2156         }
2157
2158         if (asus->driver->quirks->use_lid_flip_devid && code == NOTIFY_LID_FLIP) {
2159                 lid_flip_tablet_mode_get_state(asus);
2160                 return;
2161         }
2162
2163         if (asus->fan_boost_mode_available && code == NOTIFY_KBD_FBM) {
2164                 fan_boost_mode_switch_next(asus);
2165                 return;
2166         }
2167
2168         if (asus->throttle_thermal_policy_available && code == NOTIFY_KBD_TTP) {
2169                 throttle_thermal_policy_switch_next(asus);
2170                 return;
2171         }
2172
2173         if (is_display_toggle(code) && asus->driver->quirks->no_display_toggle)
2174                 return;
2175
2176         if (!sparse_keymap_report_event(asus->inputdev, code,
2177                                         key_value, autorelease))
2178                 pr_info("Unknown key %x pressed\n", code);
2179 }
2180
2181 static void asus_wmi_notify(u32 value, void *context)
2182 {
2183         struct asus_wmi *asus = context;
2184         int code;
2185         int i;
2186
2187         for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) {
2188                 code = asus_wmi_get_event_code(value);
2189                 if (code < 0) {
2190                         pr_warn("Failed to get notify code: %d\n", code);
2191                         return;
2192                 }
2193
2194                 if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK)
2195                         return;
2196
2197                 asus_wmi_handle_event_code(code, asus);
2198
2199                 /*
2200                  * Double check that queue is present:
2201                  * ATK (with queue) uses 0xff, ASUSWMI (without) 0xd2.
2202                  */
2203                 if (!asus->wmi_event_queue || value != WMI_EVENT_VALUE_ATK)
2204                         return;
2205         }
2206
2207         pr_warn("Failed to process event queue, last code: 0x%x\n", code);
2208 }
2209
2210 static int asus_wmi_notify_queue_flush(struct asus_wmi *asus)
2211 {
2212         int code;
2213         int i;
2214
2215         for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) {
2216                 code = asus_wmi_get_event_code(WMI_EVENT_VALUE_ATK);
2217                 if (code < 0) {
2218                         pr_warn("Failed to get event during flush: %d\n", code);
2219                         return code;
2220                 }
2221
2222                 if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK)
2223                         return 0;
2224         }
2225
2226         pr_warn("Failed to flush event queue\n");
2227         return -EIO;
2228 }
2229
2230 /* Sysfs **********************************************************************/
2231
2232 static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
2233                              const char *buf, size_t count)
2234 {
2235         u32 retval;
2236         int err, value;
2237
2238         value = asus_wmi_get_devstate_simple(asus, devid);
2239         if (value < 0)
2240                 return value;
2241
2242         err = kstrtoint(buf, 0, &value);
2243         if (err)
2244                 return err;
2245
2246         err = asus_wmi_set_devstate(devid, value, &retval);
2247         if (err < 0)
2248                 return err;
2249
2250         return count;
2251 }
2252
2253 static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
2254 {
2255         int value = asus_wmi_get_devstate_simple(asus, devid);
2256
2257         if (value < 0)
2258                 return value;
2259
2260         return sprintf(buf, "%d\n", value);
2261 }
2262
2263 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm)                  \
2264         static ssize_t show_##_name(struct device *dev,                 \
2265                                     struct device_attribute *attr,      \
2266                                     char *buf)                          \
2267         {                                                               \
2268                 struct asus_wmi *asus = dev_get_drvdata(dev);           \
2269                                                                         \
2270                 return show_sys_wmi(asus, _cm, buf);                    \
2271         }                                                               \
2272         static ssize_t store_##_name(struct device *dev,                \
2273                                      struct device_attribute *attr,     \
2274                                      const char *buf, size_t count)     \
2275         {                                                               \
2276                 struct asus_wmi *asus = dev_get_drvdata(dev);           \
2277                                                                         \
2278                 return store_sys_wmi(asus, _cm, buf, count);            \
2279         }                                                               \
2280         static struct device_attribute dev_attr_##_name = {             \
2281                 .attr = {                                               \
2282                         .name = __stringify(_name),                     \
2283                         .mode = _mode },                                \
2284                 .show   = show_##_name,                                 \
2285                 .store  = store_##_name,                                \
2286         }
2287
2288 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
2289 ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
2290 ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
2291 ASUS_WMI_CREATE_DEVICE_ATTR(lid_resume, 0644, ASUS_WMI_DEVID_LID_RESUME);
2292 ASUS_WMI_CREATE_DEVICE_ATTR(als_enable, 0644, ASUS_WMI_DEVID_ALS_ENABLE);
2293
2294 static ssize_t cpufv_store(struct device *dev, struct device_attribute *attr,
2295                            const char *buf, size_t count)
2296 {
2297         int value, rv;
2298
2299         rv = kstrtoint(buf, 0, &value);
2300         if (rv)
2301                 return rv;
2302
2303         if (value < 0 || value > 2)
2304                 return -EINVAL;
2305
2306         rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
2307         if (rv < 0)
2308                 return rv;
2309
2310         return count;
2311 }
2312
2313 static DEVICE_ATTR_WO(cpufv);
2314
2315 static struct attribute *platform_attributes[] = {
2316         &dev_attr_cpufv.attr,
2317         &dev_attr_camera.attr,
2318         &dev_attr_cardr.attr,
2319         &dev_attr_touchpad.attr,
2320         &dev_attr_lid_resume.attr,
2321         &dev_attr_als_enable.attr,
2322         &dev_attr_fan_boost_mode.attr,
2323         &dev_attr_throttle_thermal_policy.attr,
2324         NULL
2325 };
2326
2327 static umode_t asus_sysfs_is_visible(struct kobject *kobj,
2328                                     struct attribute *attr, int idx)
2329 {
2330         struct device *dev = container_of(kobj, struct device, kobj);
2331         struct asus_wmi *asus = dev_get_drvdata(dev);
2332         bool ok = true;
2333         int devid = -1;
2334
2335         if (attr == &dev_attr_camera.attr)
2336                 devid = ASUS_WMI_DEVID_CAMERA;
2337         else if (attr == &dev_attr_cardr.attr)
2338                 devid = ASUS_WMI_DEVID_CARDREADER;
2339         else if (attr == &dev_attr_touchpad.attr)
2340                 devid = ASUS_WMI_DEVID_TOUCHPAD;
2341         else if (attr == &dev_attr_lid_resume.attr)
2342                 devid = ASUS_WMI_DEVID_LID_RESUME;
2343         else if (attr == &dev_attr_als_enable.attr)
2344                 devid = ASUS_WMI_DEVID_ALS_ENABLE;
2345         else if (attr == &dev_attr_fan_boost_mode.attr)
2346                 ok = asus->fan_boost_mode_available;
2347         else if (attr == &dev_attr_throttle_thermal_policy.attr)
2348                 ok = asus->throttle_thermal_policy_available;
2349
2350         if (devid != -1)
2351                 ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
2352
2353         return ok ? attr->mode : 0;
2354 }
2355
2356 static const struct attribute_group platform_attribute_group = {
2357         .is_visible = asus_sysfs_is_visible,
2358         .attrs = platform_attributes
2359 };
2360
2361 static void asus_wmi_sysfs_exit(struct platform_device *device)
2362 {
2363         sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
2364 }
2365
2366 static int asus_wmi_sysfs_init(struct platform_device *device)
2367 {
2368         return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
2369 }
2370
2371 /* Platform device ************************************************************/
2372
2373 static int asus_wmi_platform_init(struct asus_wmi *asus)
2374 {
2375         struct device *dev = &asus->platform_device->dev;
2376         char *wmi_uid;
2377         int rv;
2378
2379         /* INIT enable hotkeys on some models */
2380         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
2381                 pr_info("Initialization: %#x\n", rv);
2382
2383         /* We don't know yet what to do with this version... */
2384         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
2385                 pr_info("BIOS WMI version: %d.%d\n", rv >> 16, rv & 0xFF);
2386                 asus->spec = rv;
2387         }
2388
2389         /*
2390          * The SFUN method probably allows the original driver to get the list
2391          * of features supported by a given model. For now, 0x0100 or 0x0800
2392          * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
2393          * The significance of others is yet to be found.
2394          */
2395         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
2396                 pr_info("SFUN value: %#x\n", rv);
2397                 asus->sfun = rv;
2398         }
2399
2400         /*
2401          * Eee PC and Notebooks seems to have different method_id for DSTS,
2402          * but it may also be related to the BIOS's SPEC.
2403          * Note, on most Eeepc, there is no way to check if a method exist
2404          * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
2405          * but once again, SPEC may probably be used for that kind of things.
2406          *
2407          * Additionally at least TUF Gaming series laptops return nothing for
2408          * unknown methods, so the detection in this way is not possible.
2409          *
2410          * There is strong indication that only ACPI WMI devices that have _UID
2411          * equal to "ASUSWMI" use DCTS whereas those with "ATK" use DSTS.
2412          */
2413         wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
2414         if (!wmi_uid)
2415                 return -ENODEV;
2416
2417         if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI)) {
2418                 dev_info(dev, "Detected ASUSWMI, use DCTS\n");
2419                 asus->dsts_id = ASUS_WMI_METHODID_DCTS;
2420         } else {
2421                 dev_info(dev, "Detected %s, not ASUSWMI, use DSTS\n", wmi_uid);
2422                 asus->dsts_id = ASUS_WMI_METHODID_DSTS;
2423         }
2424
2425         /*
2426          * Some devices can have multiple event codes stored in a queue before
2427          * the module load if it was unloaded intermittently after calling
2428          * the INIT method (enables event handling). The WMI notify handler is
2429          * expected to retrieve all event codes until a retrieved code equals
2430          * queue end marker (One or Ones). Old codes are flushed from the queue
2431          * upon module load. Not enabling this when it should be has minimal
2432          * visible impact so fall back if anything goes wrong.
2433          */
2434         wmi_uid = wmi_get_acpi_device_uid(asus->driver->event_guid);
2435         if (wmi_uid && !strcmp(wmi_uid, ASUS_ACPI_UID_ATK)) {
2436                 dev_info(dev, "Detected ATK, enable event queue\n");
2437
2438                 if (!asus_wmi_notify_queue_flush(asus))
2439                         asus->wmi_event_queue = true;
2440         }
2441
2442         /* CWAP allow to define the behavior of the Fn+F2 key,
2443          * this method doesn't seems to be present on Eee PCs */
2444         if (asus->driver->quirks->wapf >= 0)
2445                 asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP,
2446                                       asus->driver->quirks->wapf, NULL);
2447
2448         return 0;
2449 }
2450
2451 /* debugfs ********************************************************************/
2452
2453 struct asus_wmi_debugfs_node {
2454         struct asus_wmi *asus;
2455         char *name;
2456         int (*show) (struct seq_file *m, void *data);
2457 };
2458
2459 static int show_dsts(struct seq_file *m, void *data)
2460 {
2461         struct asus_wmi *asus = m->private;
2462         int err;
2463         u32 retval = -1;
2464
2465         err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
2466         if (err < 0)
2467                 return err;
2468
2469         seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
2470
2471         return 0;
2472 }
2473
2474 static int show_devs(struct seq_file *m, void *data)
2475 {
2476         struct asus_wmi *asus = m->private;
2477         int err;
2478         u32 retval = -1;
2479
2480         err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
2481                                     &retval);
2482         if (err < 0)
2483                 return err;
2484
2485         seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
2486                    asus->debug.ctrl_param, retval);
2487
2488         return 0;
2489 }
2490
2491 static int show_call(struct seq_file *m, void *data)
2492 {
2493         struct asus_wmi *asus = m->private;
2494         struct bios_args args = {
2495                 .arg0 = asus->debug.dev_id,
2496                 .arg1 = asus->debug.ctrl_param,
2497         };
2498         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
2499         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
2500         union acpi_object *obj;
2501         acpi_status status;
2502
2503         status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
2504                                      0, asus->debug.method_id,
2505                                      &input, &output);
2506
2507         if (ACPI_FAILURE(status))
2508                 return -EIO;
2509
2510         obj = (union acpi_object *)output.pointer;
2511         if (obj && obj->type == ACPI_TYPE_INTEGER)
2512                 seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
2513                            asus->debug.dev_id, asus->debug.ctrl_param,
2514                            (u32) obj->integer.value);
2515         else
2516                 seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
2517                            asus->debug.dev_id, asus->debug.ctrl_param,
2518                            obj ? obj->type : -1);
2519
2520         kfree(obj);
2521
2522         return 0;
2523 }
2524
2525 static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
2526         {NULL, "devs", show_devs},
2527         {NULL, "dsts", show_dsts},
2528         {NULL, "call", show_call},
2529 };
2530
2531 static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
2532 {
2533         struct asus_wmi_debugfs_node *node = inode->i_private;
2534
2535         return single_open(file, node->show, node->asus);
2536 }
2537
2538 static const struct file_operations asus_wmi_debugfs_io_ops = {
2539         .owner = THIS_MODULE,
2540         .open = asus_wmi_debugfs_open,
2541         .read = seq_read,
2542         .llseek = seq_lseek,
2543         .release = single_release,
2544 };
2545
2546 static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
2547 {
2548         debugfs_remove_recursive(asus->debug.root);
2549 }
2550
2551 static void asus_wmi_debugfs_init(struct asus_wmi *asus)
2552 {
2553         int i;
2554
2555         asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
2556
2557         debugfs_create_x32("method_id", S_IRUGO | S_IWUSR, asus->debug.root,
2558                            &asus->debug.method_id);
2559
2560         debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR, asus->debug.root,
2561                            &asus->debug.dev_id);
2562
2563         debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR, asus->debug.root,
2564                            &asus->debug.ctrl_param);
2565
2566         for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
2567                 struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
2568
2569                 node->asus = asus;
2570                 debugfs_create_file(node->name, S_IFREG | S_IRUGO,
2571                                     asus->debug.root, node,
2572                                     &asus_wmi_debugfs_io_ops);
2573         }
2574 }
2575
2576 /* Init / exit ****************************************************************/
2577
2578 static int asus_wmi_add(struct platform_device *pdev)
2579 {
2580         struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
2581         struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
2582         struct asus_wmi *asus;
2583         const char *chassis_type;
2584         acpi_status status;
2585         int err;
2586         u32 result;
2587
2588         asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
2589         if (!asus)
2590                 return -ENOMEM;
2591
2592         asus->driver = wdrv;
2593         asus->platform_device = pdev;
2594         wdrv->platform_device = pdev;
2595         platform_set_drvdata(asus->platform_device, asus);
2596
2597         if (wdrv->detect_quirks)
2598                 wdrv->detect_quirks(asus->driver);
2599
2600         err = asus_wmi_platform_init(asus);
2601         if (err)
2602                 goto fail_platform;
2603
2604         err = fan_boost_mode_check_present(asus);
2605         if (err)
2606                 goto fail_fan_boost_mode;
2607
2608         err = throttle_thermal_policy_check_present(asus);
2609         if (err)
2610                 goto fail_throttle_thermal_policy;
2611         else
2612                 throttle_thermal_policy_set_default(asus);
2613
2614         err = asus_wmi_sysfs_init(asus->platform_device);
2615         if (err)
2616                 goto fail_sysfs;
2617
2618         err = asus_wmi_input_init(asus);
2619         if (err)
2620                 goto fail_input;
2621
2622         err = asus_wmi_fan_init(asus); /* probably no problems on error */
2623
2624         err = asus_wmi_hwmon_init(asus);
2625         if (err)
2626                 goto fail_hwmon;
2627
2628         err = asus_wmi_led_init(asus);
2629         if (err)
2630                 goto fail_leds;
2631
2632         asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result);
2633         if (result & (ASUS_WMI_DSTS_PRESENCE_BIT | ASUS_WMI_DSTS_USER_BIT))
2634                 asus->driver->wlan_ctrl_by_user = 1;
2635
2636         if (!(asus->driver->wlan_ctrl_by_user && ashs_present())) {
2637                 err = asus_wmi_rfkill_init(asus);
2638                 if (err)
2639                         goto fail_rfkill;
2640         }
2641
2642         if (asus->driver->quirks->wmi_force_als_set)
2643                 asus_wmi_set_als();
2644
2645         /* Some Asus desktop boards export an acpi-video backlight interface,
2646            stop this from showing up */
2647         chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE);
2648         if (chassis_type && !strcmp(chassis_type, "3"))
2649                 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
2650
2651         if (asus->driver->quirks->wmi_backlight_power)
2652                 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
2653
2654         if (asus->driver->quirks->wmi_backlight_native)
2655                 acpi_video_set_dmi_backlight_type(acpi_backlight_native);
2656
2657         if (asus->driver->quirks->xusb2pr)
2658                 asus_wmi_set_xusb2pr(asus);
2659
2660         if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
2661                 err = asus_wmi_backlight_init(asus);
2662                 if (err && err != -ENODEV)
2663                         goto fail_backlight;
2664         } else if (asus->driver->quirks->wmi_backlight_set_devstate)
2665                 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT, 2, NULL);
2666
2667         if (asus_wmi_has_fnlock_key(asus)) {
2668                 asus->fnlock_locked = true;
2669                 asus_wmi_fnlock_update(asus);
2670         }
2671
2672         status = wmi_install_notify_handler(asus->driver->event_guid,
2673                                             asus_wmi_notify, asus);
2674         if (ACPI_FAILURE(status)) {
2675                 pr_err("Unable to register notify handler - %d\n", status);
2676                 err = -ENODEV;
2677                 goto fail_wmi_handler;
2678         }
2679
2680         asus_wmi_battery_init(asus);
2681
2682         asus_wmi_debugfs_init(asus);
2683
2684         return 0;
2685
2686 fail_wmi_handler:
2687         asus_wmi_backlight_exit(asus);
2688 fail_backlight:
2689         asus_wmi_rfkill_exit(asus);
2690 fail_rfkill:
2691         asus_wmi_led_exit(asus);
2692 fail_leds:
2693 fail_hwmon:
2694         asus_wmi_input_exit(asus);
2695 fail_input:
2696         asus_wmi_sysfs_exit(asus->platform_device);
2697 fail_sysfs:
2698 fail_throttle_thermal_policy:
2699 fail_fan_boost_mode:
2700 fail_platform:
2701         kfree(asus);
2702         return err;
2703 }
2704
2705 static int asus_wmi_remove(struct platform_device *device)
2706 {
2707         struct asus_wmi *asus;
2708
2709         asus = platform_get_drvdata(device);
2710         wmi_remove_notify_handler(asus->driver->event_guid);
2711         asus_wmi_backlight_exit(asus);
2712         asus_wmi_input_exit(asus);
2713         asus_wmi_led_exit(asus);
2714         asus_wmi_rfkill_exit(asus);
2715         asus_wmi_debugfs_exit(asus);
2716         asus_wmi_sysfs_exit(asus->platform_device);
2717         asus_fan_set_auto(asus);
2718         asus_wmi_battery_exit(asus);
2719
2720         kfree(asus);
2721         return 0;
2722 }
2723
2724 /* Platform driver - hibernate/resume callbacks *******************************/
2725
2726 static int asus_hotk_thaw(struct device *device)
2727 {
2728         struct asus_wmi *asus = dev_get_drvdata(device);
2729
2730         if (asus->wlan.rfkill) {
2731                 bool wlan;
2732
2733                 /*
2734                  * Work around bios bug - acpi _PTS turns off the wireless led
2735                  * during suspend.  Normally it restores it on resume, but
2736                  * we should kick it ourselves in case hibernation is aborted.
2737                  */
2738                 wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
2739                 asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
2740         }
2741
2742         return 0;
2743 }
2744
2745 static int asus_hotk_resume(struct device *device)
2746 {
2747         struct asus_wmi *asus = dev_get_drvdata(device);
2748
2749         if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
2750                 kbd_led_update(asus);
2751
2752         if (asus_wmi_has_fnlock_key(asus))
2753                 asus_wmi_fnlock_update(asus);
2754
2755         if (asus->driver->quirks->use_lid_flip_devid)
2756                 lid_flip_tablet_mode_get_state(asus);
2757
2758         return 0;
2759 }
2760
2761 static int asus_hotk_restore(struct device *device)
2762 {
2763         struct asus_wmi *asus = dev_get_drvdata(device);
2764         int bl;
2765
2766         /* Refresh both wlan rfkill state and pci hotplug */
2767         if (asus->wlan.rfkill)
2768                 asus_rfkill_hotplug(asus);
2769
2770         if (asus->bluetooth.rfkill) {
2771                 bl = !asus_wmi_get_devstate_simple(asus,
2772                                                    ASUS_WMI_DEVID_BLUETOOTH);
2773                 rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
2774         }
2775         if (asus->wimax.rfkill) {
2776                 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
2777                 rfkill_set_sw_state(asus->wimax.rfkill, bl);
2778         }
2779         if (asus->wwan3g.rfkill) {
2780                 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
2781                 rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
2782         }
2783         if (asus->gps.rfkill) {
2784                 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS);
2785                 rfkill_set_sw_state(asus->gps.rfkill, bl);
2786         }
2787         if (asus->uwb.rfkill) {
2788                 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB);
2789                 rfkill_set_sw_state(asus->uwb.rfkill, bl);
2790         }
2791         if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
2792                 kbd_led_update(asus);
2793
2794         if (asus_wmi_has_fnlock_key(asus))
2795                 asus_wmi_fnlock_update(asus);
2796
2797         if (asus->driver->quirks->use_lid_flip_devid)
2798                 lid_flip_tablet_mode_get_state(asus);
2799
2800         return 0;
2801 }
2802
2803 static const struct dev_pm_ops asus_pm_ops = {
2804         .thaw = asus_hotk_thaw,
2805         .restore = asus_hotk_restore,
2806         .resume = asus_hotk_resume,
2807 };
2808
2809 /* Registration ***************************************************************/
2810
2811 static int asus_wmi_probe(struct platform_device *pdev)
2812 {
2813         struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
2814         struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
2815         int ret;
2816
2817         if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
2818                 pr_warn("ASUS Management GUID not found\n");
2819                 return -ENODEV;
2820         }
2821
2822         if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
2823                 pr_warn("ASUS Event GUID not found\n");
2824                 return -ENODEV;
2825         }
2826
2827         if (wdrv->probe) {
2828                 ret = wdrv->probe(pdev);
2829                 if (ret)
2830                         return ret;
2831         }
2832
2833         return asus_wmi_add(pdev);
2834 }
2835
2836 static bool used;
2837
2838 int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
2839 {
2840         struct platform_driver *platform_driver;
2841         struct platform_device *platform_device;
2842
2843         if (used)
2844                 return -EBUSY;
2845
2846         platform_driver = &driver->platform_driver;
2847         platform_driver->remove = asus_wmi_remove;
2848         platform_driver->driver.owner = driver->owner;
2849         platform_driver->driver.name = driver->name;
2850         platform_driver->driver.pm = &asus_pm_ops;
2851
2852         platform_device = platform_create_bundle(platform_driver,
2853                                                  asus_wmi_probe,
2854                                                  NULL, 0, NULL, 0);
2855         if (IS_ERR(platform_device))
2856                 return PTR_ERR(platform_device);
2857
2858         used = true;
2859         return 0;
2860 }
2861 EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
2862
2863 void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
2864 {
2865         platform_device_unregister(driver->platform_device);
2866         platform_driver_unregister(&driver->platform_driver);
2867         used = false;
2868 }
2869 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
2870
2871 static int __init asus_wmi_init(void)
2872 {
2873         pr_info("ASUS WMI generic driver loaded\n");
2874         return 0;
2875 }
2876
2877 static void __exit asus_wmi_exit(void)
2878 {
2879         pr_info("ASUS WMI generic driver unloaded\n");
2880 }
2881
2882 module_init(asus_wmi_init);
2883 module_exit(asus_wmi_exit);