drivers/platform/x86/asus-wmi.c

   1 /*
   2  * Asus PC WMI hotkey driver
   3  *
   4  * Copyright(C) 2010 Intel Corporation.
   5  * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com>
   6  *
   7  * Portions based on wistron_btns.c:
   8  * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz>
   9  * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org>
  10  * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru>
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  */
  26
  27 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  28
  29 #include <linux/kernel.h>
  30 #include <linux/module.h>
  31 #include <linux/init.h>
  32 #include <linux/types.h>
  33 #include <linux/slab.h>
  34 #include <linux/input.h>
  35 #include <linux/input/sparse-keymap.h>
  36 #include <linux/fb.h>
  37 #include <linux/backlight.h>
  38 #include <linux/leds.h>
  39 #include <linux/rfkill.h>
  40 #include <linux/pci.h>
  41 #include <linux/pci_hotplug.h>
  42 #include <linux/hwmon.h>
  43 #include <linux/hwmon-sysfs.h>
  44 #include <linux/debugfs.h>
  45 #include <linux/seq_file.h>
  46 #include <linux/platform_device.h>
  47 #include <acpi/acpi_bus.h>
  48 #include <acpi/acpi_drivers.h>
  49
  50 #include "asus-wmi.h"
  51
  52 MODULE_AUTHOR("Corentin Chary <corentincj@iksaif.net>, "
  53               "Yong Wang <yong.y.wang@intel.com>");
  54 MODULE_DESCRIPTION("Asus Generic WMI Driver");
  55 MODULE_LICENSE("GPL");
  56
  57 #define to_platform_driver(drv)                                 \
  58         (container_of((drv), struct platform_driver, driver))
  59
  60 #define to_asus_wmi_driver(pdrv)                                        \
  61         (container_of((pdrv), struct asus_wmi_driver, platform_driver))
  62
  63 #define ASUS_WMI_MGMT_GUID      "97845ED0-4E6D-11DE-8A39-0800200C9A66"
  64
  65 #define NOTIFY_BRNUP_MIN                0x11
  66 #define NOTIFY_BRNUP_MAX                0x1f
  67 #define NOTIFY_BRNDOWN_MIN              0x20
  68 #define NOTIFY_BRNDOWN_MAX              0x2e
  69 #define NOTIFY_KBD_BRTUP                0xc4
  70 #define NOTIFY_KBD_BRTDWN               0xc5
  71
  72 /* WMI Methods */
  73 #define ASUS_WMI_METHODID_SPEC          0x43455053 /* BIOS SPECification */
  74 #define ASUS_WMI_METHODID_SFBD          0x44424653 /* Set First Boot Device */
  75 #define ASUS_WMI_METHODID_GLCD          0x44434C47 /* Get LCD status */
  76 #define ASUS_WMI_METHODID_GPID          0x44495047 /* Get Panel ID?? (Resol) */
  77 #define ASUS_WMI_METHODID_QMOD          0x444F4D51 /* Quiet MODe */
  78 #define ASUS_WMI_METHODID_SPLV          0x4C425053 /* Set Panel Light Value */
  79 #define ASUS_WMI_METHODID_SFUN          0x4E554653 /* FUNCtionalities */
  80 #define ASUS_WMI_METHODID_SDSP          0x50534453 /* Set DiSPlay output */
  81 #define ASUS_WMI_METHODID_GDSP          0x50534447 /* Get DiSPlay output */
  82 #define ASUS_WMI_METHODID_DEVP          0x50564544 /* DEVice Policy */
  83 #define ASUS_WMI_METHODID_OSVR          0x5256534F /* OS VeRsion */
  84 #define ASUS_WMI_METHODID_DSTS          0x53544344 /* Device STatuS */
  85 #define ASUS_WMI_METHODID_DSTS2         0x53545344 /* Device STatuS #2*/
  86 #define ASUS_WMI_METHODID_BSTS          0x53545342 /* Bios STatuS ? */
  87 #define ASUS_WMI_METHODID_DEVS          0x53564544 /* DEVice Set */
  88 #define ASUS_WMI_METHODID_CFVS          0x53564643 /* CPU Frequency Volt Set */
  89 #define ASUS_WMI_METHODID_KBFT          0x5446424B /* KeyBoard FilTer */
  90 #define ASUS_WMI_METHODID_INIT          0x54494E49 /* INITialize */
  91 #define ASUS_WMI_METHODID_HKEY          0x59454B48 /* Hot KEY ?? */
  92
  93 #define ASUS_WMI_UNSUPPORTED_METHOD     0xFFFFFFFE
  94
  95 /* Wireless */
  96 #define ASUS_WMI_DEVID_HW_SWITCH        0x00010001
  97 #define ASUS_WMI_DEVID_WIRELESS_LED     0x00010002
  98 #define ASUS_WMI_DEVID_CWAP             0x00010003
  99 #define ASUS_WMI_DEVID_WLAN             0x00010011
 100 #define ASUS_WMI_DEVID_BLUETOOTH        0x00010013
 101 #define ASUS_WMI_DEVID_GPS              0x00010015
 102 #define ASUS_WMI_DEVID_WIMAX            0x00010017
 103 #define ASUS_WMI_DEVID_WWAN3G           0x00010019
 104 #define ASUS_WMI_DEVID_UWB              0x00010021
 105
 106 /* Leds */
 107 /* 0x000200XX and 0x000400XX */
 108 #define ASUS_WMI_DEVID_LED1             0x00020011
 109 #define ASUS_WMI_DEVID_LED2             0x00020012
 110 #define ASUS_WMI_DEVID_LED3             0x00020013
 111 #define ASUS_WMI_DEVID_LED4             0x00020014
 112 #define ASUS_WMI_DEVID_LED5             0x00020015
 113 #define ASUS_WMI_DEVID_LED6             0x00020016
 114
 115 /* Backlight and Brightness */
 116 #define ASUS_WMI_DEVID_BACKLIGHT        0x00050011
 117 #define ASUS_WMI_DEVID_BRIGHTNESS       0x00050012
 118 #define ASUS_WMI_DEVID_KBD_BACKLIGHT    0x00050021
 119 #define ASUS_WMI_DEVID_LIGHT_SENSOR     0x00050022 /* ?? */
 120
 121 /* Misc */
 122 #define ASUS_WMI_DEVID_CAMERA           0x00060013
 123
 124 /* Storage */
 125 #define ASUS_WMI_DEVID_CARDREADER       0x00080013
 126
 127 /* Input */
 128 #define ASUS_WMI_DEVID_TOUCHPAD         0x00100011
 129 #define ASUS_WMI_DEVID_TOUCHPAD_LED     0x00100012
 130
 131 /* Fan, Thermal */
 132 #define ASUS_WMI_DEVID_THERMAL_CTRL     0x00110011
 133 #define ASUS_WMI_DEVID_FAN_CTRL         0x00110012
 134
 135 /* Power */
 136 #define ASUS_WMI_DEVID_PROCESSOR_STATE  0x00120012
 137
 138 /* DSTS masks */
 139 #define ASUS_WMI_DSTS_STATUS_BIT        0x00000001
 140 #define ASUS_WMI_DSTS_UNKNOWN_BIT       0x00000002
 141 #define ASUS_WMI_DSTS_PRESENCE_BIT      0x00010000
 142 #define ASUS_WMI_DSTS_USER_BIT          0x00020000
 143 #define ASUS_WMI_DSTS_BIOS_BIT          0x00040000
 144 #define ASUS_WMI_DSTS_BRIGHTNESS_MASK   0x000000FF
 145 #define ASUS_WMI_DSTS_MAX_BRIGTH_MASK   0x0000FF00
 146
 147 struct bios_args {
 148         u32 arg0;
 149         u32 arg1;
 150 } __packed;
 151
 152 /*
 153  * <platform>/    - debugfs root directory
 154  *   dev_id      - current dev_id
 155  *   ctrl_param  - current ctrl_param
 156  *   method_id   - current method_id
 157  *   devs        - call DEVS(dev_id, ctrl_param) and print result
 158  *   dsts        - call DSTS(dev_id)  and print result
 159  *   call        - call method_id(dev_id, ctrl_param) and print result
 160  */
 161 struct asus_wmi_debug {
 162         struct dentry *root;
 163         u32 method_id;
 164         u32 dev_id;
 165         u32 ctrl_param;
 166 };
 167
 168 struct asus_rfkill {
 169         struct asus_wmi *asus;
 170         struct rfkill *rfkill;
 171         u32 dev_id;
 172 };
 173
 174 struct asus_wmi {
 175         int dsts_id;
 176         int spec;
 177         int sfun;
 178
 179         struct input_dev *inputdev;
 180         struct backlight_device *backlight_device;
 181         struct device *hwmon_device;
 182         struct platform_device *platform_device;
 183
 184         struct led_classdev tpd_led;
 185         int tpd_led_wk;
 186         struct led_classdev kbd_led;
 187         int kbd_led_wk;
 188         struct workqueue_struct *led_workqueue;
 189         struct work_struct tpd_led_work;
 190         struct work_struct kbd_led_work;
 191
 192         struct asus_rfkill wlan;
 193         struct asus_rfkill bluetooth;
 194         struct asus_rfkill wimax;
 195         struct asus_rfkill wwan3g;
 196
 197         struct hotplug_slot *hotplug_slot;
 198         struct mutex hotplug_lock;
 199         struct mutex wmi_lock;
 200         struct workqueue_struct *hotplug_workqueue;
 201         struct work_struct hotplug_work;
 202
 203         struct asus_wmi_debug debug;
 204
 205         struct asus_wmi_driver *driver;
 206 };
 207
 208 static int asus_wmi_input_init(struct asus_wmi *asus)
 209 {
 210         int err;
 211
 212         asus->inputdev = input_allocate_device();
 213         if (!asus->inputdev)
 214                 return -ENOMEM;
 215
 216         asus->inputdev->name = asus->driver->input_name;
 217         asus->inputdev->phys = asus->driver->input_phys;
 218         asus->inputdev->id.bustype = BUS_HOST;
 219         asus->inputdev->dev.parent = &asus->platform_device->dev;
 220         set_bit(EV_REP, asus->inputdev->evbit);
 221
 222         err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL);
 223         if (err)
 224                 goto err_free_dev;
 225
 226         err = input_register_device(asus->inputdev);
 227         if (err)
 228                 goto err_free_keymap;
 229
 230         return 0;
 231
 232 err_free_keymap:
 233         sparse_keymap_free(asus->inputdev);
 234 err_free_dev:
 235         input_free_device(asus->inputdev);
 236         return err;
 237 }
 238
 239 static void asus_wmi_input_exit(struct asus_wmi *asus)
 240 {
 241         if (asus->inputdev) {
 242                 sparse_keymap_free(asus->inputdev);
 243                 input_unregister_device(asus->inputdev);
 244         }
 245
 246         asus->inputdev = NULL;
 247 }
 248
 249 static int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1,
 250                                     u32 *retval)
 251 {
 252         struct bios_args args = {
 253                 .arg0 = arg0,
 254                 .arg1 = arg1,
 255         };
 256         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
 257         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
 258         acpi_status status;
 259         union acpi_object *obj;
 260         u32 tmp;
 261
 262         status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1, method_id,
 263                                      &input, &output);
 264
 265         if (ACPI_FAILURE(status))
 266                 goto exit;
 267
 268         obj = (union acpi_object *)output.pointer;
 269         if (obj && obj->type == ACPI_TYPE_INTEGER)
 270                 tmp = (u32) obj->integer.value;
 271         else
 272                 tmp = 0;
 273
 274         if (retval)
 275                 *retval = tmp;
 276
 277         kfree(obj);
 278
 279 exit:
 280         if (ACPI_FAILURE(status))
 281                 return -EIO;
 282
 283         if (tmp == ASUS_WMI_UNSUPPORTED_METHOD)
 284                 return -ENODEV;
 285
 286         return 0;
 287 }
 288
 289 static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval)
 290 {
 291         return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval);
 292 }
 293
 294 static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param,
 295                                  u32 *retval)
 296 {
 297         return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id,
 298                                         ctrl_param, retval);
 299 }
 300
 301 /* Helper for special devices with magic return codes */
 302 static int asus_wmi_get_devstate_bits(struct asus_wmi *asus,
 303                                       u32 dev_id, u32 mask)
 304 {
 305         u32 retval = 0;
 306         int err;
 307
 308         err = asus_wmi_get_devstate(asus, dev_id, &retval);
 309
 310         if (err < 0)
 311                 return err;
 312
 313         if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT))
 314                 return -ENODEV;
 315
 316         if (mask == ASUS_WMI_DSTS_STATUS_BIT) {
 317                 if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT)
 318                         return -ENODEV;
 319         }
 320
 321         return retval & mask;
 322 }
 323
 324 static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id)
 325 {
 326         return asus_wmi_get_devstate_bits(asus, dev_id,
 327                                           ASUS_WMI_DSTS_STATUS_BIT);
 328 }
 329
 330 /*
 331  * LEDs
 332  */
 333 /*
 334  * These functions actually update the LED's, and are called from a
 335  * workqueue. By doing this as separate work rather than when the LED
 336  * subsystem asks, we avoid messing with the Asus ACPI stuff during a
 337  * potentially bad time, such as a timer interrupt.
 338  */
 339 static void tpd_led_update(struct work_struct *work)
 340 {
 341         int ctrl_param;
 342         struct asus_wmi *asus;
 343
 344         asus = container_of(work, struct asus_wmi, tpd_led_work);
 345
 346         ctrl_param = asus->tpd_led_wk;
 347         asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL);
 348 }
 349
 350 static void tpd_led_set(struct led_classdev *led_cdev,
 351                         enum led_brightness value)
 352 {
 353         struct asus_wmi *asus;
 354
 355         asus = container_of(led_cdev, struct asus_wmi, tpd_led);
 356
 357         asus->tpd_led_wk = !!value;
 358         queue_work(asus->led_workqueue, &asus->tpd_led_work);
 359 }
 360
 361 static int read_tpd_led_state(struct asus_wmi *asus)
 362 {
 363         return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED);
 364 }
 365
 366 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev)
 367 {
 368         struct asus_wmi *asus;
 369
 370         asus = container_of(led_cdev, struct asus_wmi, tpd_led);
 371
 372         return read_tpd_led_state(asus);
 373 }
 374
 375 static void kbd_led_update(struct work_struct *work)
 376 {
 377         int ctrl_param = 0;
 378         struct asus_wmi *asus;
 379
 380         asus = container_of(work, struct asus_wmi, kbd_led_work);
 381
 382         /*
 383          * bits 0-2: level
 384          * bit 7: light on/off
 385          */
 386         if (asus->kbd_led_wk > 0)
 387                 ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F);
 388
 389         asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL);
 390 }
 391
 392 static int kbd_led_read(struct asus_wmi *asus, int *level, int *env)
 393 {
 394         int retval;
 395
 396         /*
 397          * bits 0-2: level
 398          * bit 7: light on/off
 399          * bit 8-10: environment (0: dark, 1: normal, 2: light)
 400          * bit 17: status unknown
 401          */
 402         retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT,
 403                                             0xFFFF);
 404
 405         /* Unknown status is considered as off */
 406         if (retval == 0x8000)
 407                 retval = 0;
 408
 409         if (retval >= 0) {
 410                 if (level)
 411                         *level = retval & 0x80 ? retval & 0x7F : 0;
 412                 if (env)
 413                         *env = (retval >> 8) & 0x7F;
 414                 retval = 0;
 415         }
 416
 417         return retval;
 418 }
 419
 420 static void kbd_led_set(struct led_classdev *led_cdev,
 421                         enum led_brightness value)
 422 {
 423         struct asus_wmi *asus;
 424
 425         asus = container_of(led_cdev, struct asus_wmi, kbd_led);
 426
 427         if (value > asus->kbd_led.max_brightness)
 428                 value = asus->kbd_led.max_brightness;
 429         else if (value < 0)
 430                 value = 0;
 431
 432         asus->kbd_led_wk = value;
 433         queue_work(asus->led_workqueue, &asus->kbd_led_work);
 434 }
 435
 436 static enum led_brightness kbd_led_get(struct led_classdev *led_cdev)
 437 {
 438         struct asus_wmi *asus;
 439         int retval, value;
 440
 441         asus = container_of(led_cdev, struct asus_wmi, kbd_led);
 442
 443         retval = kbd_led_read(asus, &value, NULL);
 444
 445         if (retval < 0)
 446                 return retval;
 447
 448         return value;
 449 }
 450
 451 static void asus_wmi_led_exit(struct asus_wmi *asus)
 452 {
 453         if (asus->tpd_led.dev)
 454                 led_classdev_unregister(&asus->tpd_led);
 455         if (asus->led_workqueue)
 456                 destroy_workqueue(asus->led_workqueue);
 457 }
 458
 459 static int asus_wmi_led_init(struct asus_wmi *asus)
 460 {
 461         int rv = 0;
 462
 463         asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
 464         if (!asus->led_workqueue)
 465                 return -ENOMEM;
 466
 467         if (read_tpd_led_state(asus) >= 0) {
 468                 INIT_WORK(&asus->tpd_led_work, tpd_led_update);
 469
 470                 asus->tpd_led.name = "asus::touchpad";
 471                 asus->tpd_led.brightness_set = tpd_led_set;
 472                 asus->tpd_led.brightness_get = tpd_led_get;
 473                 asus->tpd_led.max_brightness = 1;
 474
 475                 rv = led_classdev_register(&asus->platform_device->dev,
 476                                            &asus->tpd_led);
 477                 if (rv)
 478                         goto error;
 479         }
 480
 481         if (kbd_led_read(asus, NULL, NULL) >= 0) {
 482                 INIT_WORK(&asus->kbd_led_work, kbd_led_update);
 483
 484                 asus->kbd_led.name = "asus::kbd_backlight";
 485                 asus->kbd_led.brightness_set = kbd_led_set;
 486                 asus->kbd_led.brightness_get = kbd_led_get;
 487                 asus->kbd_led.max_brightness = 3;
 488
 489                 rv = led_classdev_register(&asus->platform_device->dev,
 490                                            &asus->kbd_led);
 491         }
 492
 493 error:
 494         if (rv)
 495                 asus_wmi_led_exit(asus);
 496
 497         return rv;
 498 }
 499
 500
 501 /*
 502  * PCI hotplug (for wlan rfkill)
 503  */
 504 static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus)
 505 {
 506         int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
 507
 508         if (result < 0)
 509                 return false;
 510         return !result;
 511 }
 512
 513 static void asus_rfkill_hotplug(struct asus_wmi *asus)
 514 {
 515         struct pci_dev *dev;
 516         struct pci_bus *bus;
 517         bool blocked;
 518         bool absent;
 519         u32 l;
 520
 521         mutex_lock(&asus->wmi_lock);
 522         blocked = asus_wlan_rfkill_blocked(asus);
 523         mutex_unlock(&asus->wmi_lock);
 524
 525         mutex_lock(&asus->hotplug_lock);
 526
 527         if (asus->wlan.rfkill)
 528                 rfkill_set_sw_state(asus->wlan.rfkill, blocked);
 529
 530         if (asus->hotplug_slot) {
 531                 bus = pci_find_bus(0, 1);
 532                 if (!bus) {
 533                         pr_warn("Unable to find PCI bus 1?\n");
 534                         goto out_unlock;
 535                 }
 536
 537                 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) {
 538                         pr_err("Unable to read PCI config space?\n");
 539                         goto out_unlock;
 540                 }
 541                 absent = (l == 0xffffffff);
 542
 543                 if (blocked != absent) {
 544                         pr_warn("BIOS says wireless lan is %s, "
 545                                 "but the pci device is %s\n",
 546                                 blocked ? "blocked" : "unblocked",
 547                                 absent ? "absent" : "present");
 548                         pr_warn("skipped wireless hotplug as probably "
 549                                 "inappropriate for this model\n");
 550                         goto out_unlock;
 551                 }
 552
 553                 if (!blocked) {
 554                         dev = pci_get_slot(bus, 0);
 555                         if (dev) {
 556                                 /* Device already present */
 557                                 pci_dev_put(dev);
 558                                 goto out_unlock;
 559                         }
 560                         dev = pci_scan_single_device(bus, 0);
 561                         if (dev) {
 562                                 pci_bus_assign_resources(bus);
 563                                 if (pci_bus_add_device(dev))
 564                                         pr_err("Unable to hotplug wifi\n");
 565                         }
 566                 } else {
 567                         dev = pci_get_slot(bus, 0);
 568                         if (dev) {
 569                                 pci_remove_bus_device(dev);
 570                                 pci_dev_put(dev);
 571                         }
 572                 }
 573         }
 574
 575 out_unlock:
 576         mutex_unlock(&asus->hotplug_lock);
 577 }
 578
 579 static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data)
 580 {
 581         struct asus_wmi *asus = data;
 582
 583         if (event != ACPI_NOTIFY_BUS_CHECK)
 584                 return;
 585
 586         /*
 587          * We can't call directly asus_rfkill_hotplug because most
 588          * of the time WMBC is still being executed and not reetrant.
 589          * There is currently no way to tell ACPICA that  we want this
 590          * method to be serialized, we schedule a asus_rfkill_hotplug
 591          * call later, in a safer context.
 592          */
 593         queue_work(asus->hotplug_workqueue, &asus->hotplug_work);
 594 }
 595
 596 static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node)
 597 {
 598         acpi_status status;
 599         acpi_handle handle;
 600
 601         status = acpi_get_handle(NULL, node, &handle);
 602
 603         if (ACPI_SUCCESS(status)) {
 604                 status = acpi_install_notify_handler(handle,
 605                                                      ACPI_SYSTEM_NOTIFY,
 606                                                      asus_rfkill_notify, asus);
 607                 if (ACPI_FAILURE(status))
 608                         pr_warn("Failed to register notify on %s\n", node);
 609         } else
 610                 return -ENODEV;
 611
 612         return 0;
 613 }
 614
 615 static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node)
 616 {
 617         acpi_status status = AE_OK;
 618         acpi_handle handle;
 619
 620         status = acpi_get_handle(NULL, node, &handle);
 621
 622         if (ACPI_SUCCESS(status)) {
 623                 status = acpi_remove_notify_handler(handle,
 624                                                     ACPI_SYSTEM_NOTIFY,
 625                                                     asus_rfkill_notify);
 626                 if (ACPI_FAILURE(status))
 627                         pr_err("Error removing rfkill notify handler %s\n",
 628                                node);
 629         }
 630 }
 631
 632 static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot,
 633                                    u8 *value)
 634 {
 635         struct asus_wmi *asus = hotplug_slot->private;
 636         int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
 637
 638         if (result < 0)
 639                 return result;
 640
 641         *value = !!result;
 642         return 0;
 643 }
 644
 645 static void asus_cleanup_pci_hotplug(struct hotplug_slot *hotplug_slot)
 646 {
 647         kfree(hotplug_slot->info);
 648         kfree(hotplug_slot);
 649 }
 650
 651 static struct hotplug_slot_ops asus_hotplug_slot_ops = {
 652         .owner = THIS_MODULE,
 653         .get_adapter_status = asus_get_adapter_status,
 654         .get_power_status = asus_get_adapter_status,
 655 };
 656
 657 static void asus_hotplug_work(struct work_struct *work)
 658 {
 659         struct asus_wmi *asus;
 660
 661         asus = container_of(work, struct asus_wmi, hotplug_work);
 662         asus_rfkill_hotplug(asus);
 663 }
 664
 665 static int asus_setup_pci_hotplug(struct asus_wmi *asus)
 666 {
 667         int ret = -ENOMEM;
 668         struct pci_bus *bus = pci_find_bus(0, 1);
 669
 670         if (!bus) {
 671                 pr_err("Unable to find wifi PCI bus\n");
 672                 return -ENODEV;
 673         }
 674
 675         asus->hotplug_workqueue =
 676             create_singlethread_workqueue("hotplug_workqueue");
 677         if (!asus->hotplug_workqueue)
 678                 goto error_workqueue;
 679
 680         INIT_WORK(&asus->hotplug_work, asus_hotplug_work);
 681
 682         asus->hotplug_slot = kzalloc(sizeof(struct hotplug_slot), GFP_KERNEL);
 683         if (!asus->hotplug_slot)
 684                 goto error_slot;
 685
 686         asus->hotplug_slot->info = kzalloc(sizeof(struct hotplug_slot_info),
 687                                            GFP_KERNEL);
 688         if (!asus->hotplug_slot->info)
 689                 goto error_info;
 690
 691         asus->hotplug_slot->private = asus;
 692         asus->hotplug_slot->release = &asus_cleanup_pci_hotplug;
 693         asus->hotplug_slot->ops = &asus_hotplug_slot_ops;
 694         asus_get_adapter_status(asus->hotplug_slot,
 695                                 &asus->hotplug_slot->info->adapter_status);
 696
 697         ret = pci_hp_register(asus->hotplug_slot, bus, 0, "asus-wifi");
 698         if (ret) {
 699                 pr_err("Unable to register hotplug slot - %d\n", ret);
 700                 goto error_register;
 701         }
 702
 703         return 0;
 704
 705 error_register:
 706         kfree(asus->hotplug_slot->info);
 707 error_info:
 708         kfree(asus->hotplug_slot);
 709         asus->hotplug_slot = NULL;
 710 error_slot:
 711         destroy_workqueue(asus->hotplug_workqueue);
 712 error_workqueue:
 713         return ret;
 714 }
 715
 716 /*
 717  * Rfkill devices
 718  */
 719 static int asus_rfkill_set(void *data, bool blocked)
 720 {
 721         struct asus_rfkill *priv = data;
 722         u32 ctrl_param = !blocked;
 723
 724         return asus_wmi_set_devstate(priv->dev_id, ctrl_param, NULL);
 725 }
 726
 727 static void asus_rfkill_query(struct rfkill *rfkill, void *data)
 728 {
 729         struct asus_rfkill *priv = data;
 730         int result;
 731
 732         result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id);
 733
 734         if (result < 0)
 735                 return;
 736
 737         rfkill_set_sw_state(priv->rfkill, !result);
 738 }
 739
 740 static int asus_rfkill_wlan_set(void *data, bool blocked)
 741 {
 742         struct asus_rfkill *priv = data;
 743         struct asus_wmi *asus = priv->asus;
 744         int ret;
 745
 746         /*
 747          * This handler is enabled only if hotplug is enabled.
 748          * In this case, the asus_wmi_set_devstate() will
 749          * trigger a wmi notification and we need to wait
 750          * this call to finish before being able to call
 751          * any wmi method
 752          */
 753         mutex_lock(&asus->wmi_lock);
 754         ret = asus_rfkill_set(data, blocked);
 755         mutex_unlock(&asus->wmi_lock);
 756         return ret;
 757 }
 758
 759 static const struct rfkill_ops asus_rfkill_wlan_ops = {
 760         .set_block = asus_rfkill_wlan_set,
 761         .query = asus_rfkill_query,
 762 };
 763
 764 static const struct rfkill_ops asus_rfkill_ops = {
 765         .set_block = asus_rfkill_set,
 766         .query = asus_rfkill_query,
 767 };
 768
 769 static int asus_new_rfkill(struct asus_wmi *asus,
 770                            struct asus_rfkill *arfkill,
 771                            const char *name, enum rfkill_type type, int dev_id)
 772 {
 773         int result = asus_wmi_get_devstate_simple(asus, dev_id);
 774         struct rfkill **rfkill = &arfkill->rfkill;
 775
 776         if (result < 0)
 777                 return result;
 778
 779         arfkill->dev_id = dev_id;
 780         arfkill->asus = asus;
 781
 782         if (dev_id == ASUS_WMI_DEVID_WLAN && asus->driver->hotplug_wireless)
 783                 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
 784                                        &asus_rfkill_wlan_ops, arfkill);
 785         else
 786                 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type,
 787                                        &asus_rfkill_ops, arfkill);
 788
 789         if (!*rfkill)
 790                 return -EINVAL;
 791
 792         rfkill_init_sw_state(*rfkill, !result);
 793         result = rfkill_register(*rfkill);
 794         if (result) {
 795                 rfkill_destroy(*rfkill);
 796                 *rfkill = NULL;
 797                 return result;
 798         }
 799         return 0;
 800 }
 801
 802 static void asus_wmi_rfkill_exit(struct asus_wmi *asus)
 803 {
 804         asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
 805         asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
 806         asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
 807         if (asus->wlan.rfkill) {
 808                 rfkill_unregister(asus->wlan.rfkill);
 809                 rfkill_destroy(asus->wlan.rfkill);
 810                 asus->wlan.rfkill = NULL;
 811         }
 812         /*
 813          * Refresh pci hotplug in case the rfkill state was changed after
 814          * asus_unregister_rfkill_notifier()
 815          */
 816         asus_rfkill_hotplug(asus);
 817         if (asus->hotplug_slot)
 818                 pci_hp_deregister(asus->hotplug_slot);
 819         if (asus->hotplug_workqueue)
 820                 destroy_workqueue(asus->hotplug_workqueue);
 821
 822         if (asus->bluetooth.rfkill) {
 823                 rfkill_unregister(asus->bluetooth.rfkill);
 824                 rfkill_destroy(asus->bluetooth.rfkill);
 825                 asus->bluetooth.rfkill = NULL;
 826         }
 827         if (asus->wimax.rfkill) {
 828                 rfkill_unregister(asus->wimax.rfkill);
 829                 rfkill_destroy(asus->wimax.rfkill);
 830                 asus->wimax.rfkill = NULL;
 831         }
 832         if (asus->wwan3g.rfkill) {
 833                 rfkill_unregister(asus->wwan3g.rfkill);
 834                 rfkill_destroy(asus->wwan3g.rfkill);
 835                 asus->wwan3g.rfkill = NULL;
 836         }
 837 }
 838
 839 static int asus_wmi_rfkill_init(struct asus_wmi *asus)
 840 {
 841         int result = 0;
 842
 843         mutex_init(&asus->hotplug_lock);
 844         mutex_init(&asus->wmi_lock);
 845
 846         result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan",
 847                                  RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN);
 848
 849         if (result && result != -ENODEV)
 850                 goto exit;
 851
 852         result = asus_new_rfkill(asus, &asus->bluetooth,
 853                                  "asus-bluetooth", RFKILL_TYPE_BLUETOOTH,
 854                                  ASUS_WMI_DEVID_BLUETOOTH);
 855
 856         if (result && result != -ENODEV)
 857                 goto exit;
 858
 859         result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax",
 860                                  RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX);
 861
 862         if (result && result != -ENODEV)
 863                 goto exit;
 864
 865         result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g",
 866                                  RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G);
 867
 868         if (result && result != -ENODEV)
 869                 goto exit;
 870
 871         if (!asus->driver->hotplug_wireless)
 872                 goto exit;
 873
 874         result = asus_setup_pci_hotplug(asus);
 875         /*
 876          * If we get -EBUSY then something else is handling the PCI hotplug -
 877          * don't fail in this case
 878          */
 879         if (result == -EBUSY)
 880                 result = 0;
 881
 882         asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5");
 883         asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6");
 884         asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7");
 885         /*
 886          * Refresh pci hotplug in case the rfkill state was changed during
 887          * setup.
 888          */
 889         asus_rfkill_hotplug(asus);
 890
 891 exit:
 892         if (result && result != -ENODEV)
 893                 asus_wmi_rfkill_exit(asus);
 894
 895         if (result == -ENODEV)
 896                 result = 0;
 897
 898         return result;
 899 }
 900
 901 /*
 902  * Hwmon device
 903  */
 904 static ssize_t asus_hwmon_pwm1(struct device *dev,
 905                                struct device_attribute *attr,
 906                                char *buf)
 907 {
 908         struct asus_wmi *asus = dev_get_drvdata(dev);
 909         u32 value;
 910         int err;
 911
 912         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, &value);
 913
 914         if (err < 0)
 915                 return err;
 916
 917         value &= 0xFF;
 918
 919         if (value == 1) /* Low Speed */
 920                 value = 85;
 921         else if (value == 2)
 922                 value = 170;
 923         else if (value == 3)
 924                 value = 255;
 925         else if (value != 0) {
 926                 pr_err("Unknown fan speed %#x", value);
 927                 value = -1;
 928         }
 929
 930         return sprintf(buf, "%d\n", value);
 931 }
 932
 933 static SENSOR_DEVICE_ATTR(pwm1, S_IRUGO, asus_hwmon_pwm1, NULL, 0);
 934
 935 static ssize_t
 936 show_name(struct device *dev, struct device_attribute *attr, char *buf)
 937 {
 938         return sprintf(buf, "asus\n");
 939 }
 940 static SENSOR_DEVICE_ATTR(name, S_IRUGO, show_name, NULL, 0);
 941
 942 static struct attribute *hwmon_attributes[] = {
 943         &sensor_dev_attr_pwm1.dev_attr.attr,
 944         &sensor_dev_attr_name.dev_attr.attr,
 945         NULL
 946 };
 947
 948 static mode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj,
 949                                     struct attribute *attr, int idx)
 950 {
 951         struct device *dev = container_of(kobj, struct device, kobj);
 952         struct platform_device *pdev = to_platform_device(dev->parent);
 953         struct asus_wmi *asus = platform_get_drvdata(pdev);
 954         bool ok = true;
 955         int dev_id = -1;
 956         u32 value = ASUS_WMI_UNSUPPORTED_METHOD;
 957
 958         if (attr == &sensor_dev_attr_pwm1.dev_attr.attr)
 959                 dev_id = ASUS_WMI_DEVID_FAN_CTRL;
 960
 961         if (dev_id != -1) {
 962                 int err = asus_wmi_get_devstate(asus, dev_id, &value);
 963
 964                 if (err < 0)
 965                         return 0; /* can't return negative here */
 966         }
 967
 968         if (dev_id == ASUS_WMI_DEVID_FAN_CTRL) {
 969                 /*
 970                  * We need to find a better way, probably using sfun,
 971                  * bits or spec ...
 972                  * Currently we disable it if:
 973                  * - ASUS_WMI_UNSUPPORTED_METHOD is returned
 974                  * - reverved bits are non-zero
 975                  * - sfun and presence bit are not set
 976                  */
 977                 if (value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000
 978                     || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT)))
 979                         ok = false;
 980         }
 981
 982         return ok ? attr->mode : 0;
 983 }
 984
 985 static struct attribute_group hwmon_attribute_group = {
 986         .is_visible = asus_hwmon_sysfs_is_visible,
 987         .attrs = hwmon_attributes
 988 };
 989
 990 static void asus_wmi_hwmon_exit(struct asus_wmi *asus)
 991 {
 992         struct device *hwmon;
 993
 994         hwmon = asus->hwmon_device;
 995         if (!hwmon)
 996                 return;
 997         sysfs_remove_group(&hwmon->kobj, &hwmon_attribute_group);
 998         hwmon_device_unregister(hwmon);
 999         asus->hwmon_device = NULL;
1000 }
1001
1002 static int asus_wmi_hwmon_init(struct asus_wmi *asus)
1003 {
1004         struct device *hwmon;
1005         int result;
1006
1007         hwmon = hwmon_device_register(&asus->platform_device->dev);
1008         if (IS_ERR(hwmon)) {
1009                 pr_err("Could not register asus hwmon device\n");
1010                 return PTR_ERR(hwmon);
1011         }
1012         dev_set_drvdata(hwmon, asus);
1013         asus->hwmon_device = hwmon;
1014         result = sysfs_create_group(&hwmon->kobj, &hwmon_attribute_group);
1015         if (result)
1016                 asus_wmi_hwmon_exit(asus);
1017         return result;
1018 }
1019
1020 /*
1021  * Backlight
1022  */
1023 static int read_backlight_power(struct asus_wmi *asus)
1024 {
1025         int ret = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_BACKLIGHT);
1026
1027         if (ret < 0)
1028                 return ret;
1029
1030         return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN;
1031 }
1032
1033 static int read_brightness_max(struct asus_wmi *asus)
1034 {
1035         u32 retval;
1036         int err;
1037
1038         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1039
1040         if (err < 0)
1041                 return err;
1042
1043         retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK;
1044         retval >>= 8;
1045
1046         if (!retval)
1047                 return -ENODEV;
1048
1049         return retval;
1050 }
1051
1052 static int read_brightness(struct backlight_device *bd)
1053 {
1054         struct asus_wmi *asus = bl_get_data(bd);
1055         u32 retval;
1056         int err;
1057
1058         err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval);
1059
1060         if (err < 0)
1061                 return err;
1062
1063         return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK;
1064 }
1065
1066 static int update_bl_status(struct backlight_device *bd)
1067 {
1068         struct asus_wmi *asus = bl_get_data(bd);
1069         u32 ctrl_param;
1070         int power, err;
1071
1072         ctrl_param = bd->props.brightness;
1073
1074         err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS,
1075                                     ctrl_param, NULL);
1076
1077         if (err < 0)
1078                 return err;
1079
1080         power = read_backlight_power(asus);
1081         if (power != -ENODEV && bd->props.power != power) {
1082                 ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK);
1083                 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT,
1084                                             ctrl_param, NULL);
1085         }
1086         return err;
1087 }
1088
1089 static const struct backlight_ops asus_wmi_bl_ops = {
1090         .get_brightness = read_brightness,
1091         .update_status = update_bl_status,
1092 };
1093
1094 static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code)
1095 {
1096         struct backlight_device *bd = asus->backlight_device;
1097         int old = bd->props.brightness;
1098         int new = old;
1099
1100         if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1101                 new = code - NOTIFY_BRNUP_MIN + 1;
1102         else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX)
1103                 new = code - NOTIFY_BRNDOWN_MIN;
1104
1105         bd->props.brightness = new;
1106         backlight_update_status(bd);
1107         backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
1108
1109         return old;
1110 }
1111
1112 static int asus_wmi_backlight_init(struct asus_wmi *asus)
1113 {
1114         struct backlight_device *bd;
1115         struct backlight_properties props;
1116         int max;
1117         int power;
1118
1119         max = read_brightness_max(asus);
1120
1121         if (max == -ENODEV)
1122                 max = 0;
1123         else if (max < 0)
1124                 return max;
1125
1126         power = read_backlight_power(asus);
1127
1128         if (power == -ENODEV)
1129                 power = FB_BLANK_UNBLANK;
1130         else if (power < 0)
1131                 return power;
1132
1133         memset(&props, 0, sizeof(struct backlight_properties));
1134         props.type = BACKLIGHT_PLATFORM;
1135         props.max_brightness = max;
1136         bd = backlight_device_register(asus->driver->name,
1137                                        &asus->platform_device->dev, asus,
1138                                        &asus_wmi_bl_ops, &props);
1139         if (IS_ERR(bd)) {
1140                 pr_err("Could not register backlight device\n");
1141                 return PTR_ERR(bd);
1142         }
1143
1144         asus->backlight_device = bd;
1145
1146         bd->props.brightness = read_brightness(bd);
1147         bd->props.power = power;
1148         backlight_update_status(bd);
1149
1150         return 0;
1151 }
1152
1153 static void asus_wmi_backlight_exit(struct asus_wmi *asus)
1154 {
1155         if (asus->backlight_device)
1156                 backlight_device_unregister(asus->backlight_device);
1157
1158         asus->backlight_device = NULL;
1159 }
1160
1161 static void asus_wmi_notify(u32 value, void *context)
1162 {
1163         struct asus_wmi *asus = context;
1164         struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL };
1165         union acpi_object *obj;
1166         acpi_status status;
1167         int code;
1168         int orig_code;
1169         unsigned int key_value = 1;
1170         bool autorelease = 1;
1171
1172         status = wmi_get_event_data(value, &response);
1173         if (status != AE_OK) {
1174                 pr_err("bad event status 0x%x\n", status);
1175                 return;
1176         }
1177
1178         obj = (union acpi_object *)response.pointer;
1179
1180         if (!obj || obj->type != ACPI_TYPE_INTEGER)
1181                 goto exit;
1182
1183         code = obj->integer.value;
1184         orig_code = code;
1185
1186         if (asus->driver->key_filter) {
1187                 asus->driver->key_filter(asus->driver, &code, &key_value,
1188                                          &autorelease);
1189                 if (code == ASUS_WMI_KEY_IGNORE)
1190                         goto exit;
1191         }
1192
1193         if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX)
1194                 code = NOTIFY_BRNUP_MIN;
1195         else if (code >= NOTIFY_BRNDOWN_MIN &&
1196                  code <= NOTIFY_BRNDOWN_MAX)
1197                 code = NOTIFY_BRNDOWN_MIN;
1198
1199         if (code == NOTIFY_BRNUP_MIN || code == NOTIFY_BRNDOWN_MIN) {
1200                 if (!acpi_video_backlight_support())
1201                         asus_wmi_backlight_notify(asus, orig_code);
1202         } else if (!sparse_keymap_report_event(asus->inputdev, code,
1203                                                key_value, autorelease))
1204                 pr_info("Unknown key %x pressed\n", code);
1205
1206 exit:
1207         kfree(obj);
1208 }
1209
1210 /*
1211  * Sys helpers
1212  */
1213 static int parse_arg(const char *buf, unsigned long count, int *val)
1214 {
1215         if (!count)
1216                 return 0;
1217         if (sscanf(buf, "%i", val) != 1)
1218                 return -EINVAL;
1219         return count;
1220 }
1221
1222 static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid,
1223                              const char *buf, size_t count)
1224 {
1225         u32 retval;
1226         int rv, err, value;
1227
1228         value = asus_wmi_get_devstate_simple(asus, devid);
1229         if (value == -ENODEV)   /* Check device presence */
1230                 return value;
1231
1232         rv = parse_arg(buf, count, &value);
1233         err = asus_wmi_set_devstate(devid, value, &retval);
1234
1235         if (err < 0)
1236                 return err;
1237
1238         return rv;
1239 }
1240
1241 static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf)
1242 {
1243         int value = asus_wmi_get_devstate_simple(asus, devid);
1244
1245         if (value < 0)
1246                 return value;
1247
1248         return sprintf(buf, "%d\n", value);
1249 }
1250
1251 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm)                  \
1252         static ssize_t show_##_name(struct device *dev,                 \
1253                                     struct device_attribute *attr,      \
1254                                     char *buf)                          \
1255         {                                                               \
1256                 struct asus_wmi *asus = dev_get_drvdata(dev);           \
1257                                                                         \
1258                 return show_sys_wmi(asus, _cm, buf);                    \
1259         }                                                               \
1260         static ssize_t store_##_name(struct device *dev,                \
1261                                      struct device_attribute *attr,     \
1262                                      const char *buf, size_t count)     \
1263         {                                                               \
1264                 struct asus_wmi *asus = dev_get_drvdata(dev);           \
1265                                                                         \
1266                 return store_sys_wmi(asus, _cm, buf, count);            \
1267         }                                                               \
1268         static struct device_attribute dev_attr_##_name = {             \
1269                 .attr = {                                               \
1270                         .name = __stringify(_name),                     \
1271                         .mode = _mode },                                \
1272                 .show   = show_##_name,                                 \
1273                 .store  = store_##_name,                                \
1274         }
1275
1276 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD);
1277 ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA);
1278 ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER);
1279
1280 static ssize_t store_cpufv(struct device *dev, struct device_attribute *attr,
1281                            const char *buf, size_t count)
1282 {
1283         int value;
1284
1285         if (!count || sscanf(buf, "%i", &value) != 1)
1286                 return -EINVAL;
1287         if (value < 0 || value > 2)
1288                 return -EINVAL;
1289
1290         return asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL);
1291 }
1292
1293 static DEVICE_ATTR(cpufv, S_IRUGO | S_IWUSR, NULL, store_cpufv);
1294
1295 static struct attribute *platform_attributes[] = {
1296         &dev_attr_cpufv.attr,
1297         &dev_attr_camera.attr,
1298         &dev_attr_cardr.attr,
1299         &dev_attr_touchpad.attr,
1300         NULL
1301 };
1302
1303 static mode_t asus_sysfs_is_visible(struct kobject *kobj,
1304                                     struct attribute *attr, int idx)
1305 {
1306         struct device *dev = container_of(kobj, struct device, kobj);
1307         struct platform_device *pdev = to_platform_device(dev);
1308         struct asus_wmi *asus = platform_get_drvdata(pdev);
1309         bool ok = true;
1310         int devid = -1;
1311
1312         if (attr == &dev_attr_camera.attr)
1313                 devid = ASUS_WMI_DEVID_CAMERA;
1314         else if (attr == &dev_attr_cardr.attr)
1315                 devid = ASUS_WMI_DEVID_CARDREADER;
1316         else if (attr == &dev_attr_touchpad.attr)
1317                 devid = ASUS_WMI_DEVID_TOUCHPAD;
1318
1319         if (devid != -1)
1320                 ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0);
1321
1322         return ok ? attr->mode : 0;
1323 }
1324
1325 static struct attribute_group platform_attribute_group = {
1326         .is_visible = asus_sysfs_is_visible,
1327         .attrs = platform_attributes
1328 };
1329
1330 static void asus_wmi_sysfs_exit(struct platform_device *device)
1331 {
1332         sysfs_remove_group(&device->dev.kobj, &platform_attribute_group);
1333 }
1334
1335 static int asus_wmi_sysfs_init(struct platform_device *device)
1336 {
1337         return sysfs_create_group(&device->dev.kobj, &platform_attribute_group);
1338 }
1339
1340 /*
1341  * Platform device
1342  */
1343 static int asus_wmi_platform_init(struct asus_wmi *asus)
1344 {
1345         int rv;
1346
1347         /* INIT enable hotkeys on some models */
1348         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv))
1349                 pr_info("Initialization: %#x", rv);
1350
1351         /* We don't know yet what to do with this version... */
1352         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) {
1353                 pr_info("BIOS WMI version: %d.%d", rv >> 16, rv & 0xFF);
1354                 asus->spec = rv;
1355         }
1356
1357         /*
1358          * The SFUN method probably allows the original driver to get the list
1359          * of features supported by a given model. For now, 0x0100 or 0x0800
1360          * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
1361          * The significance of others is yet to be found.
1362          */
1363         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) {
1364                 pr_info("SFUN value: %#x", rv);
1365                 asus->sfun = rv;
1366         }
1367
1368         /*
1369          * Eee PC and Notebooks seems to have different method_id for DSTS,
1370          * but it may also be related to the BIOS's SPEC.
1371          * Note, on most Eeepc, there is no way to check if a method exist
1372          * or note, while on notebooks, they returns 0xFFFFFFFE on failure,
1373          * but once again, SPEC may probably be used for that kind of things.
1374          */
1375         if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, 0, 0, NULL))
1376                 asus->dsts_id = ASUS_WMI_METHODID_DSTS;
1377         else if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS2, 0, 0, NULL))
1378                 asus->dsts_id = ASUS_WMI_METHODID_DSTS2;
1379
1380         if (!asus->dsts_id) {
1381                 pr_err("Can't find DSTS");
1382                 return -ENODEV;
1383         }
1384
1385         return asus_wmi_sysfs_init(asus->platform_device);
1386 }
1387
1388 static void asus_wmi_platform_exit(struct asus_wmi *asus)
1389 {
1390         asus_wmi_sysfs_exit(asus->platform_device);
1391 }
1392
1393 /*
1394  * debugfs
1395  */
1396 struct asus_wmi_debugfs_node {
1397         struct asus_wmi *asus;
1398         char *name;
1399         int (*show) (struct seq_file *m, void *data);
1400 };
1401
1402 static int show_dsts(struct seq_file *m, void *data)
1403 {
1404         struct asus_wmi *asus = m->private;
1405         int err;
1406         u32 retval = -1;
1407
1408         err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval);
1409
1410         if (err < 0)
1411                 return err;
1412
1413         seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval);
1414
1415         return 0;
1416 }
1417
1418 static int show_devs(struct seq_file *m, void *data)
1419 {
1420         struct asus_wmi *asus = m->private;
1421         int err;
1422         u32 retval = -1;
1423
1424         err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param,
1425                                     &retval);
1426
1427         if (err < 0)
1428                 return err;
1429
1430         seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id,
1431                    asus->debug.ctrl_param, retval);
1432
1433         return 0;
1434 }
1435
1436 static int show_call(struct seq_file *m, void *data)
1437 {
1438         struct asus_wmi *asus = m->private;
1439         struct bios_args args = {
1440                 .arg0 = asus->debug.dev_id,
1441                 .arg1 = asus->debug.ctrl_param,
1442         };
1443         struct acpi_buffer input = { (acpi_size) sizeof(args), &args };
1444         struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL };
1445         union acpi_object *obj;
1446         acpi_status status;
1447
1448         status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID,
1449                                      1, asus->debug.method_id,
1450                                      &input, &output);
1451
1452         if (ACPI_FAILURE(status))
1453                 return -EIO;
1454
1455         obj = (union acpi_object *)output.pointer;
1456         if (obj && obj->type == ACPI_TYPE_INTEGER)
1457                 seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id,
1458                            asus->debug.dev_id, asus->debug.ctrl_param,
1459                            (u32) obj->integer.value);
1460         else
1461                 seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id,
1462                            asus->debug.dev_id, asus->debug.ctrl_param,
1463                            obj ? obj->type : -1);
1464
1465         kfree(obj);
1466
1467         return 0;
1468 }
1469
1470 static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = {
1471         {NULL, "devs", show_devs},
1472         {NULL, "dsts", show_dsts},
1473         {NULL, "call", show_call},
1474 };
1475
1476 static int asus_wmi_debugfs_open(struct inode *inode, struct file *file)
1477 {
1478         struct asus_wmi_debugfs_node *node = inode->i_private;
1479
1480         return single_open(file, node->show, node->asus);
1481 }
1482
1483 static const struct file_operations asus_wmi_debugfs_io_ops = {
1484         .owner = THIS_MODULE,
1485         .open = asus_wmi_debugfs_open,
1486         .read = seq_read,
1487         .llseek = seq_lseek,
1488         .release = single_release,
1489 };
1490
1491 static void asus_wmi_debugfs_exit(struct asus_wmi *asus)
1492 {
1493         debugfs_remove_recursive(asus->debug.root);
1494 }
1495
1496 static int asus_wmi_debugfs_init(struct asus_wmi *asus)
1497 {
1498         struct dentry *dent;
1499         int i;
1500
1501         asus->debug.root = debugfs_create_dir(asus->driver->name, NULL);
1502         if (!asus->debug.root) {
1503                 pr_err("failed to create debugfs directory");
1504                 goto error_debugfs;
1505         }
1506
1507         dent = debugfs_create_x32("method_id", S_IRUGO | S_IWUSR,
1508                                   asus->debug.root, &asus->debug.method_id);
1509         if (!dent)
1510                 goto error_debugfs;
1511
1512         dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR,
1513                                   asus->debug.root, &asus->debug.dev_id);
1514         if (!dent)
1515                 goto error_debugfs;
1516
1517         dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR,
1518                                   asus->debug.root, &asus->debug.ctrl_param);
1519         if (!dent)
1520                 goto error_debugfs;
1521
1522         for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) {
1523                 struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i];
1524
1525                 node->asus = asus;
1526                 dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO,
1527                                            asus->debug.root, node,
1528                                            &asus_wmi_debugfs_io_ops);
1529                 if (!dent) {
1530                         pr_err("failed to create debug file: %s\n", node->name);
1531                         goto error_debugfs;
1532                 }
1533         }
1534
1535         return 0;
1536
1537 error_debugfs:
1538         asus_wmi_debugfs_exit(asus);
1539         return -ENOMEM;
1540 }
1541
1542 /*
1543  * WMI Driver
1544  */
1545 static int asus_wmi_add(struct platform_device *pdev)
1546 {
1547         struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
1548         struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
1549         struct asus_wmi *asus;
1550         acpi_status status;
1551         int err;
1552
1553         asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL);
1554         if (!asus)
1555                 return -ENOMEM;
1556
1557         asus->driver = wdrv;
1558         asus->platform_device = pdev;
1559         wdrv->platform_device = pdev;
1560         platform_set_drvdata(asus->platform_device, asus);
1561
1562         if (wdrv->quirks)
1563                 wdrv->quirks(asus->driver);
1564
1565         err = asus_wmi_platform_init(asus);
1566         if (err)
1567                 goto fail_platform;
1568
1569         err = asus_wmi_input_init(asus);
1570         if (err)
1571                 goto fail_input;
1572
1573         err = asus_wmi_hwmon_init(asus);
1574         if (err)
1575                 goto fail_hwmon;
1576
1577         err = asus_wmi_led_init(asus);
1578         if (err)
1579                 goto fail_leds;
1580
1581         err = asus_wmi_rfkill_init(asus);
1582         if (err)
1583                 goto fail_rfkill;
1584
1585         if (!acpi_video_backlight_support()) {
1586                 err = asus_wmi_backlight_init(asus);
1587                 if (err && err != -ENODEV)
1588                         goto fail_backlight;
1589         } else
1590                 pr_info("Backlight controlled by ACPI video driver\n");
1591
1592         status = wmi_install_notify_handler(asus->driver->event_guid,
1593                                             asus_wmi_notify, asus);
1594         if (ACPI_FAILURE(status)) {
1595                 pr_err("Unable to register notify handler - %d\n", status);
1596                 err = -ENODEV;
1597                 goto fail_wmi_handler;
1598         }
1599
1600         err = asus_wmi_debugfs_init(asus);
1601         if (err)
1602                 goto fail_debugfs;
1603
1604         return 0;
1605
1606 fail_debugfs:
1607         wmi_remove_notify_handler(asus->driver->event_guid);
1608 fail_wmi_handler:
1609         asus_wmi_backlight_exit(asus);
1610 fail_backlight:
1611         asus_wmi_rfkill_exit(asus);
1612 fail_rfkill:
1613         asus_wmi_led_exit(asus);
1614 fail_leds:
1615         asus_wmi_hwmon_exit(asus);
1616 fail_hwmon:
1617         asus_wmi_input_exit(asus);
1618 fail_input:
1619         asus_wmi_platform_exit(asus);
1620 fail_platform:
1621         kfree(asus);
1622         return err;
1623 }
1624
1625 static int asus_wmi_remove(struct platform_device *device)
1626 {
1627         struct asus_wmi *asus;
1628
1629         asus = platform_get_drvdata(device);
1630         wmi_remove_notify_handler(asus->driver->event_guid);
1631         asus_wmi_backlight_exit(asus);
1632         asus_wmi_input_exit(asus);
1633         asus_wmi_hwmon_exit(asus);
1634         asus_wmi_led_exit(asus);
1635         asus_wmi_rfkill_exit(asus);
1636         asus_wmi_debugfs_exit(asus);
1637         asus_wmi_platform_exit(asus);
1638
1639         kfree(asus);
1640         return 0;
1641 }
1642
1643 /*
1644  * Platform driver - hibernate/resume callbacks
1645  */
1646 static int asus_hotk_thaw(struct device *device)
1647 {
1648         struct asus_wmi *asus = dev_get_drvdata(device);
1649
1650         if (asus->wlan.rfkill) {
1651                 bool wlan;
1652
1653                 /*
1654                  * Work around bios bug - acpi _PTS turns off the wireless led
1655                  * during suspend.  Normally it restores it on resume, but
1656                  * we should kick it ourselves in case hibernation is aborted.
1657                  */
1658                 wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN);
1659                 asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL);
1660         }
1661
1662         return 0;
1663 }
1664
1665 static int asus_hotk_restore(struct device *device)
1666 {
1667         struct asus_wmi *asus = dev_get_drvdata(device);
1668         int bl;
1669
1670         /* Refresh both wlan rfkill state and pci hotplug */
1671         if (asus->wlan.rfkill)
1672                 asus_rfkill_hotplug(asus);
1673
1674         if (asus->bluetooth.rfkill) {
1675                 bl = !asus_wmi_get_devstate_simple(asus,
1676                                                    ASUS_WMI_DEVID_BLUETOOTH);
1677                 rfkill_set_sw_state(asus->bluetooth.rfkill, bl);
1678         }
1679         if (asus->wimax.rfkill) {
1680                 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX);
1681                 rfkill_set_sw_state(asus->wimax.rfkill, bl);
1682         }
1683         if (asus->wwan3g.rfkill) {
1684                 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G);
1685                 rfkill_set_sw_state(asus->wwan3g.rfkill, bl);
1686         }
1687
1688         return 0;
1689 }
1690
1691 static const struct dev_pm_ops asus_pm_ops = {
1692         .thaw = asus_hotk_thaw,
1693         .restore = asus_hotk_restore,
1694 };
1695
1696 static int asus_wmi_probe(struct platform_device *pdev)
1697 {
1698         struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver);
1699         struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv);
1700         int ret;
1701
1702         if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
1703                 pr_warn("Management GUID not found\n");
1704                 return -ENODEV;
1705         }
1706
1707         if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) {
1708                 pr_warn("Event GUID not found\n");
1709                 return -ENODEV;
1710         }
1711
1712         if (wdrv->probe) {
1713                 ret = wdrv->probe(pdev);
1714                 if (ret)
1715                         return ret;
1716         }
1717
1718         return asus_wmi_add(pdev);
1719 }
1720
1721 static bool used;
1722
1723 int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver)
1724 {
1725         struct platform_driver *platform_driver;
1726         struct platform_device *platform_device;
1727
1728         if (used)
1729                 return -EBUSY;
1730
1731         platform_driver = &driver->platform_driver;
1732         platform_driver->remove = asus_wmi_remove;
1733         platform_driver->driver.owner = driver->owner;
1734         platform_driver->driver.name = driver->name;
1735         platform_driver->driver.pm = &asus_pm_ops;
1736
1737         platform_device = platform_create_bundle(platform_driver,
1738                                                  asus_wmi_probe,
1739                                                  NULL, 0, NULL, 0);
1740         if (IS_ERR(platform_device))
1741                 return PTR_ERR(platform_device);
1742
1743         used = true;
1744         return 0;
1745 }
1746 EXPORT_SYMBOL_GPL(asus_wmi_register_driver);
1747
1748 void asus_wmi_unregister_driver(struct asus_wmi_driver *driver)
1749 {
1750         platform_device_unregister(driver->platform_device);
1751         platform_driver_unregister(&driver->platform_driver);
1752         used = false;
1753 }
1754 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver);
1755
1756 static int __init asus_wmi_init(void)
1757 {
1758         if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) {
1759                 pr_info("Asus Management GUID not found");
1760                 return -ENODEV;
1761         }
1762
1763         pr_info("ASUS WMI generic driver loaded");
1764         return 0;
1765 }
1766
1767 static void __exit asus_wmi_exit(void)
1768 {
1769         pr_info("ASUS WMI generic driver unloaded");
1770 }
1771
1772 module_init(asus_wmi_init);
1773 module_exit(asus_wmi_exit);