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