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