drivers/platform/x86/asus-wmi.c

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