sys/dev/acpi_support/acpi_asus_wmi.c

   1 /*-
   2  * Copyright (c) 2012 Alexander Motin <mav@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include "opt_acpi.h"
  31 #include <sys/param.h>
  32 #include <sys/conf.h>
  33 #include <sys/uio.h>
  34 #include <sys/proc.h>
  35 #include <sys/kernel.h>
  36 #include <sys/bus.h>
  37 #include <sys/sbuf.h>
  38 #include <sys/module.h>
  39 #include <sys/sysctl.h>
  40
  41 #include <contrib/dev/acpica/include/acpi.h>
  42 #include <contrib/dev/acpica/include/accommon.h>
  43 #include <dev/acpica/acpivar.h>
  44 #include "acpi_wmi_if.h"
  45
  46 #define _COMPONENT      ACPI_OEM
  47 ACPI_MODULE_NAME("ASUS-WMI")
  48
  49 #define ACPI_ASUS_WMI_MGMT_GUID         "97845ED0-4E6D-11DE-8A39-0800200C9A66"
  50 #define ACPI_ASUS_WMI_EVENT_GUID        "0B3CBB35-E3C2-45ED-91C2-4C5A6D195D1C"
  51 #define ACPI_EEEPC_WMI_EVENT_GUID       "ABBC0F72-8EA1-11D1-00A0-C90629100000"
  52
  53 /* WMI Methods */
  54 #define ASUS_WMI_METHODID_SPEC          0x43455053
  55 #define ASUS_WMI_METHODID_SFUN          0x4E554653
  56 #define ASUS_WMI_METHODID_DSTS          0x53544344
  57 #define ASUS_WMI_METHODID_DSTS2         0x53545344
  58 #define ASUS_WMI_METHODID_DEVS          0x53564544
  59 #define ASUS_WMI_METHODID_INIT          0x54494E49
  60 #define ASUS_WMI_METHODID_HKEY          0x59454B48
  61
  62 #define ASUS_WMI_UNSUPPORTED_METHOD     0xFFFFFFFE
  63
  64 /* Wireless */
  65 #define ASUS_WMI_DEVID_HW_SWITCH        0x00010001
  66 #define ASUS_WMI_DEVID_WIRELESS_LED     0x00010002
  67 #define ASUS_WMI_DEVID_CWAP             0x00010003
  68 #define ASUS_WMI_DEVID_WLAN             0x00010011
  69 #define ASUS_WMI_DEVID_BLUETOOTH        0x00010013
  70 #define ASUS_WMI_DEVID_GPS              0x00010015
  71 #define ASUS_WMI_DEVID_WIMAX            0x00010017
  72 #define ASUS_WMI_DEVID_WWAN3G           0x00010019
  73 #define ASUS_WMI_DEVID_UWB              0x00010021
  74
  75 /* LEDs */
  76 #define ASUS_WMI_DEVID_LED1             0x00020011
  77 #define ASUS_WMI_DEVID_LED2             0x00020012
  78 #define ASUS_WMI_DEVID_LED3             0x00020013
  79 #define ASUS_WMI_DEVID_LED4             0x00020014
  80 #define ASUS_WMI_DEVID_LED5             0x00020015
  81 #define ASUS_WMI_DEVID_LED6             0x00020016
  82
  83 /* Backlight and Brightness */
  84 #define ASUS_WMI_DEVID_BACKLIGHT        0x00050011
  85 #define ASUS_WMI_DEVID_BRIGHTNESS       0x00050012
  86 #define ASUS_WMI_DEVID_KBD_BACKLIGHT    0x00050021
  87 #define ASUS_WMI_DEVID_LIGHT_SENSOR     0x00050022
  88
  89 /* Misc */
  90 #define ASUS_WMI_DEVID_CAMERA           0x00060013
  91 #define ASUS_WMI_DEVID_CARDREADER       0x00080013
  92 #define ASUS_WMI_DEVID_TOUCHPAD         0x00100011
  93 #define ASUS_WMI_DEVID_TOUCHPAD_LED     0x00100012
  94 #define ASUS_WMI_DEVID_THERMAL_CTRL     0x00110011
  95 #define ASUS_WMI_DEVID_FAN_CTRL         0x00110012
  96 #define ASUS_WMI_DEVID_PROCESSOR_STATE  0x00120012
  97
  98 /* DSTS masks */
  99 #define ASUS_WMI_DSTS_STATUS_BIT        0x00000001
 100 #define ASUS_WMI_DSTS_UNKNOWN_BIT       0x00000002
 101 #define ASUS_WMI_DSTS_PRESENCE_BIT      0x00010000
 102 #define ASUS_WMI_DSTS_USER_BIT          0x00020000
 103 #define ASUS_WMI_DSTS_BIOS_BIT          0x00040000
 104 #define ASUS_WMI_DSTS_BRIGHTNESS_MASK   0x000000FF
 105 #define ASUS_WMI_DSTS_MAX_BRIGTH_MASK   0x0000FF00
 106
 107
 108 struct acpi_asus_wmi_softc {
 109         device_t        dev;
 110         device_t        wmi_dev;
 111         const char      *notify_guid;
 112         struct sysctl_ctx_list  *sysctl_ctx;
 113         struct sysctl_oid       *sysctl_tree;
 114         int             dsts_id;
 115         int             handle_keys;
 116 };
 117
 118 static struct {
 119         char    *name;
 120         int     dev_id;
 121         char    *description;
 122         int     access;
 123 } acpi_asus_wmi_sysctls[] = {
 124         {
 125                 .name           = "hw_switch",
 126                 .dev_id         = ASUS_WMI_DEVID_HW_SWITCH,
 127                 .description    = "hw_switch",
 128                 .access         = CTLTYPE_INT | CTLFLAG_RW
 129         },
 130         {
 131                 .name           = "wireless_led",
 132                 .dev_id         = ASUS_WMI_DEVID_WIRELESS_LED,
 133                 .description    = "Wireless LED control",
 134                 .access         = CTLTYPE_INT | CTLFLAG_RW
 135         },
 136         {
 137                 .name           = "cwap",
 138                 .dev_id         = ASUS_WMI_DEVID_CWAP,
 139                 .description    = "Alt+F2 function",
 140                 .access         = CTLTYPE_INT | CTLFLAG_RW
 141         },
 142         {
 143                 .name           = "wlan",
 144                 .dev_id         = ASUS_WMI_DEVID_WLAN,
 145                 .description    = "WLAN power control",
 146                 .access         = CTLTYPE_INT | CTLFLAG_RW
 147         },
 148         {
 149                 .name           = "bluetooth",
 150                 .dev_id         = ASUS_WMI_DEVID_BLUETOOTH,
 151                 .description    = "Bluetooth power control",
 152                 .access         = CTLTYPE_INT | CTLFLAG_RW
 153         },
 154         {
 155                 .name           = "gps",
 156                 .dev_id         = ASUS_WMI_DEVID_GPS,
 157                 .description    = "GPS power control",
 158                 .access         = CTLTYPE_INT | CTLFLAG_RW
 159         },
 160         {
 161                 .name           = "wimax",
 162                 .dev_id         = ASUS_WMI_DEVID_WIMAX,
 163                 .description    = "WiMAX power control",
 164                 .access         = CTLTYPE_INT | CTLFLAG_RW
 165         },
 166         {
 167                 .name           = "wwan3g",
 168                 .dev_id         = ASUS_WMI_DEVID_WWAN3G,
 169                 .description    = "WWAN-3G power control",
 170                 .access         = CTLTYPE_INT | CTLFLAG_RW
 171         },
 172         {
 173                 .name           = "uwb",
 174                 .dev_id         = ASUS_WMI_DEVID_UWB,
 175                 .description    = "UWB power control",
 176                 .access         = CTLTYPE_INT | CTLFLAG_RW
 177         },
 178         {
 179                 .name           = "led1",
 180                 .dev_id         = ASUS_WMI_DEVID_LED1,
 181                 .description    = "LED1 control",
 182                 .access         = CTLTYPE_INT | CTLFLAG_RW
 183         },
 184         {
 185                 .name           = "led2",
 186                 .dev_id         = ASUS_WMI_DEVID_LED2,
 187                 .description    = "LED2 control",
 188                 .access         = CTLTYPE_INT | CTLFLAG_RW
 189         },
 190         {
 191                 .name           = "led3",
 192                 .dev_id         = ASUS_WMI_DEVID_LED3,
 193                 .description    = "LED3 control",
 194                 .access         = CTLTYPE_INT | CTLFLAG_RW
 195         },
 196         {
 197                 .name           = "led4",
 198                 .dev_id         = ASUS_WMI_DEVID_LED4,
 199                 .description    = "LED4 control",
 200                 .access         = CTLTYPE_INT | CTLFLAG_RW
 201         },
 202         {
 203                 .name           = "led5",
 204                 .dev_id         = ASUS_WMI_DEVID_LED5,
 205                 .description    = "LED5 control",
 206                 .access         = CTLTYPE_INT | CTLFLAG_RW
 207         },
 208         {
 209                 .name           = "led6",
 210                 .dev_id         = ASUS_WMI_DEVID_LED6,
 211                 .description    = "LED6 control",
 212                 .access         = CTLTYPE_INT | CTLFLAG_RW
 213         },
 214         {
 215                 .name           = "backlight",
 216                 .dev_id         = ASUS_WMI_DEVID_BACKLIGHT,
 217                 .description    = "LCD backlight on/off control",
 218                 .access         = CTLTYPE_INT | CTLFLAG_RW
 219         },
 220         {
 221                 .name           = "brightness",
 222                 .dev_id         = ASUS_WMI_DEVID_BRIGHTNESS,
 223                 .description    = "LCD backlight brightness control",
 224                 .access         = CTLTYPE_INT | CTLFLAG_RW
 225         },
 226         {
 227                 .name           = "kbd_backlight",
 228                 .dev_id         = ASUS_WMI_DEVID_KBD_BACKLIGHT,
 229                 .description    = "Keyboard backlight brightness control",
 230                 .access         = CTLTYPE_INT | CTLFLAG_RW
 231         },
 232         {
 233                 .name           = "light_sensor",
 234                 .dev_id         = ASUS_WMI_DEVID_LIGHT_SENSOR,
 235                 .description    = "Ambient light sensor",
 236                 .access         = CTLTYPE_INT | CTLFLAG_RW
 237         },
 238         {
 239                 .name           = "camera",
 240                 .dev_id         = ASUS_WMI_DEVID_CAMERA,
 241                 .description    = "Camera power control",
 242                 .access         = CTLTYPE_INT | CTLFLAG_RW
 243         },
 244         {
 245                 .name           = "cardreader",
 246                 .dev_id         = ASUS_WMI_DEVID_CARDREADER,
 247                 .description    = "Cardreader power control",
 248                 .access         = CTLTYPE_INT | CTLFLAG_RW
 249         },
 250         {
 251                 .name           = "touchpad",
 252                 .dev_id         = ASUS_WMI_DEVID_TOUCHPAD,
 253                 .description    = "Touchpad control",
 254                 .access         = CTLTYPE_INT | CTLFLAG_RW
 255         },
 256         {
 257                 .name           = "touchpad_led",
 258                 .dev_id         = ASUS_WMI_DEVID_TOUCHPAD_LED,
 259                 .description    = "Touchpad LED control",
 260                 .access         = CTLTYPE_INT | CTLFLAG_RW
 261         },
 262         {
 263                 .name           = "themperature",
 264                 .dev_id         = ASUS_WMI_DEVID_THERMAL_CTRL,
 265                 .description    = "Temperature (C)",
 266                 .access         = CTLTYPE_INT | CTLFLAG_RD
 267         },
 268         {
 269                 .name           = "fan_speed",
 270                 .dev_id         = ASUS_WMI_DEVID_FAN_CTRL,
 271                 .description    = "Fan speed (0-3)",
 272                 .access         = CTLTYPE_INT | CTLFLAG_RD
 273         },
 274         {
 275                 .name           = "processor_state",
 276                 .dev_id         = ASUS_WMI_DEVID_PROCESSOR_STATE,
 277                 .description    = "Processor state",
 278                 .access         = CTLTYPE_INT | CTLFLAG_RW
 279         },
 280         { NULL, 0, NULL, 0 }
 281 };
 282
 283 ACPI_SERIAL_DECL(asus_wmi, "ASUS WMI device");
 284
 285 static void     acpi_asus_wmi_identify(driver_t *driver, device_t parent);
 286 static int      acpi_asus_wmi_probe(device_t dev);
 287 static int      acpi_asus_wmi_attach(device_t dev);
 288 static int      acpi_asus_wmi_detach(device_t dev);
 289
 290 static int      acpi_asus_wmi_sysctl(SYSCTL_HANDLER_ARGS);
 291 static int      acpi_asus_wmi_sysctl_set(struct acpi_asus_wmi_softc *sc, int dev_id,
 292                     int arg, int oldarg);
 293 static int      acpi_asus_wmi_sysctl_get(struct acpi_asus_wmi_softc *sc, int dev_id);
 294 static int      acpi_asus_wmi_evaluate_method(device_t wmi_dev, int method,
 295                     UINT32 arg0, UINT32 arg1, UINT32 *retval);
 296 static int      acpi_wpi_asus_get_devstate(struct acpi_asus_wmi_softc *sc,
 297                     UINT32 dev_id, UINT32 *retval);
 298 static int      acpi_wpi_asus_set_devstate(struct acpi_asus_wmi_softc *sc,
 299                     UINT32 dev_id, UINT32 ctrl_param, UINT32 *retval);
 300 static void     acpi_asus_wmi_notify(ACPI_HANDLE h, UINT32 notify, void *context);
 301
 302 static device_method_t acpi_asus_wmi_methods[] = {
 303         DEVMETHOD(device_identify, acpi_asus_wmi_identify),
 304         DEVMETHOD(device_probe, acpi_asus_wmi_probe),
 305         DEVMETHOD(device_attach, acpi_asus_wmi_attach),
 306         DEVMETHOD(device_detach, acpi_asus_wmi_detach),
 307         {0, 0}
 308 };
 309
 310 static driver_t acpi_asus_wmi_driver = {
 311         "acpi_asus_wmi",
 312         acpi_asus_wmi_methods,
 313         sizeof(struct acpi_asus_wmi_softc),
 314 };
 315
 316 static devclass_t acpi_asus_wmi_devclass;
 317
 318 DRIVER_MODULE(acpi_asus_wmi, acpi_wmi, acpi_asus_wmi_driver,
 319     acpi_asus_wmi_devclass, 0, 0);
 320 MODULE_DEPEND(acpi_asus_wmi, acpi_wmi, 1, 1, 1);
 321 MODULE_DEPEND(acpi_asus_wmi, acpi, 1, 1, 1);
 322
 323 static void
 324 acpi_asus_wmi_identify(driver_t *driver, device_t parent)
 325 {
 326
 327         /* Don't do anything if driver is disabled. */
 328         if (acpi_disabled("asus_wmi"))
 329                 return;
 330
 331         /* Add only a single device instance. */
 332         if (device_find_child(parent, "acpi_asus_wmi", -1) != NULL)
 333                 return;
 334
 335         /* Check management GUID to see whether system is compatible. */
 336         if (!ACPI_WMI_PROVIDES_GUID_STRING(parent,
 337             ACPI_ASUS_WMI_MGMT_GUID))
 338                 return;
 339
 340         if (BUS_ADD_CHILD(parent, 0, "acpi_asus_wmi", -1) == NULL)
 341                 device_printf(parent, "add acpi_asus_wmi child failed\n");
 342 }
 343
 344 static int
 345 acpi_asus_wmi_probe(device_t dev)
 346 {
 347
 348         if (!ACPI_WMI_PROVIDES_GUID_STRING(device_get_parent(dev),
 349             ACPI_ASUS_WMI_MGMT_GUID))
 350                 return (EINVAL);
 351         device_set_desc(dev, "ASUS WMI device");
 352         return (0);
 353 }
 354
 355 static int
 356 acpi_asus_wmi_attach(device_t dev)
 357 {
 358         struct acpi_asus_wmi_softc      *sc;
 359         UINT32                  val;
 360         int                     dev_id, i;
 361
 362         ACPI_FUNCTION_TRACE((char *)(uintptr_t) __func__);
 363
 364         sc = device_get_softc(dev);
 365         sc->dev = dev;
 366         sc->wmi_dev = device_get_parent(dev);
 367         sc->handle_keys = 1;
 368
 369         /* Check management GUID. */
 370         if (!ACPI_WMI_PROVIDES_GUID_STRING(sc->wmi_dev,
 371             ACPI_ASUS_WMI_MGMT_GUID)) {
 372                 device_printf(dev,
 373                     "WMI device does not provide the ASUS management GUID\n");
 374                 return (EINVAL);
 375         }
 376
 377         /* Find proper DSTS method. */
 378         sc->dsts_id = ASUS_WMI_METHODID_DSTS;
 379 next:
 380         for (i = 0; acpi_asus_wmi_sysctls[i].name != NULL; ++i) {
 381                 dev_id = acpi_asus_wmi_sysctls[i].dev_id;
 382                 if (acpi_wpi_asus_get_devstate(sc, dev_id, &val))
 383                         continue;
 384                 break;
 385         }
 386         if (acpi_asus_wmi_sysctls[i].name == NULL) {
 387                 if (sc->dsts_id == ASUS_WMI_METHODID_DSTS) {
 388                         sc->dsts_id = ASUS_WMI_METHODID_DSTS2;
 389                         goto next;
 390                 } else {
 391                         device_printf(dev, "Can not detect DSTS method ID\n");
 392                         return (EINVAL);
 393                 }
 394         }
 395
 396         /* Find proper and attach to notufy GUID. */
 397         if (ACPI_WMI_PROVIDES_GUID_STRING(sc->wmi_dev,
 398             ACPI_ASUS_WMI_EVENT_GUID))
 399                 sc->notify_guid = ACPI_ASUS_WMI_EVENT_GUID;
 400         else if (ACPI_WMI_PROVIDES_GUID_STRING(sc->wmi_dev,
 401             ACPI_EEEPC_WMI_EVENT_GUID))
 402                 sc->notify_guid = ACPI_EEEPC_WMI_EVENT_GUID;
 403         else
 404                 sc->notify_guid = NULL;
 405         if (sc->notify_guid != NULL) {
 406                 if (ACPI_WMI_INSTALL_EVENT_HANDLER(sc->wmi_dev,
 407                     sc->notify_guid, acpi_asus_wmi_notify, dev))
 408                         sc->notify_guid = NULL;
 409         }
 410         if (sc->notify_guid == NULL)
 411                 device_printf(dev, "Could not install event handler!\n");
 412
 413         /* Initialize. */
 414         if (!acpi_asus_wmi_evaluate_method(sc->wmi_dev,
 415             ASUS_WMI_METHODID_INIT, 0, 0, &val) && bootverbose)
 416                 device_printf(dev, "Initialization: %#x\n", val);
 417         if (!acpi_asus_wmi_evaluate_method(sc->wmi_dev,
 418             ASUS_WMI_METHODID_SPEC, 0, 0x9, &val) && bootverbose)
 419                 device_printf(dev, "WMI BIOS version: %d.%d\n",
 420                     val >> 16, val & 0xFF);
 421         if (!acpi_asus_wmi_evaluate_method(sc->wmi_dev,
 422             ASUS_WMI_METHODID_SFUN, 0, 0, &val) && bootverbose)
 423                 device_printf(dev, "SFUN value: %#x\n", val);
 424
 425         ACPI_SERIAL_BEGIN(asus_wmi);
 426
 427         sc->sysctl_ctx = device_get_sysctl_ctx(dev);
 428         sc->sysctl_tree = device_get_sysctl_tree(dev);
 429         SYSCTL_ADD_INT(sc->sysctl_ctx,
 430             SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
 431             "handle_keys", CTLFLAG_RW, &sc->handle_keys,
 432             0, "Handle some hardware keys inside the driver");
 433         for (i = 0; acpi_asus_wmi_sysctls[i].name != NULL; ++i) {
 434                 dev_id = acpi_asus_wmi_sysctls[i].dev_id;
 435                 if (acpi_wpi_asus_get_devstate(sc, dev_id, &val))
 436                         continue;
 437                 switch (dev_id) {
 438                 case ASUS_WMI_DEVID_THERMAL_CTRL:
 439                 case ASUS_WMI_DEVID_PROCESSOR_STATE:
 440                 case ASUS_WMI_DEVID_FAN_CTRL:
 441                 case ASUS_WMI_DEVID_BRIGHTNESS:
 442                         if (val == 0)
 443                                 continue;
 444                         break;
 445                 default:
 446                         if ((val & ASUS_WMI_DSTS_PRESENCE_BIT) == 0)
 447                                 continue;
 448                         break;
 449                 }
 450
 451                 SYSCTL_ADD_PROC(sc->sysctl_ctx,
 452                     SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
 453                     acpi_asus_wmi_sysctls[i].name,
 454                     acpi_asus_wmi_sysctls[i].access,
 455                     sc, i, acpi_asus_wmi_sysctl, "I",
 456                     acpi_asus_wmi_sysctls[i].description);
 457         }
 458         ACPI_SERIAL_END(asus_wmi);
 459
 460         return (0);
 461 }
 462
 463 static int
 464 acpi_asus_wmi_detach(device_t dev)
 465 {
 466         struct acpi_asus_wmi_softc *sc = device_get_softc(dev);
 467
 468         ACPI_FUNCTION_TRACE((char *)(uintptr_t) __func__);
 469
 470         if (sc->notify_guid)
 471                 ACPI_WMI_REMOVE_EVENT_HANDLER(dev, sc->notify_guid);
 472
 473         return (0);
 474 }
 475
 476 static int
 477 acpi_asus_wmi_sysctl(SYSCTL_HANDLER_ARGS)
 478 {
 479         struct acpi_asus_wmi_softc      *sc;
 480         int                     arg;
 481         int                     oldarg;
 482         int                     error = 0;
 483         int                     function;
 484         int                     dev_id;
 485
 486         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 487
 488         sc = (struct acpi_asus_wmi_softc *)oidp->oid_arg1;
 489         function = oidp->oid_arg2;
 490         dev_id = acpi_asus_wmi_sysctls[function].dev_id;
 491
 492         ACPI_SERIAL_BEGIN(asus_wmi);
 493         arg = acpi_asus_wmi_sysctl_get(sc, dev_id);
 494         oldarg = arg;
 495         error = sysctl_handle_int(oidp, &arg, 0, req);
 496         if (!error && req->newptr != NULL)
 497                 error = acpi_asus_wmi_sysctl_set(sc, dev_id, arg, oldarg);
 498         ACPI_SERIAL_END(asus_wmi);
 499
 500         return (error);
 501 }
 502
 503 static int
 504 acpi_asus_wmi_sysctl_get(struct acpi_asus_wmi_softc *sc, int dev_id)
 505 {
 506         UINT32  val = 0;
 507
 508         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 509         ACPI_SERIAL_ASSERT(asus_wmi);
 510
 511         acpi_wpi_asus_get_devstate(sc, dev_id, &val);
 512
 513         switch(dev_id) {
 514         case ASUS_WMI_DEVID_THERMAL_CTRL:
 515                 val = (val - 2732 + 5) / 10;
 516                 break;
 517         case ASUS_WMI_DEVID_PROCESSOR_STATE:
 518         case ASUS_WMI_DEVID_FAN_CTRL:
 519                 break;
 520         case ASUS_WMI_DEVID_BRIGHTNESS:
 521                 val &= ASUS_WMI_DSTS_BRIGHTNESS_MASK;
 522                 break;
 523         case ASUS_WMI_DEVID_KBD_BACKLIGHT:
 524                 val &= 0x7;
 525                 break;
 526         default:
 527                 if (val & ASUS_WMI_DSTS_UNKNOWN_BIT)
 528                         val = -1;
 529                 else
 530                         val = !!(val & ASUS_WMI_DSTS_STATUS_BIT);
 531                 break;
 532         }
 533
 534         return (val);
 535 }
 536
 537 static int
 538 acpi_asus_wmi_sysctl_set(struct acpi_asus_wmi_softc *sc, int dev_id, int arg, int oldarg)
 539 {
 540         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 541         ACPI_SERIAL_ASSERT(asus_wmi);
 542
 543         switch(dev_id) {
 544         case ASUS_WMI_DEVID_KBD_BACKLIGHT:
 545                 arg = min(0x7, arg);
 546                 if (arg != 0)
 547                         arg |= 0x80;
 548                 break;
 549         }
 550
 551         acpi_wpi_asus_set_devstate(sc, dev_id, arg, NULL);
 552
 553         return (0);
 554 }
 555
 556 static __inline void
 557 acpi_asus_wmi_free_buffer(ACPI_BUFFER* buf) {
 558         if (buf && buf->Pointer) {
 559                 AcpiOsFree(buf->Pointer);
 560         }
 561 }
 562
 563 static void
 564 acpi_asus_wmi_notify(ACPI_HANDLE h, UINT32 notify, void *context)
 565 {
 566         device_t dev = context;
 567         ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, notify);
 568         UINT32 val;
 569         int code = 0;
 570
 571         struct acpi_asus_wmi_softc *sc = device_get_softc(dev);
 572         ACPI_BUFFER response = { ACPI_ALLOCATE_BUFFER, NULL };
 573         ACPI_OBJECT *obj;
 574         ACPI_WMI_GET_EVENT_DATA(sc->wmi_dev, notify, &response);
 575         obj = (ACPI_OBJECT*) response.Pointer;
 576         if (obj && obj->Type == ACPI_TYPE_INTEGER) {
 577                 code = obj->Integer.Value;
 578                 acpi_UserNotify("ASUS", ACPI_ROOT_OBJECT,
 579                     code);
 580         }
 581         if (code && sc->handle_keys) {
 582                 /* Keyboard backlight control. */
 583                 if (code == 0xc4 || code == 0xc5) {
 584                         acpi_wpi_asus_get_devstate(sc,
 585                             ASUS_WMI_DEVID_KBD_BACKLIGHT, &val);
 586                         val &= 0x7;
 587                         if (code == 0xc4) {
 588                                 if (val < 0x7)
 589                                         val++;
 590                         } else if (val > 0)
 591                                 val--;
 592                         if (val != 0)
 593                                 val |= 0x80;
 594                         acpi_wpi_asus_set_devstate(sc,
 595                             ASUS_WMI_DEVID_KBD_BACKLIGHT, val, NULL);
 596                 }
 597                 /* Touchpad control. */
 598                 if (code == 0x6b) {
 599                         acpi_wpi_asus_get_devstate(sc,
 600                             ASUS_WMI_DEVID_TOUCHPAD, &val);
 601                         val = !(val & 1);
 602                         acpi_wpi_asus_set_devstate(sc,
 603                             ASUS_WMI_DEVID_TOUCHPAD, val, NULL);
 604                 }
 605         }
 606         acpi_asus_wmi_free_buffer(&response);
 607 }
 608
 609 static int
 610 acpi_asus_wmi_evaluate_method(device_t wmi_dev, int method,
 611     UINT32 arg0, UINT32 arg1, UINT32 *retval)
 612 {
 613         UINT32          params[2] = { arg0, arg1 };
 614         UINT32          result;
 615         ACPI_OBJECT     *obj;
 616         ACPI_BUFFER     in = { sizeof(params), &params };
 617         ACPI_BUFFER     out = { ACPI_ALLOCATE_BUFFER, NULL };
 618
 619         if (ACPI_FAILURE(ACPI_WMI_EVALUATE_CALL(wmi_dev,
 620             ACPI_ASUS_WMI_MGMT_GUID, 1, method, &in, &out))) {
 621                 acpi_asus_wmi_free_buffer(&out);
 622                 return (-EINVAL);
 623         }
 624         obj = out.Pointer;
 625         if (obj && obj->Type == ACPI_TYPE_INTEGER)
 626                 result = (UINT32) obj->Integer.Value;
 627         else
 628                 result = 0;
 629         acpi_asus_wmi_free_buffer(&out);
 630         if (retval)
 631                 *retval = result;
 632         return (result == ASUS_WMI_UNSUPPORTED_METHOD ? -ENODEV : 0);
 633 }
 634
 635 static int
 636 acpi_wpi_asus_get_devstate(struct acpi_asus_wmi_softc *sc,
 637     UINT32 dev_id, UINT32 *retval)
 638 {
 639
 640         return (acpi_asus_wmi_evaluate_method(sc->wmi_dev,
 641             sc->dsts_id, dev_id, 0, retval));
 642 }
 643
 644 static int
 645 acpi_wpi_asus_set_devstate(struct acpi_asus_wmi_softc *sc,
 646     UINT32 dev_id, UINT32 ctrl_param, UINT32 *retval)
 647 {
 648
 649         return (acpi_asus_wmi_evaluate_method(sc->wmi_dev,
 650             ASUS_WMI_METHODID_DEVS, dev_id, ctrl_param, retval));
 651 }