platform/x86/asus-wmi.c

0001 // SPDX-License-Identifier: GPL-2.0-or-later
0002 /*
0003  * Asus PC WMI hotkey driver
0004  *
0005  * Copyright(C) 2010 Intel Corporation.
0006  * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
0007  *
0008  * Portions based on wistron_btns.c:
0009  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
0010  * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
0011  * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
0012  */
0013
0014 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
0015
0016 #include <linux/acpi.h>
0017 #include <linux/backlight.h>
0018 #include <linux/debugfs.h>
0019 #include <linux/dmi.h>
0020 #include <linux/fb.h>
0021 #include <linux/hwmon.h>
0022 #include <linux/hwmon-sysfs.h>
0023 #include <linux/init.h>
0024 #include <linux/input.h>
0025 #include <linux/input/sparse-keymap.h>
0026 #include <linux/kernel.h>
0027 #include <linux/leds.h>
0028 #include <linux/module.h>
0029 #include <linux/pci.h>
0030 #include <linux/pci_hotplug.h>
0031 #include <linux/platform_data/x86/asus-wmi.h>
0032 #include <linux/platform_device.h>
0033 #include <linux/platform_profile.h>
0034 #include <linux/power_supply.h>
0035 #include <linux/rfkill.h>
0036 #include <linux/seq_file.h>
0037 #include <linux/slab.h>
0038 #include <linux/types.h>
0039 #include <linux/units.h>
0040
0041 #include <acpi/battery.h>
0042 #include <acpi/video.h>
0043
0044 #include "asus-wmi.h"
0045
0046 MODULE_AUTHOR("Corentin Chary <corentin.chary@gmail.com>");
0047 MODULE_AUTHOR("Yong Wang <yong.y.wang@intel.com>");
0048 MODULE_DESCRIPTION("Asus Generic WMI Driver");
0049 MODULE_LICENSE("GPL");
0050
0051 static bool fnlock_default = true;
0052 module_param(fnlock_default, bool, 0444);
0053
0054 #define to_asus_wmi_driver(pdrv)                    \
0055     (container_of((pdrv), struct asus_wmi_driver, platform_driver))
0056
0057 #define ASUS_WMI_MGMT_GUID  "97845ED0-4E6D-11DE-8A39-0800200C9A66"
0058
0059 #define NOTIFY_BRNUP_MIN        0x11
0060 #define NOTIFY_BRNUP_MAX        0x1f
0061 #define NOTIFY_BRNDOWN_MIN      0x20
0062 #define NOTIFY_BRNDOWN_MAX      0x2e
0063 #define NOTIFY_FNLOCK_TOGGLE        0x4e
0064 #define NOTIFY_KBD_DOCK_CHANGE      0x75
0065 #define NOTIFY_KBD_BRTUP        0xc4
0066 #define NOTIFY_KBD_BRTDWN       0xc5
0067 #define NOTIFY_KBD_BRTTOGGLE        0xc7
0068 #define NOTIFY_KBD_FBM          0x99
0069 #define NOTIFY_KBD_TTP          0xae
0070 #define NOTIFY_LID_FLIP         0xfa
0071
0072 #define ASUS_WMI_FNLOCK_BIOS_DISABLED   BIT(0)
0073
0074 #define ASUS_FAN_DESC           "cpu_fan"
0075 #define ASUS_FAN_MFUN           0x13
0076 #define ASUS_FAN_SFUN_READ      0x06
0077 #define ASUS_FAN_SFUN_WRITE     0x07
0078
0079 /* Based on standard hwmon pwmX_enable values */
0080 #define ASUS_FAN_CTRL_FULLSPEED     0
0081 #define ASUS_FAN_CTRL_MANUAL        1
0082 #define ASUS_FAN_CTRL_AUTO      2
0083
0084 #define ASUS_FAN_BOOST_MODE_NORMAL      0
0085 #define ASUS_FAN_BOOST_MODE_OVERBOOST       1
0086 #define ASUS_FAN_BOOST_MODE_OVERBOOST_MASK  0x01
0087 #define ASUS_FAN_BOOST_MODE_SILENT      2
0088 #define ASUS_FAN_BOOST_MODE_SILENT_MASK     0x02
0089 #define ASUS_FAN_BOOST_MODES_MASK       0x03
0090
0091 #define ASUS_THROTTLE_THERMAL_POLICY_DEFAULT    0
0092 #define ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST  1
0093 #define ASUS_THROTTLE_THERMAL_POLICY_SILENT 2
0094
0095 #define USB_INTEL_XUSB2PR       0xD0
0096 #define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI   0x9c31
0097
0098 #define ASUS_ACPI_UID_ASUSWMI       "ASUSWMI"
0099 #define ASUS_ACPI_UID_ATK       "ATK"
0100
0101 #define WMI_EVENT_QUEUE_SIZE        0x10
0102 #define WMI_EVENT_QUEUE_END     0x1
0103 #define WMI_EVENT_MASK          0xFFFF
0104 /* The WMI hotkey event value is always the same. */
0105 #define WMI_EVENT_VALUE_ATK     0xFF
0106
0107 #define WMI_EVENT_MASK          0xFFFF
0108
0109 #define FAN_CURVE_POINTS        8
0110 #define FAN_CURVE_BUF_LEN       32
0111 #define FAN_CURVE_DEV_CPU       0x00
0112 #define FAN_CURVE_DEV_GPU       0x01
0113 /* Mask to determine if setting temperature or percentage */
0114 #define FAN_CURVE_PWM_MASK      0x04
0115
0116 static const char * const ashs_ids[] = { "ATK4001", "ATK4002", NULL };
0117
0118 static int throttle_thermal_policy_write(struct asus_wmi *);
0119
0120 static bool ashs_present(void)
0121 {
0122     int i = 0;
0123     while (ashs_ids[i]) {
0124         if (acpi_dev_found(ashs_ids[i++]))
0125             return true;
0126     }
0127     return false;
0128 }
0129
0130 struct bios_args {
0131     u32 arg0;
0132     u32 arg1;
0133     u32 arg2; /* At least TUF Gaming series uses 3 dword input buffer. */
0134     u32 arg3;
0135     u32 arg4; /* Some ROG laptops require a full 5 input args */
0136     u32 arg5;
0137 } __packed;
0138
0139 /*
0140  * Struct that's used for all methods called via AGFN. Naming is
0141  * identically to the AML code.
0142  */
0143 struct agfn_args {
0144     u16 mfun; /* probably "Multi-function" to be called */
0145     u16 sfun; /* probably "Sub-function" to be called */
0146     u16 len;  /* size of the hole struct, including subfunction fields */
0147     u8 stas;  /* not used by now */
0148     u8 err;   /* zero on success */
0149 } __packed;
0150
0151 /* struct used for calling fan read and write methods */
0152 struct agfn_fan_args {
0153     struct agfn_args agfn;  /* common fields */
0154     u8 fan;         /* fan number: 0: set auto mode 1: 1st fan */
0155     u32 speed;      /* read: RPM/100 - write: 0-255 */
0156 } __packed;
0157
0158 /*
0159  * <platform>/    - debugfs root directory
0160  *   dev_id      - current dev_id
0161  *   ctrl_param  - current ctrl_param
0162  *   method_id   - current method_id
0163  *   devs        - call DEVS(dev_id, ctrl_param) and print result
0164  *   dsts        - call DSTS(dev_id)  and print result
0165  *   call        - call method_id(dev_id, ctrl_param) and print result
0166  */
0167 struct asus_wmi_debug {
0168     struct dentry *root;
0169     u32 method_id;
0170     u32 dev_id;
0171     u32 ctrl_param;
0172 };
0173
0174 struct asus_rfkill {
0175     struct asus_wmi *asus;
0176     struct rfkill *rfkill;
0177     u32 dev_id;
0178 };
0179
0180 enum fan_type {
0181     FAN_TYPE_NONE = 0,
0182     FAN_TYPE_AGFN,      /* deprecated on newer platforms */
0183     FAN_TYPE_SPEC83,    /* starting in Spec 8.3, use CPU_FAN_CTRL */
0184 };
0185
0186 struct fan_curve_data {
0187     bool enabled;
0188     u32 device_id;
0189     u8 temps[FAN_CURVE_POINTS];
0190     u8 percents[FAN_CURVE_POINTS];
0191 };
0192
0193 struct asus_wmi {
0194     int dsts_id;
0195     int spec;
0196     int sfun;
0197     bool wmi_event_queue;
0198
0199     struct input_dev *inputdev;
0200     struct backlight_device *backlight_device;
0201     struct platform_device *platform_device;
0202
0203     struct led_classdev wlan_led;
0204     int wlan_led_wk;
0205     struct led_classdev tpd_led;
0206     int tpd_led_wk;
0207     struct led_classdev kbd_led;
0208     int kbd_led_wk;
0209     struct led_classdev lightbar_led;
0210     int lightbar_led_wk;
0211     struct led_classdev micmute_led;
0212     struct workqueue_struct *led_workqueue;
0213     struct work_struct tpd_led_work;
0214     struct work_struct wlan_led_work;
0215     struct work_struct lightbar_led_work;
0216
0217     struct asus_rfkill wlan;
0218     struct asus_rfkill bluetooth;
0219     struct asus_rfkill wimax;
0220     struct asus_rfkill wwan3g;
0221     struct asus_rfkill gps;
0222     struct asus_rfkill uwb;
0223
0224     enum fan_type fan_type;
0225     int fan_pwm_mode;
0226     int agfn_pwm;
0227
0228     bool fan_boost_mode_available;
0229     u8 fan_boost_mode_mask;
0230     u8 fan_boost_mode;
0231
0232     bool egpu_enable_available; // 0 = enable
0233     bool egpu_enable;
0234
0235     bool dgpu_disable_available;
0236     bool dgpu_disable;
0237
0238     bool throttle_thermal_policy_available;
0239     u8 throttle_thermal_policy_mode;
0240
0241     bool cpu_fan_curve_available;
0242     bool gpu_fan_curve_available;
0243     struct fan_curve_data custom_fan_curves[2];
0244
0245     struct platform_profile_handler platform_profile_handler;
0246     bool platform_profile_support;
0247
0248     // The RSOC controls the maximum charging percentage.
0249     bool battery_rsoc_available;
0250
0251     bool panel_overdrive_available;
0252     bool panel_overdrive;
0253
0254     struct hotplug_slot hotplug_slot;
0255     struct mutex hotplug_lock;
0256     struct mutex wmi_lock;
0257     struct workqueue_struct *hotplug_workqueue;
0258     struct work_struct hotplug_work;
0259
0260     bool fnlock_locked;
0261
0262     struct asus_wmi_debug debug;
0263
0264     struct asus_wmi_driver *driver;
0265 };
0266
0267 /* WMI ************************************************************************/
0268
0269 static int asus_wmi_evaluate_method3(u32 method_id,
0270         u32 arg0, u32 arg1, u32 arg2, u32 *retval)
0271 {
0272     struct bios_args args = {
0273         .arg0 = arg0,
0274         .arg1 = arg1,
0275         .arg2 = arg2,
0276     };
0277     struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
0278     struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
0279     acpi_status status;
0280     union acpi_object *obj;
0281     u32 tmp = 0;
0282
0283     status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
0284                      &input, &output);
0285
0286     if (ACPI_FAILURE(status))
0287         return -EIO;
0288
0289     obj = (union acpi_object *)output.pointer;
0290     if (obj && obj->type == ACPI_TYPE_INTEGER)
0291         tmp = (u32) obj->integer.value;
0292
0293     if (retval)
0294         *retval = tmp;
0295
0296     kfree(obj);
0297
0298     if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
0299         return -ENODEV;
0300
0301     return 0;
0302 }
0303
0304 int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1, u32 *retval)
0305 {
0306     return asus_wmi_evaluate_method3(method_id, arg0, arg1, 0, retval);
0307 }
0308 EXPORT_SYMBOL_GPL(asus_wmi_evaluate_method);
0309
0310 static int asus_wmi_evaluate_method5(u32 method_id,
0311         u32 arg0, u32 arg1, u32 arg2, u32 arg3, u32 arg4, u32 *retval)
0312 {
0313     struct bios_args args = {
0314         .arg0 = arg0,
0315         .arg1 = arg1,
0316         .arg2 = arg2,
0317         .arg3 = arg3,
0318         .arg4 = arg4,
0319     };
0320     struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
0321     struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
0322     acpi_status status;
0323     union acpi_object *obj;
0324     u32 tmp = 0;
0325
0326     status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
0327                      &input, &output);
0328
0329     if (ACPI_FAILURE(status))
0330         return -EIO;
0331
0332     obj = (union acpi_object *)output.pointer;
0333     if (obj && obj->type == ACPI_TYPE_INTEGER)
0334         tmp = (u32) obj->integer.value;
0335
0336     if (retval)
0337         *retval = tmp;
0338
0339     kfree(obj);
0340
0341     if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
0342         return -ENODEV;
0343
0344     return 0;
0345 }
0346
0347 /*
0348  * Returns as an error if the method output is not a buffer. Typically this
0349  * means that the method called is unsupported.
0350  */
0351 static int asus_wmi_evaluate_method_buf(u32 method_id,
0352         u32 arg0, u32 arg1, u8 *ret_buffer, size_t size)
0353 {
0354     struct bios_args args = {
0355         .arg0 = arg0,
0356         .arg1 = arg1,
0357         .arg2 = 0,
0358     };
0359     struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
0360     struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
0361     acpi_status status;
0362     union acpi_object *obj;
0363     int err = 0;
0364
0365     status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id,
0366                      &input, &output);
0367
0368     if (ACPI_FAILURE(status))
0369         return -EIO;
0370
0371     obj = (union acpi_object *)output.pointer;
0372
0373     switch (obj->type) {
0374     case ACPI_TYPE_BUFFER:
0375         if (obj->buffer.length > size) {
0376             err = -ENOSPC;
0377             break;
0378         }
0379         if (obj->buffer.length == 0) {
0380             err = -ENODATA;
0381             break;
0382         }
0383
0384         memcpy(ret_buffer, obj->buffer.pointer, obj->buffer.length);
0385         break;
0386     case ACPI_TYPE_INTEGER:
0387         err = (u32)obj->integer.value;
0388
0389         if (err == ASUS_WMI_UNSUPPORTED_METHOD)
0390             err = -ENODEV;
0391         /*
0392          * At least one method returns a 0 with no buffer if no arg
0393          * is provided, such as ASUS_WMI_DEVID_CPU_FAN_CURVE
0394          */
0395         if (err == 0)
0396             err = -ENODATA;
0397         break;
0398     default:
0399         err = -ENODATA;
0400         break;
0401     }
0402
0403     kfree(obj);
0404
0405     if (err)
0406         return err;
0407
0408     return 0;
0409 }
0410
0411 static int asus_wmi_evaluate_method_agfn(const struct acpi_buffer args)
0412 {
0413     struct acpi_buffer input;
0414     u64 phys_addr;
0415     u32 retval;
0416     u32 status;
0417
0418     /*
0419      * Copy to dma capable address otherwise memory corruption occurs as
0420      * bios has to be able to access it.
0421      */
0422     input.pointer = kmemdup(args.pointer, args.length, GFP_DMA | GFP_KERNEL);
0423     input.length = args.length;
0424     if (!input.pointer)
0425         return -ENOMEM;
0426     phys_addr = virt_to_phys(input.pointer);
0427
0428     status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_AGFN,
0429                     phys_addr, 0, &retval);
0430     if (!status)
0431         memcpy(args.pointer, input.pointer, args.length);
0432
0433     kfree(input.pointer);
0434     if (status)
0435         return -ENXIO;
0436
0437     return retval;
0438 }
0439
0440 static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
0441 {
0442     return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
0443 }
0444
0445 static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
0446                  u32 *retval)
0447 {
0448     return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
0449                     ctrl_param, retval);
0450 }
0451
0452 /* Helper for special devices with magic return codes */
0453 static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
0454                       u32 dev_id, u32 mask)
0455 {
0456     u32 retval = 0;
0457     int err;
0458
0459     err = asus_wmi_get_devstate(asus, dev_id, &retval);
0460     if (err < 0)
0461         return err;
0462
0463     if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
0464         return -ENODEV;
0465
0466     if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
0467         if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
0468             return -ENODEV;
0469     }
0470
0471     return retval & mask;
0472 }
0473
0474 static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
0475 {
0476     return asus_wmi_get_devstate_bits(asus, dev_id,
0477                       ASUS_WMI_DSTS_STATUS_BIT);
0478 }
0479
0480 static bool asus_wmi_dev_is_present(struct asus_wmi *asus, u32 dev_id)
0481 {
0482     u32 retval;
0483     int status = asus_wmi_get_devstate(asus, dev_id, &retval);
0484
0485     return status == 0 && (retval & ASUS_WMI_DSTS_PRESENCE_BIT);
0486 }
0487
0488 /* Input **********************************************************************/
0489
0490 static int asus_wmi_input_init(struct asus_wmi *asus)
0491 {
0492     int err, result;
0493
0494     asus->inputdev = input_allocate_device();
0495     if (!asus->inputdev)
0496         return -ENOMEM;
0497
0498     asus->inputdev->name = asus->driver->input_name;
0499     asus->inputdev->phys = asus->driver->input_phys;
0500     asus->inputdev->id.bustype = BUS_HOST;
0501     asus->inputdev->dev.parent = &asus->platform_device->dev;
0502     set_bit(EV_REP, asus->inputdev->evbit);
0503
0504     err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
0505     if (err)
0506         goto err_free_dev;
0507
0508     if (asus->driver->quirks->use_kbd_dock_devid) {
0509         result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_KBD_DOCK);
0510         if (result >= 0) {
0511             input_set_capability(asus->inputdev, EV_SW, SW_TABLET_MODE);
0512             input_report_switch(asus->inputdev, SW_TABLET_MODE, !result);
0513         } else if (result != -ENODEV) {
0514             pr_err("Error checking for keyboard-dock: %d\n", result);
0515         }
0516     }
0517
0518     if (asus->driver->quirks->use_lid_flip_devid) {
0519         result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_LID_FLIP);
0520         if (result < 0)
0521             asus->driver->quirks->use_lid_flip_devid = 0;
0522         if (result >= 0) {
0523             input_set_capability(asus->inputdev, EV_SW, SW_TABLET_MODE);
0524             input_report_switch(asus->inputdev, SW_TABLET_MODE, result);
0525         } else if (result == -ENODEV) {
0526             pr_err("This device has lid_flip quirk but got ENODEV checking it. This is a bug.");
0527         } else {
0528             pr_err("Error checking for lid-flip: %d\n", result);
0529         }
0530     }
0531
0532     err = input_register_device(asus->inputdev);
0533     if (err)
0534         goto err_free_dev;
0535
0536     return 0;
0537
0538 err_free_dev:
0539     input_free_device(asus->inputdev);
0540     return err;
0541 }
0542
0543 static void asus_wmi_input_exit(struct asus_wmi *asus)
0544 {
0545     if (asus->inputdev)
0546         input_unregister_device(asus->inputdev);
0547
0548     asus->inputdev = NULL;
0549 }
0550
0551 /* Tablet mode ****************************************************************/
0552
0553 static void lid_flip_tablet_mode_get_state(struct asus_wmi *asus)
0554 {
0555     int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_LID_FLIP);
0556
0557     if (result >= 0) {
0558         input_report_switch(asus->inputdev, SW_TABLET_MODE, result);
0559         input_sync(asus->inputdev);
0560     }
0561 }
0562
0563 /* dGPU ********************************************************************/
0564 static int dgpu_disable_check_present(struct asus_wmi *asus)
0565 {
0566     u32 result;
0567     int err;
0568
0569     asus->dgpu_disable_available = false;
0570
0571     err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_DGPU, &result);
0572     if (err) {
0573         if (err == -ENODEV)
0574             return 0;
0575         return err;
0576     }
0577
0578     if (result & ASUS_WMI_DSTS_PRESENCE_BIT) {
0579         asus->dgpu_disable_available = true;
0580         asus->dgpu_disable = result & ASUS_WMI_DSTS_STATUS_BIT;
0581     }
0582
0583     return 0;
0584 }
0585
0586 static int dgpu_disable_write(struct asus_wmi *asus)
0587 {
0588     u32 retval;
0589     u8 value;
0590     int err;
0591
0592     /* Don't rely on type conversion */
0593     value = asus->dgpu_disable ? 1 : 0;
0594
0595     err = asus_wmi_set_devstate(ASUS_WMI_DEVID_DGPU, value, &retval);
0596     if (err) {
0597         pr_warn("Failed to set dgpu disable: %d\n", err);
0598         return err;
0599     }
0600
0601     if (retval > 1) {
0602         pr_warn("Failed to set dgpu disable (retval): 0x%x\n", retval);
0603         return -EIO;
0604     }
0605
0606     sysfs_notify(&asus->platform_device->dev.kobj, NULL, "dgpu_disable");
0607
0608     return 0;
0609 }
0610
0611 static ssize_t dgpu_disable_show(struct device *dev,
0612                    struct device_attribute *attr, char *buf)
0613 {
0614     struct asus_wmi *asus = dev_get_drvdata(dev);
0615     u8 mode = asus->dgpu_disable;
0616
0617     return sysfs_emit(buf, "%d\n", mode);
0618 }
0619
0620 /*
0621  * A user may be required to store the value twice, typcial store first, then
0622  * rescan PCI bus to activate power, then store a second time to save correctly.
0623  * The reason for this is that an extra code path in the ACPI is enabled when
0624  * the device and bus are powered.
0625  */
0626 static ssize_t dgpu_disable_store(struct device *dev,
0627                     struct device_attribute *attr,
0628                     const char *buf, size_t count)
0629 {
0630     bool disable;
0631     int result;
0632
0633     struct asus_wmi *asus = dev_get_drvdata(dev);
0634
0635     result = kstrtobool(buf, &disable);
0636     if (result)
0637         return result;
0638
0639     asus->dgpu_disable = disable;
0640
0641     result = dgpu_disable_write(asus);
0642     if (result)
0643         return result;
0644
0645     return count;
0646 }
0647
0648 static DEVICE_ATTR_RW(dgpu_disable);
0649
0650 /* eGPU ********************************************************************/
0651 static int egpu_enable_check_present(struct asus_wmi *asus)
0652 {
0653     u32 result;
0654     int err;
0655
0656     asus->egpu_enable_available = false;
0657
0658     err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_EGPU, &result);
0659     if (err) {
0660         if (err == -ENODEV)
0661             return 0;
0662         return err;
0663     }
0664
0665     if (result & ASUS_WMI_DSTS_PRESENCE_BIT) {
0666         asus->egpu_enable_available = true;
0667         asus->egpu_enable = result & ASUS_WMI_DSTS_STATUS_BIT;
0668     }
0669
0670     return 0;
0671 }
0672
0673 static int egpu_enable_write(struct asus_wmi *asus)
0674 {
0675     u32 retval;
0676     u8 value;
0677     int err;
0678
0679     /* Don't rely on type conversion */
0680     value = asus->egpu_enable ? 1 : 0;
0681
0682     err = asus_wmi_set_devstate(ASUS_WMI_DEVID_EGPU, value, &retval);
0683
0684     if (err) {
0685         pr_warn("Failed to set egpu disable: %d\n", err);
0686         return err;
0687     }
0688
0689     if (retval > 1) {
0690         pr_warn("Failed to set egpu disable (retval): 0x%x\n", retval);
0691         return -EIO;
0692     }
0693
0694     sysfs_notify(&asus->platform_device->dev.kobj, NULL, "egpu_enable");
0695
0696     return 0;
0697 }
0698
0699 static ssize_t egpu_enable_show(struct device *dev,
0700                    struct device_attribute *attr, char *buf)
0701 {
0702     struct asus_wmi *asus = dev_get_drvdata(dev);
0703     bool mode = asus->egpu_enable;
0704
0705     return sysfs_emit(buf, "%d\n", mode);
0706 }
0707
0708 /* The ACPI call to enable the eGPU also disables the internal dGPU */
0709 static ssize_t egpu_enable_store(struct device *dev,
0710                     struct device_attribute *attr,
0711                     const char *buf, size_t count)
0712 {
0713     bool enable;
0714     int result;
0715
0716     struct asus_wmi *asus = dev_get_drvdata(dev);
0717
0718     result = kstrtobool(buf, &enable);
0719     if (result)
0720         return result;
0721
0722     asus->egpu_enable = enable;
0723
0724     result = egpu_enable_write(asus);
0725     if (result)
0726         return result;
0727
0728     /* Ensure that the kernel status of dgpu is updated */
0729     result = dgpu_disable_check_present(asus);
0730     if (result)
0731         return result;
0732
0733     return count;
0734 }
0735
0736 static DEVICE_ATTR_RW(egpu_enable);
0737
0738 /* Battery ********************************************************************/
0739
0740 /* The battery maximum charging percentage */
0741 static int charge_end_threshold;
0742
0743 static ssize_t charge_control_end_threshold_store(struct device *dev,
0744                           struct device_attribute *attr,
0745                           const char *buf, size_t count)
0746 {
0747     int value, ret, rv;
0748
0749     ret = kstrtouint(buf, 10, &value);
0750     if (ret)
0751         return ret;
0752
0753     if (value < 0 || value > 100)
0754         return -EINVAL;
0755
0756     ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, value, &rv);
0757     if (ret)
0758         return ret;
0759
0760     if (rv != 1)
0761         return -EIO;
0762
0763     /* There isn't any method in the DSDT to read the threshold, so we
0764      * save the threshold.
0765      */
0766     charge_end_threshold = value;
0767     return count;
0768 }
0769
0770 static ssize_t charge_control_end_threshold_show(struct device *device,
0771                          struct device_attribute *attr,
0772                          char *buf)
0773 {
0774     return sprintf(buf, "%d\n", charge_end_threshold);
0775 }
0776
0777 static DEVICE_ATTR_RW(charge_control_end_threshold);
0778
0779 static int asus_wmi_battery_add(struct power_supply *battery)
0780 {
0781     /* The WMI method does not provide a way to specific a battery, so we
0782      * just assume it is the first battery.
0783      * Note: On some newer ASUS laptops (Zenbook UM431DA), the primary/first
0784      * battery is named BATT.
0785      */
0786     if (strcmp(battery->desc->name, "BAT0") != 0 &&
0787         strcmp(battery->desc->name, "BAT1") != 0 &&
0788         strcmp(battery->desc->name, "BATC") != 0 &&
0789         strcmp(battery->desc->name, "BATT") != 0)
0790         return -ENODEV;
0791
0792     if (device_create_file(&battery->dev,
0793         &dev_attr_charge_control_end_threshold))
0794         return -ENODEV;
0795
0796     /* The charge threshold is only reset when the system is power cycled,
0797      * and we can't get the current threshold so let set it to 100% when
0798      * a battery is added.
0799      */
0800     asus_wmi_set_devstate(ASUS_WMI_DEVID_RSOC, 100, NULL);
0801     charge_end_threshold = 100;
0802
0803     return 0;
0804 }
0805
0806 static int asus_wmi_battery_remove(struct power_supply *battery)
0807 {
0808     device_remove_file(&battery->dev,
0809                &dev_attr_charge_control_end_threshold);
0810     return 0;
0811 }
0812
0813 static struct acpi_battery_hook battery_hook = {
0814     .add_battery = asus_wmi_battery_add,
0815     .remove_battery = asus_wmi_battery_remove,
0816     .name = "ASUS Battery Extension",
0817 };
0818
0819 static void asus_wmi_battery_init(struct asus_wmi *asus)
0820 {
0821     asus->battery_rsoc_available = false;
0822     if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_RSOC)) {
0823         asus->battery_rsoc_available = true;
0824         battery_hook_register(&battery_hook);
0825     }
0826 }
0827
0828 static void asus_wmi_battery_exit(struct asus_wmi *asus)
0829 {
0830     if (asus->battery_rsoc_available)
0831         battery_hook_unregister(&battery_hook);
0832 }
0833
0834 /* LEDs ***********************************************************************/
0835
0836 /*
0837  * These functions actually update the LED's, and are called from a
0838  * workqueue. By doing this as separate work rather than when the LED
0839  * subsystem asks, we avoid messing with the Asus ACPI stuff during a
0840  * potentially bad time, such as a timer interrupt.
0841  */
0842 static void tpd_led_update(struct work_struct *work)
0843 {
0844     int ctrl_param;
0845     struct asus_wmi *asus;
0846
0847     asus = container_of(work, struct asus_wmi, tpd_led_work);
0848
0849     ctrl_param = asus->tpd_led_wk;
0850     asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
0851 }
0852
0853 static void tpd_led_set(struct led_classdev *led_cdev,
0854             enum led_brightness value)
0855 {
0856     struct asus_wmi *asus;
0857
0858     asus = container_of(led_cdev, struct asus_wmi, tpd_led);
0859
0860     asus->tpd_led_wk = !!value;
0861     queue_work(asus->led_workqueue, &asus->tpd_led_work);
0862 }
0863
0864 static int read_tpd_led_state(struct asus_wmi *asus)
0865 {
0866     return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
0867 }
0868
0869 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
0870 {
0871     struct asus_wmi *asus;
0872
0873     asus = container_of(led_cdev, struct asus_wmi, tpd_led);
0874
0875     return read_tpd_led_state(asus);
0876 }
0877
0878 static void kbd_led_update(struct asus_wmi *asus)
0879 {
0880     int ctrl_param = 0;
0881
0882     ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
0883     asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
0884 }
0885
0886 static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
0887 {
0888     int retval;
0889
0890     /*
0891      * bits 0-2: level
0892      * bit 7: light on/off
0893      * bit 8-10: environment (0: dark, 1: normal, 2: light)
0894      * bit 17: status unknown
0895      */
0896     retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
0897                         0xFFFF);
0898
0899     /* Unknown status is considered as off */
0900     if (retval == 0x8000)
0901         retval = 0;
0902
0903     if (retval < 0)
0904         return retval;
0905
0906     if (level)
0907         *level = retval & 0x7F;
0908     if (env)
0909         *env = (retval >> 8) & 0x7F;
0910     return 0;
0911 }
0912
0913 static void do_kbd_led_set(struct led_classdev *led_cdev, int value)
0914 {
0915     struct asus_wmi *asus;
0916     int max_level;
0917
0918     asus = container_of(led_cdev, struct asus_wmi, kbd_led);
0919     max_level = asus->kbd_led.max_brightness;
0920
0921     asus->kbd_led_wk = clamp_val(value, 0, max_level);
0922     kbd_led_update(asus);
0923 }
0924
0925 static void kbd_led_set(struct led_classdev *led_cdev,
0926             enum led_brightness value)
0927 {
0928     /* Prevent disabling keyboard backlight on module unregister */
0929     if (led_cdev->flags & LED_UNREGISTERING)
0930         return;
0931
0932     do_kbd_led_set(led_cdev, value);
0933 }
0934
0935 static void kbd_led_set_by_kbd(struct asus_wmi *asus, enum led_brightness value)
0936 {
0937     struct led_classdev *led_cdev = &asus->kbd_led;
0938
0939     do_kbd_led_set(led_cdev, value);
0940     led_classdev_notify_brightness_hw_changed(led_cdev, asus->kbd_led_wk);
0941 }
0942
0943 static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
0944 {
0945     struct asus_wmi *asus;
0946     int retval, value;
0947
0948     asus = container_of(led_cdev, struct asus_wmi, kbd_led);
0949
0950     retval = kbd_led_read(asus, &value, NULL);
0951     if (retval < 0)
0952         return retval;
0953
0954     return value;
0955 }
0956
0957 static int wlan_led_unknown_state(struct asus_wmi *asus)
0958 {
0959     u32 result;
0960
0961     asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
0962
0963     return result & ASUS_WMI_DSTS_UNKNOWN_BIT;
0964 }
0965
0966 static void wlan_led_update(struct work_struct *work)
0967 {
0968     int ctrl_param;
0969     struct asus_wmi *asus;
0970
0971     asus = container_of(work, struct asus_wmi, wlan_led_work);
0972
0973     ctrl_param = asus->wlan_led_wk;
0974     asus_wmi_set_devstate(ASUS_WMI_DEVID_WIRELESS_LED, ctrl_param, NULL);
0975 }
0976
0977 static void wlan_led_set(struct led_classdev *led_cdev,
0978              enum led_brightness value)
0979 {
0980     struct asus_wmi *asus;
0981
0982     asus = container_of(led_cdev, struct asus_wmi, wlan_led);
0983
0984     asus->wlan_led_wk = !!value;
0985     queue_work(asus->led_workqueue, &asus->wlan_led_work);
0986 }
0987
0988 static enum led_brightness wlan_led_get(struct led_classdev *led_cdev)
0989 {
0990     struct asus_wmi *asus;
0991     u32 result;
0992
0993     asus = container_of(led_cdev, struct asus_wmi, wlan_led);
0994     asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result);
0995
0996     return result & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
0997 }
0998
0999 static void lightbar_led_update(struct work_struct *work)
1000 {
1001     struct asus_wmi *asus;
1002     int ctrl_param;
1003
1004     asus = container_of(work, struct asus_wmi, lightbar_led_work);
1005
1006     ctrl_param = asus->lightbar_led_wk;
1007     asus_wmi_set_devstate(ASUS_WMI_DEVID_LIGHTBAR, ctrl_param, NULL);
1008 }
1009
1010 static void lightbar_led_set(struct led_classdev *led_cdev,
1011                  enum led_brightness value)
1012 {
1013     struct asus_wmi *asus;
1014
1015     asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
1016
1017     asus->lightbar_led_wk = !!value;
1018     queue_work(asus->led_workqueue, &asus->lightbar_led_work);
1019 }
1020
1021 static enum led_brightness lightbar_led_get(struct led_classdev *led_cdev)
1022 {
1023     struct asus_wmi *asus;
1024     u32 result;
1025
1026     asus = container_of(led_cdev, struct asus_wmi, lightbar_led);
1027     asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_LIGHTBAR, &result);
1028
1029     return result & ASUS_WMI_DSTS_LIGHTBAR_MASK;
1030 }
1031
1032 static int micmute_led_set(struct led_classdev *led_cdev,
1033                enum led_brightness brightness)
1034 {
1035     int state = brightness != LED_OFF;
1036     int err;
1037
1038     err = asus_wmi_set_devstate(ASUS_WMI_DEVID_MICMUTE_LED, state, NULL);
1039     return err < 0 ? err : 0;
1040 }
1041
1042 static void asus_wmi_led_exit(struct asus_wmi *asus)
1043 {
1044     led_classdev_unregister(&asus->kbd_led);
1045     led_classdev_unregister(&asus->tpd_led);
1046     led_classdev_unregister(&asus->wlan_led);
1047     led_classdev_unregister(&asus->lightbar_led);
1048     led_classdev_unregister(&asus->micmute_led);
1049
1050     if (asus->led_workqueue)
1051         destroy_workqueue(asus->led_workqueue);
1052 }
1053
1054 static int asus_wmi_led_init(struct asus_wmi *asus)
1055 {
1056     int rv = 0, led_val;
1057
1058     asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
1059     if (!asus->led_workqueue)
1060         return -ENOMEM;
1061
1062     if (read_tpd_led_state(asus) >= 0) {
1063         INIT_WORK(&asus->tpd_led_work, tpd_led_update);
1064
1065         asus->tpd_led.name = "asus::touchpad";
1066         asus->tpd_led.brightness_set = tpd_led_set;
1067         asus->tpd_led.brightness_get = tpd_led_get;
1068         asus->tpd_led.max_brightness = 1;
1069
1070         rv = led_classdev_register(&asus->platform_device->dev,
1071                        &asus->tpd_led);
1072         if (rv)
1073             goto error;
1074     }
1075
1076     if (!kbd_led_read(asus, &led_val, NULL)) {
1077         asus->kbd_led_wk = led_val;
1078         asus->kbd_led.name = "asus::kbd_backlight";
1079         asus->kbd_led.flags = LED_BRIGHT_HW_CHANGED;
1080         asus->kbd_led.brightness_set = kbd_led_set;
1081         asus->kbd_led.brightness_get = kbd_led_get;
1082         asus->kbd_led.max_brightness = 3;
1083
1084         rv = led_classdev_register(&asus->platform_device->dev,
1085                        &asus->kbd_led);
1086         if (rv)
1087             goto error;
1088     }
1089
1090     if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_WIRELESS_LED)
1091             && (asus->driver->quirks->wapf > 0)) {
1092         INIT_WORK(&asus->wlan_led_work, wlan_led_update);
1093
1094         asus->wlan_led.name = "asus::wlan";
1095         asus->wlan_led.brightness_set = wlan_led_set;
1096         if (!wlan_led_unknown_state(asus))
1097             asus->wlan_led.brightness_get = wlan_led_get;
1098         asus->wlan_led.flags = LED_CORE_SUSPENDRESUME;
1099         asus->wlan_led.max_brightness = 1;
1100         asus->wlan_led.default_trigger = "asus-wlan";
1101
1102         rv = led_classdev_register(&asus->platform_device->dev,
1103                        &asus->wlan_led);
1104         if (rv)
1105             goto error;
1106     }
1107
1108     if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_LIGHTBAR)) {
1109         INIT_WORK(&asus->lightbar_led_work, lightbar_led_update);
1110
1111         asus->lightbar_led.name = "asus::lightbar";
1112         asus->lightbar_led.brightness_set = lightbar_led_set;
1113         asus->lightbar_led.brightness_get = lightbar_led_get;
1114         asus->lightbar_led.max_brightness = 1;
1115
1116         rv = led_classdev_register(&asus->platform_device->dev,
1117                        &asus->lightbar_led);
1118     }
1119
1120     if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_MICMUTE_LED)) {
1121         asus->micmute_led.name = "platform::micmute";
1122         asus->micmute_led.max_brightness = 1;
1123         asus->micmute_led.brightness = ledtrig_audio_get(LED_AUDIO_MICMUTE);
1124         asus->micmute_led.brightness_set_blocking = micmute_led_set;
1125         asus->micmute_led.default_trigger = "audio-micmute";
1126
1127         rv = led_classdev_register(&asus->platform_device->dev,
1128                         &asus->micmute_led);
1129         if (rv)
1130             goto error;
1131     }
1132
1133 error:
1134     if (rv)
1135         asus_wmi_led_exit(asus);
1136
1137     return rv;
1138 }
1139
1140 /* RF *************************************************************************/
1141
1142 /*
1143  * PCI hotplug (for wlan rfkill)
1144  */
1145 static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
1146 {
1147     int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
1148
1149     if (result < 0)
1150         return false;
1151     return !result;
1152 }
1153
1154 static void asus_rfkill_hotplug(struct asus_wmi *asus)
1155 {
1156     struct pci_dev *dev;
1157     struct pci_bus *bus;
1158     bool blocked;
1159     bool absent;
1160     u32 l;
1161
1162     mutex_lock(&asus->wmi_lock);
1163     blocked = asus_wlan_rfkill_blocked(asus);
1164     mutex_unlock(&asus->wmi_lock);
1165
1166     mutex_lock(&asus->hotplug_lock);
1167     pci_lock_rescan_remove();
1168
1169     if (asus->wlan.rfkill)
1170         rfkill_set_sw_state(asus->wlan.rfkill, blocked);
1171
1172     if (asus->hotplug_slot.ops) {
1173         bus = pci_find_bus(0, 1);
1174         if (!bus) {
1175             pr_warn("Unable to find PCI bus 1?\n");
1176             goto out_unlock;
1177         }
1178
1179         if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
1180             pr_err("Unable to read PCI config space?\n");
1181             goto out_unlock;
1182         }
1183         absent = (l == 0xffffffff);
1184
1185         if (blocked != absent) {
1186             pr_warn("BIOS says wireless lan is %s, but the pci device is %s\n",
1187                 blocked ? "blocked" : "unblocked",
1188                 absent ? "absent" : "present");
1189             pr_warn("skipped wireless hotplug as probably inappropriate for this model\n");
1190             goto out_unlock;
1191         }
1192
1193         if (!blocked) {
1194             dev = pci_get_slot(bus, 0);
1195             if (dev) {
1196                 /* Device already present */
1197                 pci_dev_put(dev);
1198                 goto out_unlock;
1199             }
1200             dev = pci_scan_single_device(bus, 0);
1201             if (dev) {
1202                 pci_bus_assign_resources(bus);
1203                 pci_bus_add_device(dev);
1204             }
1205         } else {
1206             dev = pci_get_slot(bus, 0);
1207             if (dev) {
1208                 pci_stop_and_remove_bus_device(dev);
1209                 pci_dev_put(dev);
1210             }
1211         }
1212     }
1213
1214 out_unlock:
1215     pci_unlock_rescan_remove();
1216     mutex_unlock(&asus->hotplug_lock);
1217 }
1218
1219 static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
1220 {
1221     struct asus_wmi *asus = data;
1222
1223     if (event != ACPI_NOTIFY_BUS_CHECK)
1224         return;
1225
1226     /*
1227      * We can't call directly asus_rfkill_hotplug because most
1228      * of the time WMBC is still being executed and not reetrant.
1229      * There is currently no way to tell ACPICA that  we want this
1230      * method to be serialized, we schedule a asus_rfkill_hotplug
1231      * call later, in a safer context.
1232      */
1233     queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
1234 }
1235
1236 static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
1237 {
1238     acpi_status status;
1239     acpi_handle handle;
1240
1241     status = acpi_get_handle(NULL, node, &handle);
1242     if (ACPI_FAILURE(status))
1243         return -ENODEV;
1244
1245     status = acpi_install_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
1246                          asus_rfkill_notify, asus);
1247     if (ACPI_FAILURE(status))
1248         pr_warn("Failed to register notify on %s\n", node);
1249
1250     return 0;
1251 }
1252
1253 static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
1254 {
1255     acpi_status status = AE_OK;
1256     acpi_handle handle;
1257
1258     status = acpi_get_handle(NULL, node, &handle);
1259     if (ACPI_FAILURE(status))
1260         return;
1261
1262     status = acpi_remove_notify_handler(handle, ACPI_SYSTEM_NOTIFY,
1263                         asus_rfkill_notify);
1264     if (ACPI_FAILURE(status))
1265         pr_err("Error removing rfkill notify handler %s\n", node);
1266 }
1267
1268 static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
1269                    u8 *value)
1270 {
1271     struct asus_wmi *asus = container_of(hotplug_slot,
1272                          struct asus_wmi, hotplug_slot);
1273     int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
1274
1275     if (result < 0)
1276         return result;
1277
1278     *value = !!result;
1279     return 0;
1280 }
1281
1282 static const struct hotplug_slot_ops asus_hotplug_slot_ops = {
1283     .get_adapter_status = asus_get_adapter_status,
1284     .get_power_status = asus_get_adapter_status,
1285 };
1286
1287 static void asus_hotplug_work(struct work_struct *work)
1288 {
1289     struct asus_wmi *asus;
1290
1291     asus = container_of(work, struct asus_wmi, hotplug_work);
1292     asus_rfkill_hotplug(asus);
1293 }
1294
1295 static int asus_setup_pci_hotplug(struct asus_wmi *asus)
1296 {
1297     int ret = -ENOMEM;
1298     struct pci_bus *bus = pci_find_bus(0, 1);
1299
1300     if (!bus) {
1301         pr_err("Unable to find wifi PCI bus\n");
1302         return -ENODEV;
1303     }
1304
1305     asus->hotplug_workqueue =
1306         create_singlethread_workqueue("hotplug_workqueue");
1307     if (!asus->hotplug_workqueue)
1308         goto error_workqueue;
1309
1310     INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
1311
1312     asus->hotplug_slot.ops = &asus_hotplug_slot_ops;
1313
1314     ret = pci_hp_register(&asus->hotplug_slot, bus, 0, "asus-wifi");
1315     if (ret) {
1316         pr_err("Unable to register hotplug slot - %d\n", ret);
1317         goto error_register;
1318     }
1319
1320     return 0;
1321
1322 error_register:
1323     asus->hotplug_slot.ops = NULL;
1324     destroy_workqueue(asus->hotplug_workqueue);
1325 error_workqueue:
1326     return ret;
1327 }
1328
1329 /*
1330  * Rfkill devices
1331  */
1332 static int asus_rfkill_set(void *data, bool blocked)
1333 {
1334     struct asus_rfkill *priv = data;
1335     u32 ctrl_param = !blocked;
1336     u32 dev_id = priv->dev_id;
1337
1338     /*
1339      * If the user bit is set, BIOS can't set and record the wlan status,
1340      * it will report the value read from id ASUS_WMI_DEVID_WLAN_LED
1341      * while we query the wlan status through WMI(ASUS_WMI_DEVID_WLAN).
1342      * So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED
1343      * while setting the wlan status through WMI.
1344      * This is also the behavior that windows app will do.
1345      */
1346     if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
1347          priv->asus->driver->wlan_ctrl_by_user)
1348         dev_id = ASUS_WMI_DEVID_WLAN_LED;
1349
1350     return asus_wmi_set_devstate(dev_id, ctrl_param, NULL);
1351 }
1352
1353 static void asus_rfkill_query(struct rfkill *rfkill, void *data)
1354 {
1355     struct asus_rfkill *priv = data;
1356     int result;
1357
1358     result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
1359
1360     if (result < 0)
1361         return;
1362
1363     rfkill_set_sw_state(priv->rfkill, !result);
1364 }
1365
1366 static int asus_rfkill_wlan_set(void *data, bool blocked)
1367 {
1368     struct asus_rfkill *priv = data;
1369     struct asus_wmi *asus = priv->asus;
1370     int ret;
1371
1372     /*
1373      * This handler is enabled only if hotplug is enabled.
1374      * In this case, the asus_wmi_set_devstate() will
1375      * trigger a wmi notification and we need to wait
1376      * this call to finish before being able to call
1377      * any wmi method
1378      */
1379     mutex_lock(&asus->wmi_lock);
1380     ret = asus_rfkill_set(data, blocked);
1381     mutex_unlock(&asus->wmi_lock);
1382     return ret;
1383 }
1384
1385 static const struct rfkill_ops asus_rfkill_wlan_ops = {
1386     .set_block = asus_rfkill_wlan_set,
1387     .query = asus_rfkill_query,
1388 };
1389
1390 static const struct rfkill_ops asus_rfkill_ops = {
1391     .set_block = asus_rfkill_set,
1392     .query = asus_rfkill_query,
1393 };
1394
1395 static int asus_new_rfkill(struct asus_wmi *asus,
1396                struct asus_rfkill *arfkill,
1397                const char *name, enum rfkill_type type, int dev_id)
1398 {
1399     int result = asus_wmi_get_devstate_simple(asus, dev_id);
1400     struct rfkill **rfkill = &arfkill->rfkill;
1401
1402     if (result < 0)
1403         return result;
1404
1405     arfkill->dev_id = dev_id;
1406     arfkill->asus = asus;
1407
1408     if (dev_id == ASUS_WMI_DEVID_WLAN &&
1409         asus->driver->quirks->hotplug_wireless)
1410         *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
1411                        &asus_rfkill_wlan_ops, arfkill);
1412     else
1413         *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
1414                        &asus_rfkill_ops, arfkill);
1415
1416     if (!*rfkill)
1417         return -EINVAL;
1418
1419     if ((dev_id == ASUS_WMI_DEVID_WLAN) &&
1420             (asus->driver->quirks->wapf > 0))
1421         rfkill_set_led_trigger_name(*rfkill, "asus-wlan");
1422
1423     rfkill_init_sw_state(*rfkill, !result);
1424     result = rfkill_register(*rfkill);
1425     if (result) {
1426         rfkill_destroy(*rfkill);
1427         *rfkill = NULL;
1428         return result;
1429     }
1430     return 0;
1431 }
1432
1433 static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
1434 {
1435     if (asus->driver->wlan_ctrl_by_user && ashs_present())
1436         return;
1437
1438     asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
1439     asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
1440     asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
1441     if (asus->wlan.rfkill) {
1442         rfkill_unregister(asus->wlan.rfkill);
1443         rfkill_destroy(asus->wlan.rfkill);
1444         asus->wlan.rfkill = NULL;
1445     }
1446     /*
1447      * Refresh pci hotplug in case the rfkill state was changed after
1448      * asus_unregister_rfkill_notifier()
1449      */
1450     asus_rfkill_hotplug(asus);
1451     if (asus->hotplug_slot.ops)
1452         pci_hp_deregister(&asus->hotplug_slot);
1453     if (asus->hotplug_workqueue)
1454         destroy_workqueue(asus->hotplug_workqueue);
1455
1456     if (asus->bluetooth.rfkill) {
1457         rfkill_unregister(asus->bluetooth.rfkill);
1458         rfkill_destroy(asus->bluetooth.rfkill);
1459         asus->bluetooth.rfkill = NULL;
1460     }
1461     if (asus->wimax.rfkill) {
1462         rfkill_unregister(asus->wimax.rfkill);
1463         rfkill_destroy(asus->wimax.rfkill);
1464         asus->wimax.rfkill = NULL;
1465     }
1466     if (asus->wwan3g.rfkill) {
1467         rfkill_unregister(asus->wwan3g.rfkill);
1468         rfkill_destroy(asus->wwan3g.rfkill);
1469         asus->wwan3g.rfkill = NULL;
1470     }
1471     if (asus->gps.rfkill) {
1472         rfkill_unregister(asus->gps.rfkill);
1473         rfkill_destroy(asus->gps.rfkill);
1474         asus->gps.rfkill = NULL;
1475     }
1476     if (asus->uwb.rfkill) {
1477         rfkill_unregister(asus->uwb.rfkill);
1478         rfkill_destroy(asus->uwb.rfkill);
1479         asus->uwb.rfkill = NULL;
1480     }
1481 }
1482
1483 static int asus_wmi_rfkill_init(struct asus_wmi *asus)
1484 {
1485     int result = 0;
1486
1487     mutex_init(&asus->hotplug_lock);
1488     mutex_init(&asus->wmi_lock);
1489
1490     result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
1491                  RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
1492
1493     if (result && result != -ENODEV)
1494         goto exit;
1495
1496     result = asus_new_rfkill(asus, &asus->bluetooth,
1497                  "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
1498                  ASUS_WMI_DEVID_BLUETOOTH);
1499
1500     if (result && result != -ENODEV)
1501         goto exit;
1502
1503     result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
1504                  RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
1505
1506     if (result && result != -ENODEV)
1507         goto exit;
1508
1509     result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
1510                  RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
1511
1512     if (result && result != -ENODEV)
1513         goto exit;
1514
1515     result = asus_new_rfkill(asus, &asus->gps, "asus-gps",
1516                  RFKILL_TYPE_GPS, ASUS_WMI_DEVID_GPS);
1517
1518     if (result && result != -ENODEV)
1519         goto exit;
1520
1521     result = asus_new_rfkill(asus, &asus->uwb, "asus-uwb",
1522                  RFKILL_TYPE_UWB, ASUS_WMI_DEVID_UWB);
1523
1524     if (result && result != -ENODEV)
1525         goto exit;
1526
1527     if (!asus->driver->quirks->hotplug_wireless)
1528         goto exit;
1529
1530     result = asus_setup_pci_hotplug(asus);
1531     /*
1532      * If we get -EBUSY then something else is handling the PCI hotplug -
1533      * don't fail in this case
1534      */
1535     if (result == -EBUSY)
1536         result = 0;
1537
1538     asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
1539     asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
1540     asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
1541     /*
1542      * Refresh pci hotplug in case the rfkill state was changed during
1543      * setup.
1544      */
1545     asus_rfkill_hotplug(asus);
1546
1547 exit:
1548     if (result && result != -ENODEV)
1549         asus_wmi_rfkill_exit(asus);
1550
1551     if (result == -ENODEV)
1552         result = 0;
1553
1554     return result;
1555 }
1556
1557 /* Panel Overdrive ************************************************************/
1558 static int panel_od_check_present(struct asus_wmi *asus)
1559 {
1560     u32 result;
1561     int err;
1562
1563     asus->panel_overdrive_available = false;
1564
1565     err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_PANEL_OD, &result);
1566     if (err) {
1567         if (err == -ENODEV)
1568             return 0;
1569         return err;
1570     }
1571
1572     if (result & ASUS_WMI_DSTS_PRESENCE_BIT) {
1573         asus->panel_overdrive_available = true;
1574         asus->panel_overdrive = result & ASUS_WMI_DSTS_STATUS_BIT;
1575     }
1576
1577     return 0;
1578 }
1579
1580 static int panel_od_write(struct asus_wmi *asus)
1581 {
1582     u32 retval;
1583     u8 value;
1584     int err;
1585
1586     /* Don't rely on type conversion */
1587     value = asus->panel_overdrive ? 1 : 0;
1588
1589     err = asus_wmi_set_devstate(ASUS_WMI_DEVID_PANEL_OD, value, &retval);
1590
1591     if (err) {
1592         pr_warn("Failed to set panel overdrive: %d\n", err);
1593         return err;
1594     }
1595
1596     if (retval > 1) {
1597         pr_warn("Failed to set panel overdrive (retval): 0x%x\n", retval);
1598         return -EIO;
1599     }
1600
1601     sysfs_notify(&asus->platform_device->dev.kobj, NULL, "panel_od");
1602
1603     return 0;
1604 }
1605
1606 static ssize_t panel_od_show(struct device *dev,
1607                    struct device_attribute *attr, char *buf)
1608 {
1609     struct asus_wmi *asus = dev_get_drvdata(dev);
1610
1611     return sysfs_emit(buf, "%d\n", asus->panel_overdrive);
1612 }
1613
1614 static ssize_t panel_od_store(struct device *dev,
1615                     struct device_attribute *attr,
1616                     const char *buf, size_t count)
1617 {
1618     bool overdrive;
1619     int result;
1620
1621     struct asus_wmi *asus = dev_get_drvdata(dev);
1622
1623     result = kstrtobool(buf, &overdrive);
1624     if (result)
1625         return result;
1626
1627     asus->panel_overdrive = overdrive;
1628     result = panel_od_write(asus);
1629
1630     if (result)
1631         return result;
1632
1633     return count;
1634 }
1635
1636 static DEVICE_ATTR_RW(panel_od);
1637
1638 /* Quirks *********************************************************************/
1639
1640 static void asus_wmi_set_xusb2pr(struct asus_wmi *asus)
1641 {
1642     struct pci_dev *xhci_pdev;
1643     u32 orig_ports_available;
1644     u32 ports_available = asus->driver->quirks->xusb2pr;
1645
1646     xhci_pdev = pci_get_device(PCI_VENDOR_ID_INTEL,
1647             PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI,
1648             NULL);
1649
1650     if (!xhci_pdev)
1651         return;
1652
1653     pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
1654                 &orig_ports_available);
1655
1656     pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR,
1657                 cpu_to_le32(ports_available));
1658
1659     pr_info("set USB_INTEL_XUSB2PR old: 0x%04x, new: 0x%04x\n",
1660             orig_ports_available, ports_available);
1661 }
1662
1663 /*
1664  * Some devices dont support or have borcken get_als method
1665  * but still support set method.
1666  */
1667 static void asus_wmi_set_als(void)
1668 {
1669     asus_wmi_set_devstate(ASUS_WMI_DEVID_ALS_ENABLE, 1, NULL);
1670 }
1671
1672 /* Hwmon device ***************************************************************/
1673
1674 static int asus_agfn_fan_speed_read(struct asus_wmi *asus, int fan,
1675                       int *speed)
1676 {
1677     struct agfn_fan_args args = {
1678         .agfn.len = sizeof(args),
1679         .agfn.mfun = ASUS_FAN_MFUN,
1680         .agfn.sfun = ASUS_FAN_SFUN_READ,
1681         .fan = fan,
1682         .speed = 0,
1683     };
1684     struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1685     int status;
1686
1687     if (fan != 1)
1688         return -EINVAL;
1689
1690     status = asus_wmi_evaluate_method_agfn(input);
1691
1692     if (status || args.agfn.err)
1693         return -ENXIO;
1694
1695     if (speed)
1696         *speed = args.speed;
1697
1698     return 0;
1699 }
1700
1701 static int asus_agfn_fan_speed_write(struct asus_wmi *asus, int fan,
1702                      int *speed)
1703 {
1704     struct agfn_fan_args args = {
1705         .agfn.len = sizeof(args),
1706         .agfn.mfun = ASUS_FAN_MFUN,
1707         .agfn.sfun = ASUS_FAN_SFUN_WRITE,
1708         .fan = fan,
1709         .speed = speed ?  *speed : 0,
1710     };
1711     struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1712     int status;
1713
1714     /* 1: for setting 1st fan's speed 0: setting auto mode */
1715     if (fan != 1 && fan != 0)
1716         return -EINVAL;
1717
1718     status = asus_wmi_evaluate_method_agfn(input);
1719
1720     if (status || args.agfn.err)
1721         return -ENXIO;
1722
1723     if (speed && fan == 1)
1724         asus->agfn_pwm = *speed;
1725
1726     return 0;
1727 }
1728
1729 /*
1730  * Check if we can read the speed of one fan. If true we assume we can also
1731  * control it.
1732  */
1733 static bool asus_wmi_has_agfn_fan(struct asus_wmi *asus)
1734 {
1735     int status;
1736     int speed;
1737     u32 value;
1738
1739     status = asus_agfn_fan_speed_read(asus, 1, &speed);
1740     if (status != 0)
1741         return false;
1742
1743     status = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
1744     if (status != 0)
1745         return false;
1746
1747     /*
1748      * We need to find a better way, probably using sfun,
1749      * bits or spec ...
1750      * Currently we disable it if:
1751      * - ASUS_WMI_UNSUPPORTED_METHOD is returned
1752      * - reverved bits are non-zero
1753      * - sfun and presence bit are not set
1754      */
1755     return !(value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
1756          || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)));
1757 }
1758
1759 static int asus_fan_set_auto(struct asus_wmi *asus)
1760 {
1761     int status;
1762     u32 retval;
1763
1764     switch (asus->fan_type) {
1765     case FAN_TYPE_SPEC83:
1766         status = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
1767                            0, &retval);
1768         if (status)
1769             return status;
1770
1771         if (retval != 1)
1772             return -EIO;
1773         break;
1774
1775     case FAN_TYPE_AGFN:
1776         status = asus_agfn_fan_speed_write(asus, 0, NULL);
1777         if (status)
1778             return -ENXIO;
1779         break;
1780
1781     default:
1782         return -ENXIO;
1783     }
1784
1785
1786     return 0;
1787 }
1788
1789 static ssize_t pwm1_show(struct device *dev,
1790                    struct device_attribute *attr,
1791                    char *buf)
1792 {
1793     struct asus_wmi *asus = dev_get_drvdata(dev);
1794     int err;
1795     int value;
1796
1797     /* If we already set a value then just return it */
1798     if (asus->agfn_pwm >= 0)
1799         return sprintf(buf, "%d\n", asus->agfn_pwm);
1800
1801     /*
1802      * If we haven't set already set a value through the AGFN interface,
1803      * we read a current value through the (now-deprecated) FAN_CTRL device.
1804      */
1805     err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
1806     if (err < 0)
1807         return err;
1808
1809     value &= 0xFF;
1810
1811     if (value == 1) /* Low Speed */
1812         value = 85;
1813     else if (value == 2)
1814         value = 170;
1815     else if (value == 3)
1816         value = 255;
1817     else if (value) {
1818         pr_err("Unknown fan speed %#x\n", value);
1819         value = -1;
1820     }
1821
1822     return sprintf(buf, "%d\n", value);
1823 }
1824
1825 static ssize_t pwm1_store(struct device *dev,
1826                      struct device_attribute *attr,
1827                      const char *buf, size_t count) {
1828     struct asus_wmi *asus = dev_get_drvdata(dev);
1829     int value;
1830     int state;
1831     int ret;
1832
1833     ret = kstrtouint(buf, 10, &value);
1834     if (ret)
1835         return ret;
1836
1837     value = clamp(value, 0, 255);
1838
1839     state = asus_agfn_fan_speed_write(asus, 1, &value);
1840     if (state)
1841         pr_warn("Setting fan speed failed: %d\n", state);
1842     else
1843         asus->fan_pwm_mode = ASUS_FAN_CTRL_MANUAL;
1844
1845     return count;
1846 }
1847
1848 static ssize_t fan1_input_show(struct device *dev,
1849                     struct device_attribute *attr,
1850                     char *buf)
1851 {
1852     struct asus_wmi *asus = dev_get_drvdata(dev);
1853     int value;
1854     int ret;
1855
1856     switch (asus->fan_type) {
1857     case FAN_TYPE_SPEC83:
1858         ret = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL,
1859                         &value);
1860         if (ret < 0)
1861             return ret;
1862
1863         value &= 0xffff;
1864         break;
1865
1866     case FAN_TYPE_AGFN:
1867         /* no speed readable on manual mode */
1868         if (asus->fan_pwm_mode == ASUS_FAN_CTRL_MANUAL)
1869             return -ENXIO;
1870
1871         ret = asus_agfn_fan_speed_read(asus, 1, &value);
1872         if (ret) {
1873             pr_warn("reading fan speed failed: %d\n", ret);
1874             return -ENXIO;
1875         }
1876         break;
1877
1878     default:
1879         return -ENXIO;
1880     }
1881
1882     return sprintf(buf, "%d\n", value < 0 ? -1 : value*100);
1883 }
1884
1885 static ssize_t pwm1_enable_show(struct device *dev,
1886                          struct device_attribute *attr,
1887                          char *buf)
1888 {
1889     struct asus_wmi *asus = dev_get_drvdata(dev);
1890
1891     /*
1892      * Just read back the cached pwm mode.
1893      *
1894      * For the CPU_FAN device, the spec indicates that we should be
1895      * able to read the device status and consult bit 19 to see if we
1896      * are in Full On or Automatic mode. However, this does not work
1897      * in practice on X532FL at least (the bit is always 0) and there's
1898      * also nothing in the DSDT to indicate that this behaviour exists.
1899      */
1900     return sprintf(buf, "%d\n", asus->fan_pwm_mode);
1901 }
1902
1903 static ssize_t pwm1_enable_store(struct device *dev,
1904                           struct device_attribute *attr,
1905                           const char *buf, size_t count)
1906 {
1907     struct asus_wmi *asus = dev_get_drvdata(dev);
1908     int status = 0;
1909     int state;
1910     int value;
1911     int ret;
1912     u32 retval;
1913
1914     ret = kstrtouint(buf, 10, &state);
1915     if (ret)
1916         return ret;
1917
1918     if (asus->fan_type == FAN_TYPE_SPEC83) {
1919         switch (state) { /* standard documented hwmon values */
1920         case ASUS_FAN_CTRL_FULLSPEED:
1921             value = 1;
1922             break;
1923         case ASUS_FAN_CTRL_AUTO:
1924             value = 0;
1925             break;
1926         default:
1927             return -EINVAL;
1928         }
1929
1930         ret = asus_wmi_set_devstate(ASUS_WMI_DEVID_CPU_FAN_CTRL,
1931                         value, &retval);
1932         if (ret)
1933             return ret;
1934
1935         if (retval != 1)
1936             return -EIO;
1937     } else if (asus->fan_type == FAN_TYPE_AGFN) {
1938         switch (state) {
1939         case ASUS_FAN_CTRL_MANUAL:
1940             break;
1941
1942         case ASUS_FAN_CTRL_AUTO:
1943             status = asus_fan_set_auto(asus);
1944             if (status)
1945                 return status;
1946             break;
1947
1948         default:
1949             return -EINVAL;
1950         }
1951     }
1952
1953     asus->fan_pwm_mode = state;
1954
1955     /* Must set to disabled if mode is toggled */
1956     if (asus->cpu_fan_curve_available)
1957         asus->custom_fan_curves[FAN_CURVE_DEV_CPU].enabled = false;
1958     if (asus->gpu_fan_curve_available)
1959         asus->custom_fan_curves[FAN_CURVE_DEV_GPU].enabled = false;
1960
1961     return count;
1962 }
1963
1964 static ssize_t fan1_label_show(struct device *dev,
1965                       struct device_attribute *attr,
1966                       char *buf)
1967 {
1968     return sprintf(buf, "%s\n", ASUS_FAN_DESC);
1969 }
1970
1971 static ssize_t asus_hwmon_temp1(struct device *dev,
1972                 struct device_attribute *attr,
1973                 char *buf)
1974 {
1975     struct asus_wmi *asus = dev_get_drvdata(dev);
1976     u32 value;
1977     int err;
1978
1979     err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_THERMAL_CTRL, &value);
1980     if (err < 0)
1981         return err;
1982
1983     return sprintf(buf, "%ld\n",
1984                deci_kelvin_to_millicelsius(value & 0xFFFF));
1985 }
1986
1987 /* Fan1 */
1988 static DEVICE_ATTR_RW(pwm1);
1989 static DEVICE_ATTR_RW(pwm1_enable);
1990 static DEVICE_ATTR_RO(fan1_input);
1991 static DEVICE_ATTR_RO(fan1_label);
1992
1993 /* Temperature */
1994 static DEVICE_ATTR(temp1_input, S_IRUGO, asus_hwmon_temp1, NULL);
1995
1996 static struct attribute *hwmon_attributes[] = {
1997     &dev_attr_pwm1.attr,
1998     &dev_attr_pwm1_enable.attr,
1999     &dev_attr_fan1_input.attr,
2000     &dev_attr_fan1_label.attr,
2001
2002     &dev_attr_temp1_input.attr,
2003     NULL
2004 };
2005
2006 static umode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
2007                       struct attribute *attr, int idx)
2008 {
2009     struct device *dev = container_of(kobj, struct device, kobj);
2010     struct asus_wmi *asus = dev_get_drvdata(dev->parent);
2011     u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
2012
2013     if (attr == &dev_attr_pwm1.attr) {
2014         if (asus->fan_type != FAN_TYPE_AGFN)
2015             return 0;
2016     } else if (attr == &dev_attr_fan1_input.attr
2017         || attr == &dev_attr_fan1_label.attr
2018         || attr == &dev_attr_pwm1_enable.attr) {
2019         if (asus->fan_type == FAN_TYPE_NONE)
2020             return 0;
2021     } else if (attr == &dev_attr_temp1_input.attr) {
2022         int err = asus_wmi_get_devstate(asus,
2023                         ASUS_WMI_DEVID_THERMAL_CTRL,
2024                         &value);
2025
2026         if (err < 0)
2027             return 0; /* can't return negative here */
2028
2029         /*
2030          * If the temperature value in deci-Kelvin is near the absolute
2031          * zero temperature, something is clearly wrong
2032          */
2033         if (value == 0 || value == 1)
2034             return 0;
2035     }
2036
2037     return attr->mode;
2038 }
2039
2040 static const struct attribute_group hwmon_attribute_group = {
2041     .is_visible = asus_hwmon_sysfs_is_visible,
2042     .attrs = hwmon_attributes
2043 };
2044 __ATTRIBUTE_GROUPS(hwmon_attribute);
2045
2046 static int asus_wmi_hwmon_init(struct asus_wmi *asus)
2047 {
2048     struct device *dev = &asus->platform_device->dev;
2049     struct device *hwmon;
2050
2051     hwmon = devm_hwmon_device_register_with_groups(dev, "asus", asus,
2052             hwmon_attribute_groups);
2053
2054     if (IS_ERR(hwmon)) {
2055         pr_err("Could not register asus hwmon device\n");
2056         return PTR_ERR(hwmon);
2057     }
2058     return 0;
2059 }
2060
2061 static int asus_wmi_fan_init(struct asus_wmi *asus)
2062 {
2063     asus->fan_type = FAN_TYPE_NONE;
2064     asus->agfn_pwm = -1;
2065
2066     if (asus_wmi_dev_is_present(asus, ASUS_WMI_DEVID_CPU_FAN_CTRL))
2067         asus->fan_type = FAN_TYPE_SPEC83;
2068     else if (asus_wmi_has_agfn_fan(asus))
2069         asus->fan_type = FAN_TYPE_AGFN;
2070
2071     if (asus->fan_type == FAN_TYPE_NONE)
2072         return -ENODEV;
2073
2074     asus_fan_set_auto(asus);
2075     asus->fan_pwm_mode = ASUS_FAN_CTRL_AUTO;
2076     return 0;
2077 }
2078
2079 /* Fan mode *******************************************************************/
2080
2081 static int fan_boost_mode_check_present(struct asus_wmi *asus)
2082 {
2083     u32 result;
2084     int err;
2085
2086     asus->fan_boost_mode_available = false;
2087
2088     err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_BOOST_MODE,
2089                     &result);
2090     if (err) {
2091         if (err == -ENODEV)
2092             return 0;
2093         else
2094             return err;
2095     }
2096
2097     if ((result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
2098             (result & ASUS_FAN_BOOST_MODES_MASK)) {
2099         asus->fan_boost_mode_available = true;
2100         asus->fan_boost_mode_mask = result & ASUS_FAN_BOOST_MODES_MASK;
2101     }
2102
2103     return 0;
2104 }
2105
2106 static int fan_boost_mode_write(struct asus_wmi *asus)
2107 {
2108     u32 retval;
2109     u8 value;
2110     int err;
2111
2112     value = asus->fan_boost_mode;
2113
2114     pr_info("Set fan boost mode: %u\n", value);
2115     err = asus_wmi_set_devstate(ASUS_WMI_DEVID_FAN_BOOST_MODE, value,
2116                     &retval);
2117
2118     sysfs_notify(&asus->platform_device->dev.kobj, NULL,
2119             "fan_boost_mode");
2120
2121     if (err) {
2122         pr_warn("Failed to set fan boost mode: %d\n", err);
2123         return err;
2124     }
2125
2126     if (retval != 1) {
2127         pr_warn("Failed to set fan boost mode (retval): 0x%x\n",
2128             retval);
2129         return -EIO;
2130     }
2131
2132     return 0;
2133 }
2134
2135 static int fan_boost_mode_switch_next(struct asus_wmi *asus)
2136 {
2137     u8 mask = asus->fan_boost_mode_mask;
2138
2139     if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_NORMAL) {
2140         if (mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK)
2141             asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_OVERBOOST;
2142         else if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
2143             asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
2144     } else if (asus->fan_boost_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
2145         if (mask & ASUS_FAN_BOOST_MODE_SILENT_MASK)
2146             asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_SILENT;
2147         else
2148             asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
2149     } else {
2150         asus->fan_boost_mode = ASUS_FAN_BOOST_MODE_NORMAL;
2151     }
2152
2153     return fan_boost_mode_write(asus);
2154 }
2155
2156 static ssize_t fan_boost_mode_show(struct device *dev,
2157                    struct device_attribute *attr, char *buf)
2158 {
2159     struct asus_wmi *asus = dev_get_drvdata(dev);
2160
2161     return scnprintf(buf, PAGE_SIZE, "%d\n", asus->fan_boost_mode);
2162 }
2163
2164 static ssize_t fan_boost_mode_store(struct device *dev,
2165                     struct device_attribute *attr,
2166                     const char *buf, size_t count)
2167 {
2168     struct asus_wmi *asus = dev_get_drvdata(dev);
2169     u8 mask = asus->fan_boost_mode_mask;
2170     u8 new_mode;
2171     int result;
2172
2173     result = kstrtou8(buf, 10, &new_mode);
2174     if (result < 0) {
2175         pr_warn("Trying to store invalid value\n");
2176         return result;
2177     }
2178
2179     if (new_mode == ASUS_FAN_BOOST_MODE_OVERBOOST) {
2180         if (!(mask & ASUS_FAN_BOOST_MODE_OVERBOOST_MASK))
2181             return -EINVAL;
2182     } else if (new_mode == ASUS_FAN_BOOST_MODE_SILENT) {
2183         if (!(mask & ASUS_FAN_BOOST_MODE_SILENT_MASK))
2184             return -EINVAL;
2185     } else if (new_mode != ASUS_FAN_BOOST_MODE_NORMAL) {
2186         return -EINVAL;
2187     }
2188
2189     asus->fan_boost_mode = new_mode;
2190     fan_boost_mode_write(asus);
2191
2192     return count;
2193 }
2194
2195 // Fan boost mode: 0 - normal, 1 - overboost, 2 - silent
2196 static DEVICE_ATTR_RW(fan_boost_mode);
2197
2198 /* Custom fan curves **********************************************************/
2199
2200 static void fan_curve_copy_from_buf(struct fan_curve_data *data, u8 *buf)
2201 {
2202     int i;
2203
2204     for (i = 0; i < FAN_CURVE_POINTS; i++) {
2205         data->temps[i] = buf[i];
2206     }
2207
2208     for (i = 0; i < FAN_CURVE_POINTS; i++) {
2209         data->percents[i] =
2210             255 * buf[i + FAN_CURVE_POINTS] / 100;
2211     }
2212 }
2213
2214 static int fan_curve_get_factory_default(struct asus_wmi *asus, u32 fan_dev)
2215 {
2216     struct fan_curve_data *curves;
2217     u8 buf[FAN_CURVE_BUF_LEN];
2218     int fan_idx = 0;
2219     u8 mode = 0;
2220     int err;
2221
2222     if (asus->throttle_thermal_policy_available)
2223         mode = asus->throttle_thermal_policy_mode;
2224     /* DEVID_<C/G>PU_FAN_CURVE is switched for OVERBOOST vs SILENT */
2225     if (mode == 2)
2226         mode = 1;
2227     else if (mode == 1)
2228         mode = 2;
2229
2230     if (fan_dev == ASUS_WMI_DEVID_GPU_FAN_CURVE)
2231         fan_idx = FAN_CURVE_DEV_GPU;
2232
2233     curves = &asus->custom_fan_curves[fan_idx];
2234     err = asus_wmi_evaluate_method_buf(asus->dsts_id, fan_dev, mode, buf,
2235                        FAN_CURVE_BUF_LEN);
2236     if (err) {
2237         pr_warn("%s (0x%08x) failed: %d\n", __func__, fan_dev, err);
2238         return err;
2239     }
2240
2241     fan_curve_copy_from_buf(curves, buf);
2242     curves->device_id = fan_dev;
2243
2244     return 0;
2245 }
2246
2247 /* Check if capability exists, and populate defaults */
2248 static int fan_curve_check_present(struct asus_wmi *asus, bool *available,
2249                    u32 fan_dev)
2250 {
2251     int err;
2252
2253     *available = false;
2254
2255     err = fan_curve_get_factory_default(asus, fan_dev);
2256     if (err) {
2257         return 0;
2258     }
2259
2260     *available = true;
2261     return 0;
2262 }
2263
2264 /* Determine which fan the attribute is for if SENSOR_ATTR */
2265 static struct fan_curve_data *fan_curve_attr_select(struct asus_wmi *asus,
2266                           struct device_attribute *attr)
2267 {
2268     int index = to_sensor_dev_attr(attr)->index;
2269
2270     return &asus->custom_fan_curves[index & FAN_CURVE_DEV_GPU];
2271 }
2272
2273 /* Determine which fan the attribute is for if SENSOR_ATTR_2 */
2274 static struct fan_curve_data *fan_curve_attr_2_select(struct asus_wmi *asus,
2275                         struct device_attribute *attr)
2276 {
2277     int nr = to_sensor_dev_attr_2(attr)->nr;
2278
2279     return &asus->custom_fan_curves[nr & FAN_CURVE_DEV_GPU];
2280 }
2281
2282 static ssize_t fan_curve_show(struct device *dev,
2283                   struct device_attribute *attr, char *buf)
2284 {
2285     struct sensor_device_attribute_2 *dev_attr = to_sensor_dev_attr_2(attr);
2286     struct asus_wmi *asus = dev_get_drvdata(dev);
2287     struct fan_curve_data *data;
2288     int value, index, nr;
2289
2290     data = fan_curve_attr_2_select(asus, attr);
2291     index = dev_attr->index;
2292     nr = dev_attr->nr;
2293
2294     if (nr & FAN_CURVE_PWM_MASK)
2295         value = data->percents[index];
2296     else
2297         value = data->temps[index];
2298
2299     return sysfs_emit(buf, "%d\n", value);
2300 }
2301
2302 /*
2303  * "fan_dev" is the related WMI method such as ASUS_WMI_DEVID_CPU_FAN_CURVE.
2304  */
2305 static int fan_curve_write(struct asus_wmi *asus,
2306                struct fan_curve_data *data)
2307 {
2308     u32 arg1 = 0, arg2 = 0, arg3 = 0, arg4 = 0;
2309     u8 *percents = data->percents;
2310     u8 *temps = data->temps;
2311     int ret, i, shift = 0;
2312
2313     if (!data->enabled)
2314         return 0;
2315
2316     for (i = 0; i < FAN_CURVE_POINTS / 2; i++) {
2317         arg1 += (temps[i]) << shift;
2318         arg2 += (temps[i + 4]) << shift;
2319         /* Scale to percentage for device */
2320         arg3 += (100 * percents[i] / 255) << shift;
2321         arg4 += (100 * percents[i + 4] / 255) << shift;
2322         shift += 8;
2323     }
2324
2325     return asus_wmi_evaluate_method5(ASUS_WMI_METHODID_DEVS,
2326                      data->device_id,
2327                      arg1, arg2, arg3, arg4, &ret);
2328 }
2329
2330 static ssize_t fan_curve_store(struct device *dev,
2331                    struct device_attribute *attr, const char *buf,
2332                    size_t count)
2333 {
2334     struct sensor_device_attribute_2 *dev_attr = to_sensor_dev_attr_2(attr);
2335     struct asus_wmi *asus = dev_get_drvdata(dev);
2336     struct fan_curve_data *data;
2337     u8 value;
2338     int err;
2339
2340     int pwm = dev_attr->nr & FAN_CURVE_PWM_MASK;
2341     int index = dev_attr->index;
2342
2343     data = fan_curve_attr_2_select(asus, attr);
2344
2345     err = kstrtou8(buf, 10, &value);
2346     if (err < 0)
2347         return err;
2348
2349     if (pwm) {
2350         data->percents[index] = value;
2351     } else {
2352         data->temps[index] = value;
2353     }
2354
2355     /*
2356      * Mark as disabled so the user has to explicitly enable to apply a
2357      * changed fan curve. This prevents potential lockups from writing out
2358      * many changes as one-write-per-change.
2359      */
2360     data->enabled = false;
2361
2362     return count;
2363 }
2364
2365 static ssize_t fan_curve_enable_show(struct device *dev,
2366                      struct device_attribute *attr, char *buf)
2367 {
2368     struct asus_wmi *asus = dev_get_drvdata(dev);
2369     struct fan_curve_data *data;
2370     int out = 2;
2371
2372     data = fan_curve_attr_select(asus, attr);
2373
2374     if (data->enabled)
2375         out = 1;
2376
2377     return sysfs_emit(buf, "%d\n", out);
2378 }
2379
2380 static ssize_t fan_curve_enable_store(struct device *dev,
2381                       struct device_attribute *attr,
2382                       const char *buf, size_t count)
2383 {
2384     struct asus_wmi *asus = dev_get_drvdata(dev);
2385     struct fan_curve_data *data;
2386     int value, err;
2387
2388     data = fan_curve_attr_select(asus, attr);
2389
2390     err = kstrtoint(buf, 10, &value);
2391     if (err < 0)
2392         return err;
2393
2394     switch (value) {
2395     case 1:
2396         data->enabled = true;
2397         break;
2398     case 2:
2399         data->enabled = false;
2400         break;
2401     /*
2402      * Auto + reset the fan curve data to defaults. Make it an explicit
2403      * option so that users don't accidentally overwrite a set fan curve.
2404      */
2405     case 3:
2406         err = fan_curve_get_factory_default(asus, data->device_id);
2407         if (err)
2408             return err;
2409         data->enabled = false;
2410         break;
2411     default:
2412         return -EINVAL;
2413     }
2414
2415     if (data->enabled) {
2416         err = fan_curve_write(asus, data);
2417         if (err)
2418             return err;
2419     } else {
2420         /*
2421          * For machines with throttle this is the only way to reset fans
2422          * to default mode of operation (does not erase curve data).
2423          */
2424         if (asus->throttle_thermal_policy_available) {
2425             err = throttle_thermal_policy_write(asus);
2426             if (err)
2427                 return err;
2428         /* Similar is true for laptops with this fan */
2429         } else if (asus->fan_type == FAN_TYPE_SPEC83) {
2430             err = asus_fan_set_auto(asus);
2431             if (err)
2432                 return err;
2433         } else {
2434             /* Safeguard against fautly ACPI tables */
2435             err = fan_curve_get_factory_default(asus, data->device_id);
2436             if (err)
2437                 return err;
2438             err = fan_curve_write(asus, data);
2439             if (err)
2440                 return err;
2441         }
2442     }
2443     return count;
2444 }
2445
2446 /* CPU */
2447 static SENSOR_DEVICE_ATTR_RW(pwm1_enable, fan_curve_enable, FAN_CURVE_DEV_CPU);
2448 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_temp, fan_curve,
2449                    FAN_CURVE_DEV_CPU, 0);
2450 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_temp, fan_curve,
2451                    FAN_CURVE_DEV_CPU, 1);
2452 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_temp, fan_curve,
2453                    FAN_CURVE_DEV_CPU, 2);
2454 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_temp, fan_curve,
2455                    FAN_CURVE_DEV_CPU, 3);
2456 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_temp, fan_curve,
2457                    FAN_CURVE_DEV_CPU, 4);
2458 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point6_temp, fan_curve,
2459                    FAN_CURVE_DEV_CPU, 5);
2460 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point7_temp, fan_curve,
2461                    FAN_CURVE_DEV_CPU, 6);
2462 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point8_temp, fan_curve,
2463                    FAN_CURVE_DEV_CPU, 7);
2464
2465 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point1_pwm, fan_curve,
2466                    FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 0);
2467 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point2_pwm, fan_curve,
2468                    FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 1);
2469 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point3_pwm, fan_curve,
2470                    FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 2);
2471 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point4_pwm, fan_curve,
2472                    FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 3);
2473 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point5_pwm, fan_curve,
2474                    FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 4);
2475 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point6_pwm, fan_curve,
2476                    FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 5);
2477 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point7_pwm, fan_curve,
2478                    FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 6);
2479 static SENSOR_DEVICE_ATTR_2_RW(pwm1_auto_point8_pwm, fan_curve,
2480                    FAN_CURVE_DEV_CPU | FAN_CURVE_PWM_MASK, 7);
2481
2482 /* GPU */
2483 static SENSOR_DEVICE_ATTR_RW(pwm2_enable, fan_curve_enable, FAN_CURVE_DEV_GPU);
2484 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_temp, fan_curve,
2485                    FAN_CURVE_DEV_GPU, 0);
2486 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_temp, fan_curve,
2487                    FAN_CURVE_DEV_GPU, 1);
2488 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_temp, fan_curve,
2489                    FAN_CURVE_DEV_GPU, 2);
2490 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_temp, fan_curve,
2491                    FAN_CURVE_DEV_GPU, 3);
2492 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_temp, fan_curve,
2493                    FAN_CURVE_DEV_GPU, 4);
2494 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point6_temp, fan_curve,
2495                    FAN_CURVE_DEV_GPU, 5);
2496 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point7_temp, fan_curve,
2497                    FAN_CURVE_DEV_GPU, 6);
2498 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point8_temp, fan_curve,
2499                    FAN_CURVE_DEV_GPU, 7);
2500
2501 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point1_pwm, fan_curve,
2502                    FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 0);
2503 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point2_pwm, fan_curve,
2504                    FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 1);
2505 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point3_pwm, fan_curve,
2506                    FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 2);
2507 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point4_pwm, fan_curve,
2508                    FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 3);
2509 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point5_pwm, fan_curve,
2510                    FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 4);
2511 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point6_pwm, fan_curve,
2512                    FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 5);
2513 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point7_pwm, fan_curve,
2514                    FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 6);
2515 static SENSOR_DEVICE_ATTR_2_RW(pwm2_auto_point8_pwm, fan_curve,
2516                    FAN_CURVE_DEV_GPU | FAN_CURVE_PWM_MASK, 7);
2517
2518 static struct attribute *asus_fan_curve_attr[] = {
2519     /* CPU */
2520     &sensor_dev_attr_pwm1_enable.dev_attr.attr,
2521     &sensor_dev_attr_pwm1_auto_point1_temp.dev_attr.attr,
2522     &sensor_dev_attr_pwm1_auto_point2_temp.dev_attr.attr,
2523     &sensor_dev_attr_pwm1_auto_point3_temp.dev_attr.attr,
2524     &sensor_dev_attr_pwm1_auto_point4_temp.dev_attr.attr,
2525     &sensor_dev_attr_pwm1_auto_point5_temp.dev_attr.attr,
2526     &sensor_dev_attr_pwm1_auto_point6_temp.dev_attr.attr,
2527     &sensor_dev_attr_pwm1_auto_point7_temp.dev_attr.attr,
2528     &sensor_dev_attr_pwm1_auto_point8_temp.dev_attr.attr,
2529     &sensor_dev_attr_pwm1_auto_point1_pwm.dev_attr.attr,
2530     &sensor_dev_attr_pwm1_auto_point2_pwm.dev_attr.attr,
2531     &sensor_dev_attr_pwm1_auto_point3_pwm.dev_attr.attr,
2532     &sensor_dev_attr_pwm1_auto_point4_pwm.dev_attr.attr,
2533     &sensor_dev_attr_pwm1_auto_point5_pwm.dev_attr.attr,
2534     &sensor_dev_attr_pwm1_auto_point6_pwm.dev_attr.attr,
2535     &sensor_dev_attr_pwm1_auto_point7_pwm.dev_attr.attr,
2536     &sensor_dev_attr_pwm1_auto_point8_pwm.dev_attr.attr,
2537     /* GPU */
2538     &sensor_dev_attr_pwm2_enable.dev_attr.attr,
2539     &sensor_dev_attr_pwm2_auto_point1_temp.dev_attr.attr,
2540     &sensor_dev_attr_pwm2_auto_point2_temp.dev_attr.attr,
2541     &sensor_dev_attr_pwm2_auto_point3_temp.dev_attr.attr,
2542     &sensor_dev_attr_pwm2_auto_point4_temp.dev_attr.attr,
2543     &sensor_dev_attr_pwm2_auto_point5_temp.dev_attr.attr,
2544     &sensor_dev_attr_pwm2_auto_point6_temp.dev_attr.attr,
2545     &sensor_dev_attr_pwm2_auto_point7_temp.dev_attr.attr,
2546     &sensor_dev_attr_pwm2_auto_point8_temp.dev_attr.attr,
2547     &sensor_dev_attr_pwm2_auto_point1_pwm.dev_attr.attr,
2548     &sensor_dev_attr_pwm2_auto_point2_pwm.dev_attr.attr,
2549     &sensor_dev_attr_pwm2_auto_point3_pwm.dev_attr.attr,
2550     &sensor_dev_attr_pwm2_auto_point4_pwm.dev_attr.attr,
2551     &sensor_dev_attr_pwm2_auto_point5_pwm.dev_attr.attr,
2552     &sensor_dev_attr_pwm2_auto_point6_pwm.dev_attr.attr,
2553     &sensor_dev_attr_pwm2_auto_point7_pwm.dev_attr.attr,
2554     &sensor_dev_attr_pwm2_auto_point8_pwm.dev_attr.attr,
2555     NULL
2556 };
2557
2558 static umode_t asus_fan_curve_is_visible(struct kobject *kobj,
2559                      struct attribute *attr, int idx)
2560 {
2561     struct device *dev = kobj_to_dev(kobj);
2562     struct asus_wmi *asus = dev_get_drvdata(dev->parent);
2563
2564     /*
2565      * Check the char instead of casting attr as there are two attr types
2566      * involved here (attr1 and attr2)
2567      */
2568     if (asus->cpu_fan_curve_available && attr->name[3] == '1')
2569         return 0644;
2570
2571     if (asus->gpu_fan_curve_available && attr->name[3] == '2')
2572         return 0644;
2573
2574     return 0;
2575 }
2576
2577 static const struct attribute_group asus_fan_curve_attr_group = {
2578     .is_visible = asus_fan_curve_is_visible,
2579     .attrs = asus_fan_curve_attr,
2580 };
2581 __ATTRIBUTE_GROUPS(asus_fan_curve_attr);
2582
2583 /*
2584  * Must be initialised after throttle_thermal_policy_check_present() as
2585  * we check the status of throttle_thermal_policy_available during init.
2586  */
2587 static int asus_wmi_custom_fan_curve_init(struct asus_wmi *asus)
2588 {
2589     struct device *dev = &asus->platform_device->dev;
2590     struct device *hwmon;
2591     int err;
2592
2593     err = fan_curve_check_present(asus, &asus->cpu_fan_curve_available,
2594                       ASUS_WMI_DEVID_CPU_FAN_CURVE);
2595     if (err)
2596         return err;
2597
2598     err = fan_curve_check_present(asus, &asus->gpu_fan_curve_available,
2599                       ASUS_WMI_DEVID_GPU_FAN_CURVE);
2600     if (err)
2601         return err;
2602
2603     if (!asus->cpu_fan_curve_available && !asus->gpu_fan_curve_available)
2604         return 0;
2605
2606     hwmon = devm_hwmon_device_register_with_groups(
2607         dev, "asus_custom_fan_curve", asus, asus_fan_curve_attr_groups);
2608
2609     if (IS_ERR(hwmon)) {
2610         dev_err(dev,
2611             "Could not register asus_custom_fan_curve device\n");
2612         return PTR_ERR(hwmon);
2613     }
2614
2615     return 0;
2616 }
2617
2618 /* Throttle thermal policy ****************************************************/
2619
2620 static int throttle_thermal_policy_check_present(struct asus_wmi *asus)
2621 {
2622     u32 result;
2623     int err;
2624
2625     asus->throttle_thermal_policy_available = false;
2626
2627     err = asus_wmi_get_devstate(asus,
2628                     ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY,
2629                     &result);
2630     if (err) {
2631         if (err == -ENODEV)
2632             return 0;
2633         return err;
2634     }
2635
2636     if (result & ASUS_WMI_DSTS_PRESENCE_BIT)
2637         asus->throttle_thermal_policy_available = true;
2638
2639     return 0;
2640 }
2641
2642 static int throttle_thermal_policy_write(struct asus_wmi *asus)
2643 {
2644     int err;
2645     u8 value;
2646     u32 retval;
2647
2648     value = asus->throttle_thermal_policy_mode;
2649
2650     err = asus_wmi_set_devstate(ASUS_WMI_DEVID_THROTTLE_THERMAL_POLICY,
2651                     value, &retval);
2652
2653     sysfs_notify(&asus->platform_device->dev.kobj, NULL,
2654             "throttle_thermal_policy");
2655
2656     if (err) {
2657         pr_warn("Failed to set throttle thermal policy: %d\n", err);
2658         return err;
2659     }
2660
2661     if (retval != 1) {
2662         pr_warn("Failed to set throttle thermal policy (retval): 0x%x\n",
2663             retval);
2664         return -EIO;
2665     }
2666
2667     /* Must set to disabled if mode is toggled */
2668     if (asus->cpu_fan_curve_available)
2669         asus->custom_fan_curves[FAN_CURVE_DEV_CPU].enabled = false;
2670     if (asus->gpu_fan_curve_available)
2671         asus->custom_fan_curves[FAN_CURVE_DEV_GPU].enabled = false;
2672
2673     return 0;
2674 }
2675
2676 static int throttle_thermal_policy_set_default(struct asus_wmi *asus)
2677 {
2678     if (!asus->throttle_thermal_policy_available)
2679         return 0;
2680
2681     asus->throttle_thermal_policy_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
2682     return throttle_thermal_policy_write(asus);
2683 }
2684
2685 static int throttle_thermal_policy_switch_next(struct asus_wmi *asus)
2686 {
2687     u8 new_mode = asus->throttle_thermal_policy_mode + 1;
2688     int err;
2689
2690     if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT)
2691         new_mode = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
2692
2693     asus->throttle_thermal_policy_mode = new_mode;
2694     err = throttle_thermal_policy_write(asus);
2695     if (err)
2696         return err;
2697
2698     /*
2699      * Ensure that platform_profile updates userspace with the change to ensure
2700      * that platform_profile and throttle_thermal_policy_mode are in sync.
2701      */
2702     platform_profile_notify();
2703
2704     return 0;
2705 }
2706
2707 static ssize_t throttle_thermal_policy_show(struct device *dev,
2708                    struct device_attribute *attr, char *buf)
2709 {
2710     struct asus_wmi *asus = dev_get_drvdata(dev);
2711     u8 mode = asus->throttle_thermal_policy_mode;
2712
2713     return scnprintf(buf, PAGE_SIZE, "%d\n", mode);
2714 }
2715
2716 static ssize_t throttle_thermal_policy_store(struct device *dev,
2717                     struct device_attribute *attr,
2718                     const char *buf, size_t count)
2719 {
2720     struct asus_wmi *asus = dev_get_drvdata(dev);
2721     u8 new_mode;
2722     int result;
2723     int err;
2724
2725     result = kstrtou8(buf, 10, &new_mode);
2726     if (result < 0)
2727         return result;
2728
2729     if (new_mode > ASUS_THROTTLE_THERMAL_POLICY_SILENT)
2730         return -EINVAL;
2731
2732     asus->throttle_thermal_policy_mode = new_mode;
2733     err = throttle_thermal_policy_write(asus);
2734     if (err)
2735         return err;
2736
2737     /*
2738      * Ensure that platform_profile updates userspace with the change to ensure
2739      * that platform_profile and throttle_thermal_policy_mode are in sync.
2740      */
2741     platform_profile_notify();
2742
2743     return count;
2744 }
2745
2746 // Throttle thermal policy: 0 - default, 1 - overboost, 2 - silent
2747 static DEVICE_ATTR_RW(throttle_thermal_policy);
2748
2749 /* Platform profile ***********************************************************/
2750 static int asus_wmi_platform_profile_get(struct platform_profile_handler *pprof,
2751                     enum platform_profile_option *profile)
2752 {
2753     struct asus_wmi *asus;
2754     int tp;
2755
2756     asus = container_of(pprof, struct asus_wmi, platform_profile_handler);
2757
2758     tp = asus->throttle_thermal_policy_mode;
2759
2760     switch (tp) {
2761     case ASUS_THROTTLE_THERMAL_POLICY_DEFAULT:
2762         *profile = PLATFORM_PROFILE_BALANCED;
2763         break;
2764     case ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST:
2765         *profile = PLATFORM_PROFILE_PERFORMANCE;
2766         break;
2767     case ASUS_THROTTLE_THERMAL_POLICY_SILENT:
2768         *profile = PLATFORM_PROFILE_QUIET;
2769         break;
2770     default:
2771         return -EINVAL;
2772     }
2773
2774     return 0;
2775 }
2776
2777 static int asus_wmi_platform_profile_set(struct platform_profile_handler *pprof,
2778                     enum platform_profile_option profile)
2779 {
2780     struct asus_wmi *asus;
2781     int tp;
2782
2783     asus = container_of(pprof, struct asus_wmi, platform_profile_handler);
2784
2785     switch (profile) {
2786     case PLATFORM_PROFILE_PERFORMANCE:
2787         tp = ASUS_THROTTLE_THERMAL_POLICY_OVERBOOST;
2788         break;
2789     case PLATFORM_PROFILE_BALANCED:
2790         tp = ASUS_THROTTLE_THERMAL_POLICY_DEFAULT;
2791         break;
2792     case PLATFORM_PROFILE_QUIET:
2793         tp = ASUS_THROTTLE_THERMAL_POLICY_SILENT;
2794         break;
2795     default:
2796         return -EOPNOTSUPP;
2797     }
2798
2799     asus->throttle_thermal_policy_mode = tp;
2800     return throttle_thermal_policy_write(asus);
2801 }
2802
2803 static int platform_profile_setup(struct asus_wmi *asus)
2804 {
2805     struct device *dev = &asus->platform_device->dev;
2806     int err;
2807
2808     /*
2809      * Not an error if a component platform_profile relies on is unavailable
2810      * so early return, skipping the setup of platform_profile.
2811      */
2812     if (!asus->throttle_thermal_policy_available)
2813         return 0;
2814
2815     dev_info(dev, "Using throttle_thermal_policy for platform_profile support\n");
2816
2817     asus->platform_profile_handler.profile_get = asus_wmi_platform_profile_get;
2818     asus->platform_profile_handler.profile_set = asus_wmi_platform_profile_set;
2819
2820     set_bit(PLATFORM_PROFILE_QUIET, asus->platform_profile_handler.choices);
2821     set_bit(PLATFORM_PROFILE_BALANCED,
2822         asus->platform_profile_handler.choices);
2823     set_bit(PLATFORM_PROFILE_PERFORMANCE,
2824         asus->platform_profile_handler.choices);
2825
2826     err = platform_profile_register(&asus->platform_profile_handler);
2827     if (err)
2828         return err;
2829
2830     asus->platform_profile_support = true;
2831     return 0;
2832 }
2833
2834 /* Backlight ******************************************************************/
2835
2836 static int read_backlight_power(struct asus_wmi *asus)
2837 {
2838     int ret;
2839
2840     if (asus->driver->quirks->store_backlight_power)
2841         ret = !asus->driver->panel_power;
2842     else
2843         ret = asus_wmi_get_devstate_simple(asus,
2844                            ASUS_WMI_DEVID_BACKLIGHT);
2845
2846     if (ret < 0)
2847         return ret;
2848
2849     return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
2850 }
2851
2852 static int read_brightness_max(struct asus_wmi *asus)
2853 {
2854     u32 retval;
2855     int err;
2856
2857     err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
2858     if (err < 0)
2859         return err;
2860
2861     retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
2862     retval >>= 8;
2863
2864     if (!retval)
2865         return -ENODEV;
2866
2867     return retval;
2868 }
2869
2870 static int read_brightness(struct backlight_device *bd)
2871 {
2872     struct asus_wmi *asus = bl_get_data(bd);
2873     u32 retval;
2874     int err;
2875
2876     err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
2877     if (err < 0)
2878         return err;
2879
2880     return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
2881 }
2882
2883 static u32 get_scalar_command(struct backlight_device *bd)
2884 {
2885     struct asus_wmi *asus = bl_get_data(bd);
2886     u32 ctrl_param = 0;
2887
2888     if ((asus->driver->brightness < bd->props.brightness) ||
2889         bd->props.brightness == bd->props.max_brightness)
2890         ctrl_param = 0x00008001;
2891     else if ((asus->driver->brightness > bd->props.brightness) ||
2892          bd->props.brightness == 0)
2893         ctrl_param = 0x00008000;
2894
2895     asus->driver->brightness = bd->props.brightness;
2896
2897     return ctrl_param;
2898 }
2899
2900 static int update_bl_status(struct backlight_device *bd)
2901 {
2902     struct asus_wmi *asus = bl_get_data(bd);
2903     u32 ctrl_param;
2904     int power, err = 0;
2905
2906     power = read_backlight_power(asus);
2907     if (power != -ENODEV && bd->props.power != power) {
2908         ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
2909         err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
2910                         ctrl_param, NULL);
2911         if (asus->driver->quirks->store_backlight_power)
2912             asus->driver->panel_power = bd->props.power;
2913
2914         /* When using scalar brightness, updating the brightness
2915          * will mess with the backlight power */
2916         if (asus->driver->quirks->scalar_panel_brightness)
2917             return err;
2918     }
2919
2920     if (asus->driver->quirks->scalar_panel_brightness)
2921         ctrl_param = get_scalar_command(bd);
2922     else
2923         ctrl_param = bd->props.brightness;
2924
2925     err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
2926                     ctrl_param, NULL);
2927
2928     return err;
2929 }
2930
2931 static const struct backlight_ops asus_wmi_bl_ops = {
2932     .get_brightness = read_brightness,
2933     .update_status = update_bl_status,
2934 };
2935
2936 static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
2937 {
2938     struct backlight_device *bd = asus->backlight_device;
2939     int old = bd->props.brightness;
2940     int new = old;
2941
2942     if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
2943         new = code - NOTIFY_BRNUP_MIN + 1;
2944     else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
2945         new = code - NOTIFY_BRNDOWN_MIN;
2946
2947     bd->props.brightness = new;
2948     backlight_update_status(bd);
2949     backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
2950
2951     return old;
2952 }
2953
2954 static int asus_wmi_backlight_init(struct asus_wmi *asus)
2955 {
2956     struct backlight_device *bd;
2957     struct backlight_properties props;
2958     int max;
2959     int power;
2960
2961     max = read_brightness_max(asus);
2962     if (max < 0)
2963         return max;
2964
2965     power = read_backlight_power(asus);
2966     if (power == -ENODEV)
2967         power = FB_BLANK_UNBLANK;
2968     else if (power < 0)
2969         return power;
2970
2971     memset(&props, 0, sizeof(struct backlight_properties));
2972     props.type = BACKLIGHT_PLATFORM;
2973     props.max_brightness = max;
2974     bd = backlight_device_register(asus->driver->name,
2975                        &asus->platform_device->dev, asus,
2976                        &asus_wmi_bl_ops, &props);
2977     if (IS_ERR(bd)) {
2978         pr_err("Could not register backlight device\n");
2979         return PTR_ERR(bd);
2980     }
2981
2982     asus->backlight_device = bd;
2983
2984     if (asus->driver->quirks->store_backlight_power)
2985         asus->driver->panel_power = power;
2986
2987     bd->props.brightness = read_brightness(bd);
2988     bd->props.power = power;
2989     backlight_update_status(bd);
2990
2991     asus->driver->brightness = bd->props.brightness;
2992
2993     return 0;
2994 }
2995
2996 static void asus_wmi_backlight_exit(struct asus_wmi *asus)
2997 {
2998     backlight_device_unregister(asus->backlight_device);
2999
3000     asus->backlight_device = NULL;
3001 }
3002
3003 static int is_display_toggle(int code)
3004 {
3005     /* display toggle keys */
3006     if ((code >= 0x61 && code <= 0x67) ||
3007         (code >= 0x8c && code <= 0x93) ||
3008         (code >= 0xa0 && code <= 0xa7) ||
3009         (code >= 0xd0 && code <= 0xd5))
3010         return 1;
3011
3012     return 0;
3013 }
3014
3015 /* Fn-lock ********************************************************************/
3016
3017 static bool asus_wmi_has_fnlock_key(struct asus_wmi *asus)
3018 {
3019     u32 result;
3020
3021     asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FNLOCK, &result);
3022
3023     return (result & ASUS_WMI_DSTS_PRESENCE_BIT) &&
3024         !(result & ASUS_WMI_FNLOCK_BIOS_DISABLED);
3025 }
3026
3027 static void asus_wmi_fnlock_update(struct asus_wmi *asus)
3028 {
3029     int mode = asus->fnlock_locked;
3030
3031     asus_wmi_set_devstate(ASUS_WMI_DEVID_FNLOCK, mode, NULL);
3032 }
3033
3034 /* WMI events *****************************************************************/
3035
3036 static int asus_wmi_get_event_code(u32 value)
3037 {
3038     struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
3039     union acpi_object *obj;
3040     acpi_status status;
3041     int code;
3042
3043     status = wmi_get_event_data(value, &response);
3044     if (ACPI_FAILURE(status)) {
3045         pr_warn("Failed to get WMI notify code: %s\n",
3046                 acpi_format_exception(status));
3047         return -EIO;
3048     }
3049
3050     obj = (union acpi_object *)response.pointer;
3051
3052     if (obj && obj->type == ACPI_TYPE_INTEGER)
3053         code = (int)(obj->integer.value & WMI_EVENT_MASK);
3054     else
3055         code = -EIO;
3056
3057     kfree(obj);
3058     return code;
3059 }
3060
3061 static void asus_wmi_handle_event_code(int code, struct asus_wmi *asus)
3062 {
3063     unsigned int key_value = 1;
3064     bool autorelease = 1;
3065     int result, orig_code;
3066
3067     orig_code = code;
3068
3069     if (asus->driver->key_filter) {
3070         asus->driver->key_filter(asus->driver, &code, &key_value,
3071                      &autorelease);
3072         if (code == ASUS_WMI_KEY_IGNORE)
3073             return;
3074     }
3075
3076     if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
3077         code = ASUS_WMI_BRN_UP;
3078     else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
3079         code = ASUS_WMI_BRN_DOWN;
3080
3081     if (code == ASUS_WMI_BRN_DOWN || code == ASUS_WMI_BRN_UP) {
3082         if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
3083             asus_wmi_backlight_notify(asus, orig_code);
3084             return;
3085         }
3086     }
3087
3088     if (code == NOTIFY_KBD_BRTUP) {
3089         kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
3090         return;
3091     }
3092     if (code == NOTIFY_KBD_BRTDWN) {
3093         kbd_led_set_by_kbd(asus, asus->kbd_led_wk - 1);
3094         return;
3095     }
3096     if (code == NOTIFY_KBD_BRTTOGGLE) {
3097         if (asus->kbd_led_wk == asus->kbd_led.max_brightness)
3098             kbd_led_set_by_kbd(asus, 0);
3099         else
3100             kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1);
3101         return;
3102     }
3103
3104     if (code == NOTIFY_FNLOCK_TOGGLE) {
3105         asus->fnlock_locked = !asus->fnlock_locked;
3106         asus_wmi_fnlock_update(asus);
3107         return;
3108     }
3109
3110     if (asus->driver->quirks->use_kbd_dock_devid && code == NOTIFY_KBD_DOCK_CHANGE) {
3111         result = asus_wmi_get_devstate_simple(asus,
3112                               ASUS_WMI_DEVID_KBD_DOCK);
3113         if (result >= 0) {
3114             input_report_switch(asus->inputdev, SW_TABLET_MODE,
3115                         !result);
3116             input_sync(asus->inputdev);
3117         }
3118         return;
3119     }
3120
3121     if (asus->driver->quirks->use_lid_flip_devid && code == NOTIFY_LID_FLIP) {
3122         lid_flip_tablet_mode_get_state(asus);
3123         return;
3124     }
3125
3126     if (asus->fan_boost_mode_available && code == NOTIFY_KBD_FBM) {
3127         fan_boost_mode_switch_next(asus);
3128         return;
3129     }
3130
3131     if (asus->throttle_thermal_policy_available && code == NOTIFY_KBD_TTP) {
3132         throttle_thermal_policy_switch_next(asus);
3133         return;
3134     }
3135
3136     if (is_display_toggle(code) && asus->driver->quirks->no_display_toggle)
3137         return;
3138
3139     if (!sparse_keymap_report_event(asus->inputdev, code,
3140                     key_value, autorelease))
3141         pr_info("Unknown key code 0x%x\n", code);
3142 }
3143
3144 static void asus_wmi_notify(u32 value, void *context)
3145 {
3146     struct asus_wmi *asus = context;
3147     int code;
3148     int i;
3149
3150     for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) {
3151         code = asus_wmi_get_event_code(value);
3152         if (code < 0) {
3153             pr_warn("Failed to get notify code: %d\n", code);
3154             return;
3155         }
3156
3157         if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK)
3158             return;
3159
3160         asus_wmi_handle_event_code(code, asus);
3161
3162         /*
3163          * Double check that queue is present:
3164          * ATK (with queue) uses 0xff, ASUSWMI (without) 0xd2.
3165          */
3166         if (!asus->wmi_event_queue || value != WMI_EVENT_VALUE_ATK)
3167             return;
3168     }
3169
3170     pr_warn("Failed to process event queue, last code: 0x%x\n", code);
3171 }
3172
3173 static int asus_wmi_notify_queue_flush(struct asus_wmi *asus)
3174 {
3175     int code;
3176     int i;
3177
3178     for (i = 0; i < WMI_EVENT_QUEUE_SIZE + 1; i++) {
3179         code = asus_wmi_get_event_code(WMI_EVENT_VALUE_ATK);
3180         if (code < 0) {
3181             pr_warn("Failed to get event during flush: %d\n", code);
3182             return code;
3183         }
3184
3185         if (code == WMI_EVENT_QUEUE_END || code == WMI_EVENT_MASK)
3186             return 0;
3187     }
3188
3189     pr_warn("Failed to flush event queue\n");
3190     return -EIO;
3191 }
3192
3193 /* Sysfs **********************************************************************/
3194
3195 static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
3196                  const char *buf, size_t count)
3197 {
3198     u32 retval;
3199     int err, value;
3200
3201     value = asus_wmi_get_devstate_simple(asus, devid);
3202     if (value < 0)
3203         return value;
3204
3205     err = kstrtoint(buf, 0, &value);
3206     if (err)
3207         return err;
3208
3209     err = asus_wmi_set_devstate(devid, value, &retval);
3210     if (err < 0)
3211         return err;
3212
3213     return count;
3214 }
3215
3216 static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
3217 {
3218     int value = asus_wmi_get_devstate_simple(asus, devid);
3219
3220     if (value < 0)
3221         return value;
3222
3223     return sprintf(buf, "%d\n", value);
3224 }
3225
3226 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm)          \
3227     static ssize_t show_##_name(struct device *dev,         \
3228                     struct device_attribute *attr,  \
3229                     char *buf)              \
3230     {                               \
3231         struct asus_wmi *asus = dev_get_drvdata(dev);       \
3232                                     \
3233         return show_sys_wmi(asus, _cm, buf);            \
3234     }                               \
3235     static ssize_t store_##_name(struct device *dev,        \
3236                      struct device_attribute *attr, \
3237                      const char *buf, size_t count) \
3238     {                               \
3239         struct asus_wmi *asus = dev_get_drvdata(dev);       \
3240                                     \
3241         return store_sys_wmi(asus, _cm, buf, count);        \
3242     }                               \
3243     static struct device_attribute dev_attr_##_name = {     \
3244         .attr = {                       \
3245             .name = __stringify(_name),         \
3246             .mode = _mode },                \
3247         .show   = show_##_name,                 \
3248         .store  = store_##_name,                \
3249     }
3250
3251 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
3252 ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
3253 ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
3254 ASUS_WMI_CREATE_DEVICE_ATTR(lid_resume, 0644, ASUS_WMI_DEVID_LID_RESUME);
3255 ASUS_WMI_CREATE_DEVICE_ATTR(als_enable, 0644, ASUS_WMI_DEVID_ALS_ENABLE);
3256
3257 static ssize_t cpufv_store(struct device *dev, struct device_attribute *attr,
3258                const char *buf, size_t count)
3259 {
3260     int value, rv;
3261
3262     rv = kstrtoint(buf, 0, &value);
3263     if (rv)
3264         return rv;
3265
3266     if (value < 0 || value > 2)
3267         return -EINVAL;
3268
3269     rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
3270     if (rv < 0)
3271         return rv;
3272
3273     return count;
3274 }
3275
3276 static DEVICE_ATTR_WO(cpufv);
3277
3278 static struct attribute *platform_attributes[] = {
3279     &dev_attr_cpufv.attr,
3280     &dev_attr_camera.attr,
3281     &dev_attr_cardr.attr,
3282     &dev_attr_touchpad.attr,
3283     &dev_attr_egpu_enable.attr,
3284     &dev_attr_dgpu_disable.attr,
3285     &dev_attr_lid_resume.attr,
3286     &dev_attr_als_enable.attr,
3287     &dev_attr_fan_boost_mode.attr,
3288     &dev_attr_throttle_thermal_policy.attr,
3289     &dev_attr_panel_od.attr,
3290     NULL
3291 };
3292
3293 static umode_t asus_sysfs_is_visible(struct kobject *kobj,
3294                     struct attribute *attr, int idx)
3295 {
3296     struct device *dev = container_of(kobj, struct device, kobj);
3297     struct asus_wmi *asus = dev_get_drvdata(dev);
3298     bool ok = true;
3299     int devid = -1;
3300
3301     if (attr == &dev_attr_camera.attr)
3302         devid = ASUS_WMI_DEVID_CAMERA;
3303     else if (attr == &dev_attr_cardr.attr)
3304         devid = ASUS_WMI_DEVID_CARDREADER;
3305     else if (attr == &dev_attr_touchpad.attr)
3306         devid = ASUS_WMI_DEVID_TOUCHPAD;
3307     else if (attr == &dev_attr_lid_resume.attr)
3308         devid = ASUS_WMI_DEVID_LID_RESUME;
3309     else if (attr == &dev_attr_als_enable.attr)
3310         devid = ASUS_WMI_DEVID_ALS_ENABLE;
3311     else if (attr == &dev_attr_egpu_enable.attr)
3312         ok = asus->egpu_enable_available;
3313     else if (attr == &dev_attr_dgpu_disable.attr)
3314         ok = asus->dgpu_disable_available;
3315     else if (attr == &dev_attr_fan_boost_mode.attr)
3316         ok = asus->fan_boost_mode_available;
3317     else if (attr == &dev_attr_throttle_thermal_policy.attr)
3318         ok = asus->throttle_thermal_policy_available;
3319     else if (attr == &dev_attr_panel_od.attr)
3320         ok = asus->panel_overdrive_available;
3321
3322     if (devid != -1)
3323         ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
3324
3325     return ok ? attr->mode : 0;
3326 }
3327
3328 static const struct attribute_group platform_attribute_group = {
3329     .is_visible = asus_sysfs_is_visible,
3330     .attrs = platform_attributes
3331 };
3332
3333 static void asus_wmi_sysfs_exit(struct platform_device *device)
3334 {
3335     sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
3336 }
3337
3338 static int asus_wmi_sysfs_init(struct platform_device *device)
3339 {
3340     return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
3341 }
3342
3343 /* Platform device ************************************************************/
3344
3345 static int asus_wmi_platform_init(struct asus_wmi *asus)
3346 {
3347     struct device *dev = &asus->platform_device->dev;
3348     char *wmi_uid;
3349     int rv;
3350
3351     /* INIT enable hotkeys on some models */
3352     if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
3353         pr_info("Initialization: %#x\n", rv);
3354
3355     /* We don't know yet what to do with this version... */
3356     if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
3357         pr_info("BIOS WMI version: %d.%d\n", rv >> 16, rv & 0xFF);
3358         asus->spec = rv;
3359     }
3360
3361     /*
3362      * The SFUN method probably allows the original driver to get the list
3363      * of features supported by a given model. For now, 0x0100 or 0x0800
3364      * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
3365      * The significance of others is yet to be found.
3366      */
3367     if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
3368         pr_info("SFUN value: %#x\n", rv);
3369         asus->sfun = rv;
3370     }
3371
3372     /*
3373      * Eee PC and Notebooks seems to have different method_id for DSTS,
3374      * but it may also be related to the BIOS's SPEC.
3375      * Note, on most Eeepc, there is no way to check if a method exist
3376      * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
3377      * but once again, SPEC may probably be used for that kind of things.
3378      *
3379      * Additionally at least TUF Gaming series laptops return nothing for
3380      * unknown methods, so the detection in this way is not possible.
3381      *
3382      * There is strong indication that only ACPI WMI devices that have _UID
3383      * equal to "ASUSWMI" use DCTS whereas those with "ATK" use DSTS.
3384      */
3385     wmi_uid = wmi_get_acpi_device_uid(ASUS_WMI_MGMT_GUID);
3386     if (!wmi_uid)
3387         return -ENODEV;
3388
3389     if (!strcmp(wmi_uid, ASUS_ACPI_UID_ASUSWMI)) {
3390         dev_info(dev, "Detected ASUSWMI, use DCTS\n");
3391         asus->dsts_id = ASUS_WMI_METHODID_DCTS;
3392     } else {
3393         dev_info(dev, "Detected %s, not ASUSWMI, use DSTS\n", wmi_uid);
3394         asus->dsts_id = ASUS_WMI_METHODID_DSTS;
3395     }
3396
3397     /*
3398      * Some devices can have multiple event codes stored in a queue before
3399      * the module load if it was unloaded intermittently after calling
3400      * the INIT method (enables event handling). The WMI notify handler is
3401      * expected to retrieve all event codes until a retrieved code equals
3402      * queue end marker (One or Ones). Old codes are flushed from the queue
3403      * upon module load. Not enabling this when it should be has minimal
3404      * visible impact so fall back if anything goes wrong.
3405      */
3406     wmi_uid = wmi_get_acpi_device_uid(asus->driver->event_guid);
3407     if (wmi_uid && !strcmp(wmi_uid, ASUS_ACPI_UID_ATK)) {
3408         dev_info(dev, "Detected ATK, enable event queue\n");
3409
3410         if (!asus_wmi_notify_queue_flush(asus))
3411             asus->wmi_event_queue = true;
3412     }
3413
3414     /* CWAP allow to define the behavior of the Fn+F2 key,
3415      * this method doesn't seems to be present on Eee PCs */
3416     if (asus->driver->quirks->wapf >= 0)
3417         asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP,
3418                       asus->driver->quirks->wapf, NULL);
3419
3420     return 0;
3421 }
3422
3423 /* debugfs ********************************************************************/
3424
3425 struct asus_wmi_debugfs_node {
3426     struct asus_wmi *asus;
3427     char *name;
3428     int (*show) (struct seq_file *m, void *data);
3429 };
3430
3431 static int show_dsts(struct seq_file *m, void *data)
3432 {
3433     struct asus_wmi *asus = m->private;
3434     int err;
3435     u32 retval = -1;
3436
3437     err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
3438     if (err < 0)
3439         return err;
3440
3441     seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
3442
3443     return 0;
3444 }
3445
3446 static int show_devs(struct seq_file *m, void *data)
3447 {
3448     struct asus_wmi *asus = m->private;
3449     int err;
3450     u32 retval = -1;
3451
3452     err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
3453                     &retval);
3454     if (err < 0)
3455         return err;
3456
3457     seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
3458            asus->debug.ctrl_param, retval);
3459
3460     return 0;
3461 }
3462
3463 static int show_call(struct seq_file *m, void *data)
3464 {
3465     struct asus_wmi *asus = m->private;
3466     struct bios_args args = {
3467         .arg0 = asus->debug.dev_id,
3468         .arg1 = asus->debug.ctrl_param,
3469     };
3470     struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
3471     struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
3472     union acpi_object *obj;
3473     acpi_status status;
3474
3475     status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
3476                      0, asus->debug.method_id,
3477                      &input, &output);
3478
3479     if (ACPI_FAILURE(status))
3480         return -EIO;
3481
3482     obj = (union acpi_object *)output.pointer;
3483     if (obj && obj->type == ACPI_TYPE_INTEGER)
3484         seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
3485                asus->debug.dev_id, asus->debug.ctrl_param,
3486                (u32) obj->integer.value);
3487     else
3488         seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
3489                asus->debug.dev_id, asus->debug.ctrl_param,
3490                obj ? obj->type : -1);
3491
3492     kfree(obj);
3493
3494     return 0;
3495 }
3496
3497 static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
3498     {NULL, "devs", show_devs},
3499     {NULL, "dsts", show_dsts},
3500     {NULL, "call", show_call},
3501 };
3502
3503 static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
3504 {
3505     struct asus_wmi_debugfs_node *node = inode->i_private;
3506
3507     return single_open(file, node->show, node->asus);
3508 }
3509
3510 static const struct file_operations asus_wmi_debugfs_io_ops = {
3511     .owner = THIS_MODULE,
3512     .open = asus_wmi_debugfs_open,
3513     .read = seq_read,
3514     .llseek = seq_lseek,
3515     .release = single_release,
3516 };
3517
3518 static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
3519 {
3520     debugfs_remove_recursive(asus->debug.root);
3521 }
3522
3523 static void asus_wmi_debugfs_init(struct asus_wmi *asus)
3524 {
3525     int i;
3526
3527     asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
3528
3529     debugfs_create_x32("method_id", S_IRUGO | S_IWUSR, asus->debug.root,
3530                &asus->debug.method_id);
3531
3532     debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR, asus->debug.root,
3533                &asus->debug.dev_id);
3534
3535     debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR, asus->debug.root,
3536                &asus->debug.ctrl_param);
3537
3538     for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
3539         struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
3540
3541         node->asus = asus;
3542         debugfs_create_file(node->name, S_IFREG | S_IRUGO,
3543                     asus->debug.root, node,
3544                     &asus_wmi_debugfs_io_ops);
3545     }
3546 }
3547
3548 /* Init / exit ****************************************************************/
3549
3550 static int asus_wmi_add(struct platform_device *pdev)
3551 {
3552     struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
3553     struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
3554     struct asus_wmi *asus;
3555     const char *chassis_type;
3556     acpi_status status;
3557     int err;
3558     u32 result;
3559
3560     asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
3561     if (!asus)
3562         return -ENOMEM;
3563
3564     asus->driver = wdrv;
3565     asus->platform_device = pdev;
3566     wdrv->platform_device = pdev;
3567     platform_set_drvdata(asus->platform_device, asus);
3568
3569     if (wdrv->detect_quirks)
3570         wdrv->detect_quirks(asus->driver);
3571
3572     err = asus_wmi_platform_init(asus);
3573     if (err)
3574         goto fail_platform;
3575
3576     err = egpu_enable_check_present(asus);
3577     if (err)
3578         goto fail_egpu_enable;
3579
3580     err = dgpu_disable_check_present(asus);
3581     if (err)
3582         goto fail_dgpu_disable;
3583
3584     err = fan_boost_mode_check_present(asus);
3585     if (err)
3586         goto fail_fan_boost_mode;
3587
3588     err = throttle_thermal_policy_check_present(asus);
3589     if (err)
3590         goto fail_throttle_thermal_policy;
3591     else
3592         throttle_thermal_policy_set_default(asus);
3593
3594     err = platform_profile_setup(asus);
3595     if (err)
3596         goto fail_platform_profile_setup;
3597
3598     err = panel_od_check_present(asus);
3599     if (err)
3600         goto fail_panel_od;
3601
3602     err = asus_wmi_sysfs_init(asus->platform_device);
3603     if (err)
3604         goto fail_sysfs;
3605
3606     err = asus_wmi_input_init(asus);
3607     if (err)
3608         goto fail_input;
3609
3610     err = asus_wmi_fan_init(asus); /* probably no problems on error */
3611
3612     err = asus_wmi_hwmon_init(asus);
3613     if (err)
3614         goto fail_hwmon;
3615
3616     err = asus_wmi_custom_fan_curve_init(asus);
3617     if (err)
3618         goto fail_custom_fan_curve;
3619
3620     err = asus_wmi_led_init(asus);
3621     if (err)
3622         goto fail_leds;
3623
3624     asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result);
3625     if (result & (ASUS_WMI_DSTS_PRESENCE_BIT | ASUS_WMI_DSTS_USER_BIT))
3626         asus->driver->wlan_ctrl_by_user = 1;
3627
3628     if (!(asus->driver->wlan_ctrl_by_user && ashs_present())) {
3629         err = asus_wmi_rfkill_init(asus);
3630         if (err)
3631             goto fail_rfkill;
3632     }
3633
3634     if (asus->driver->quirks->wmi_force_als_set)
3635         asus_wmi_set_als();
3636
3637     /* Some Asus desktop boards export an acpi-video backlight interface,
3638        stop this from showing up */
3639     chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE);
3640     if (chassis_type && !strcmp(chassis_type, "3"))
3641         acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
3642
3643     if (asus->driver->quirks->wmi_backlight_power)
3644         acpi_video_set_dmi_backlight_type(acpi_backlight_vendor);
3645
3646     if (asus->driver->quirks->wmi_backlight_native)
3647         acpi_video_set_dmi_backlight_type(acpi_backlight_native);
3648
3649     if (asus->driver->quirks->xusb2pr)
3650         asus_wmi_set_xusb2pr(asus);
3651
3652     if (acpi_video_get_backlight_type() == acpi_backlight_vendor) {
3653         err = asus_wmi_backlight_init(asus);
3654         if (err && err != -ENODEV)
3655             goto fail_backlight;
3656     } else if (asus->driver->quirks->wmi_backlight_set_devstate)
3657         err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT, 2, NULL);
3658
3659     if (asus_wmi_has_fnlock_key(asus)) {
3660         asus->fnlock_locked = fnlock_default;
3661         asus_wmi_fnlock_update(asus);
3662     }
3663
3664     status = wmi_install_notify_handler(asus->driver->event_guid,
3665                         asus_wmi_notify, asus);
3666     if (ACPI_FAILURE(status)) {
3667         pr_err("Unable to register notify handler - %d\n", status);
3668         err = -ENODEV;
3669         goto fail_wmi_handler;
3670     }
3671
3672     asus_wmi_battery_init(asus);
3673
3674     asus_wmi_debugfs_init(asus);
3675
3676     return 0;
3677
3678 fail_wmi_handler:
3679     asus_wmi_backlight_exit(asus);
3680 fail_backlight:
3681     asus_wmi_rfkill_exit(asus);
3682 fail_rfkill:
3683     asus_wmi_led_exit(asus);
3684 fail_leds:
3685 fail_hwmon:
3686     asus_wmi_input_exit(asus);
3687 fail_input:
3688     asus_wmi_sysfs_exit(asus->platform_device);
3689 fail_sysfs:
3690 fail_throttle_thermal_policy:
3691 fail_custom_fan_curve:
3692 fail_platform_profile_setup:
3693     if (asus->platform_profile_support)
3694         platform_profile_remove();
3695 fail_fan_boost_mode:
3696 fail_egpu_enable:
3697 fail_dgpu_disable:
3698 fail_platform:
3699 fail_panel_od:
3700     kfree(asus);
3701     return err;
3702 }
3703
3704 static int asus_wmi_remove(struct platform_device *device)
3705 {
3706     struct asus_wmi *asus;
3707
3708     asus = platform_get_drvdata(device);
3709     wmi_remove_notify_handler(asus->driver->event_guid);
3710     asus_wmi_backlight_exit(asus);
3711     asus_wmi_input_exit(asus);
3712     asus_wmi_led_exit(asus);
3713     asus_wmi_rfkill_exit(asus);
3714     asus_wmi_debugfs_exit(asus);
3715     asus_wmi_sysfs_exit(asus->platform_device);
3716     asus_fan_set_auto(asus);
3717     throttle_thermal_policy_set_default(asus);
3718     asus_wmi_battery_exit(asus);
3719
3720     if (asus->platform_profile_support)
3721         platform_profile_remove();
3722
3723     kfree(asus);
3724     return 0;
3725 }
3726
3727 /* Platform driver - hibernate/resume callbacks *******************************/
3728
3729 static int asus_hotk_thaw(struct device *device)
3730 {
3731     struct asus_wmi *asus = dev_get_drvdata(device);
3732
3733     if (asus->wlan.rfkill) {
3734         bool wlan;
3735
3736         /*
3737          * Work around bios bug - acpi _PTS turns off the wireless led
3738          * during suspend.  Normally it restores it on resume, but
3739          * we should kick it ourselves in case hibernation is aborted.
3740          */
3741         wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
3742         asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
3743     }
3744
3745     return 0;
3746 }
3747
3748 static int asus_hotk_resume(struct device *device)
3749 {
3750     struct asus_wmi *asus = dev_get_drvdata(device);
3751
3752     if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
3753         kbd_led_update(asus);
3754
3755     if (asus_wmi_has_fnlock_key(asus))
3756         asus_wmi_fnlock_update(asus);
3757
3758     if (asus->driver->quirks->use_lid_flip_devid)
3759         lid_flip_tablet_mode_get_state(asus);
3760
3761     return 0;
3762 }
3763
3764 static int asus_hotk_restore(struct device *device)
3765 {
3766     struct asus_wmi *asus = dev_get_drvdata(device);
3767     int bl;
3768
3769     /* Refresh both wlan rfkill state and pci hotplug */
3770     if (asus->wlan.rfkill)
3771         asus_rfkill_hotplug(asus);
3772
3773     if (asus->bluetooth.rfkill) {
3774         bl = !asus_wmi_get_devstate_simple(asus,
3775                            ASUS_WMI_DEVID_BLUETOOTH);
3776         rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
3777     }
3778     if (asus->wimax.rfkill) {
3779         bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
3780         rfkill_set_sw_state(asus->wimax.rfkill, bl);
3781     }
3782     if (asus->wwan3g.rfkill) {
3783         bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
3784         rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
3785     }
3786     if (asus->gps.rfkill) {
3787         bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS);
3788         rfkill_set_sw_state(asus->gps.rfkill, bl);
3789     }
3790     if (asus->uwb.rfkill) {
3791         bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB);
3792         rfkill_set_sw_state(asus->uwb.rfkill, bl);
3793     }
3794     if (!IS_ERR_OR_NULL(asus->kbd_led.dev))
3795         kbd_led_update(asus);
3796
3797     if (asus_wmi_has_fnlock_key(asus))
3798         asus_wmi_fnlock_update(asus);
3799
3800     if (asus->driver->quirks->use_lid_flip_devid)
3801         lid_flip_tablet_mode_get_state(asus);
3802
3803     return 0;
3804 }
3805
3806 static const struct dev_pm_ops asus_pm_ops = {
3807     .thaw = asus_hotk_thaw,
3808     .restore = asus_hotk_restore,
3809     .resume = asus_hotk_resume,
3810 };
3811
3812 /* Registration ***************************************************************/
3813
3814 static int asus_wmi_probe(struct platform_device *pdev)
3815 {
3816     struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
3817     struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
3818     int ret;
3819
3820     if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
3821         pr_warn("ASUS Management GUID not found\n");
3822         return -ENODEV;
3823     }
3824
3825     if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
3826         pr_warn("ASUS Event GUID not found\n");
3827         return -ENODEV;
3828     }
3829
3830     if (wdrv->probe) {
3831         ret = wdrv->probe(pdev);
3832         if (ret)
3833             return ret;
3834     }
3835
3836     return asus_wmi_add(pdev);
3837 }
3838
3839 static bool used;
3840
3841 int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
3842 {
3843     struct platform_driver *platform_driver;
3844     struct platform_device *platform_device;
3845
3846     if (used)
3847         return -EBUSY;
3848
3849     platform_driver = &driver->platform_driver;
3850     platform_driver->remove = asus_wmi_remove;
3851     platform_driver->driver.owner = driver->owner;
3852     platform_driver->driver.name = driver->name;
3853     platform_driver->driver.pm = &asus_pm_ops;
3854
3855     platform_device = platform_create_bundle(platform_driver,
3856                          asus_wmi_probe,
3857                          NULL, 0, NULL, 0);
3858     if (IS_ERR(platform_device))
3859         return PTR_ERR(platform_device);
3860
3861     used = true;
3862     return 0;
3863 }
3864 EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
3865
3866 void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
3867 {
3868     platform_device_unregister(driver->platform_device);
3869     platform_driver_unregister(&driver->platform_driver);
3870     used = false;
3871 }
3872 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
3873
3874 static int __init asus_wmi_init(void)
3875 {
3876     pr_info("ASUS WMI generic driver loaded\n");
3877     return 0;
3878 }
3879
3880 static void __exit asus_wmi_exit(void)
3881 {
3882     pr_info("ASUS WMI generic driver unloaded\n");
3883 }
3884
3885 module_init(asus_wmi_init);
3886 module_exit(asus_wmi_exit);