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