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