drivers/platform/x86/asus-wmi.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Asus PC WMI hotkey driver
   4  *
   5  * Copyright(C) 2010 Intel Corporation.
   6  * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
   7  *
   8  * Portions based on wistron_btns.c:
   9  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
  10  * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
  11  * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
  12  */
  13
  14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  15
  16 #include <linux/acpi.h>
  17 #include <linux/backlight.h>
  18 #include <linux/debugfs.h>
  19 #include <linux/dmi.h>
  20 #include <linux/fb.h>
  21 #include <linux/hwmon.h>
  22 #include <linux/hwmon-sysfs.h>
  23 #include <linux/init.h>
  24 #include <linux/input.h>
  25 #include <linux/input/sparse-keymap.h>
  26 #include <linux/kernel.h>
  27 #include <linux/leds.h>
  28 #include <linux/module.h>
  29 #include <linux/pci.h>
  30 #include <linux/pci_hotplug.h>
  31 #include <linux/platform_data/x86/asus-wmi.h>
  32 #include <linux/platform_device.h>
  33 #include <linux/platform_profile.h>
  34 #include <linux/power_supply.h>
  35 #include <linux/rfkill.h>
  36 #include <linux/seq_file.h>
  37 #include <linux/slab.h>
  38 #include <linux/types.h>
  39 #include <linux/units.h>
  40
  41 #include <acpi/battery.h>
  42 #include <acpi/video.h>
  43
  44 #include "asus-wmi.h"
  45
  46 MODULE_AUTHOR("Corentin Chary <corentin.chary@gmail.com>");
  47 MODULE_AUTHOR("Yong Wang <yong.y.wang@intel.com>");
  48 MODULE_DESCRIPTION("Asus Generic WMI Driver");
  49 MODULE_LICENSE("GPL");
  50
  51 static bool fnlock_default = true;
  52 module_param(fnlock_default, bool, 0444);
  53
  54 #define to_asus_wmi_driver(pdrv)                                        \
  55         (container_of((pdrv), struct asus_wmi_driver, platform_driver))
  56
  57 #define ASUS_WMI_MGMT_GUID      "97845ED0-4E6D-11DE-8A39-0800200C9A66"
  58
  59 #define NOTIFY_BRNUP_MIN                0x11
  60 #define NOTIFY_BRNUP_MAX                0x1f
  61 #define NOTIFY_BRNDOWN_MIN              0x20
  62 #define NOTIFY_BRNDOWN_MAX              0x2e
  63 #define NOTIFY_FNLOCK_TOGGLE            0x4e
  64 #define NOTIFY_KBD_DOCK_CHANGE          0x75
  65 #define NOTIFY_KBD_BRTUP                0xc4
  66 #define NOTIFY_KBD_BRTDWN               0xc5
  67 #define NOTIFY_KBD_BRTTOGGLE            0xc7
  68 #define NOTIFY_KBD_FBM                  0x99
  69 #define NOTIFY_KBD_TTP                  0xae
  70 #define NOTIFY_LID_FLIP                 0xfa
  71
  72 #define ASUS_WMI_FNLOCK_BIOS_DISABLED   BIT(0)
  73
  74 #define ASUS_FAN_DESC                   "cpu_fan"
  75 #define ASUS_FAN_MFUN                   0x13
  76 #define ASUS_FAN_SFUN_READ              0x06
  77 #define ASUS_FAN_SFUN_WRITE             0x07
  78
  79 /* Based on standard hwmon pwmX_enable values */
  80 #define ASUS_FAN_CTRL_FULLSPEED         0
  81 #define ASUS_FAN_CTRL_MANUAL            1
  82 #define ASUS_FAN_CTRL_AUTO              2
  83
  84 #define ASUS_FAN_BOOST_MODE_NORMAL              0
  85 #define ASUS_FAN_BOOST_MODE_OVERBOOST           1
  86 #define ASUS_FAN_BOOST_MODE_OVERBOOST_MASK      0x01
  87 #define ASUS_FAN_BOOST_MODE_SILENT              2
  88 #define ASUS_FAN_BOOST_MODE_SILENT_MASK         0x02
  89 #define ASUS_FAN_BOOST_MODES_MASK               0x03
  90
  91 #define ASUS_THROTTLE_THERMAL_POLICY_DEFAULT    0
  92 #define ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST  1
  93 #define ASUS_THROTTLE_THERMAL_POLICY_SILENT     2
  94
  95 #define USB_INTEL_XUSB2PR               0xD0
  96 #define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI   0x9c31
  97
  98 #define ASUS_ACPI_UID_ASUSWMI           "ASUSWMI"
  99 #define ASUS_ACPI_UID_ATK               "ATK"
 100
 101 #define WMI_EVENT_QUEUE_SIZE            0x10
 102 #define WMI_EVENT_QUEUE_END             0x1
 103 #define WMI_EVENT_MASK                  0xFFFF
 104 /* The WMI hotkey event value is always the same. */
 105 #define WMI_EVENT_VALUE_ATK             0xFF
 106
 107 #define WMI_EVENT_MASK                  0xFFFF
 108
 109 #define FAN_CURVE_POINTS                8
 110 #define FAN_CURVE_BUF_LEN               (FAN_CURVE_POINTS * 2)
 111 #define FAN_CURVE_DEV_CPU               0x00
 112 #define FAN_CURVE_DEV_GPU               0x01
 113 /* Mask to determine if setting temperature or percentage */
 114 #define FAN_CURVE_PWM_MASK              0x04
 115
 116 static const char * const ashs_ids[] = { "ATK4001", "ATK4002", NULL };
 117
 118 static int throttle_thermal_policy_write(struct asus_wmi *);
 119
 120 static bool ashs_present(void)
 121 {
 122         int i = 0;
 123         while (ashs_ids[i]) {
 124                 if (acpi_dev_found(ashs_ids[i++]))
 125                         return true;
 126         }
 127         return false;
 128 }
 129
 130 struct bios_args {
 131         u32 arg0;
 132         u32 arg1;
 133         u32 arg2; /* At least TUF Gaming series uses 3 dword input buffer. */
 134         u32 arg3;
 135         u32 arg4; /* Some ROG laptops require a full 5 input args */
 136         u32 arg5;
 137 } __packed;
 138
 139 /*
 140  * Struct that's used for all methods called via AGFN. Naming is
 141  * identically to the AML code.
 142  */
 143 struct agfn_args {
 144         u16 mfun; /* probably "Multi-function" to be called */
 145         u16 sfun; /* probably "Sub-function" to be called */
 146         u16 len;  /* size of the hole struct, including subfunction fields */
 147         u8 stas;  /* not used by now */
 148         u8 err;   /* zero on success */
 149 } __packed;
 150
 151 /* struct used for calling fan read and write methods */
 152 struct agfn_fan_args {
 153         struct agfn_args agfn;  /* common fields */
 154         u8 fan;                 /* fan number: 0: set auto mode 1: 1st fan */
 155         u32 speed;              /* read: RPM/100 - write: 0-255 */
 156 } __packed;
 157
 158 /*
 159  * <platform>/    - debugfs root directory
 160  *   dev_id      - current dev_id
 161  *   ctrl_param  - current ctrl_param
 162  *   method_id   - current method_id
 163  *   devs        - call DEVS(dev_id, ctrl_param) and print result
 164  *   dsts        - call DSTS(dev_id)  and print result
 165  *   call        - call method_id(dev_id, ctrl_param) and print result
 166  */
 167 struct asus_wmi_debug {
 168         struct dentry *root;
 169         u32 method_id;
 170         u32 dev_id;
 171         u32 ctrl_param;
 172 };
 173
 174 struct asus_rfkill {
 175         struct asus_wmi *asus;
 176         struct rfkill *rfkill;
 177         u32 dev_id;
 178 };
 179
 180 enum fan_type {
 181         FAN_TYPE_NONE = 0,
 182         FAN_TYPE_AGFN,          /* deprecated on newer platforms */
 183         FAN_TYPE_SPEC83,        /* starting in Spec 8.3, use CPU_FAN_CTRL */
 184 };
 185
 186 struct fan_curve_data {
 187         bool enabled;
 188         u32 device_id;
 189         u8 temps[FAN_CURVE_POINTS];
 190         u8 percents[FAN_CURVE_POINTS];
 191 };
 192
 193 struct asus_wmi {
 194         int dsts_id;
 195         int spec;
 196         int sfun;
 197         bool wmi_event_queue;
 198
 199         struct input_dev *inputdev;
 200         struct backlight_device *backlight_device;
 201         struct platform_device *platform_device;
 202
 203         struct led_classdev wlan_led;
 204         int wlan_led_wk;
 205         struct led_classdev tpd_led;
 206         int tpd_led_wk;
 207         struct led_classdev kbd_led;
 208         int kbd_led_wk;
 209         struct led_classdev lightbar_led;
 210         int lightbar_led_wk;
 211         struct workqueue_struct *led_workqueue;
 212         struct work_struct tpd_led_work;
 213         struct work_struct wlan_led_work;
 214         struct work_struct lightbar_led_work;
 215
 216         struct asus_rfkill wlan;
 217         struct asus_rfkill bluetooth;
 218         struct asus_rfkill wimax;
 219         struct asus_rfkill wwan3g;
 220         struct asus_rfkill gps;
 221         struct asus_rfkill uwb;
 222
 223         enum fan_type fan_type;
 224         int fan_pwm_mode;
 225         int agfn_pwm;
 226
 227         bool fan_boost_mode_available;
 228         u8 fan_boost_mode_mask;
 229         u8 fan_boost_mode;
 230
 231         bool egpu_enable_available; // 0 = enable
 232         bool egpu_enable;
 233
 234         bool dgpu_disable_available;
 235         bool dgpu_disable;
 236
 237         bool throttle_thermal_policy_available;
 238         u8 throttle_thermal_policy_mode;
 239
 240         bool cpu_fan_curve_available;
 241         bool gpu_fan_curve_available;
 242         struct fan_curve_data custom_fan_curves[2];
 243
 244         struct platform_profile_handler platform_profile_handler;
 245         bool platform_profile_support;
 246
 247         // The RSOC controls the maximum charging percentage.
 248         bool battery_rsoc_available;
 249
 250         bool panel_overdrive_available;
 251         bool panel_overdrive;
 252
 253         struct hotplug_slot hotplug_slot;
 254         struct mutex hotplug_lock;
 255         struct mutex wmi_lock;
 256         struct workqueue_struct *hotplug_workqueue;
 257         struct work_struct hotplug_work;
 258
 259         bool fnlock_locked;
 260
 261         struct asus_wmi_debug debug;
 262
 263         struct asus_wmi_driver *driver;
 264 };
 265
 266 /* WMI ************************************************************************/
 267
 268 static int asus_wmi_evaluate_method3(u32 method_id,
 269                 u32 arg0, u32 arg1, u32 arg2, u32 *retval)
 270 {
 271         struct bios_args args = {
 272                 .arg0 = arg0,
 273                 .arg1 = arg1,
 274                 .arg2 = arg2,
 275         };
 276         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
 277         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
 278         acpi_status status;
 279         union acpi_object *obj;
 280         u32 tmp = 0;
 281
 282         status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
 283                                      &input, &output);
 284
 285         if (ACPI_FAILURE(status))
 286                 return -EIO;
 287
 288         obj = (union acpi_object *)output.pointer;
 289         if (obj && obj->type == ACPI_TYPE_INTEGER)
 290                 tmp = (u32) obj->integer.value;
 291
 292         if (retval)
 293                 *retval = tmp;
 294
 295         kfree(obj);
 296
 297         if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
 298                 return -ENODEV;
 299
 300         return 0;
 301 }
 302
 303 int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1, u32 *retval)
 304 {
 305         return asus_wmi_evaluate_method3(method_id, arg0, arg1, 0, retval);
 306 }
 307 EXPORT_SYMBOL_GPL(asus_wmi_evaluate_method);
 308
 309 static int asus_wmi_evaluate_method5(u32 method_id,
 310                 u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4, u32 *retval)
 311 {
 312         struct bios_args args = {
 313                 .arg0 = arg0,
 314                 .arg1 = arg1,
 315                 .arg2 = arg2,
 316                 .arg3 = arg3,
 317                 .arg4 = arg4,
 318         };
 319         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
 320         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
 321         acpi_status status;
 322         union acpi_object *obj;
 323         u32 tmp = 0;
 324
 325         status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
 326                                      &input, &output);
 327
 328         if (ACPI_FAILURE(status))
 329                 return -EIO;
 330
 331         obj = (union acpi_object *)output.pointer;
 332         if (obj && obj->type == ACPI_TYPE_INTEGER)
 333                 tmp = (u32) obj->integer.value;
 334
 335         if (retval)
 336                 *retval = tmp;
 337
 338         kfree(obj);
 339
 340         if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
 341                 return -ENODEV;
 342
 343         return 0;
 344 }
 345
 346 /*
 347  * Returns as an error if the method output is not a buffer. Typically this
 348  * means that the method called is unsupported.
 349  */
 350 static int asus_wmi_evaluate_method_buf(u32 method_id,
 351                 u32 arg0, u32 arg1, u8 *ret_buffer, size_t size)
 352 {
 353         struct bios_args args = {
 354                 .arg0 = arg0,
 355                 .arg1 = arg1,
 356                 .arg2 = 0,
 357         };
 358         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
 359         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
 360         acpi_status status;
 361         union acpi_object *obj;
 362         int err = 0;
 363
 364         status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
 365                                      &input, &output);
 366
 367         if (ACPI_FAILURE(status))
 368                 return -EIO;
 369
 370         obj = (union acpi_object *)output.pointer;
 371
 372         switch (obj->type) {
 373         case ACPI_TYPE_BUFFER:
 374                 if (obj->buffer.length > size) {
 375                         err = -ENOSPC;
 376                         break;
 377                 }
 378                 if (obj->buffer.length == 0) {
 379                         err = -ENODATA;
 380                         break;
 381                 }
 382
 383                 memcpy(ret_buffer, obj->buffer.pointer, obj->buffer.length);
 384                 break;
 385         case ACPI_TYPE_INTEGER:
 386                 err = (u32)obj->integer.value;
 387
 388                 if (err == ASUS_WMI_UNSUPPORTED_METHOD)
 389                         err = -ENODEV;
 390                 /*
 391                  * At least one method returns a 0 with no buffer if no arg
 392                  * is provided, such as ASUS_WMI_DEVID_CPU_FAN_CURVE
 393                  */
 394                 if (err == 0)
 395                         err = -ENODATA;
 396                 break;
 397         default:
 398                 err = -ENODATA;
 399                 break;
 400         }
 401
 402         kfree(obj);
 403
 404         if (err)
 405                 return err;
 406
 407         return 0;
 408 }
 409
 410 static int asus_wmi_evaluate_method_agfn(const struct acpi_buffer args)
 411 {
 412         struct acpi_buffer input;
 413         u64 phys_addr;
 414         u32 retval;
 415         u32 status;
 416
 417         /*
 418          * Copy to dma capable address otherwise memory corruption occurs as
 419          * bios has to be able to access it.
 420          */
 421         input.pointer = kmemdup(args.pointer, args.length, GFP_DMA | GFP_KERNEL);
 422         input.length = args.length;
 423         if (!input.pointer)
 424                 return -ENOMEM;
 425         phys_addr = virt_to_phys(input.pointer);
 426
 427         status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_AGFN,
 428                                         phys_addr, 0, &retval);
 429         if (!status)
 430                 memcpy(args.pointer, input.pointer, args.length);
 431
 432         kfree(input.pointer);
 433         if (status)
 434                 return -ENXIO;
 435
 436         return retval;
 437 }
 438
 439 static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
 440 {
 441         return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
 442 }
 443
 444 static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
 445                                  u32 *retval)
 446 {
 447         return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
 448                                         ctrl_param, retval);
 449 }
 450
 451 /* Helper for special devices with magic return codes */
 452 static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
 453                                       u32 dev_id, u32 mask)
 454 {
 455         u32 retval = 0;
 456         int err;
 457
 458         err = asus_wmi_get_devstate(asus, dev_id, &retval);
 459         if (err < 0)
 460                 return err;
 461
 462         if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
 463                 return -ENODEV;
 464
 465         if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
 466                 if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
 467                         return -ENODEV;
 468         }
 469
 470         return retval & mask;
 471 }
 472
 473 static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
 474 {
 475         return asus_wmi_get_devstate_bits(asus, dev_id,
 476                                           ASUS_WMI_DSTS_STATUS_BIT);
 477 }
 478
 479 static bool asus_wmi_dev_is_present(struct asus_wmi *asus, u32 dev_id)
 480 {
 481         u32 retval;
 482         int status = asus_wmi_get_devstate(asus, dev_id, &retval);
 483
 484         return status == 0 && (retval & ASUS_WMI_DSTS_PRESENCE_BIT);
 485 }
 486
 487 /* Input **********************************************************************/
 488
 489 static int asus_wmi_input_init(struct asus_wmi *asus)
 490 {
 491         int err, result;
 492
 493         asus->inputdev = input_allocate_device();
 494         if (!asus->inputdev)
 495                 return -ENOMEM;
 496
 497         asus->inputdev->name = asus->driver->input_name;
 498         asus->inputdev->phys = asus->driver->input_phys;
 499         asus->inputdev->id.bustype = BUS_HOST;
 500         asus->inputdev->dev.parent = &asus->platform_device->dev;
 501         set_bit(EV_REP, asus->inputdev->evbit);
 502
 503         err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
 504         if (err)
 505                 goto err_free_dev;
 506
 507         if (asus->driver->quirks->use_kbd_dock_devid) {
 508                 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_KBD_DOCK);
 509                 if (result >= 0) {
 510                         input_set_capability(asus->inputdev, EV_SW, SW_TABLET_MODE);
 511                         input_report_switch(asus->inputdev, SW_TABLET_MODE, !result);
 512                 } else if (result != -ENODEV) {
 513                         pr_err("Error checking for keyboard-dock: %d\n", result);
 514                 }
 515         }
 516
 517         if (asus->driver->quirks->use_lid_flip_devid) {
 518                 result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_LID_FLIP);
 519                 if (result < 0)
 520                         asus->driver->quirks->use_lid_flip_devid = 0;
 521                 if (result >= 0) {
 522                         input_set_capability(asus->inputdev, EV_SW, SW_TABLET_MODE);
 523                         input_report_switch(asus->inputdev, SW_TABLET_MODE, result);
 524                 } else if (result == -ENODEV) {
 525                         pr_err("This device has lid_flip quirk but got ENODEV checking it. This is a bug.");
 526                 } else {
 527                         pr_err("Error checking for lid-flip: %d\n", result);
 528                 }
 529         }
 530
 531         err = input_register_device(asus->inputdev);
 532         if (err)
 533                 goto err_free_dev;
 534
 535         return 0;
 536
 537 err_free_dev:
 538         input_free_device(asus->inputdev);
 539         return err;
 540 }
 541
 542 static void asus_wmi_input_exit(struct asus_wmi *asus)
 543 {
 544         if (asus->inputdev)
 545                 input_unregister_device(asus->inputdev);
 546
 547         asus->inputdev = NULL;
 548 }
 549
 550 /* Tablet mode ****************************************************************/
 551
 552 static void lid_flip_tablet_mode_get_state(struct asus_wmi *asus)
 553 {
 554         int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_LID_FLIP);
 555
 556         if (result >= 0) {
 557                 input_report_switch(asus->inputdev, SW_TABLET_MODE, result);
 558                 input_sync(asus->inputdev);
 559         }
 560 }
 561
 562 /* dGPU ********************************************************************/
 563 static int dgpu_disable_check_present(struct asus_wmi *asus)
 564 {
 565         u32 result;
 566         int err;
 567
 568         asus->dgpu_disable_available = false;
 569
 570         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_DGPU, &result);
 571         if (err) {
 572                 if (err == -ENODEV)
 573                         return 0;
 574                 return err;
 575         }
 576
 577         if (result & ASUS_WMI_DSTS_PRESENCE_BIT) {
 578                 asus->dgpu_disable_available = true;
 579                 asus->dgpu_disable = result & ASUS_WMI_DSTS_STATUS_BIT;
 580         }
 581
 582         return 0;
 583 }
 584
 585 static int dgpu_disable_write(struct asus_wmi *asus)
 586 {
 587         u32 retval;
 588         u8 value;
 589         int err;
 590
 591         /* Don't rely on type conversion */
 592         value = asus->dgpu_disable ? 1 : 0;
 593
 594         err = asus_wmi_set_devstate(ASUS_WMI_DEVID_DGPU, value, &retval);
 595         if (err) {
 596                 pr_warn("Failed to set dgpu disable: %d\n", err);
 597                 return err;
 598         }
 599
 600         if (retval > 1) {
 601                 pr_warn("Failed to set dgpu disable (retval): 0x%x\n", retval);
 602                 return -EIO;
 603         }
 604
 605         sysfs_notify(&asus->platform_device->dev.kobj, NULL, "dgpu_disable");
 606
 607         return 0;
 608 }
 609
 610 static ssize_t dgpu_disable_show(struct device *dev,
 611                                    struct device_attribute *attr, char *buf)
 612 {
 613         struct asus_wmi *asus = dev_get_drvdata(dev);
 614         u8 mode = asus->dgpu_disable;
 615
 616         return sysfs_emit(buf, "%d\n", mode);
 617 }
 618
 619 /*
 620  * A user may be required to store the value twice, typcial store first, then
 621  * rescan PCI bus to activate power, then store a second time to save correctly.
 622  * The reason for this is that an extra code path in the ACPI is enabled when
 623  * the device and bus are powered.
 624  */
 625 static ssize_t dgpu_disable_store(struct device *dev,
 626                                     struct device_attribute *attr,
 627                                     const char *buf, size_t count)
 628 {
 629         bool disable;
 630         int result;
 631
 632         struct asus_wmi *asus = dev_get_drvdata(dev);
 633
 634         result = kstrtobool(buf, &disable);
 635         if (result)
 636                 return result;
 637
 638         asus->dgpu_disable = disable;
 639
 640         result = dgpu_disable_write(asus);
 641         if (result)
 642                 return result;
 643
 644         return count;
 645 }
 646
 647 static DEVICE_ATTR_RW(dgpu_disable);
 648
 649 /* eGPU ********************************************************************/
 650 static int egpu_enable_check_present(struct asus_wmi *asus)
 651 {
 652         u32 result;
 653         int err;
 654
 655         asus->egpu_enable_available = false;
 656
 657         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_EGPU, &result);
 658         if (err) {
 659                 if (err == -ENODEV)
 660                         return 0;
 661                 return err;
 662         }
 663
 664         if (result & ASUS_WMI_DSTS_PRESENCE_BIT) {
 665                 asus->egpu_enable_available = true;
 666                 asus->egpu_enable = result & ASUS_WMI_DSTS_STATUS_BIT;
 667         }
 668
 669         return 0;
 670 }
 671
 672 static int egpu_enable_write(struct asus_wmi *asus)
 673 {
 674         u32 retval;
 675         u8 value;
 676         int err;
 677
 678         /* Don't rely on type conversion */
 679         value = asus->egpu_enable ? 1 : 0;
 680
 681         err = asus_wmi_set_devstate(ASUS_WMI_DEVID_EGPU, value, &retval);
 682
 683         if (err) {
 684                 pr_warn("Failed to set egpu disable: %d\n", err);
 685                 return err;
 686         }
 687
 688         if (retval > 1) {
 689                 pr_warn("Failed to set egpu disable (retval): 0x%x\n", retval);
 690                 return -EIO;
 691         }
 692
 693         sysfs_notify(&asus->platform_device->dev.kobj, NULL, "egpu_enable");
 694
 695         return 0;
 696 }
 697
 698 static ssize_t egpu_enable_show(struct device *dev,
 699                                    struct device_attribute *attr, char *buf)
 700 {
 701         struct asus_wmi *asus = dev_get_drvdata(dev);
 702         bool mode = asus->egpu_enable;
 703
 704         return sysfs_emit(buf, "%d\n", mode);
 705 }
 706
 707 /* The ACPI call to enable the eGPU also disables the internal dGPU */
 708 static ssize_t egpu_enable_store(struct device *dev,
 709                                     struct device_attribute *attr,
 710                                     const char *buf, size_t count)
 711 {
 712         bool enable;
 713         int result;
 714
 715         struct asus_wmi *asus = dev_get_drvdata(dev);
 716
 717         result = kstrtobool(buf, &enable);
 718         if (result)
 719                 return result;
 720
 721         asus->egpu_enable = enable;
 722
 723         result = egpu_enable_write(asus);
 724         if (result)
 725                 return result;
 726
 727         /* Ensure that the kernel status of dgpu is updated */
 728         result = dgpu_disable_check_present(asus);
 729         if (result)
 730                 return result;
 731
 732         return count;
 733 }
 734
 735 static DEVICE_ATTR_RW(egpu_enable);
 736
 737 /* Battery ********************************************************************/
 738
 739 /* The battery maximum charging percentage */
 740 static int charge_end_threshold;
 741
 742 static ssize_t charge_control_end_threshold_store(struct device *dev,
 743                                                   struct device_attribute *attr,
 744                                                   const char *buf, size_t count)
 745 {
 746         int value, ret, rv;
 747
 748         ret = kstrtouint(buf, 10, &value);
 749         if (ret)
 750                 return ret;
 751
 752         if (value < 0 || value > 100)
 753                 return -EINVAL;
 754
 755         ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, value, &rv);
 756         if (ret)
 757                 return ret;
 758
 759         if (rv != 1)
 760                 return -EIO;
 761
 762         /* There isn't any method in the DSDT to read the threshold, so we
 763          * save the threshold.
 764          */
 765         charge_end_threshold = value;
 766         return count;
 767 }
 768
 769 static ssize_t charge_control_end_threshold_show(struct device *device,
 770                                                  struct device_attribute *attr,
 771                                                  char *buf)
 772 {
 773         return sprintf(buf, "%d\n", charge_end_threshold);
 774 }
 775
 776 static DEVICE_ATTR_RW(charge_control_end_threshold);
 777
 778 static int asus_wmi_battery_add(struct power_supply *battery)
 779 {
 780         /* The WMI method does not provide a way to specific a battery, so we
 781          * just assume it is the first battery.
 782          * Note: On some newer ASUS laptops (Zenbook UM431DA), the primary/first
 783          * battery is named BATT.
 784          */
 785         if (strcmp(battery->desc->name, "BAT0") != 0 &&
 786             strcmp(battery->desc->name, "BAT1") != 0 &&
 787             strcmp(battery->desc->name, "BATC") != 0 &&
 788             strcmp(battery->desc->name, "BATT") != 0)
 789                 return -ENODEV;
 790
 791         if (device_create_file(&battery->dev,
 792             &dev_attr_charge_control_end_threshold))
 793                 return -ENODEV;
 794
 795         /* The charge threshold is only reset when the system is power cycled,
 796          * and we can't get the current threshold so let set it to 100% when
 797          * a battery is added.
 798          */
 799         asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, 100, NULL);
 800         charge_end_threshold = 100;
 801
 802         return 0;
 803 }
 804
 805 static int asus_wmi_battery_remove(struct power_supply *battery)
 806 {
 807         device_remove_file(&battery->dev,
 808                            &dev_attr_charge_control_end_threshold);
 809         return 0;
 810 }
 811
 812 static struct acpi_battery_hook battery_hook = {
 813         .add_battery = asus_wmi_battery_add,
 814         .remove_battery = asus_wmi_battery_remove,
 815         .name = "ASUS Battery Extension",
 816 };
 817
 818 static void asus_wmi_battery_init(struct asus_wmi *asus)
 819 {
 820         asus->battery_rsoc_available = false;
 821         if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_RSOC)) {
 822                 asus->battery_rsoc_available = true;
 823                 battery_hook_register(&battery_hook);
 824         }
 825 }
 826
 827 static void asus_wmi_battery_exit(struct asus_wmi *asus)
 828 {
 829         if (asus->battery_rsoc_available)
 830                 battery_hook_unregister(&battery_hook);
 831 }
 832
 833 /* LEDs ***********************************************************************/
 834
 835 /*
 836  * These functions actually update the LED's, and are called from a
 837  * workqueue. By doing this as separate work rather than when the LED
 838  * subsystem asks, we avoid messing with the Asus ACPI stuff during a
 839  * potentially bad time, such as a timer interrupt.
 840  */
 841 static void tpd_led_update(struct work_struct *work)
 842 {
 843         int ctrl_param;
 844         struct asus_wmi *asus;
 845
 846         asus = container_of(work, struct asus_wmi, tpd_led_work);
 847
 848         ctrl_param = asus->tpd_led_wk;
 849         asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
 850 }
 851
 852 static void tpd_led_set(struct led_classdev *led_cdev,
 853                         enum led_brightness value)
 854 {
 855         struct asus_wmi *asus;
 856
 857         asus = container_of(led_cdev, struct asus_wmi, tpd_led);
 858
 859         asus->tpd_led_wk = !!value;
 860         queue_work(asus->led_workqueue, &asus->tpd_led_work);
 861 }
 862
 863 static int read_tpd_led_state(struct asus_wmi *asus)
 864 {
 865         return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
 866 }
 867
 868 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
 869 {
 870         struct asus_wmi *asus;
 871
 872         asus = container_of(led_cdev, struct asus_wmi, tpd_led);
 873
 874         return read_tpd_led_state(asus);
 875 }
 876
 877 static void kbd_led_update(struct asus_wmi *asus)
 878 {
 879         int ctrl_param = 0;
 880
 881         ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
 882         asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
 883 }
 884
 885 static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
 886 {
 887         int retval;
 888
 889         /*
 890          * bits 0-2: level
 891          * bit 7: light on/off
 892          * bit 8-10: environment (0: dark, 1: normal, 2: light)
 893          * bit 17: status unknown
 894          */
 895         retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
 896                                             0xFFFF);
 897
 898         /* Unknown status is considered as off */
 899         if (retval == 0x8000)
 900                 retval = 0;
 901
 902         if (retval < 0)
 903                 return retval;
 904
 905         if (level)
 906                 *level = retval & 0x7F;
 907         if (env)
 908                 *env = (retval >> 8) & 0x7F;
 909         return 0;
 910 }
 911
 912 static void do_kbd_led_set(struct led_classdev *led_cdev, int value)
 913 {
 914         struct asus_wmi *asus;
 915         int max_level;
 916
 917         asus = container_of(led_cdev, struct asus_wmi, kbd_led);
 918         max_level = asus->kbd_led.max_brightness;
 919
 920         asus->kbd_led_wk = clamp_val(value, 0, max_level);
 921         kbd_led_update(asus);
 922 }
 923
 924 static void kbd_led_set(struct led_classdev *led_cdev,
 925                         enum led_brightness value)
 926 {
 927         /* Prevent disabling keyboard backlight on module unregister */
 928         if (led_cdev->flags & LED_UNREGISTERING)
 929                 return;
 930
 931         do_kbd_led_set(led_cdev, value);
 932 }
 933
 934 static void kbd_led_set_by_kbd(struct asus_wmi *asus, enum led_brightness value)
 935 {
 936         struct led_classdev *led_cdev = &asus->kbd_led;
 937
 938         do_kbd_led_set(led_cdev, value);
 939         led_classdev_notify_brightness_hw_changed(led_cdev, asus->kbd_led_wk);
 940 }
 941
 942 static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
 943 {
 944         struct asus_wmi *asus;
 945         int retval, value;
 946
 947         asus = container_of(led_cdev, struct asus_wmi, kbd_led);
 948
 949         retval = kbd_led_read(asus, &value, NULL);
 950         if (retval < 0)
 951                 return retval;
 952
 953         return value;
 954 }
 955
 956 static int wlan_led_unknown_state(struct asus_wmi *asus)
 957 {
 958         u32 result;
 959
 960         asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
 961
 962         return result & ASUS_WMI_DSTS_UNKNOWN_BIT;
 963 }
 964
 965 static void wlan_led_update(struct work_struct *work)
 966 {
 967         int ctrl_param;
 968         struct asus_wmi *asus;
 969
 970         asus = container_of(work, struct asus_wmi, wlan_led_work);
 971
 972         ctrl_param = asus->wlan_led_wk;
 973         asus_wmi_set_devstate(ASUS_WMI_DEVID_WIRELESS_LED, ctrl_param, NULL);
 974 }
 975
 976 static void wlan_led_set(struct led_classdev *led_cdev,
 977                          enum led_brightness value)
 978 {
 979         struct asus_wmi *asus;
 980
 981         asus = container_of(led_cdev, struct asus_wmi, wlan_led);
 982
 983         asus->wlan_led_wk = !!value;
 984         queue_work(asus->led_workqueue, &asus->wlan_led_work);
 985 }
 986
 987 static enum led_brightness wlan_led_get(struct led_classdev *led_cdev)
 988 {
 989         struct asus_wmi *asus;
 990         u32 result;
 991
 992         asus = container_of(led_cdev, struct asus_wmi, wlan_led);
 993         asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
 994
 995         return result & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
 996 }
 997
 998 static void lightbar_led_update(struct work_struct *work)
 999 {
1000         struct asus_wmi *asus;
1001         int ctrl_param;
1002
1003         asus = container_of(work, struct asus_wmi, lightbar_led_work);
1004
1005         ctrl_param = asus->lightbar_led_wk;
1006         asus_wmi_set_devstate(ASUS_WMI_DEVID_LIGHTBAR, ctrl_param, NULL);
1007 }
1008
1009 static void lightbar_led_set(struct led_classdev *led_cdev,
1010                              enum led_brightness value)
1011 {
1012         struct asus_wmi *asus;
1013
1014         asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
1015
1016         asus->lightbar_led_wk = !!value;
1017         queue_work(asus->led_workqueue, &asus->lightbar_led_work);
1018 }
1019
1020 static enum led_brightness lightbar_led_get(struct led_classdev *led_cdev)
1021 {
1022         struct asus_wmi *asus;
1023         u32 result;
1024
1025         asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
1026         asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_LIGHTBAR, &result);
1027
1028         return result & ASUS_WMI_DSTS_LIGHTBAR_MASK;
1029 }
1030
1031 static void asus_wmi_led_exit(struct asus_wmi *asus)
1032 {
1033         led_classdev_unregister(&asus->kbd_led);
1034         led_classdev_unregister(&asus->tpd_led);
1035         led_classdev_unregister(&asus->wlan_led);
1036         led_classdev_unregister(&asus->lightbar_led);
1037
1038         if (asus->led_workqueue)
1039                 destroy_workqueue(asus->led_workqueue);
1040 }
1041
1042 static int asus_wmi_led_init(struct asus_wmi *asus)
1043 {
1044         int rv = 0, led_val;
1045
1046         asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
1047         if (!asus->led_workqueue)
1048                 return -ENOMEM;
1049
1050         if (read_tpd_led_state(asus) >= 0) {
1051                 INIT_WORK(&asus->tpd_led_work, tpd_led_update);
1052
1053                 asus->tpd_led.name = "asus::touchpad";
1054                 asus->tpd_led.brightness_set = tpd_led_set;
1055                 asus->tpd_led.brightness_get = tpd_led_get;
1056                 asus->tpd_led.max_brightness = 1;
1057
1058                 rv = led_classdev_register(&asus->platform_device->dev,
1059                                            &asus->tpd_led);
1060                 if (rv)
1061                         goto error;
1062         }
1063
1064         if (!kbd_led_read(asus, &led_val, NULL)) {
1065                 asus->kbd_led_wk = led_val;
1066                 asus->kbd_led.name = "asus::kbd_backlight";
1067                 asus->kbd_led.flags = LED_BRIGHT_HW_CHANGED;
1068                 asus->kbd_led.brightness_set = kbd_led_set;
1069                 asus->kbd_led.brightness_get = kbd_led_get;
1070                 asus->kbd_led.max_brightness = 3;
1071
1072                 rv = led_classdev_register(&asus->platform_device->dev,
1073                                            &asus->kbd_led);
1074                 if (rv)
1075                         goto error;
1076         }
1077
1078         if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_WIRELESS_LED)
1079                         && (asus->driver->quirks->wapf > 0)) {
1080                 INIT_WORK(&asus->wlan_led_work, wlan_led_update);
1081
1082                 asus->wlan_led.name = "asus::wlan";
1083                 asus->wlan_led.brightness_set = wlan_led_set;
1084                 if (!wlan_led_unknown_state(asus))
1085                         asus->wlan_led.brightness_get = wlan_led_get;
1086                 asus->wlan_led.flags = LED_CORE_SUSPENDRESUME;
1087                 asus->wlan_led.max_brightness = 1;
1088                 asus->wlan_led.default_trigger = "asus-wlan";
1089
1090                 rv = led_classdev_register(&asus->platform_device->dev,
1091                                            &asus->wlan_led);
1092                 if (rv)
1093                         goto error;
1094         }
1095
1096         if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_LIGHTBAR)) {
1097                 INIT_WORK(&asus->lightbar_led_work, lightbar_led_update);
1098
1099                 asus->lightbar_led.name = "asus::lightbar";
1100                 asus->lightbar_led.brightness_set = lightbar_led_set;
1101                 asus->lightbar_led.brightness_get = lightbar_led_get;
1102                 asus->lightbar_led.max_brightness = 1;
1103
1104                 rv = led_classdev_register(&asus->platform_device->dev,
1105                                            &asus->lightbar_led);
1106         }
1107
1108 error:
1109         if (rv)
1110                 asus_wmi_led_exit(asus);
1111
1112         return rv;
1113 }
1114
1115 /* RF *************************************************************************/
1116
1117 /*
1118  * PCI hotplug (for wlan rfkill)
1119  */
1120 static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
1121 {
1122         int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
1123
1124         if (result < 0)
1125                 return false;
1126         return !result;
1127 }
1128
1129 static void asus_rfkill_hotplug(struct asus_wmi *asus)
1130 {
1131         struct pci_dev *dev;
1132         struct pci_bus *bus;
1133         bool blocked;
1134         bool absent;
1135         u32 l;
1136
1137         mutex_lock(&asus->wmi_lock);
1138         blocked = asus_wlan_rfkill_blocked(asus);
1139         mutex_unlock(&asus->wmi_lock);
1140
1141         mutex_lock(&asus->hotplug_lock);
1142         pci_lock_rescan_remove();
1143
1144         if (asus->wlan.rfkill)
1145                 rfkill_set_sw_state(asus->wlan.rfkill, blocked);
1146
1147         if (asus->hotplug_slot.ops) {
1148                 bus = pci_find_bus(0, 1);
1149                 if (!bus) {
1150                         pr_warn("Unable to find PCI bus 1?\n");
1151                         goto out_unlock;
1152                 }
1153
1154                 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
1155                         pr_err("Unable to read PCI config space?\n");
1156                         goto out_unlock;
1157                 }
1158                 absent = (l == 0xffffffff);
1159
1160                 if (blocked != absent) {
1161                         pr_warn("BIOS says wireless lan is %s, but the pci device is %s\n",
1162                                 blocked ? "blocked" : "unblocked",
1163                                 absent ? "absent" : "present");
1164                         pr_warn("skipped wireless hotplug as probably inappropriate for this model\n");
1165                         goto out_unlock;
1166                 }
1167
1168                 if (!blocked) {
1169                         dev = pci_get_slot(bus, 0);
1170                         if (dev) {
1171                                 /* Device already present */
1172                                 pci_dev_put(dev);
1173                                 goto out_unlock;
1174                         }
1175                         dev = pci_scan_single_device(bus, 0);
1176                         if (dev) {
1177                                 pci_bus_assign_resources(bus);
1178                                 pci_bus_add_device(dev);
1179                         }
1180                 } else {
1181                         dev = pci_get_slot(bus, 0);
1182                         if (dev) {
1183                                 pci_stop_and_remove_bus_device(dev);
1184                                 pci_dev_put(dev);
1185                         }
1186                 }
1187         }
1188
1189 out_unlock:
1190         pci_unlock_rescan_remove();
1191         mutex_unlock(&asus->hotplug_lock);
1192 }
1193
1194 static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
1195 {
1196         struct asus_wmi *asus = data;
1197
1198         if (event != ACPI_NOTIFY_BUS_CHECK)
1199                 return;
1200
1201         /*
1202          * We can't call directly asus_rfkill_hotplug because most
1203          * of the time WMBC is still being executed and not reetrant.
1204          * There is currently no way to tell ACPICA that  we want this
1205          * method to be serialized, we schedule a asus_rfkill_hotplug
1206          * call later, in a safer context.
1207          */
1208         queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
1209 }
1210
1211 static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
1212 {
1213         acpi_status status;
1214         acpi_handle handle;
1215
1216         status = acpi_get_handle(NULL, node, &handle);
1217         if (ACPI_FAILURE(status))
1218                 return -ENODEV;
1219
1220         status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
1221                                              asus_rfkill_notify, asus);
1222         if (ACPI_FAILURE(status))
1223                 pr_warn("Failed to register notify on %s\n", node);
1224
1225         return 0;
1226 }
1227
1228 static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
1229 {
1230         acpi_status status = AE_OK;
1231         acpi_handle handle;
1232
1233         status = acpi_get_handle(NULL, node, &handle);
1234         if (ACPI_FAILURE(status))
1235                 return;
1236
1237         status = acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
1238                                             asus_rfkill_notify);
1239         if (ACPI_FAILURE(status))
1240                 pr_err("Error removing rfkill notify handler %s\n", node);
1241 }
1242
1243 static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
1244                                    u8 *value)
1245 {
1246         struct asus_wmi *asus = container_of(hotplug_slot,
1247                                              struct asus_wmi, hotplug_slot);
1248         int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
1249
1250         if (result < 0)
1251                 return result;
1252
1253         *value = !!result;
1254         return 0;
1255 }
1256
1257 static const struct hotplug_slot_ops asus_hotplug_slot_ops = {
1258         .get_adapter_status = asus_get_adapter_status,
1259         .get_power_status = asus_get_adapter_status,
1260 };
1261
1262 static void asus_hotplug_work(struct work_struct *work)
1263 {
1264         struct asus_wmi *asus;
1265
1266         asus = container_of(work, struct asus_wmi, hotplug_work);
1267         asus_rfkill_hotplug(asus);
1268 }
1269
1270 static int asus_setup_pci_hotplug(struct asus_wmi *asus)
1271 {
1272         int ret = -ENOMEM;
1273         struct pci_bus *bus = pci_find_bus(0, 1);
1274
1275         if (!bus) {
1276                 pr_err("Unable to find wifi PCI bus\n");
1277                 return -ENODEV;
1278         }
1279
1280         asus->hotplug_workqueue =
1281             create_singlethread_workqueue("hotplug_workqueue");
1282         if (!asus->hotplug_workqueue)
1283                 goto error_workqueue;
1284
1285         INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
1286
1287         asus->hotplug_slot.ops = &asus_hotplug_slot_ops;
1288
1289         ret = pci_hp_register(&asus->hotplug_slot, bus, 0, "asus-wifi");
1290         if (ret) {
1291                 pr_err("Unable to register hotplug slot - %d\n", ret);
1292                 goto error_register;
1293         }
1294
1295         return 0;
1296
1297 error_register:
1298         asus->hotplug_slot.ops = NULL;
1299         destroy_workqueue(asus->hotplug_workqueue);
1300 error_workqueue:
1301         return ret;
1302 }
1303
1304 /*
1305  * Rfkill devices
1306  */
1307 static int asus_rfkill_set(void *data, bool blocked)
1308 {
1309         struct asus_rfkill *priv = data;
1310         u32 ctrl_param = !blocked;
1311         u32 dev_id = priv->dev_id;
1312
1313         /*
1314          * If the user bit is set, BIOS can't set and record the wlan status,
1315          * it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
1316          * while we query the wlan status through WMI(ASUS_WMI_DEVID_WLAN).
1317          * So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
1318          * while setting the wlan status through WMI.
1319          * This is also the behavior that windows app will do.
1320          */
1321         if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
1322              priv->asus->driver->wlan_ctrl_by_user)
1323                 dev_id = ASUS_WMI_DEVID_WLAN_LED;
1324
1325         return asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
1326 }
1327
1328 static void asus_rfkill_query(struct rfkill *rfkill, void *data)
1329 {
1330         struct asus_rfkill *priv = data;
1331         int result;
1332
1333         result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
1334
1335         if (result < 0)
1336                 return;
1337
1338         rfkill_set_sw_state(priv->rfkill, !result);
1339 }
1340
1341 static int asus_rfkill_wlan_set(void *data, bool blocked)
1342 {
1343         struct asus_rfkill *priv = data;
1344         struct asus_wmi *asus = priv->asus;
1345         int ret;
1346
1347         /*
1348          * This handler is enabled only if hotplug is enabled.
1349          * In this case, the asus_wmi_set_devstate() will
1350          * trigger a wmi notification and we need to wait
1351          * this call to finish before being able to call
1352          * any wmi method
1353          */
1354         mutex_lock(&asus->wmi_lock);
1355         ret = asus_rfkill_set(data, blocked);
1356         mutex_unlock(&asus->wmi_lock);
1357         return ret;
1358 }
1359
1360 static const struct rfkill_ops asus_rfkill_wlan_ops = {
1361         .set_block = asus_rfkill_wlan_set,
1362         .query = asus_rfkill_query,
1363 };
1364
1365 static const struct rfkill_ops asus_rfkill_ops = {
1366         .set_block = asus_rfkill_set,
1367         .query = asus_rfkill_query,
1368 };
1369
1370 static int asus_new_rfkill(struct asus_wmi *asus,
1371                            struct asus_rfkill *arfkill,
1372                            const char *name, enum rfkill_type type, int dev_id)
1373 {
1374         int result = asus_wmi_get_devstate_simple(asus, dev_id);
1375         struct rfkill **rfkill = &arfkill->rfkill;
1376
1377         if (result < 0)
1378                 return result;
1379
1380         arfkill->dev_id = dev_id;
1381         arfkill->asus = asus;
1382
1383         if (dev_id == ASUS_WMI_DEVID_WLAN &&
1384             asus->driver->quirks->hotplug_wireless)
1385                 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
1386                                        &asus_rfkill_wlan_ops, arfkill);
1387         else
1388                 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
1389                                        &asus_rfkill_ops, arfkill);
1390
1391         if (!*rfkill)
1392                 return -EINVAL;
1393
1394         if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
1395                         (asus->driver->quirks->wapf > 0))
1396                 rfkill_set_led_trigger_name(*rfkill, "asus-wlan");
1397
1398         rfkill_init_sw_state(*rfkill, !result);
1399         result = rfkill_register(*rfkill);
1400         if (result) {
1401                 rfkill_destroy(*rfkill);
1402                 *rfkill = NULL;
1403                 return result;
1404         }
1405         return 0;
1406 }
1407
1408 static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
1409 {
1410         if (asus->driver->wlan_ctrl_by_user && ashs_present())
1411                 return;
1412
1413         asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
1414         asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
1415         asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
1416         if (asus->wlan.rfkill) {
1417                 rfkill_unregister(asus->wlan.rfkill);
1418                 rfkill_destroy(asus->wlan.rfkill);
1419                 asus->wlan.rfkill = NULL;
1420         }
1421         /*
1422          * Refresh pci hotplug in case the rfkill state was changed after
1423          * asus_unregister_rfkill_notifier()
1424          */
1425         asus_rfkill_hotplug(asus);
1426         if (asus->hotplug_slot.ops)
1427                 pci_hp_deregister(&asus->hotplug_slot);
1428         if (asus->hotplug_workqueue)
1429                 destroy_workqueue(asus->hotplug_workqueue);
1430
1431         if (asus->bluetooth.rfkill) {
1432                 rfkill_unregister(asus->bluetooth.rfkill);
1433                 rfkill_destroy(asus->bluetooth.rfkill);
1434                 asus->bluetooth.rfkill = NULL;
1435         }
1436         if (asus->wimax.rfkill) {
1437                 rfkill_unregister(asus->wimax.rfkill);
1438                 rfkill_destroy(asus->wimax.rfkill);
1439                 asus->wimax.rfkill = NULL;
1440         }
1441         if (asus->wwan3g.rfkill) {
1442                 rfkill_unregister(asus->wwan3g.rfkill);
1443                 rfkill_destroy(asus->wwan3g.rfkill);
1444                 asus->wwan3g.rfkill = NULL;
1445         }
1446         if (asus->gps.rfkill) {
1447                 rfkill_unregister(asus->gps.rfkill);
1448                 rfkill_destroy(asus->gps.rfkill);
1449                 asus->gps.rfkill = NULL;
1450         }
1451         if (asus->uwb.rfkill) {
1452                 rfkill_unregister(asus->uwb.rfkill);
1453                 rfkill_destroy(asus->uwb.rfkill);
1454                 asus->uwb.rfkill = NULL;
1455         }
1456 }
1457
1458 static int asus_wmi_rfkill_init(struct asus_wmi *asus)
1459 {
1460         int result = 0;
1461
1462         mutex_init(&asus->hotplug_lock);
1463         mutex_init(&asus->wmi_lock);
1464
1465         result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
1466                                  RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
1467
1468         if (result && result != -ENODEV)
1469                 goto exit;
1470
1471         result = asus_new_rfkill(asus, &asus->bluetooth,
1472                                  "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
1473                                  ASUS_WMI_DEVID_BLUETOOTH);
1474
1475         if (result && result != -ENODEV)
1476                 goto exit;
1477
1478         result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
1479                                  RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
1480
1481         if (result && result != -ENODEV)
1482                 goto exit;
1483
1484         result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
1485                                  RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
1486
1487         if (result && result != -ENODEV)
1488                 goto exit;
1489
1490         result = asus_new_rfkill(asus, &asus->gps, "asus-gps",
1491                                  RFKILL_TYPE_GPS, ASUS_WMI_DEVID_GPS);
1492
1493         if (result && result != -ENODEV)
1494                 goto exit;
1495
1496         result = asus_new_rfkill(asus, &asus->uwb, "asus-uwb",
1497                                  RFKILL_TYPE_UWB, ASUS_WMI_DEVID_UWB);
1498
1499         if (result && result != -ENODEV)
1500                 goto exit;
1501
1502         if (!asus->driver->quirks->hotplug_wireless)
1503                 goto exit;
1504
1505         result = asus_setup_pci_hotplug(asus);
1506         /*
1507          * If we get -EBUSY then something else is handling the PCI hotplug -
1508          * don't fail in this case
1509          */
1510         if (result == -EBUSY)
1511                 result = 0;
1512
1513         asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
1514         asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
1515         asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
1516         /*
1517          * Refresh pci hotplug in case the rfkill state was changed during
1518          * setup.
1519          */
1520         asus_rfkill_hotplug(asus);
1521
1522 exit:
1523         if (result && result != -ENODEV)
1524                 asus_wmi_rfkill_exit(asus);
1525
1526         if (result == -ENODEV)
1527                 result = 0;
1528
1529         return result;
1530 }
1531
1532 /* Panel Overdrive ************************************************************/
1533 static int panel_od_check_present(struct asus_wmi *asus)
1534 {
1535         u32 result;
1536         int err;
1537
1538         asus->panel_overdrive_available = false;
1539
1540         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_PANEL_OD, &result);
1541         if (err) {
1542                 if (err == -ENODEV)
1543                         return 0;
1544                 return err;
1545         }
1546
1547         if (result & ASUS_WMI_DSTS_PRESENCE_BIT) {
1548                 asus->panel_overdrive_available = true;
1549                 asus->panel_overdrive = result & ASUS_WMI_DSTS_STATUS_BIT;
1550         }
1551
1552         return 0;
1553 }
1554
1555 static int panel_od_write(struct asus_wmi *asus)
1556 {
1557         u32 retval;
1558         u8 value;
1559         int err;
1560
1561         /* Don't rely on type conversion */
1562         value = asus->panel_overdrive ? 1 : 0;
1563
1564         err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PANEL_OD, value, &retval);
1565
1566         if (err) {
1567                 pr_warn("Failed to set panel overdrive: %d\n", err);
1568                 return err;
1569         }
1570
1571         if (retval > 1) {
1572                 pr_warn("Failed to set panel overdrive (retval): 0x%x\n", retval);
1573                 return -EIO;
1574         }
1575
1576         sysfs_notify(&asus->platform_device->dev.kobj, NULL, "panel_od");
1577
1578         return 0;
1579 }
1580
1581 static ssize_t panel_od_show(struct device *dev,
1582                                    struct device_attribute *attr, char *buf)
1583 {
1584         struct asus_wmi *asus = dev_get_drvdata(dev);
1585
1586         return sysfs_emit(buf, "%d\n", asus->panel_overdrive);
1587 }
1588
1589 static ssize_t panel_od_store(struct device *dev,
1590                                     struct device_attribute *attr,
1591                                     const char *buf, size_t count)
1592 {
1593         bool overdrive;
1594         int result;
1595
1596         struct asus_wmi *asus = dev_get_drvdata(dev);
1597
1598         result = kstrtobool(buf, &overdrive);
1599         if (result)
1600                 return result;
1601
1602         asus->panel_overdrive = overdrive;
1603         result = panel_od_write(asus);
1604
1605         if (result)
1606                 return result;
1607
1608         return count;
1609 }
1610
1611 static DEVICE_ATTR_RW(panel_od);
1612
1613 /* Quirks *********************************************************************/
1614
1615 static void asus_wmi_set_xusb2pr(struct asus_wmi *asus)
1616 {
1617         struct pci_dev *xhci_pdev;
1618         u32 orig_ports_available;
1619         u32 ports_available = asus->driver->quirks->xusb2pr;
1620
1621         xhci_pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
1622                         PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI,
1623                         NULL);
1624
1625         if (!xhci_pdev)
1626                 return;
1627
1628         pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
1629                                 &orig_ports_available);
1630
1631         pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
1632                                 cpu_to_le32(ports_available));
1633
1634         pr_info("set USB_INTEL_XUSB2PR old: 0x%04x, new: 0x%04x\n",
1635                         orig_ports_available, ports_available);
1636 }
1637
1638 /*
1639  * Some devices dont support or have borcken get_als method
1640  * but still support set method.
1641  */
1642 static void asus_wmi_set_als(void)
1643 {
1644         asus_wmi_set_devstate(ASUS_WMI_DEVID_ALS_ENABLE, 1, NULL);
1645 }
1646
1647 /* Hwmon device ***************************************************************/
1648
1649 static int asus_agfn_fan_speed_read(struct asus_wmi *asus, int fan,
1650                                           int *speed)
1651 {
1652         struct agfn_fan_args args = {
1653                 .agfn.len = sizeof(args),
1654                 .agfn.mfun = ASUS_FAN_MFUN,
1655                 .agfn.sfun = ASUS_FAN_SFUN_READ,
1656                 .fan = fan,
1657                 .speed = 0,
1658         };
1659         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1660         int status;
1661
1662         if (fan != 1)
1663                 return -EINVAL;
1664
1665         status = asus_wmi_evaluate_method_agfn(input);
1666
1667         if (status || args.agfn.err)
1668                 return -ENXIO;
1669
1670         if (speed)
1671                 *speed = args.speed;
1672
1673         return 0;
1674 }
1675
1676 static int asus_agfn_fan_speed_write(struct asus_wmi *asus, int fan,
1677                                      int *speed)
1678 {
1679         struct agfn_fan_args args = {
1680                 .agfn.len = sizeof(args),
1681                 .agfn.mfun = ASUS_FAN_MFUN,
1682                 .agfn.sfun = ASUS_FAN_SFUN_WRITE,
1683                 .fan = fan,
1684                 .speed = speed ?  *speed : 0,
1685         };
1686         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1687         int status;
1688
1689         /* 1: for setting 1st fan's speed 0: setting auto mode */
1690         if (fan != 1 && fan != 0)
1691                 return -EINVAL;
1692
1693         status = asus_wmi_evaluate_method_agfn(input);
1694
1695         if (status || args.agfn.err)
1696                 return -ENXIO;
1697
1698         if (speed && fan == 1)
1699                 asus->agfn_pwm = *speed;
1700
1701         return 0;
1702 }
1703
1704 /*
1705  * Check if we can read the speed of one fan. If true we assume we can also
1706  * control it.
1707  */
1708 static bool asus_wmi_has_agfn_fan(struct asus_wmi *asus)
1709 {
1710         int status;
1711         int speed;
1712         u32 value;
1713
1714         status = asus_agfn_fan_speed_read(asus, 1, &speed);
1715         if (status != 0)
1716                 return false;
1717
1718         status = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
1719         if (status != 0)
1720                 return false;
1721
1722         /*
1723          * We need to find a better way, probably using sfun,
1724          * bits or spec ...
1725          * Currently we disable it if:
1726          * - ASUS_WMI_UNSUPPORTED_METHOD is returned
1727          * - reverved bits are non-zero
1728          * - sfun and presence bit are not set
1729          */
1730         return !(value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
1731                  || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)));
1732 }
1733
1734 static int asus_fan_set_auto(struct asus_wmi *asus)
1735 {
1736         int status;
1737         u32 retval;
1738
1739         switch (asus->fan_type) {
1740         case FAN_TYPE_SPEC83:
1741                 status = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
1742                                                0, &retval);
1743                 if (status)
1744                         return status;
1745
1746                 if (retval != 1)
1747                         return -EIO;
1748                 break;
1749
1750         case FAN_TYPE_AGFN:
1751                 status = asus_agfn_fan_speed_write(asus, 0, NULL);
1752                 if (status)
1753                         return -ENXIO;
1754                 break;
1755
1756         default:
1757                 return -ENXIO;
1758         }
1759
1760
1761         return 0;
1762 }
1763
1764 static ssize_t pwm1_show(struct device *dev,
1765                                struct device_attribute *attr,
1766                                char *buf)
1767 {
1768         struct asus_wmi *asus = dev_get_drvdata(dev);
1769         int err;
1770         int value;
1771
1772         /* If we already set a value then just return it */
1773         if (asus->agfn_pwm >= 0)
1774                 return sprintf(buf, "%d\n", asus->agfn_pwm);
1775
1776         /*
1777          * If we haven't set already set a value through the AGFN interface,
1778          * we read a current value through the (now-deprecated) FAN_CTRL device.
1779          */
1780         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
1781         if (err < 0)
1782                 return err;
1783
1784         value &= 0xFF;
1785
1786         if (value == 1) /* Low Speed */
1787                 value = 85;
1788         else if (value == 2)
1789                 value = 170;
1790         else if (value == 3)
1791                 value = 255;
1792         else if (value) {
1793                 pr_err("Unknown fan speed %#x\n", value);
1794                 value = -1;
1795         }
1796
1797         return sprintf(buf, "%d\n", value);
1798 }
1799
1800 static ssize_t pwm1_store(struct device *dev,
1801                                      struct device_attribute *attr,
1802                                      const char *buf, size_t count) {
1803         struct asus_wmi *asus = dev_get_drvdata(dev);
1804         int value;
1805         int state;
1806         int ret;
1807
1808         ret = kstrtouint(buf, 10, &value);
1809         if (ret)
1810                 return ret;
1811
1812         value = clamp(value, 0, 255);
1813
1814         state = asus_agfn_fan_speed_write(asus, 1, &value);
1815         if (state)
1816                 pr_warn("Setting fan speed failed: %d\n", state);
1817         else
1818                 asus->fan_pwm_mode = ASUS_FAN_CTRL_MANUAL;
1819
1820         return count;
1821 }
1822
1823 static ssize_t fan1_input_show(struct device *dev,
1824                                         struct device_attribute *attr,
1825                                         char *buf)
1826 {
1827         struct asus_wmi *asus = dev_get_drvdata(dev);
1828         int value;
1829         int ret;
1830
1831         switch (asus->fan_type) {
1832         case FAN_TYPE_SPEC83:
1833                 ret = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL,
1834                                             &value);
1835                 if (ret < 0)
1836                         return ret;
1837
1838                 value &= 0xffff;
1839                 break;
1840
1841         case FAN_TYPE_AGFN:
1842                 /* no speed readable on manual mode */
1843                 if (asus->fan_pwm_mode == ASUS_FAN_CTRL_MANUAL)
1844                         return -ENXIO;
1845
1846                 ret = asus_agfn_fan_speed_read(asus, 1, &value);
1847                 if (ret) {
1848                         pr_warn("reading fan speed failed: %d\n", ret);
1849                         return -ENXIO;
1850                 }
1851                 break;
1852
1853         default:
1854                 return -ENXIO;
1855         }
1856
1857         return sprintf(buf, "%d\n", value < 0 ? -1 : value*100);
1858 }
1859
1860 static ssize_t pwm1_enable_show(struct device *dev,
1861                                                  struct device_attribute *attr,
1862                                                  char *buf)
1863 {
1864         struct asus_wmi *asus = dev_get_drvdata(dev);
1865
1866         /*
1867          * Just read back the cached pwm mode.
1868          *
1869          * For the CPU_FAN device, the spec indicates that we should be
1870          * able to read the device status and consult bit 19 to see if we
1871          * are in Full On or Automatic mode. However, this does not work
1872          * in practice on X532FL at least (the bit is always 0) and there's
1873          * also nothing in the DSDT to indicate that this behaviour exists.
1874          */
1875         return sprintf(buf, "%d\n", asus->fan_pwm_mode);
1876 }
1877
1878 static ssize_t pwm1_enable_store(struct device *dev,
1879                                                   struct device_attribute *attr,
1880                                                   const char *buf, size_t count)
1881 {
1882         struct asus_wmi *asus = dev_get_drvdata(dev);
1883         int status = 0;
1884         int state;
1885         int value;
1886         int ret;
1887         u32 retval;
1888
1889         ret = kstrtouint(buf, 10, &state);
1890         if (ret)
1891                 return ret;
1892
1893         if (asus->fan_type == FAN_TYPE_SPEC83) {
1894                 switch (state) { /* standard documented hwmon values */
1895                 case ASUS_FAN_CTRL_FULLSPEED:
1896                         value = 1;
1897                         break;
1898                 case ASUS_FAN_CTRL_AUTO:
1899                         value = 0;
1900                         break;
1901                 default:
1902                         return -EINVAL;
1903                 }
1904
1905                 ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
1906                                             value, &retval);
1907                 if (ret)
1908                         return ret;
1909
1910                 if (retval != 1)
1911                         return -EIO;
1912         } else if (asus->fan_type == FAN_TYPE_AGFN) {
1913                 switch (state) {
1914                 case ASUS_FAN_CTRL_MANUAL:
1915                         break;
1916
1917                 case ASUS_FAN_CTRL_AUTO:
1918                         status = asus_fan_set_auto(asus);
1919                         if (status)
1920                                 return status;
1921                         break;
1922
1923                 default:
1924                         return -EINVAL;
1925                 }
1926         }
1927
1928         asus->fan_pwm_mode = state;
1929
1930         /* Must set to disabled if mode is toggled */
1931         if (asus->cpu_fan_curve_available)
1932                 asus->custom_fan_curves[FAN_CURVE_DEV_CPU].enabled = false;
1933         if (asus->gpu_fan_curve_available)
1934                 asus->custom_fan_curves[FAN_CURVE_DEV_GPU].enabled = false;
1935
1936         return count;
1937 }
1938
1939 static ssize_t fan1_label_show(struct device *dev,
1940                                           struct device_attribute *attr,
1941                                           char *buf)
1942 {
1943         return sprintf(buf, "%s\n", ASUS_FAN_DESC);
1944 }
1945
1946 static ssize_t asus_hwmon_temp1(struct device *dev,
1947                                 struct device_attribute *attr,
1948                                 char *buf)
1949 {
1950         struct asus_wmi *asus = dev_get_drvdata(dev);
1951         u32 value;
1952         int err;
1953
1954         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_THERMAL_CTRL, &value);
1955         if (err < 0)
1956                 return err;
1957
1958         return sprintf(buf, "%ld\n",
1959                        deci_kelvin_to_millicelsius(value & 0xFFFF));
1960 }
1961
1962 /* Fan1 */
1963 static DEVICE_ATTR_RW(pwm1);
1964 static DEVICE_ATTR_RW(pwm1_enable);
1965 static DEVICE_ATTR_RO(fan1_input);
1966 static DEVICE_ATTR_RO(fan1_label);
1967
1968 /* Temperature */
1969 static DEVICE_ATTR(temp1_input, S_IRUGO, asus_hwmon_temp1, NULL);
1970
1971 static struct attribute *hwmon_attributes[] = {
1972         &dev_attr_pwm1.attr,
1973         &dev_attr_pwm1_enable.attr,
1974         &dev_attr_fan1_input.attr,
1975         &dev_attr_fan1_label.attr,
1976
1977         &dev_attr_temp1_input.attr,
1978         NULL
1979 };
1980
1981 static umode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
1982                                           struct attribute *attr, int idx)
1983 {
1984         struct device *dev = container_of(kobj, struct device, kobj);
1985         struct asus_wmi *asus = dev_get_drvdata(dev->parent);
1986         u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
1987
1988         if (attr == &dev_attr_pwm1.attr) {
1989                 if (asus->fan_type != FAN_TYPE_AGFN)
1990                         return 0;
1991         } else if (attr == &dev_attr_fan1_input.attr
1992             || attr == &dev_attr_fan1_label.attr
1993             || attr == &dev_attr_pwm1_enable.attr) {
1994                 if (asus->fan_type == FAN_TYPE_NONE)
1995                         return 0;
1996         } else if (attr == &dev_attr_temp1_input.attr) {
1997                 int err = asus_wmi_get_devstate(asus,
1998                                                 ASUS_WMI_DEVID_THERMAL_CTRL,
1999                                                 &value);
2000
2001                 if (err < 0)
2002                         return 0; /* can't return negative here */
2003
2004                 /*
2005                  * If the temperature value in deci-Kelvin is near the absolute
2006                  * zero temperature, something is clearly wrong
2007                  */
2008                 if (value == 0 || value == 1)
2009                         return 0;
2010         }
2011
2012         return attr->mode;
2013 }
2014
2015 static const struct attribute_group hwmon_attribute_group = {
2016         .is_visible = asus_hwmon_sysfs_is_visible,
2017         .attrs = hwmon_attributes
2018 };
2019 __ATTRIBUTE_GROUPS(hwmon_attribute);
2020
2021 static int asus_wmi_hwmon_init(struct asus_wmi *asus)
2022 {
2023         struct device *dev = &asus->platform_device->dev;
2024         struct device *hwmon;
2025
2026         hwmon = devm_hwmon_device_register_with_groups(dev, "asus", asus,
2027                         hwmon_attribute_groups);
2028
2029         if (IS_ERR(hwmon)) {
2030                 pr_err("Could not register asus hwmon device\n");
2031                 return PTR_ERR(hwmon);
2032         }
2033         return 0;
2034 }
2035
2036 static int asus_wmi_fan_init(struct asus_wmi *asus)
2037 {
2038         asus->fan_type = FAN_TYPE_NONE;
2039         asus->agfn_pwm = -1;
2040
2041         if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL))
2042                 asus->fan_type = FAN_TYPE_SPEC83;
2043         else if (asus_wmi_has_agfn_fan(asus))
2044                 asus->fan_type = FAN_TYPE_AGFN;
2045
2046         if (asus->fan_type == FAN_TYPE_NONE)
2047                 return -ENODEV;
2048
2049         asus_fan_set_auto(asus);
2050         asus->fan_pwm_mode = ASUS_FAN_CTRL_AUTO;
2051         return 0;
2052 }
2053
2054 /* Fan mode *******************************************************************/
2055
2056 static int fan_boost_mode_check_present(struct asus_wmi *asus)
2057 {
2058         u32 result;
2059         int err;
2060
2061         asus->fan_boost_mode_available = false;
2062
2063         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_BOOST_MODE,
2064                                     &result);
2065         if (err) {
2066                 if (err == -ENODEV)
2067                         return 0;
2068                 else
2069                         return err;
2070         }
2071
2072         if ((result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
2073                         (result & ASUS_FAN_BOOST_MODES_MASK)) {
2074                 asus->fan_boost_mode_available = true;
2075                 asus->fan_boost_mode_mask = result & ASUS_FAN_BOOST_MODES_MASK;
2076         }
2077
2078         return 0;
2079 }
2080
2081 static int fan_boost_mode_write(struct asus_wmi *asus)
2082 {
2083         u32 retval;
2084         u8 value;
2085         int err;
2086
2087         value = asus->fan_boost_mode;
2088
2089         pr_info("Set fan boost mode: %u\n", value);
2090         err = asus_wmi_set_devstate(ASUS_WMI_DEVID_FAN_BOOST_MODE, value,
2091                                     &retval);
2092
2093         sysfs_notify(&asus->platform_device->dev.kobj, NULL,
2094                         "fan_boost_mode");
2095
2096         if (err) {
2097                 pr_warn("Failed to set fan boost mode: %d\n", err);
2098                 return err;
2099         }
2100
2101         if (retval != 1) {
2102                 pr_warn("Failed to set fan boost mode (retval): 0x%x\n",
2103                         retval);
2104                 return -EIO;
2105         }
2106
2107         return 0;
2108 }
2109
2110 static int fan_boost_mode_switch_next(struct asus_wmi *asus)
2111 {
2112         u8 mask = asus->fan_boost_mode_mask;
2113
2114         if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_NORMAL) {
2115                 if (mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK)
2116                         asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_OVERBOOST;
2117                 else if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
2118                         asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
2119         } else if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
2120                 if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
2121                         asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
2122                 else
2123                         asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
2124         } else {
2125                 asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
2126         }
2127
2128         return fan_boost_mode_write(asus);
2129 }
2130
2131 static ssize_t fan_boost_mode_show(struct device *dev,
2132                                    struct device_attribute *attr, char *buf)
2133 {
2134         struct asus_wmi *asus = dev_get_drvdata(dev);
2135
2136         return scnprintf(buf, PAGE_SIZE, "%d\n", asus->fan_boost_mode);
2137 }
2138
2139 static ssize_t fan_boost_mode_store(struct device *dev,
2140                                     struct device_attribute *attr,
2141                                     const char *buf, size_t count)
2142 {
2143         struct asus_wmi *asus = dev_get_drvdata(dev);
2144         u8 mask = asus->fan_boost_mode_mask;
2145         u8 new_mode;
2146         int result;
2147
2148         result = kstrtou8(buf, 10, &new_mode);
2149         if (result < 0) {
2150                 pr_warn("Trying to store invalid value\n");
2151                 return result;
2152         }
2153
2154         if (new_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
2155                 if (!(mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK))
2156                         return -EINVAL;
2157         } else if (new_mode == ASUS_FAN_BOOST_MODE_SILENT) {
2158                 if (!(mask & ASUS_FAN_BOOST_MODE_SILENT_MASK))
2159                         return -EINVAL;
2160         } else if (new_mode != ASUS_FAN_BOOST_MODE_NORMAL) {
2161                 return -EINVAL;
2162         }
2163
2164         asus->fan_boost_mode = new_mode;
2165         fan_boost_mode_write(asus);
2166
2167         return count;
2168 }
2169
2170 // Fan boost mode: 0 - normal, 1 - overboost, 2 - silent
2171 static DEVICE_ATTR_RW(fan_boost_mode);
2172
2173 /* Custom fan curves **********************************************************/
2174
2175 static void fan_curve_copy_from_buf(struct fan_curve_data *data, u8 *buf)
2176 {
2177         int i;
2178
2179         for (i = 0; i < FAN_CURVE_POINTS; i++) {
2180                 data->temps[i] = buf[i];
2181         }
2182
2183         for (i = 0; i < FAN_CURVE_POINTS; i++) {
2184                 data->percents[i] =
2185                         255 * buf[i + FAN_CURVE_POINTS] / 100;
2186         }
2187 }
2188
2189 static int fan_curve_get_factory_default(struct asus_wmi *asus, u32 fan_dev)
2190 {
2191         struct fan_curve_data *curves;
2192         u8 buf[FAN_CURVE_BUF_LEN];
2193         int fan_idx = 0;
2194         u8 mode = 0;
2195         int err;
2196
2197         if (asus->throttle_thermal_policy_available)
2198                 mode = asus->throttle_thermal_policy_mode;
2199         /* DEVID_<C/G>PU_FAN_CURVE is switched for OVERBOOST vs SILENT */
2200         if (mode == 2)
2201                 mode = 1;
2202         else if (mode == 1)
2203                 mode = 2;
2204
2205         if (fan_dev == ASUS_WMI_DEVID_GPU_FAN_CURVE)
2206                 fan_idx = FAN_CURVE_DEV_GPU;
2207
2208         curves = &asus->custom_fan_curves[fan_idx];
2209         err = asus_wmi_evaluate_method_buf(asus->dsts_id, fan_dev, mode, buf,
2210                                            FAN_CURVE_BUF_LEN);
2211         if (err)
2212                 return err;
2213
2214         fan_curve_copy_from_buf(curves, buf);
2215         curves->device_id = fan_dev;
2216
2217         return 0;
2218 }
2219
2220 /* Check if capability exists, and populate defaults */
2221 static int fan_curve_check_present(struct asus_wmi *asus, bool *available,
2222                                    u32 fan_dev)
2223 {
2224         int err;
2225
2226         *available = false;
2227
2228         err = fan_curve_get_factory_default(asus, fan_dev);
2229         if (err) {
2230                 pr_debug("fan_curve_get_factory_default(0x%08x) failed: %d\n",
2231                          fan_dev, err);
2232                 /* Don't cause probe to fail on devices without fan-curves */
2233                 return 0;
2234         }
2235
2236         *available = true;
2237         return 0;
2238 }
2239
2240 /* Determine which fan the attribute is for if SENSOR_ATTR */
2241 static struct fan_curve_data *fan_curve_attr_select(struct asus_wmi *asus,
2242                                               struct device_attribute *attr)
2243 {
2244         int index = to_sensor_dev_attr(attr)->index;
2245
2246         return &asus->custom_fan_curves[index & FAN_CURVE_DEV_GPU];
2247 }
2248
2249 /* Determine which fan the attribute is for if SENSOR_ATTR_2 */
2250 static struct fan_curve_data *fan_curve_attr_2_select(struct asus_wmi *asus,
2251                                             struct device_attribute *attr)
2252 {
2253         int nr = to_sensor_dev_attr_2(attr)->nr;
2254
2255         return &asus->custom_fan_curves[nr & FAN_CURVE_DEV_GPU];
2256 }
2257
2258 static ssize_t fan_curve_show(struct device *dev,
2259                               struct device_attribute *attr, char *buf)
2260 {
2261         struct sensor_device_attribute_2 *dev_attr = to_sensor_dev_attr_2(attr);
2262         struct asus_wmi *asus = dev_get_drvdata(dev);
2263         struct fan_curve_data *data;
2264         int value, index, nr;
2265
2266         data = fan_curve_attr_2_select(asus, attr);
2267         index = dev_attr->index;
2268         nr = dev_attr->nr;
2269
2270         if (nr & FAN_CURVE_PWM_MASK)
2271                 value = data->percents[index];
2272         else
2273                 value = data->temps[index];
2274
2275         return sysfs_emit(buf, "%d\n", value);
2276 }
2277
2278 /*
2279  * "fan_dev" is the related WMI method such as ASUS_WMI_DEVID_CPU_FAN_CURVE.
2280  */
2281 static int fan_curve_write(struct asus_wmi *asus,
2282                            struct fan_curve_data *data)
2283 {
2284         u32 arg1 = 0, arg2 = 0, arg3 = 0, arg4 = 0;
2285         u8 *percents = data->percents;
2286         u8 *temps = data->temps;
2287         int ret, i, shift = 0;
2288
2289         if (!data->enabled)
2290                 return 0;
2291
2292         for (i = 0; i < FAN_CURVE_POINTS / 2; i++) {
2293                 arg1 += (temps[i]) << shift;
2294                 arg2 += (temps[i + 4]) << shift;
2295                 /* Scale to percentage for device */
2296                 arg3 += (100 * percents[i] / 255) << shift;
2297                 arg4 += (100 * percents[i + 4] / 255) << shift;
2298                 shift += 8;
2299         }
2300
2301         return asus_wmi_evaluate_method5(ASUS_WMI_METHODID_DEVS,
2302                                          data->device_id,
2303                                          arg1, arg2, arg3, arg4, &ret);
2304 }
2305
2306 static ssize_t fan_curve_store(struct device *dev,
2307                                struct device_attribute *attr, const char *buf,
2308                                size_t count)
2309 {
2310         struct sensor_device_attribute_2 *dev_attr = to_sensor_dev_attr_2(attr);
2311         struct asus_wmi *asus = dev_get_drvdata(dev);
2312         struct fan_curve_data *data;
2313         u8 value;
2314         int err;
2315
2316         int pwm = dev_attr->nr & FAN_CURVE_PWM_MASK;
2317         int index = dev_attr->index;
2318
2319         data = fan_curve_attr_2_select(asus, attr);
2320
2321         err = kstrtou8(buf, 10, &value);
2322         if (err < 0)
2323                 return err;
2324
2325         if (pwm) {
2326                 data->percents[index] = value;
2327         } else {
2328                 data->temps[index] = value;
2329         }
2330
2331         /*
2332          * Mark as disabled so the user has to explicitly enable to apply a
2333          * changed fan curve. This prevents potential lockups from writing out
2334          * many changes as one-write-per-change.
2335          */
2336         data->enabled = false;
2337
2338         return count;
2339 }
2340
2341 static ssize_t fan_curve_enable_show(struct device *dev,
2342                                      struct device_attribute *attr, char *buf)
2343 {
2344         struct asus_wmi *asus = dev_get_drvdata(dev);
2345         struct fan_curve_data *data;
2346         int out = 2;
2347
2348         data = fan_curve_attr_select(asus, attr);
2349
2350         if (data->enabled)
2351                 out = 1;
2352
2353         return sysfs_emit(buf, "%d\n", out);
2354 }
2355
2356 static ssize_t fan_curve_enable_store(struct device *dev,
2357                                       struct device_attribute *attr,
2358                                       const char *buf, size_t count)
2359 {
2360         struct asus_wmi *asus = dev_get_drvdata(dev);
2361         struct fan_curve_data *data;
2362         int value, err;
2363
2364         data = fan_curve_attr_select(asus, attr);
2365
2366         err = kstrtoint(buf, 10, &value);
2367         if (err < 0)
2368                 return err;
2369
2370         switch (value) {
2371         case 1:
2372                 data->enabled = true;
2373                 break;
2374         case 2:
2375                 data->enabled = false;
2376                 break;
2377         /*
2378          * Auto + reset the fan curve data to defaults. Make it an explicit
2379          * option so that users don't accidentally overwrite a set fan curve.
2380          */
2381         case 3:
2382                 err = fan_curve_get_factory_default(asus, data->device_id);
2383                 if (err)
2384                         return err;
2385                 data->enabled = false;
2386                 break;
2387         default:
2388                 return -EINVAL;
2389         }
2390
2391         if (data->enabled) {
2392                 err = fan_curve_write(asus, data);
2393                 if (err)
2394                         return err;
2395         } else {
2396                 /*
2397                  * For machines with throttle this is the only way to reset fans
2398                  * to default mode of operation (does not erase curve data).
2399                  */
2400                 if (asus->throttle_thermal_policy_available) {
2401                         err = throttle_thermal_policy_write(asus);
2402                         if (err)
2403                                 return err;
2404                 /* Similar is true for laptops with this fan */
2405                 } else if (asus->fan_type == FAN_TYPE_SPEC83) {
2406                         err = asus_fan_set_auto(asus);
2407                         if (err)
2408                                 return err;
2409                 } else {
2410                         /* Safeguard against fautly ACPI tables */
2411                         err = fan_curve_get_factory_default(asus, data->device_id);
2412                         if (err)
2413                                 return err;
2414                         err = fan_curve_write(asus, data);
2415                         if (err)
2416                                 return err;
2417                 }
2418         }
2419         return count;
2420 }
2421
2422 /* CPU */
2423 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, fan_curve_enable, FAN_CURVE_DEV_CPU);
2424 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_temp, fan_curve,
2425                                FAN_CURVE_DEV_CPU, 0);
2426 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_temp, fan_curve,
2427                                FAN_CURVE_DEV_CPU, 1);
2428 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_temp, fan_curve,
2429                                FAN_CURVE_DEV_CPU, 2);
2430 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_temp, fan_curve,
2431                                FAN_CURVE_DEV_CPU, 3);
2432 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_temp, fan_curve,
2433                                FAN_CURVE_DEV_CPU, 4);
2434 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point6_temp, fan_curve,
2435                                FAN_CURVE_DEV_CPU, 5);
2436 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point7_temp, fan_curve,
2437                                FAN_CURVE_DEV_CPU, 6);
2438 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point8_temp, fan_curve,
2439                                FAN_CURVE_DEV_CPU, 7);
2440
2441 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_pwm, fan_curve,
2442                                FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 0);
2443 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_pwm, fan_curve,
2444                                FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 1);
2445 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_pwm, fan_curve,
2446                                FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 2);
2447 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_pwm, fan_curve,
2448                                FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 3);
2449 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_pwm, fan_curve,
2450                                FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 4);
2451 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point6_pwm, fan_curve,
2452                                FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 5);
2453 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point7_pwm, fan_curve,
2454                                FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 6);
2455 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point8_pwm, fan_curve,
2456                                FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 7);
2457
2458 /* GPU */
2459 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, fan_curve_enable, FAN_CURVE_DEV_GPU);
2460 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_temp, fan_curve,
2461                                FAN_CURVE_DEV_GPU, 0);
2462 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_temp, fan_curve,
2463                                FAN_CURVE_DEV_GPU, 1);
2464 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_temp, fan_curve,
2465                                FAN_CURVE_DEV_GPU, 2);
2466 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_temp, fan_curve,
2467                                FAN_CURVE_DEV_GPU, 3);
2468 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_temp, fan_curve,
2469                                FAN_CURVE_DEV_GPU, 4);
2470 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point6_temp, fan_curve,
2471                                FAN_CURVE_DEV_GPU, 5);
2472 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point7_temp, fan_curve,
2473                                FAN_CURVE_DEV_GPU, 6);
2474 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point8_temp, fan_curve,
2475                                FAN_CURVE_DEV_GPU, 7);
2476
2477 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_pwm, fan_curve,
2478                                FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 0);
2479 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_pwm, fan_curve,
2480                                FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 1);
2481 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_pwm, fan_curve,
2482                                FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 2);
2483 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_pwm, fan_curve,
2484                                FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 3);
2485 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_pwm, fan_curve,
2486                                FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 4);
2487 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point6_pwm, fan_curve,
2488                                FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 5);
2489 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point7_pwm, fan_curve,
2490                                FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 6);
2491 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point8_pwm, fan_curve,
2492                                FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 7);
2493
2494 static struct attribute *asus_fan_curve_attr[] = {
2495         /* CPU */
2496         &sensor_dev_attr_pwm1_enable.dev_attr.attr,
2497         &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
2498         &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
2499         &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr,
2500         &sensor_dev_attr_pwm1_auto_point4_temp.dev_attr.attr,
2501         &sensor_dev_attr_pwm1_auto_point5_temp.dev_attr.attr,
2502         &sensor_dev_attr_pwm1_auto_point6_temp.dev_attr.attr,
2503         &sensor_dev_attr_pwm1_auto_point7_temp.dev_attr.attr,
2504         &sensor_dev_attr_pwm1_auto_point8_temp.dev_attr.attr,
2505         &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
2506         &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
2507         &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
2508         &sensor_dev_attr_pwm1_auto_point4_pwm.dev_attr.attr,
2509         &sensor_dev_attr_pwm1_auto_point5_pwm.dev_attr.attr,
2510         &sensor_dev_attr_pwm1_auto_point6_pwm.dev_attr.attr,
2511         &sensor_dev_attr_pwm1_auto_point7_pwm.dev_attr.attr,
2512         &sensor_dev_attr_pwm1_auto_point8_pwm.dev_attr.attr,
2513         /* GPU */
2514         &sensor_dev_attr_pwm2_enable.dev_attr.attr,
2515         &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
2516         &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
2517         &sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr,
2518         &sensor_dev_attr_pwm2_auto_point4_temp.dev_attr.attr,
2519         &sensor_dev_attr_pwm2_auto_point5_temp.dev_attr.attr,
2520         &sensor_dev_attr_pwm2_auto_point6_temp.dev_attr.attr,
2521         &sensor_dev_attr_pwm2_auto_point7_temp.dev_attr.attr,
2522         &sensor_dev_attr_pwm2_auto_point8_temp.dev_attr.attr,
2523         &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
2524         &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
2525         &sensor_dev_attr_pwm2_auto_point3_pwm.dev_attr.attr,
2526         &sensor_dev_attr_pwm2_auto_point4_pwm.dev_attr.attr,
2527         &sensor_dev_attr_pwm2_auto_point5_pwm.dev_attr.attr,
2528         &sensor_dev_attr_pwm2_auto_point6_pwm.dev_attr.attr,
2529         &sensor_dev_attr_pwm2_auto_point7_pwm.dev_attr.attr,
2530         &sensor_dev_attr_pwm2_auto_point8_pwm.dev_attr.attr,
2531         NULL
2532 };
2533
2534 static umode_t asus_fan_curve_is_visible(struct kobject *kobj,
2535                                          struct attribute *attr, int idx)
2536 {
2537         struct device *dev = kobj_to_dev(kobj);
2538         struct asus_wmi *asus = dev_get_drvdata(dev->parent);
2539
2540         /*
2541          * Check the char instead of casting attr as there are two attr types
2542          * involved here (attr1 and attr2)
2543          */
2544         if (asus->cpu_fan_curve_available && attr->name[3] == '1')
2545                 return 0644;
2546
2547         if (asus->gpu_fan_curve_available && attr->name[3] == '2')
2548                 return 0644;
2549
2550         return 0;
2551 }
2552
2553 static const struct attribute_group asus_fan_curve_attr_group = {
2554         .is_visible = asus_fan_curve_is_visible,
2555         .attrs = asus_fan_curve_attr,
2556 };
2557 __ATTRIBUTE_GROUPS(asus_fan_curve_attr);
2558
2559 /*
2560  * Must be initialised after throttle_thermal_policy_check_present() as
2561  * we check the status of throttle_thermal_policy_available during init.
2562  */
2563 static int asus_wmi_custom_fan_curve_init(struct asus_wmi *asus)
2564 {
2565         struct device *dev = &asus->platform_device->dev;
2566         struct device *hwmon;
2567         int err;
2568
2569         err = fan_curve_check_present(asus, &asus->cpu_fan_curve_available,
2570                                       ASUS_WMI_DEVID_CPU_FAN_CURVE);
2571         if (err)
2572                 return err;
2573
2574         err = fan_curve_check_present(asus, &asus->gpu_fan_curve_available,
2575                                       ASUS_WMI_DEVID_GPU_FAN_CURVE);
2576         if (err)
2577                 return err;
2578
2579         if (!asus->cpu_fan_curve_available && !asus->gpu_fan_curve_available)
2580                 return 0;
2581
2582         hwmon = devm_hwmon_device_register_with_groups(
2583                 dev, "asus_custom_fan_curve", asus, asus_fan_curve_attr_groups);
2584
2585         if (IS_ERR(hwmon)) {
2586                 dev_err(dev,
2587                         "Could not register asus_custom_fan_curve device\n");
2588                 return PTR_ERR(hwmon);
2589         }
2590
2591         return 0;
2592 }
2593
2594 /* Throttle thermal policy ****************************************************/
2595
2596 static int throttle_thermal_policy_check_present(struct asus_wmi *asus)
2597 {
2598         u32 result;
2599         int err;
2600
2601         asus->throttle_thermal_policy_available = false;
2602
2603         err = asus_wmi_get_devstate(asus,
2604                                     ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY,
2605                                     &result);
2606         if (err) {
2607                 if (err == -ENODEV)
2608                         return 0;
2609                 return err;
2610         }
2611
2612         if (result & ASUS_WMI_DSTS_PRESENCE_BIT)
2613                 asus->throttle_thermal_policy_available = true;
2614
2615         return 0;
2616 }
2617
2618 static int throttle_thermal_policy_write(struct asus_wmi *asus)
2619 {
2620         int err;
2621         u8 value;
2622         u32 retval;
2623
2624         value = asus->throttle_thermal_policy_mode;
2625
2626         err = asus_wmi_set_devstate(ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY,
2627                                     value, &retval);
2628
2629         sysfs_notify(&asus->platform_device->dev.kobj, NULL,
2630                         "throttle_thermal_policy");
2631
2632         if (err) {
2633                 pr_warn("Failed to set throttle thermal policy: %d\n", err);
2634                 return err;
2635         }
2636
2637         if (retval != 1) {
2638                 pr_warn("Failed to set throttle thermal policy (retval): 0x%x\n",
2639                         retval);
2640                 return -EIO;
2641         }
2642
2643         /* Must set to disabled if mode is toggled */
2644         if (asus->cpu_fan_curve_available)
2645                 asus->custom_fan_curves[FAN_CURVE_DEV_CPU].enabled = false;
2646         if (asus->gpu_fan_curve_available)
2647                 asus->custom_fan_curves[FAN_CURVE_DEV_GPU].enabled = false;
2648
2649         return 0;
2650 }
2651
2652 static int throttle_thermal_policy_set_default(struct asus_wmi *asus)
2653 {
2654         if (!asus->throttle_thermal_policy_available)
2655                 return 0;
2656
2657         asus->throttle_thermal_policy_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
2658         return throttle_thermal_policy_write(asus);
2659 }
2660
2661 static int throttle_thermal_policy_switch_next(struct asus_wmi *asus)
2662 {
2663         u8 new_mode = asus->throttle_thermal_policy_mode + 1;
2664         int err;
2665
2666         if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT)
2667                 new_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
2668
2669         asus->throttle_thermal_policy_mode = new_mode;
2670         err = throttle_thermal_policy_write(asus);
2671         if (err)
2672                 return err;
2673
2674         /*
2675          * Ensure that platform_profile updates userspace with the change to ensure
2676          * that platform_profile and throttle_thermal_policy_mode are in sync.
2677          */
2678         platform_profile_notify();
2679
2680         return 0;
2681 }
2682
2683 static ssize_t throttle_thermal_policy_show(struct device *dev,
2684                                    struct device_attribute *attr, char *buf)
2685 {
2686         struct asus_wmi *asus = dev_get_drvdata(dev);
2687         u8 mode = asus->throttle_thermal_policy_mode;
2688
2689         return scnprintf(buf, PAGE_SIZE, "%d\n", mode);
2690 }
2691
2692 static ssize_t throttle_thermal_policy_store(struct device *dev,
2693                                     struct device_attribute *attr,
2694                                     const char *buf, size_t count)
2695 {
2696         struct asus_wmi *asus = dev_get_drvdata(dev);
2697         u8 new_mode;
2698         int result;
2699         int err;
2700
2701         result = kstrtou8(buf, 10, &new_mode);
2702         if (result < 0)
2703                 return result;
2704
2705         if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT)
2706                 return -EINVAL;
2707
2708         asus->throttle_thermal_policy_mode = new_mode;
2709         err = throttle_thermal_policy_write(asus);
2710         if (err)
2711                 return err;
2712
2713         /*
2714          * Ensure that platform_profile updates userspace with the change to ensure
2715          * that platform_profile and throttle_thermal_policy_mode are in sync.
2716          */
2717         platform_profile_notify();
2718
2719         return count;
2720 }
2721
2722 // Throttle thermal policy: 0 - default, 1 - overboost, 2 - silent
2723 static DEVICE_ATTR_RW(throttle_thermal_policy);
2724
2725 /* Platform profile ***********************************************************/
2726 static int asus_wmi_platform_profile_get(struct platform_profile_handler *pprof,
2727                                         enum platform_profile_option *profile)
2728 {
2729         struct asus_wmi *asus;
2730         int tp;
2731
2732         asus = container_of(pprof, struct asus_wmi, platform_profile_handler);
2733
2734         tp = asus->throttle_thermal_policy_mode;
2735
2736         switch (tp) {
2737         case ASUS_THROTTLE_THERMAL_POLICY_DEFAULT:
2738                 *profile = PLATFORM_PROFILE_BALANCED;
2739                 break;
2740         case ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST:
2741                 *profile = PLATFORM_PROFILE_PERFORMANCE;
2742                 break;
2743         case ASUS_THROTTLE_THERMAL_POLICY_SILENT:
2744                 *profile = PLATFORM_PROFILE_QUIET;
2745                 break;
2746         default:
2747                 return -EINVAL;
2748         }
2749
2750         return 0;
2751 }
2752
2753 static int asus_wmi_platform_profile_set(struct platform_profile_handler *pprof,
2754                                         enum platform_profile_option profile)
2755 {
2756         struct asus_wmi *asus;
2757         int tp;
2758
2759         asus = container_of(pprof, struct asus_wmi, platform_profile_handler);
2760
2761         switch (profile) {
2762         case PLATFORM_PROFILE_PERFORMANCE:
2763                 tp = ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST;
2764                 break;
2765         case PLATFORM_PROFILE_BALANCED:
2766                 tp = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
2767                 break;
2768         case PLATFORM_PROFILE_QUIET:
2769                 tp = ASUS_THROTTLE_THERMAL_POLICY_SILENT;
2770                 break;
2771         default:
2772                 return -EOPNOTSUPP;
2773         }
2774
2775         asus->throttle_thermal_policy_mode = tp;
2776         return throttle_thermal_policy_write(asus);
2777 }
2778
2779 static int platform_profile_setup(struct asus_wmi *asus)
2780 {
2781         struct device *dev = &asus->platform_device->dev;
2782         int err;
2783
2784         /*
2785          * Not an error if a component platform_profile relies on is unavailable
2786          * so early return, skipping the setup of platform_profile.
2787          */
2788         if (!asus->throttle_thermal_policy_available)
2789                 return 0;
2790
2791         dev_info(dev, "Using throttle_thermal_policy for platform_profile support\n");
2792
2793         asus->platform_profile_handler.profile_get = asus_wmi_platform_profile_get;
2794         asus->platform_profile_handler.profile_set = asus_wmi_platform_profile_set;
2795
2796         set_bit(PLATFORM_PROFILE_QUIET, asus->platform_profile_handler.choices);
2797         set_bit(PLATFORM_PROFILE_BALANCED,
2798                 asus->platform_profile_handler.choices);
2799         set_bit(PLATFORM_PROFILE_PERFORMANCE,
2800                 asus->platform_profile_handler.choices);
2801
2802         err = platform_profile_register(&asus->platform_profile_handler);
2803         if (err)
2804                 return err;
2805
2806         asus->platform_profile_support = true;
2807         return 0;
2808 }
2809
2810 /* Backlight ******************************************************************/
2811
2812 static int read_backlight_power(struct asus_wmi *asus)
2813 {
2814         int ret;
2815
2816         if (asus->driver->quirks->store_backlight_power)
2817                 ret = !asus->driver->panel_power;
2818         else
2819                 ret = asus_wmi_get_devstate_simple(asus,
2820                                                    ASUS_WMI_DEVID_BACKLIGHT);
2821
2822         if (ret < 0)
2823                 return ret;
2824
2825         return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
2826 }
2827
2828 static int read_brightness_max(struct asus_wmi *asus)
2829 {
2830         u32 retval;
2831         int err;
2832
2833         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
2834         if (err < 0)
2835                 return err;
2836
2837         retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
2838         retval >>= 8;
2839
2840         if (!retval)
2841                 return -ENODEV;
2842
2843         return retval;
2844 }
2845
2846 static int read_brightness(struct backlight_device *bd)
2847 {
2848         struct asus_wmi *asus = bl_get_data(bd);
2849         u32 retval;
2850         int err;
2851
2852         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
2853         if (err < 0)
2854                 return err;
2855
2856         return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
2857 }
2858
2859 static u32 get_scalar_command(struct backlight_device *bd)
2860 {
2861         struct asus_wmi *asus = bl_get_data(bd);
2862         u32 ctrl_param = 0;
2863
2864         if ((asus->driver->brightness < bd->props.brightness) ||
2865             bd->props.brightness == bd->props.max_brightness)
2866                 ctrl_param = 0x00008001;
2867         else if ((asus->driver->brightness > bd->props.brightness) ||
2868                  bd->props.brightness == 0)
2869                 ctrl_param = 0x00008000;
2870
2871         asus->driver->brightness = bd->props.brightness;
2872
2873         return ctrl_param;
2874 }
2875
2876 static int update_bl_status(struct backlight_device *bd)
2877 {
2878         struct asus_wmi *asus = bl_get_data(bd);
2879         u32 ctrl_param;
2880         int power, err = 0;
2881
2882         power = read_backlight_power(asus);
2883         if (power != -ENODEV && bd->props.power != power) {
2884                 ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
2885                 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
2886                                             ctrl_param, NULL);
2887                 if (asus->driver->quirks->store_backlight_power)
2888                         asus->driver->panel_power = bd->props.power;
2889
2890                 /* When using scalar brightness, updating the brightness
2891                  * will mess with the backlight power */
2892                 if (asus->driver->quirks->scalar_panel_brightness)
2893                         return err;
2894         }
2895
2896         if (asus->driver->quirks->scalar_panel_brightness)
2897                 ctrl_param = get_scalar_command(bd);
2898         else
2899                 ctrl_param = bd->props.brightness;
2900
2901         err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
2902                                     ctrl_param, NULL);
2903
2904         return err;
2905 }
2906
2907 static const struct backlight_ops asus_wmi_bl_ops = {
2908         .get_brightness = read_brightness,
2909         .update_status = update_bl_status,
2910 };
2911
2912 static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
2913 {
2914         struct backlight_device *bd = asus->backlight_device;
2915         int old = bd->props.brightness;
2916         int new = old;
2917
2918         if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
2919                 new = code - NOTIFY_BRNUP_MIN + 1;
2920         else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
2921                 new = code - NOTIFY_BRNDOWN_MIN;
2922
2923         bd->props.brightness = new;
2924         backlight_update_status(bd);
2925         backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
2926
2927         return old;
2928 }
2929
2930 static int asus_wmi_backlight_init(struct asus_wmi *asus)
2931 {
2932         struct backlight_device *bd;
2933         struct backlight_properties props;
2934         int max;
2935         int power;
2936
2937         max = read_brightness_max(asus);
2938         if (max < 0)
2939                 return max;
2940
2941         power = read_backlight_power(asus);
2942         if (power == -ENODEV)
2943                 power = FB_BLANK_UNBLANK;
2944         else if (power < 0)
2945                 return power;
2946
2947         memset(&props, 0, sizeof(struct backlight_properties));
2948         props.type = BACKLIGHT_PLATFORM;
2949         props.max_brightness = max;
2950         bd = backlight_device_register(asus->driver->name,
2951                                        &asus->platform_device->dev, asus,
2952                                        &asus_wmi_bl_ops, &props);
2953         if (IS_ERR(bd)) {
2954                 pr_err("Could not register backlight device\n");
2955                 return PTR_ERR(bd);
2956         }
2957
2958         asus->backlight_device = bd;
2959
2960         if (asus->driver->quirks->store_backlight_power)
2961                 asus->driver->panel_power = power;
2962
2963         bd->props.brightness = read_brightness(bd);
2964         bd->props.power = power;
2965         backlight_update_status(bd);
2966
2967         asus->driver->brightness = bd->props.brightness;
2968
2969         return 0;
2970 }
2971
2972 static void asus_wmi_backlight_exit(struct asus_wmi *asus)
2973 {
2974         backlight_device_unregister(asus->backlight_device);
2975
2976         asus->backlight_device = NULL;
2977 }
2978
2979 static int is_display_toggle(int code)
2980 {
2981         /* display toggle keys */
2982         if ((code >= 0x61 && code <= 0x67) ||
2983             (code >= 0x8c && code <= 0x93) ||
2984             (code >= 0xa0 && code <= 0xa7) ||
2985             (code >= 0xd0 && code <= 0xd5))
2986                 return 1;
2987
2988         return 0;
2989 }
2990
2991 /* Fn-lock ********************************************************************/
2992
2993 static bool asus_wmi_has_fnlock_key(struct asus_wmi *asus)
2994 {
2995         u32 result;
2996
2997         asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FNLOCK, &result);
2998
2999         return (result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
3000                 !(result & ASUS_WMI_FNLOCK_BIOS_DISABLED);
3001 }
3002
3003 static void asus_wmi_fnlock_update(struct asus_wmi *asus)
3004 {
3005         int mode = asus->fnlock_locked;
3006
3007         asus_wmi_set_devstate(ASUS_WMI_DEVID_FNLOCK, mode, NULL);
3008 }
3009
3010 /* WMI events *****************************************************************/
3011
3012 static int asus_wmi_get_event_code(u32 value)
3013 {
3014         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
3015         union acpi_object *obj;
3016         acpi_status status;
3017         int code;
3018
3019         status = wmi_get_event_data(value, &response);
3020         if (ACPI_FAILURE(status)) {
3021                 pr_warn("Failed to get WMI notify code: %s\n",
3022                                 acpi_format_exception(status));
3023                 return -EIO;
3024         }
3025
3026         obj = (union acpi_object *)response.pointer;
3027
3028         if (obj && obj->type == ACPI_TYPE_INTEGER)
3029                 code = (int)(obj->integer.value & WMI_EVENT_MASK);
3030         else
3031                 code = -EIO;
3032
3033         kfree(obj);
3034         return code;
3035 }
3036
3037 static void asus_wmi_handle_event_code(int code, struct asus_wmi *asus)
3038 {
3039         unsigned int key_value = 1;
3040         bool autorelease = 1;
3041         int result, orig_code;
3042
3043         orig_code = code;
3044
3045         if (asus->driver->key_filter) {
3046                 asus->driver->key_filter(asus->driver, &code, &key_value,
3047                                          &autorelease);
3048                 if (code == ASUS_WMI_KEY_IGNORE)
3049                         return;
3050         }
3051
3052         if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
3053                 code = ASUS_WMI_BRN_UP;
3054         else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
3055                 code = ASUS_WMI_BRN_DOWN;
3056
3057         if (code == ASUS_WMI_BRN_DOWN || code == ASUS_WMI_BRN_UP) {
3058                 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
3059                         asus_wmi_backlight_notify(asus, orig_code);
3060                         return;
3061                 }
3062         }
3063
3064         if (code == NOTIFY_KBD_BRTUP) {
3065                 kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
3066                 return;
3067         }
3068         if (code == NOTIFY_KBD_BRTDWN) {
3069                 kbd_led_set_by_kbd(asus, asus->kbd_led_wk - 1);
3070                 return;
3071         }
3072         if (code == NOTIFY_KBD_BRTTOGGLE) {
3073                 if (asus->kbd_led_wk == asus->kbd_led.max_brightness)
3074                         kbd_led_set_by_kbd(asus, 0);
3075                 else
3076                         kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
3077                 return;
3078         }
3079
3080         if (code == NOTIFY_FNLOCK_TOGGLE) {
3081                 asus->fnlock_locked = !asus->fnlock_locked;
3082                 asus_wmi_fnlock_update(asus);
3083                 return;
3084         }
3085
3086         if (asus->driver->quirks->use_kbd_dock_devid && code == NOTIFY_KBD_DOCK_CHANGE) {
3087                 result = asus_wmi_get_devstate_simple(asus,
3088                                                       ASUS_WMI_DEVID_KBD_DOCK);
3089                 if (result >= 0) {
3090                         input_report_switch(asus->inputdev, SW_TABLET_MODE,
3091                                             !result);
3092                         input_sync(asus->inputdev);
3093                 }
3094                 return;
3095         }
3096
3097         if (asus->driver->quirks->use_lid_flip_devid && code == NOTIFY_LID_FLIP) {
3098                 lid_flip_tablet_mode_get_state(asus);
3099                 return;
3100         }
3101
3102         if (asus->fan_boost_mode_available && code == NOTIFY_KBD_FBM) {
3103                 fan_boost_mode_switch_next(asus);
3104                 return;
3105         }
3106
3107         if (asus->throttle_thermal_policy_available && code == NOTIFY_KBD_TTP) {
3108                 throttle_thermal_policy_switch_next(asus);
3109                 return;
3110         }
3111
3112         if (is_display_toggle(code) && asus->driver->quirks->no_display_toggle)
3113                 return;
3114
3115         if (!sparse_keymap_report_event(asus->inputdev, code,
3116                                         key_value, autorelease))
3117                 pr_info("Unknown key code 0x%x\n", code);
3118 }
3119
3120 static void asus_wmi_notify(u32 value, void *context)
3121 {
3122         struct asus_wmi *asus = context;
3123         int code;
3124         int i;
3125
3126         for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) {
3127                 code = asus_wmi_get_event_code(value);
3128                 if (code < 0) {
3129                         pr_warn("Failed to get notify code: %d\n", code);
3130                         return;
3131                 }
3132
3133                 if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK)
3134                         return;
3135
3136                 asus_wmi_handle_event_code(code, asus);
3137
3138                 /*
3139                  * Double check that queue is present:
3140                  * ATK (with queue) uses 0xff, ASUSWMI (without) 0xd2.
3141                  */
3142                 if (!asus->wmi_event_queue || value != WMI_EVENT_VALUE_ATK)
3143                         return;
3144         }
3145
3146         pr_warn("Failed to process event queue, last code: 0x%x\n", code);
3147 }
3148
3149 static int asus_wmi_notify_queue_flush(struct asus_wmi *asus)
3150 {
3151         int code;
3152         int i;
3153
3154         for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) {
3155                 code = asus_wmi_get_event_code(WMI_EVENT_VALUE_ATK);
3156                 if (code < 0) {
3157                         pr_warn("Failed to get event during flush: %d\n", code);
3158                         return code;
3159                 }
3160
3161                 if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK)
3162                         return 0;
3163         }
3164
3165         pr_warn("Failed to flush event queue\n");
3166         return -EIO;
3167 }
3168
3169 /* Sysfs **********************************************************************/
3170
3171 static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
3172                              const char *buf, size_t count)
3173 {
3174         u32 retval;
3175         int err, value;
3176
3177         value = asus_wmi_get_devstate_simple(asus, devid);
3178         if (value < 0)
3179                 return value;
3180
3181         err = kstrtoint(buf, 0, &value);
3182         if (err)
3183                 return err;
3184
3185         err = asus_wmi_set_devstate(devid, value, &retval);
3186         if (err < 0)
3187                 return err;
3188
3189         return count;
3190 }
3191
3192 static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
3193 {
3194         int value = asus_wmi_get_devstate_simple(asus, devid);
3195
3196         if (value < 0)
3197                 return value;
3198
3199         return sprintf(buf, "%d\n", value);
3200 }
3201
3202 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm)                  \
3203         static ssize_t show_##_name(struct device *dev,                 \
3204                                     struct device_attribute *attr,      \
3205                                     char *buf)                          \
3206         {                                                               \
3207                 struct asus_wmi *asus = dev_get_drvdata(dev);           \
3208                                                                         \
3209                 return show_sys_wmi(asus, _cm, buf);                    \
3210         }                                                               \
3211         static ssize_t store_##_name(struct device *dev,                \
3212                                      struct device_attribute *attr,     \
3213                                      const char *buf, size_t count)     \
3214         {                                                               \
3215                 struct asus_wmi *asus = dev_get_drvdata(dev);           \
3216                                                                         \
3217                 return store_sys_wmi(asus, _cm, buf, count);            \
3218         }                                                               \
3219         static struct device_attribute dev_attr_##_name = {             \
3220                 .attr = {                                               \
3221                         .name = __stringify(_name),                     \
3222                         .mode = _mode },                                \
3223                 .show   = show_##_name,                                 \
3224                 .store  = store_##_name,                                \
3225         }
3226
3227 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
3228 ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
3229 ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
3230 ASUS_WMI_CREATE_DEVICE_ATTR(lid_resume, 0644, ASUS_WMI_DEVID_LID_RESUME);
3231 ASUS_WMI_CREATE_DEVICE_ATTR(als_enable, 0644, ASUS_WMI_DEVID_ALS_ENABLE);
3232
3233 static ssize_t cpufv_store(struct device *dev, struct device_attribute *attr,
3234                            const char *buf, size_t count)
3235 {
3236         int value, rv;
3237
3238         rv = kstrtoint(buf, 0, &value);
3239         if (rv)
3240                 return rv;
3241
3242         if (value < 0 || value > 2)
3243                 return -EINVAL;
3244
3245         rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
3246         if (rv < 0)
3247                 return rv;
3248
3249         return count;
3250 }
3251
3252 static DEVICE_ATTR_WO(cpufv);
3253
3254 static struct attribute *platform_attributes[] = {
3255         &dev_attr_cpufv.attr,
3256         &dev_attr_camera.attr,
3257         &dev_attr_cardr.attr,
3258         &dev_attr_touchpad.attr,
3259         &dev_attr_egpu_enable.attr,
3260         &dev_attr_dgpu_disable.attr,
3261         &dev_attr_lid_resume.attr,
3262         &dev_attr_als_enable.attr,
3263         &dev_attr_fan_boost_mode.attr,
3264         &dev_attr_throttle_thermal_policy.attr,
3265         &dev_attr_panel_od.attr,
3266         NULL
3267 };
3268
3269 static umode_t asus_sysfs_is_visible(struct kobject *kobj,
3270                                     struct attribute *attr, int idx)
3271 {
3272         struct device *dev = container_of(kobj, struct device, kobj);
3273         struct asus_wmi *asus = dev_get_drvdata(dev);
3274         bool ok = true;
3275         int devid = -1;
3276
3277         if (attr == &dev_attr_camera.attr)
3278                 devid = ASUS_WMI_DEVID_CAMERA;
3279         else if (attr == &dev_attr_cardr.attr)
3280                 devid = ASUS_WMI_DEVID_CARDREADER;
3281         else if (attr == &dev_attr_touchpad.attr)
3282                 devid = ASUS_WMI_DEVID_TOUCHPAD;
3283         else if (attr == &dev_attr_lid_resume.attr)
3284                 devid = ASUS_WMI_DEVID_LID_RESUME;
3285         else if (attr == &dev_attr_als_enable.attr)
3286                 devid = ASUS_WMI_DEVID_ALS_ENABLE;
3287         else if (attr == &dev_attr_egpu_enable.attr)
3288                 ok = asus->egpu_enable_available;
3289         else if (attr == &dev_attr_dgpu_disable.attr)
3290                 ok = asus->dgpu_disable_available;
3291         else if (attr == &dev_attr_fan_boost_mode.attr)
3292                 ok = asus->fan_boost_mode_available;
3293         else if (attr == &dev_attr_throttle_thermal_policy.attr)
3294                 ok = asus->throttle_thermal_policy_available;
3295         else if (attr == &dev_attr_panel_od.attr)
3296                 ok = asus->panel_overdrive_available;
3297
3298         if (devid != -1)
3299                 ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
3300
3301         return ok ? attr->mode : 0;
3302 }
3303
3304 static const struct attribute_group platform_attribute_group = {
3305         .is_visible = asus_sysfs_is_visible,
3306         .attrs = platform_attributes
3307 };
3308
3309 static void asus_wmi_sysfs_exit(struct platform_device *device)
3310 {
3311         sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
3312 }
3313
3314 static int asus_wmi_sysfs_init(struct platform_device *device)
3315 {
3316         return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
3317 }
3318
3319 /* Platform device ************************************************************/
3320
3321 static int asus_wmi_platform_init(struct asus_wmi *asus)
3322 {
3323         struct device *dev = &asus->platform_device->dev;
3324         char *wmi_uid;
3325         int rv;
3326
3327         /* INIT enable hotkeys on some models */
3328         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
3329                 pr_info("Initialization: %#x\n", rv);
3330
3331         /* We don't know yet what to do with this version... */
3332         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
3333                 pr_info("BIOS WMI version: %d.%d\n", rv >> 16, rv & 0xFF);
3334                 asus->spec = rv;
3335         }
3336
3337         /*
3338          * The SFUN method probably allows the original driver to get the list
3339          * of features supported by a given model. For now, 0x0100 or 0x0800
3340          * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
3341          * The significance of others is yet to be found.
3342          */
3343         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
3344                 pr_info("SFUN value: %#x\n", rv);
3345                 asus->sfun = rv;
3346         }
3347
3348         /*
3349          * Eee PC and Notebooks seems to have different method_id for DSTS,
3350          * but it may also be related to the BIOS's SPEC.
3351          * Note, on most Eeepc, there is no way to check if a method exist
3352          * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
3353          * but once again, SPEC may probably be used for that kind of things.
3354          *
3355          * Additionally at least TUF Gaming series laptops return nothing for
3356          * unknown methods, so the detection in this way is not possible.
3357          *
3358          * There is strong indication that only ACPI WMI devices that have _UID
3359          * equal to "ASUSWMI" use DCTS whereas those with "ATK" use DSTS.
3360          */
3361         wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
3362         if (!wmi_uid)
3363                 return -ENODEV;
3364
3365         if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI)) {
3366                 dev_info(dev, "Detected ASUSWMI, use DCTS\n");
3367                 asus->dsts_id = ASUS_WMI_METHODID_DCTS;
3368         } else {
3369                 dev_info(dev, "Detected %s, not ASUSWMI, use DSTS\n", wmi_uid);
3370                 asus->dsts_id = ASUS_WMI_METHODID_DSTS;
3371         }
3372
3373         /*
3374          * Some devices can have multiple event codes stored in a queue before
3375          * the module load if it was unloaded intermittently after calling
3376          * the INIT method (enables event handling). The WMI notify handler is
3377          * expected to retrieve all event codes until a retrieved code equals
3378          * queue end marker (One or Ones). Old codes are flushed from the queue
3379          * upon module load. Not enabling this when it should be has minimal
3380          * visible impact so fall back if anything goes wrong.
3381          */
3382         wmi_uid = wmi_get_acpi_device_uid(asus->driver->event_guid);
3383         if (wmi_uid && !strcmp(wmi_uid, ASUS_ACPI_UID_ATK)) {
3384                 dev_info(dev, "Detected ATK, enable event queue\n");
3385
3386                 if (!asus_wmi_notify_queue_flush(asus))
3387                         asus->wmi_event_queue = true;
3388         }
3389
3390         /* CWAP allow to define the behavior of the Fn+F2 key,
3391          * this method doesn't seems to be present on Eee PCs */
3392         if (asus->driver->quirks->wapf >= 0)
3393                 asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP,
3394                                       asus->driver->quirks->wapf, NULL);
3395
3396         return 0;
3397 }
3398
3399 /* debugfs ********************************************************************/
3400
3401 struct asus_wmi_debugfs_node {
3402         struct asus_wmi *asus;
3403         char *name;
3404         int (*show) (struct seq_file *m, void *data);
3405 };
3406
3407 static int show_dsts(struct seq_file *m, void *data)
3408 {
3409         struct asus_wmi *asus = m->private;
3410         int err;
3411         u32 retval = -1;
3412
3413         err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
3414         if (err < 0)
3415                 return err;
3416
3417         seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
3418
3419         return 0;
3420 }
3421
3422 static int show_devs(struct seq_file *m, void *data)
3423 {
3424         struct asus_wmi *asus = m->private;
3425         int err;
3426         u32 retval = -1;
3427
3428         err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
3429                                     &retval);
3430         if (err < 0)
3431                 return err;
3432
3433         seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
3434                    asus->debug.ctrl_param, retval);
3435
3436         return 0;
3437 }
3438
3439 static int show_call(struct seq_file *m, void *data)
3440 {
3441         struct asus_wmi *asus = m->private;
3442         struct bios_args args = {
3443                 .arg0 = asus->debug.dev_id,
3444                 .arg1 = asus->debug.ctrl_param,
3445         };
3446         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
3447         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
3448         union acpi_object *obj;
3449         acpi_status status;
3450
3451         status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
3452                                      0, asus->debug.method_id,
3453                                      &input, &output);
3454
3455         if (ACPI_FAILURE(status))
3456                 return -EIO;
3457
3458         obj = (union acpi_object *)output.pointer;
3459         if (obj && obj->type == ACPI_TYPE_INTEGER)
3460                 seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
3461                            asus->debug.dev_id, asus->debug.ctrl_param,
3462                            (u32) obj->integer.value);
3463         else
3464                 seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
3465                            asus->debug.dev_id, asus->debug.ctrl_param,
3466                            obj ? obj->type : -1);
3467
3468         kfree(obj);
3469
3470         return 0;
3471 }
3472
3473 static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
3474         {NULL, "devs", show_devs},
3475         {NULL, "dsts", show_dsts},
3476         {NULL, "call", show_call},
3477 };
3478
3479 static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
3480 {
3481         struct asus_wmi_debugfs_node *node = inode->i_private;
3482
3483         return single_open(file, node->show, node->asus);
3484 }
3485
3486 static const struct file_operations asus_wmi_debugfs_io_ops = {
3487         .owner = THIS_MODULE,
3488         .open = asus_wmi_debugfs_open,
3489         .read = seq_read,
3490         .llseek = seq_lseek,
3491         .release = single_release,
3492 };
3493
3494 static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
3495 {
3496         debugfs_remove_recursive(asus->debug.root);
3497 }
3498
3499 static void asus_wmi_debugfs_init(struct asus_wmi *asus)
3500 {
3501         int i;
3502
3503         asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
3504
3505         debugfs_create_x32("method_id", S_IRUGO | S_IWUSR, asus->debug.root,
3506                            &asus->debug.method_id);
3507
3508         debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR, asus->debug.root,
3509                            &asus->debug.dev_id);
3510
3511         debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR, asus->debug.root,
3512                            &asus->debug.ctrl_param);
3513
3514         for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
3515                 struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
3516
3517                 node->asus = asus;
3518                 debugfs_create_file(node->name, S_IFREG | S_IRUGO,
3519                                     asus->debug.root, node,
3520                                     &asus_wmi_debugfs_io_ops);
3521         }
3522 }
3523
3524 /* Init / exit ****************************************************************/
3525
3526 static int asus_wmi_add(struct platform_device *pdev)
3527 {
3528         struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
3529         struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
3530         struct asus_wmi *asus;
3531         const char *chassis_type;
3532         acpi_status status;
3533         int err;
3534         u32 result;
3535
3536         asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
3537         if (!asus)
3538                 return -ENOMEM;
3539
3540         asus->driver = wdrv;
3541         asus->platform_device = pdev;
3542         wdrv->platform_device = pdev;
3543         platform_set_drvdata(asus->platform_device, asus);
3544
3545         if (wdrv->detect_quirks)
3546                 wdrv->detect_quirks(asus->driver);
3547
3548         err = asus_wmi_platform_init(asus);
3549         if (err)
3550                 goto fail_platform;
3551
3552         err = egpu_enable_check_present(asus);
3553         if (err)
3554                 goto fail_egpu_enable;
3555
3556         err = dgpu_disable_check_present(asus);
3557         if (err)
3558                 goto fail_dgpu_disable;
3559
3560         err = fan_boost_mode_check_present(asus);
3561         if (err)
3562                 goto fail_fan_boost_mode;
3563
3564         err = throttle_thermal_policy_check_present(asus);
3565         if (err)
3566                 goto fail_throttle_thermal_policy;
3567         else
3568                 throttle_thermal_policy_set_default(asus);
3569
3570         err = platform_profile_setup(asus);
3571         if (err)
3572                 goto fail_platform_profile_setup;
3573
3574         err = panel_od_check_present(asus);
3575         if (err)
3576                 goto fail_panel_od;
3577
3578         err = asus_wmi_sysfs_init(asus->platform_device);
3579         if (err)
3580                 goto fail_sysfs;
3581
3582         err = asus_wmi_input_init(asus);
3583         if (err)
3584                 goto fail_input;
3585
3586         err = asus_wmi_fan_init(asus); /* probably no problems on error */
3587
3588         err = asus_wmi_hwmon_init(asus);
3589         if (err)
3590                 goto fail_hwmon;
3591
3592         err = asus_wmi_custom_fan_curve_init(asus);
3593         if (err)
3594                 goto fail_custom_fan_curve;
3595
3596         err = asus_wmi_led_init(asus);
3597         if (err)
3598                 goto fail_leds;
3599
3600         asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result);
3601         if (result & (ASUS_WMI_DSTS_PRESENCE_BIT | ASUS_WMI_DSTS_USER_BIT))
3602                 asus->driver->wlan_ctrl_by_user = 1;
3603
3604         if (!(asus->driver->wlan_ctrl_by_user && ashs_present())) {
3605                 err = asus_wmi_rfkill_init(asus);
3606                 if (err)
3607                         goto fail_rfkill;
3608         }
3609
3610         if (asus->driver->quirks->wmi_force_als_set)
3611                 asus_wmi_set_als();
3612
3613         /* Some Asus desktop boards export an acpi-video backlight interface,
3614            stop this from showing up */
3615         chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE);
3616         if (chassis_type && !strcmp(chassis_type, "3"))
3617                 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
3618
3619         if (asus->driver->quirks->wmi_backlight_power)
3620                 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
3621
3622         if (asus->driver->quirks->wmi_backlight_native)
3623                 acpi_video_set_dmi_backlight_type(acpi_backlight_native);
3624
3625         if (asus->driver->quirks->xusb2pr)
3626                 asus_wmi_set_xusb2pr(asus);
3627
3628         if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
3629                 err = asus_wmi_backlight_init(asus);
3630                 if (err && err != -ENODEV)
3631                         goto fail_backlight;
3632         } else if (asus->driver->quirks->wmi_backlight_set_devstate)
3633                 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT, 2, NULL);
3634
3635         if (asus_wmi_has_fnlock_key(asus)) {
3636                 asus->fnlock_locked = fnlock_default;
3637                 asus_wmi_fnlock_update(asus);
3638         }
3639
3640         status = wmi_install_notify_handler(asus->driver->event_guid,
3641                                             asus_wmi_notify, asus);
3642         if (ACPI_FAILURE(status)) {
3643                 pr_err("Unable to register notify handler - %d\n", status);
3644                 err = -ENODEV;
3645                 goto fail_wmi_handler;
3646         }
3647
3648         asus_wmi_battery_init(asus);
3649
3650         asus_wmi_debugfs_init(asus);
3651
3652         return 0;
3653
3654 fail_wmi_handler:
3655         asus_wmi_backlight_exit(asus);
3656 fail_backlight:
3657         asus_wmi_rfkill_exit(asus);
3658 fail_rfkill:
3659         asus_wmi_led_exit(asus);
3660 fail_leds:
3661 fail_hwmon:
3662         asus_wmi_input_exit(asus);
3663 fail_input:
3664         asus_wmi_sysfs_exit(asus->platform_device);
3665 fail_sysfs:
3666 fail_throttle_thermal_policy:
3667 fail_custom_fan_curve:
3668 fail_platform_profile_setup:
3669         if (asus->platform_profile_support)
3670                 platform_profile_remove();
3671 fail_fan_boost_mode:
3672 fail_egpu_enable:
3673 fail_dgpu_disable:
3674 fail_platform:
3675 fail_panel_od:
3676         kfree(asus);
3677         return err;
3678 }
3679
3680 static int asus_wmi_remove(struct platform_device *device)
3681 {
3682         struct asus_wmi *asus;
3683
3684         asus = platform_get_drvdata(device);
3685         wmi_remove_notify_handler(asus->driver->event_guid);
3686         asus_wmi_backlight_exit(asus);
3687         asus_wmi_input_exit(asus);
3688         asus_wmi_led_exit(asus);
3689         asus_wmi_rfkill_exit(asus);
3690         asus_wmi_debugfs_exit(asus);
3691         asus_wmi_sysfs_exit(asus->platform_device);
3692         asus_fan_set_auto(asus);
3693         throttle_thermal_policy_set_default(asus);
3694         asus_wmi_battery_exit(asus);
3695
3696         if (asus->platform_profile_support)
3697                 platform_profile_remove();
3698
3699         kfree(asus);
3700         return 0;
3701 }
3702
3703 /* Platform driver - hibernate/resume callbacks *******************************/
3704
3705 static int asus_hotk_thaw(struct device *device)
3706 {
3707         struct asus_wmi *asus = dev_get_drvdata(device);
3708
3709         if (asus->wlan.rfkill) {
3710                 bool wlan;
3711
3712                 /*
3713                  * Work around bios bug - acpi _PTS turns off the wireless led
3714                  * during suspend.  Normally it restores it on resume, but
3715                  * we should kick it ourselves in case hibernation is aborted.
3716                  */
3717                 wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
3718                 asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
3719         }
3720
3721         return 0;
3722 }
3723
3724 static int asus_hotk_resume(struct device *device)
3725 {
3726         struct asus_wmi *asus = dev_get_drvdata(device);
3727
3728         if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
3729                 kbd_led_update(asus);
3730
3731         if (asus_wmi_has_fnlock_key(asus))
3732                 asus_wmi_fnlock_update(asus);
3733
3734         if (asus->driver->quirks->use_lid_flip_devid)
3735                 lid_flip_tablet_mode_get_state(asus);
3736
3737         return 0;
3738 }
3739
3740 static int asus_hotk_restore(struct device *device)
3741 {
3742         struct asus_wmi *asus = dev_get_drvdata(device);
3743         int bl;
3744
3745         /* Refresh both wlan rfkill state and pci hotplug */
3746         if (asus->wlan.rfkill)
3747                 asus_rfkill_hotplug(asus);
3748
3749         if (asus->bluetooth.rfkill) {
3750                 bl = !asus_wmi_get_devstate_simple(asus,
3751                                                    ASUS_WMI_DEVID_BLUETOOTH);
3752                 rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
3753         }
3754         if (asus->wimax.rfkill) {
3755                 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
3756                 rfkill_set_sw_state(asus->wimax.rfkill, bl);
3757         }
3758         if (asus->wwan3g.rfkill) {
3759                 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
3760                 rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
3761         }
3762         if (asus->gps.rfkill) {
3763                 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS);
3764                 rfkill_set_sw_state(asus->gps.rfkill, bl);
3765         }
3766         if (asus->uwb.rfkill) {
3767                 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB);
3768                 rfkill_set_sw_state(asus->uwb.rfkill, bl);
3769         }
3770         if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
3771                 kbd_led_update(asus);
3772
3773         if (asus_wmi_has_fnlock_key(asus))
3774                 asus_wmi_fnlock_update(asus);
3775
3776         if (asus->driver->quirks->use_lid_flip_devid)
3777                 lid_flip_tablet_mode_get_state(asus);
3778
3779         return 0;
3780 }
3781
3782 static const struct dev_pm_ops asus_pm_ops = {
3783         .thaw = asus_hotk_thaw,
3784         .restore = asus_hotk_restore,
3785         .resume = asus_hotk_resume,
3786 };
3787
3788 /* Registration ***************************************************************/
3789
3790 static int asus_wmi_probe(struct platform_device *pdev)
3791 {
3792         struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
3793         struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
3794         int ret;
3795
3796         if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
3797                 pr_warn("ASUS Management GUID not found\n");
3798                 return -ENODEV;
3799         }
3800
3801         if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
3802                 pr_warn("ASUS Event GUID not found\n");
3803                 return -ENODEV;
3804         }
3805
3806         if (wdrv->probe) {
3807                 ret = wdrv->probe(pdev);
3808                 if (ret)
3809                         return ret;
3810         }
3811
3812         return asus_wmi_add(pdev);
3813 }
3814
3815 static bool used;
3816
3817 int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
3818 {
3819         struct platform_driver *platform_driver;
3820         struct platform_device *platform_device;
3821
3822         if (used)
3823                 return -EBUSY;
3824
3825         platform_driver = &driver->platform_driver;
3826         platform_driver->remove = asus_wmi_remove;
3827         platform_driver->driver.owner = driver->owner;
3828         platform_driver->driver.name = driver->name;
3829         platform_driver->driver.pm = &asus_pm_ops;
3830
3831         platform_device = platform_create_bundle(platform_driver,
3832                                                  asus_wmi_probe,
3833                                                  NULL, 0, NULL, 0);
3834         if (IS_ERR(platform_device))
3835                 return PTR_ERR(platform_device);
3836
3837         used = true;
3838         return 0;
3839 }
3840 EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
3841
3842 void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
3843 {
3844         platform_device_unregister(driver->platform_device);
3845         platform_driver_unregister(&driver->platform_driver);
3846         used = false;
3847 }
3848 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
3849
3850 static int __init asus_wmi_init(void)
3851 {
3852         pr_info("ASUS WMI generic driver loaded\n");
3853         return 0;
3854 }
3855
3856 static void __exit asus_wmi_exit(void)
3857 {
3858         pr_info("ASUS WMI generic driver unloaded\n");
3859 }
3860
3861 module_init(asus_wmi_init);
3862 module_exit(asus_wmi_exit);