sys/dev/acpi_support/acpi_asus.c

   1 /*-
   2  * Copyright (c) 2004, 2005 Philip Paeps <philip@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 /*
  31  * Driver for extra ACPI-controlled gadgets (hotkeys, leds, etc) found on
  32  * recent Asus (and Medion) laptops.  Inspired by the acpi4asus project which
  33  * implements these features in the Linux kernel.
  34  *
  35  *   <http://sourceforge.net/projects/acpi4asus/>
  36  *
  37  * Currently should support most features, but could use some more testing.
  38  * Particularly the display-switching stuff is a bit hairy.  If you have an
  39  * Asus laptop which doesn't appear to be supported, or strange things happen
  40  * when using this driver, please report to <acpi@FreeBSD.org>.
  41  */
  42
  43 #include "opt_acpi.h"
  44 #include <sys/param.h>
  45 #include <sys/kernel.h>
  46 #include <sys/module.h>
  47 #include <sys/bus.h>
  48 #include <sys/sbuf.h>
  49
  50 #include <contrib/dev/acpica/acpi.h>
  51 #include <dev/acpica/acpivar.h>
  52 #include <dev/led/led.h>
  53
  54 /* Methods */
  55 #define ACPI_ASUS_METHOD_BRN    1
  56 #define ACPI_ASUS_METHOD_DISP   2
  57 #define ACPI_ASUS_METHOD_LCD    3
  58 #define ACPI_ASUS_METHOD_CAMERA 4
  59 #define ACPI_ASUS_METHOD_CARDRD 5
  60 #define ACPI_ASUS_METHOD_WLAN   6
  61
  62 #define _COMPONENT      ACPI_OEM
  63 ACPI_MODULE_NAME("ASUS")
  64
  65 struct acpi_asus_model {
  66         char    *name;
  67
  68         char    *bled_set;
  69         char    *dled_set;
  70         char    *gled_set;
  71         char    *mled_set;
  72         char    *tled_set;
  73         char    *wled_set;
  74
  75         char    *brn_get;
  76         char    *brn_set;
  77         char    *brn_up;
  78         char    *brn_dn;
  79
  80         char    *lcd_get;
  81         char    *lcd_set;
  82
  83         char    *disp_get;
  84         char    *disp_set;
  85
  86         char    *cam_get;
  87         char    *cam_set;
  88
  89         char    *crd_get;
  90         char    *crd_set;
  91
  92         char    *wlan_get;
  93         char    *wlan_set;
  94
  95         void    (*n_func)(ACPI_HANDLE, UINT32, void *);
  96
  97         char    *lcdd;
  98         void    (*lcdd_n_func)(ACPI_HANDLE, UINT32, void *);
  99 };
 100
 101 struct acpi_asus_led {
 102         struct acpi_asus_softc *sc;
 103         struct cdev     *cdev;
 104         int             busy;
 105         int             state;
 106         enum {
 107                 ACPI_ASUS_LED_BLED,
 108                 ACPI_ASUS_LED_DLED,
 109                 ACPI_ASUS_LED_GLED,
 110                 ACPI_ASUS_LED_MLED,
 111                 ACPI_ASUS_LED_TLED,
 112                 ACPI_ASUS_LED_WLED,
 113         } type;
 114 };
 115
 116 struct acpi_asus_softc {
 117         device_t                dev;
 118         ACPI_HANDLE             handle;
 119         ACPI_HANDLE             lcdd_handle;
 120
 121         struct acpi_asus_model  *model;
 122         struct sysctl_ctx_list  sysctl_ctx;
 123         struct sysctl_oid       *sysctl_tree;
 124
 125         struct acpi_asus_led    s_bled;
 126         struct acpi_asus_led    s_dled;
 127         struct acpi_asus_led    s_gled;
 128         struct acpi_asus_led    s_mled;
 129         struct acpi_asus_led    s_tled;
 130         struct acpi_asus_led    s_wled;
 131
 132         int                     s_brn;
 133         int                     s_disp;
 134         int                     s_lcd;
 135         int                     s_cam;
 136         int                     s_crd;
 137         int                     s_wlan;
 138 };
 139
 140 static void     acpi_asus_lcdd_notify(ACPI_HANDLE h, UINT32 notify,
 141     void *context);
 142
 143 /*
 144  * We can identify Asus laptops from the string they return
 145  * as a result of calling the ATK0100 'INIT' method.
 146  */
 147 static struct acpi_asus_model acpi_asus_models[] = {
 148         {
 149                 .name           = "xxN",
 150                 .mled_set       = "MLED",
 151                 .wled_set       = "WLED",
 152                 .lcd_get        = "\\BKLT",
 153                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
 154                 .brn_get        = "GPLV",
 155                 .brn_set        = "SPLV",
 156                 .disp_get       = "\\ADVG",
 157                 .disp_set       = "SDSP"
 158         },
 159         {
 160                 .name           = "A1x",
 161                 .mled_set       = "MLED",
 162                 .lcd_get        = "\\BKLI",
 163                 .lcd_set        = "\\_SB.PCI0.ISA.EC0._Q10",
 164                 .brn_up         = "\\_SB.PCI0.ISA.EC0._Q0E",
 165                 .brn_dn         = "\\_SB.PCI0.ISA.EC0._Q0F"
 166         },
 167         {
 168                 .name           = "A2x",
 169                 .mled_set       = "MLED",
 170                 .wled_set       = "WLED",
 171                 .lcd_get        = "\\BAOF",
 172                 .lcd_set        = "\\Q10",
 173                 .brn_get        = "GPLV",
 174                 .brn_set        = "SPLV",
 175                 .disp_get       = "\\INFB",
 176                 .disp_set       = "SDSP"
 177         },
 178         {
 179                 .name           = "A3N",
 180                 .mled_set       = "MLED",
 181                 .bled_set       = "BLED",
 182                 .wled_set       = "WLED",
 183                 .lcd_get        = NULL,
 184                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
 185                 .brn_set        = "SPLV",
 186                 .brn_get        = "SDSP",
 187                 .disp_set       = "SDSP",
 188                 .disp_get       = "\\_SB.PCI0.P0P3.VGA.GETD"
 189         },
 190         {
 191                 .name           = "A4D",
 192                 .mled_set       = "MLED",
 193                 .brn_up         = "\\_SB_.PCI0.SBRG.EC0._Q0E",
 194                 .brn_dn         = "\\_SB_.PCI0.SBRG.EC0._Q0F",
 195                 .brn_get        = "GPLV",
 196                 .brn_set        = "SPLV",
 197 #ifdef notyet
 198                 .disp_get       = "\\_SB_.PCI0.SBRG.EC0._Q10",
 199                 .disp_set       = "\\_SB_.PCI0.SBRG.EC0._Q11"
 200 #endif
 201         },
 202         {
 203                 .name           = "A6V",
 204                 .bled_set       = "BLED",
 205                 .mled_set       = "MLED",
 206                 .wled_set       = "WLED",
 207                 .lcd_get        = NULL,
 208                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
 209                 .brn_get        = "GPLV",
 210                 .brn_set        = "SPLV",
 211                 .disp_get       = "\\_SB.PCI0.P0P3.VGA.GETD",
 212                 .disp_set       = "SDSP"
 213         },
 214         {
 215                 .name           = "A8SR",
 216                 .bled_set       = "BLED",
 217                 .mled_set       = "MLED",
 218                 .wled_set       = "WLED",
 219                 .lcd_get        = NULL,
 220                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
 221                 .brn_get        = "GPLV",
 222                 .brn_set        = "SPLV",
 223                 .disp_get       = "\\_SB.PCI0.P0P1.VGA.GETD",
 224                 .disp_set       = "SDSP",
 225                 .lcdd           = "\\_SB.PCI0.P0P1.VGA.LCDD",
 226                 .lcdd_n_func    = acpi_asus_lcdd_notify
 227         },
 228         {
 229                 .name           = "D1x",
 230                 .mled_set       = "MLED",
 231                 .lcd_get        = "\\GP11",
 232                 .lcd_set        = "\\Q0D",
 233                 .brn_up         = "\\Q0C",
 234                 .brn_dn         = "\\Q0B",
 235                 .disp_get       = "\\INFB",
 236                 .disp_set       = "SDSP"
 237         },
 238         {
 239                 .name           = "G2K",
 240                 .bled_set       = "BLED",
 241                 .dled_set       = "DLED",
 242                 .gled_set       = "GLED",
 243                 .mled_set       = "MLED",
 244                 .tled_set       = "TLED",
 245                 .wled_set       = "WLED",
 246                 .brn_get        = "GPLV",
 247                 .brn_set        = "SPLV",
 248                 .lcd_get        = "\\_SB.PCI0.SBRG.EC0.RPIN",
 249                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
 250                 .disp_get       = "\\_SB.PCI0.PCE2.VGA.GETD",
 251                 .disp_set       = "SDSP",
 252         },
 253         {
 254                 .name           = "L2D",
 255                 .mled_set       = "MLED",
 256                 .wled_set       = "WLED",
 257                 .brn_up         = "\\Q0E",
 258                 .brn_dn         = "\\Q0F",
 259                 .lcd_get        = "\\SGP0",
 260                 .lcd_set        = "\\Q10"
 261         },
 262         {
 263                 .name           = "L3C",
 264                 .mled_set       = "MLED",
 265                 .wled_set       = "WLED",
 266                 .brn_get        = "GPLV",
 267                 .brn_set        = "SPLV",
 268                 .lcd_get        = "\\GL32",
 269                 .lcd_set        = "\\_SB.PCI0.PX40.ECD0._Q10"
 270         },
 271         {
 272                 .name           = "L3D",
 273                 .mled_set       = "MLED",
 274                 .wled_set       = "WLED",
 275                 .brn_get        = "GPLV",
 276                 .brn_set        = "SPLV",
 277                 .lcd_get        = "\\BKLG",
 278                 .lcd_set        = "\\Q10"
 279         },
 280         {
 281                 .name           = "L3H",
 282                 .mled_set       = "MLED",
 283                 .wled_set       = "WLED",
 284                 .brn_get        = "GPLV",
 285                 .brn_set        = "SPLV",
 286                 .lcd_get        = "\\_SB.PCI0.PM.PBC",
 287                 .lcd_set        = "EHK",
 288                 .disp_get       = "\\_SB.INFB",
 289                 .disp_set       = "SDSP"
 290         },
 291         {
 292                 .name           = "L4R",
 293                 .mled_set       = "MLED",
 294                 .wled_set       = "WLED",
 295                 .brn_get        = "GPLV",
 296                 .brn_set        = "SPLV",
 297                 .lcd_get        = "\\_SB.PCI0.SBSM.SEO4",
 298                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
 299                 .disp_get       = "\\_SB.PCI0.P0P1.VGA.GETD",
 300                 .disp_set       = "SDSP"
 301         },
 302         {
 303                 .name           = "L5x",
 304                 .mled_set       = "MLED",
 305                 .tled_set       = "TLED",
 306                 .lcd_get        = "\\BAOF",
 307                 .lcd_set        = "\\Q0D",
 308                 .brn_get        = "GPLV",
 309                 .brn_set        = "SPLV",
 310                 .disp_get       = "\\INFB",
 311                 .disp_set       = "SDSP"
 312         },
 313         {
 314                 .name           = "L8L"
 315                 /* Only has hotkeys, apparently */
 316         },
 317         {
 318                 .name           = "M1A",
 319                 .mled_set       = "MLED",
 320                 .brn_up         = "\\_SB.PCI0.PX40.EC0.Q0E",
 321                 .brn_dn         = "\\_SB.PCI0.PX40.EC0.Q0F",
 322                 .lcd_get        = "\\PNOF",
 323                 .lcd_set        = "\\_SB.PCI0.PX40.EC0.Q10"
 324         },
 325         {
 326                 .name           = "M2E",
 327                 .mled_set       = "MLED",
 328                 .wled_set       = "WLED",
 329                 .brn_get        = "GPLV",
 330                 .brn_set        = "SPLV",
 331                 .lcd_get        = "\\GP06",
 332                 .lcd_set        = "\\Q10"
 333         },
 334         {
 335                 .name           = "M6N",
 336                 .mled_set       = "MLED",
 337                 .wled_set       = "WLED",
 338                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
 339                 .lcd_get        = "\\_SB.BKLT",
 340                 .brn_set        = "SPLV",
 341                 .brn_get        = "GPLV",
 342                 .disp_set       = "SDSP",
 343                 .disp_get       = "\\SSTE"
 344         },
 345         {
 346                 .name           = "M6R",
 347                 .mled_set       = "MLED",
 348                 .wled_set       = "WLED",
 349                 .brn_get        = "GPLV",
 350                 .brn_set        = "SPLV",
 351                 .lcd_get        = "\\_SB.PCI0.SBSM.SEO4",
 352                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
 353                 .disp_get       = "\\SSTE",
 354                 .disp_set       = "SDSP"
 355         },
 356         {
 357                 .name           = "S1x",
 358                 .mled_set       = "MLED",
 359                 .wled_set       = "WLED",
 360                 .lcd_get        = "\\PNOF",
 361                 .lcd_set        = "\\_SB.PCI0.PX40.Q10",
 362                 .brn_get        = "GPLV",
 363                 .brn_set        = "SPLV"
 364         },
 365         {
 366                 .name           = "S2x",
 367                 .mled_set       = "MLED",
 368                 .lcd_get        = "\\BKLI",
 369                 .lcd_set        = "\\_SB.PCI0.ISA.EC0._Q10",
 370                 .brn_up         = "\\_SB.PCI0.ISA.EC0._Q0B",
 371                 .brn_dn         = "\\_SB.PCI0.ISA.EC0._Q0A"
 372         },
 373         {
 374                 .name           = "V6V",
 375                 .bled_set       = "BLED",
 376                 .tled_set       = "TLED",
 377                 .wled_set       = "WLED",
 378                 .lcd_get        = "\\BKLT",
 379                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
 380                 .brn_get        = "GPLV",
 381                 .brn_set        = "SPLV",
 382                 .disp_get       = "\\_SB.PCI0.P0P1.VGA.GETD",
 383                 .disp_set       = "SDSP"
 384         },
 385         {
 386                 .name           = "W5A",
 387                 .bled_set       = "BLED",
 388                 .lcd_get        = "\\BKLT",
 389                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
 390                 .brn_get        = "GPLV",
 391                 .brn_set        = "SPLV",
 392                 .disp_get       = "\\_SB.PCI0.P0P2.VGA.GETD",
 393                 .disp_set       = "SDSP"
 394         },
 395
 396         { .name = NULL }
 397 };
 398
 399 /*
 400  * Samsung P30/P35 laptops have an Asus ATK0100 gadget interface,
 401  * but they can't be probed quite the same way as Asus laptops.
 402  */
 403 static struct acpi_asus_model acpi_samsung_models[] = {
 404         {
 405                 .name           = "P30",
 406                 .wled_set       = "WLED",
 407                 .brn_up         = "\\_SB.PCI0.LPCB.EC0._Q68",
 408                 .brn_dn         = "\\_SB.PCI0.LPCB.EC0._Q69",
 409                 .lcd_get        = "\\BKLT",
 410                 .lcd_set        = "\\_SB.PCI0.LPCB.EC0._Q0E"
 411         },
 412
 413         { .name = NULL }
 414 };
 415
 416 static void     acpi_asus_eeepc_notify(ACPI_HANDLE h, UINT32 notify, void *context);
 417
 418 /*
 419  * EeePC have an Asus ASUS010 gadget interface,
 420  * but they can't be probed quite the same way as Asus laptops.
 421  */
 422 static struct acpi_asus_model acpi_eeepc_models[] = {
 423         {
 424                 .name           = "EEE",
 425                 .brn_get        = "\\_SB.ATKD.PBLG",
 426                 .brn_set        = "\\_SB.ATKD.PBLS",
 427                 .cam_get        = "\\_SB.ATKD.CAMG",
 428                 .cam_set        = "\\_SB.ATKD.CAMS",
 429                 .crd_set        = "\\_SB.ATKD.CRDS",
 430                 .crd_get        = "\\_SB.ATKD.CRDG",
 431                 .wlan_get       = "\\_SB.ATKD.WLDG",
 432                 .wlan_set       = "\\_SB.ATKD.WLDS",
 433                 .n_func         = acpi_asus_eeepc_notify
 434         },
 435
 436         { .name = NULL }
 437 };
 438
 439 static struct {
 440         char    *name;
 441         char    *description;
 442         int     method;
 443         int     flags;
 444 } acpi_asus_sysctls[] = {
 445         {
 446                 .name           = "lcd_backlight",
 447                 .method         = ACPI_ASUS_METHOD_LCD,
 448                 .description    = "state of the lcd backlight",
 449                 .flags          = CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY
 450         },
 451         {
 452                 .name           = "lcd_brightness",
 453                 .method         = ACPI_ASUS_METHOD_BRN,
 454                 .description    = "brightness of the lcd panel",
 455                 .flags          = CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY
 456         },
 457         {
 458                 .name           = "video_output",
 459                 .method         = ACPI_ASUS_METHOD_DISP,
 460                 .description    = "display output state",
 461                 .flags          = CTLTYPE_INT | CTLFLAG_RW
 462         },
 463         {
 464                 .name           = "camera",
 465                 .method         = ACPI_ASUS_METHOD_CAMERA,
 466                 .description    = "internal camera state",
 467                 .flags          = CTLTYPE_INT | CTLFLAG_RW
 468         },
 469         {
 470                 .name           = "cardreader",
 471                 .method         = ACPI_ASUS_METHOD_CARDRD,
 472                 .description    = "internal card reader state",
 473                 .flags          = CTLTYPE_INT | CTLFLAG_RW
 474         },
 475         {
 476                 .name           = "wlan",
 477                 .method         = ACPI_ASUS_METHOD_WLAN,
 478                 .description    = "wireless lan state",
 479                 .flags          = CTLTYPE_INT | CTLFLAG_RW
 480         },
 481
 482         { .name = NULL }
 483 };
 484
 485 ACPI_SERIAL_DECL(asus, "ACPI ASUS extras");
 486
 487 /* Function prototypes */
 488 static int      acpi_asus_probe(device_t dev);
 489 static int      acpi_asus_attach(device_t dev);
 490 static int      acpi_asus_detach(device_t dev);
 491
 492 static void     acpi_asus_led(struct acpi_asus_led *led, int state);
 493 static void     acpi_asus_led_task(struct acpi_asus_led *led, int pending __unused);
 494
 495 static int      acpi_asus_sysctl(SYSCTL_HANDLER_ARGS);
 496 static int      acpi_asus_sysctl_init(struct acpi_asus_softc *sc, int method);
 497 static int      acpi_asus_sysctl_get(struct acpi_asus_softc *sc, int method);
 498 static int      acpi_asus_sysctl_set(struct acpi_asus_softc *sc, int method, int val);
 499
 500 static void     acpi_asus_notify(ACPI_HANDLE h, UINT32 notify, void *context);
 501
 502 static device_method_t acpi_asus_methods[] = {
 503         DEVMETHOD(device_probe,  acpi_asus_probe),
 504         DEVMETHOD(device_attach, acpi_asus_attach),
 505         DEVMETHOD(device_detach, acpi_asus_detach),
 506
 507         { 0, 0 }
 508 };
 509
 510 static driver_t acpi_asus_driver = {
 511         "acpi_asus",
 512         acpi_asus_methods,
 513         sizeof(struct acpi_asus_softc)
 514 };
 515
 516 static devclass_t acpi_asus_devclass;
 517
 518 DRIVER_MODULE(acpi_asus, acpi, acpi_asus_driver, acpi_asus_devclass, 0, 0);
 519 MODULE_DEPEND(acpi_asus, acpi, 1, 1, 1);
 520
 521 static int
 522 acpi_asus_probe(device_t dev)
 523 {
 524         struct acpi_asus_model  *model;
 525         struct acpi_asus_softc  *sc;
 526         struct sbuf             *sb;
 527         ACPI_BUFFER             Buf;
 528         ACPI_OBJECT             Arg, *Obj;
 529         ACPI_OBJECT_LIST        Args;
 530         static char             *asus_ids[] = { "ATK0100", "ASUS010", NULL };
 531         char *rstr;
 532
 533         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 534
 535         if (acpi_disabled("asus"))
 536                 return (ENXIO);
 537         rstr = ACPI_ID_PROBE(device_get_parent(dev), dev, asus_ids);
 538         if (rstr == NULL) {
 539                 return (ENXIO);
 540         }
 541
 542         sc = device_get_softc(dev);
 543         sc->dev = dev;
 544         sc->handle = acpi_get_handle(dev);
 545
 546         Arg.Type = ACPI_TYPE_INTEGER;
 547         Arg.Integer.Value = 0;
 548
 549         Args.Count = 1;
 550         Args.Pointer = &Arg;
 551
 552         Buf.Pointer = NULL;
 553         Buf.Length = ACPI_ALLOCATE_BUFFER;
 554
 555         AcpiEvaluateObject(sc->handle, "INIT", &Args, &Buf);
 556         Obj = Buf.Pointer;
 557
 558         /*
 559          * The Samsung P30 returns a null-pointer from INIT, we
 560          * can identify it from the 'ODEM' string in the DSDT.
 561          */
 562         if (Obj->String.Pointer == NULL) {
 563                 ACPI_STATUS             status;
 564                 ACPI_TABLE_HEADER       th;
 565
 566                 status = AcpiGetTableHeader(ACPI_SIG_DSDT, 0, &th);
 567                 if (ACPI_FAILURE(status)) {
 568                         device_printf(dev, "Unsupported (Samsung?) laptop\n");
 569                         AcpiOsFree(Buf.Pointer);
 570                         return (ENXIO);
 571                 }
 572
 573                 if (strncmp("ODEM", th.OemTableId, 4) == 0) {
 574                         sc->model = &acpi_samsung_models[0];
 575                         device_set_desc(dev, "Samsung P30 Laptop Extras");
 576                         AcpiOsFree(Buf.Pointer);
 577                         return (0);
 578                 }
 579
 580                 /* if EeePC */
 581                 if (strncmp("ASUS010", rstr, 7) == 0) {
 582                         sc->model = &acpi_eeepc_models[0];
 583                         device_set_desc(dev, "ASUS EeePC");
 584                         AcpiOsFree(Buf.Pointer);
 585                         return (0);
 586                 }
 587         }
 588
 589         sb = sbuf_new_auto();
 590         if (sb == NULL)
 591                 return (ENOMEM);
 592
 593         /*
 594          * Asus laptops are simply identified by name, easy!
 595          */
 596         for (model = acpi_asus_models; model->name != NULL; model++) {
 597                 if (strncmp(Obj->String.Pointer, model->name, 3) == 0) {
 598
 599 good:
 600                         sbuf_printf(sb, "Asus %s Laptop Extras",
 601                             Obj->String.Pointer);
 602                         sbuf_finish(sb);
 603
 604                         sc->model = model;
 605                         device_set_desc_copy(dev, sbuf_data(sb));
 606
 607                         sbuf_delete(sb);
 608                         AcpiOsFree(Buf.Pointer);
 609                         return (0);
 610                 }
 611
 612                 /*
 613                  * Some models look exactly the same as other models, but have
 614                  * their own ids.  If we spot these, set them up with the same
 615                  * details as the models they're like, possibly dealing with
 616                  * small differences.
 617                  *
 618                  * XXX: there must be a prettier way to do this!
 619                  */
 620                 else if (strncmp(model->name, "xxN", 3) == 0 &&
 621                     (strncmp(Obj->String.Pointer, "M3N", 3) == 0 ||
 622                      strncmp(Obj->String.Pointer, "S1N", 3) == 0))
 623                         goto good;
 624                 else if (strncmp(model->name, "A1x", 3) == 0 &&
 625                     strncmp(Obj->String.Pointer, "A1", 2) == 0)
 626                         goto good;
 627                 else if (strncmp(model->name, "A2x", 3) == 0 &&
 628                     strncmp(Obj->String.Pointer, "A2", 2) == 0)
 629                         goto good;
 630                 else if (strncmp(model->name, "D1x", 3) == 0 &&
 631                     strncmp(Obj->String.Pointer, "D1", 2) == 0)
 632                         goto good;
 633                 else if (strncmp(model->name, "L3H", 3) == 0 &&
 634                     strncmp(Obj->String.Pointer, "L2E", 3) == 0)
 635                         goto good;
 636                 else if (strncmp(model->name, "L5x", 3) == 0 &&
 637                     strncmp(Obj->String.Pointer, "L5", 2) == 0)
 638                         goto good;
 639                 else if (strncmp(model->name, "M2E", 3) == 0 &&
 640                     (strncmp(Obj->String.Pointer, "M2", 2) == 0 ||
 641                      strncmp(Obj->String.Pointer, "L4E", 3) == 0))
 642                         goto good;
 643                 else if (strncmp(model->name, "S1x", 3) == 0 &&
 644                     (strncmp(Obj->String.Pointer, "L8", 2) == 0 ||
 645                      strncmp(Obj->String.Pointer, "S1", 2) == 0))
 646                         goto good;
 647                 else if (strncmp(model->name, "S2x", 3) == 0 &&
 648                     (strncmp(Obj->String.Pointer, "J1", 2) == 0 ||
 649                      strncmp(Obj->String.Pointer, "S2", 2) == 0))
 650                         goto good;
 651
 652                 /* L2B is like L3C but has no lcd_get method */
 653                 else if (strncmp(model->name, "L3C", 3) == 0 &&
 654                     strncmp(Obj->String.Pointer, "L2B", 3) == 0) {
 655                         model->lcd_get = NULL;
 656                         goto good;
 657                 }
 658
 659                 /* A3G is like M6R but with a different lcd_get method */
 660                 else if (strncmp(model->name, "M6R", 3) == 0 &&
 661                     strncmp(Obj->String.Pointer, "A3G", 3) == 0) {
 662                         model->lcd_get = "\\BLFG";
 663                         goto good;
 664                 }
 665
 666                 /* M2N and W1N are like xxN with added WLED */
 667                 else if (strncmp(model->name, "xxN", 3) == 0 &&
 668                     (strncmp(Obj->String.Pointer, "M2N", 3) == 0 ||
 669                      strncmp(Obj->String.Pointer, "W1N", 3) == 0)) {
 670                         model->wled_set = "WLED";
 671                         goto good;
 672                 }
 673
 674                 /* M5N and S5N are like xxN without MLED */
 675                 else if (strncmp(model->name, "xxN", 3) == 0 &&
 676                     (strncmp(Obj->String.Pointer, "M5N", 3) == 0 ||
 677                      strncmp(Obj->String.Pointer, "S5N", 3) == 0)) {
 678                         model->mled_set = NULL;
 679                         goto good;
 680                 }
 681         }
 682
 683         sbuf_printf(sb, "Unsupported Asus laptop: %s\n", Obj->String.Pointer);
 684         sbuf_finish(sb);
 685
 686         device_printf(dev, sbuf_data(sb));
 687
 688         sbuf_delete(sb);
 689         AcpiOsFree(Buf.Pointer);
 690
 691         return (ENXIO);
 692 }
 693
 694 static int
 695 acpi_asus_attach(device_t dev)
 696 {
 697         struct acpi_asus_softc  *sc;
 698         struct acpi_softc       *acpi_sc;
 699
 700         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 701
 702         sc = device_get_softc(dev);
 703         acpi_sc = acpi_device_get_parent_softc(dev);
 704
 705         /* Build sysctl tree */
 706         sysctl_ctx_init(&sc->sysctl_ctx);
 707         sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
 708             SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
 709             OID_AUTO, "asus", CTLFLAG_RD, 0, "");
 710
 711         /* Hook up nodes */
 712         for (int i = 0; acpi_asus_sysctls[i].name != NULL; i++) {
 713                 if (!acpi_asus_sysctl_init(sc, acpi_asus_sysctls[i].method))
 714                         continue;
 715
 716                 SYSCTL_ADD_PROC(&sc->sysctl_ctx,
 717                     SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
 718                     acpi_asus_sysctls[i].name,
 719                     acpi_asus_sysctls[i].flags,
 720                     sc, i, acpi_asus_sysctl, "I",
 721                     acpi_asus_sysctls[i].description);
 722         }
 723
 724         /* Attach leds */
 725         if (sc->model->bled_set) {
 726                 sc->s_bled.busy = 0;
 727                 sc->s_bled.sc = sc;
 728                 sc->s_bled.type = ACPI_ASUS_LED_BLED;
 729                 sc->s_bled.cdev =
 730                     led_create_state((led_t *)acpi_asus_led, &sc->s_bled,
 731                         "bled", 1);
 732         }
 733
 734         if (sc->model->dled_set) {
 735                 sc->s_dled.busy = 0;
 736                 sc->s_dled.sc = sc;
 737                 sc->s_dled.type = ACPI_ASUS_LED_DLED;
 738                 sc->s_dled.cdev =
 739                     led_create((led_t *)acpi_asus_led, &sc->s_dled, "dled");
 740         }
 741
 742         if (sc->model->gled_set) {
 743                 sc->s_gled.busy = 0;
 744                 sc->s_gled.sc = sc;
 745                 sc->s_gled.type = ACPI_ASUS_LED_GLED;
 746                 sc->s_gled.cdev =
 747                     led_create((led_t *)acpi_asus_led, &sc->s_gled, "gled");
 748         }
 749
 750         if (sc->model->mled_set) {
 751                 sc->s_mled.busy = 0;
 752                 sc->s_mled.sc = sc;
 753                 sc->s_mled.type = ACPI_ASUS_LED_MLED;
 754                 sc->s_mled.cdev =
 755                     led_create((led_t *)acpi_asus_led, &sc->s_mled, "mled");
 756         }
 757
 758         if (sc->model->tled_set) {
 759                 sc->s_tled.busy = 0;
 760                 sc->s_tled.sc = sc;
 761                 sc->s_tled.type = ACPI_ASUS_LED_TLED;
 762                 sc->s_tled.cdev =
 763                     led_create_state((led_t *)acpi_asus_led, &sc->s_tled,
 764                         "tled", 1);
 765         }
 766
 767         if (sc->model->wled_set) {
 768                 sc->s_wled.busy = 0;
 769                 sc->s_wled.sc = sc;
 770                 sc->s_wled.type = ACPI_ASUS_LED_WLED;
 771                 sc->s_wled.cdev =
 772                     led_create_state((led_t *)acpi_asus_led, &sc->s_wled,
 773                         "wled", 1);
 774         }
 775
 776         /* Activate hotkeys */
 777         AcpiEvaluateObject(sc->handle, "BSTS", NULL, NULL);
 778
 779         /* Handle notifies */
 780         if (sc->model->n_func == NULL)
 781                 sc->model->n_func = acpi_asus_notify;
 782
 783         AcpiInstallNotifyHandler(sc->handle, ACPI_SYSTEM_NOTIFY,
 784             sc->model->n_func, dev);
 785
 786         /* Find and hook the 'LCDD' object */
 787         if (sc->model->lcdd != NULL && sc->model->lcdd_n_func != NULL) {
 788                 ACPI_STATUS res;
 789
 790                 sc->lcdd_handle = NULL;
 791                 res = AcpiGetHandle((sc->model->lcdd[0] == '\\' ?
 792                     NULL : sc->handle), sc->model->lcdd, &(sc->lcdd_handle));
 793                 if (ACPI_SUCCESS(res)) {
 794                         AcpiInstallNotifyHandler((sc->lcdd_handle),
 795                             ACPI_DEVICE_NOTIFY, sc->model->lcdd_n_func, dev);
 796                 } else {
 797                         printf("%s: unable to find LCD device '%s'\n",
 798                             __func__, sc->model->lcdd);
 799                 }
 800         }
 801
 802         return (0);
 803 }
 804
 805 static int
 806 acpi_asus_detach(device_t dev)
 807 {
 808         struct acpi_asus_softc  *sc;
 809
 810         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 811
 812         sc = device_get_softc(dev);
 813
 814         /* Turn the lights off */
 815         if (sc->model->bled_set)
 816                 led_destroy(sc->s_bled.cdev);
 817
 818         if (sc->model->dled_set)
 819                 led_destroy(sc->s_dled.cdev);
 820
 821         if (sc->model->gled_set)
 822                 led_destroy(sc->s_gled.cdev);
 823
 824         if (sc->model->mled_set)
 825                 led_destroy(sc->s_mled.cdev);
 826
 827         if (sc->model->tled_set)
 828                 led_destroy(sc->s_tled.cdev);
 829
 830         if (sc->model->wled_set)
 831                 led_destroy(sc->s_wled.cdev);
 832
 833         /* Remove notify handler */
 834         AcpiRemoveNotifyHandler(sc->handle, ACPI_SYSTEM_NOTIFY,
 835             acpi_asus_notify);
 836
 837         if (sc->lcdd_handle) {
 838                 KASSERT(sc->model->lcdd_n_func != NULL,
 839                     ("model->lcdd_n_func is NULL, but lcdd_handle is non-zero"));
 840                 AcpiRemoveNotifyHandler((sc->lcdd_handle),
 841                     ACPI_DEVICE_NOTIFY, sc->model->lcdd_n_func);
 842         }
 843
 844         /* Free sysctl tree */
 845         sysctl_ctx_free(&sc->sysctl_ctx);
 846
 847         return (0);
 848 }
 849
 850 static void
 851 acpi_asus_led_task(struct acpi_asus_led *led, int pending __unused)
 852 {
 853         struct acpi_asus_softc  *sc;
 854         char                    *method;
 855         int                     state;
 856
 857         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 858
 859         sc = led->sc;
 860
 861         switch (led->type) {
 862         case ACPI_ASUS_LED_BLED:
 863                 method = sc->model->bled_set;
 864                 state = led->state;
 865                 break;
 866         case ACPI_ASUS_LED_DLED:
 867                 method = sc->model->dled_set;
 868                 state = led->state;
 869                 break;
 870         case ACPI_ASUS_LED_GLED:
 871                 method = sc->model->gled_set;
 872                 state = led->state + 1; /* 1: off, 2: on */
 873                 break;
 874         case ACPI_ASUS_LED_MLED:
 875                 method = sc->model->mled_set;
 876                 state = !led->state;    /* inverted */
 877                 break;
 878         case ACPI_ASUS_LED_TLED:
 879                 method = sc->model->tled_set;
 880                 state = led->state;
 881                 break;
 882         case ACPI_ASUS_LED_WLED:
 883                 method = sc->model->wled_set;
 884                 state = led->state;
 885                 break;
 886         default:
 887                 printf("acpi_asus_led: invalid LED type %d\n",
 888                     (int)led->type);
 889                 return;
 890         }
 891
 892         acpi_SetInteger(sc->handle, method, state);
 893         led->busy = 0;
 894 }
 895
 896 static void
 897 acpi_asus_led(struct acpi_asus_led *led, int state)
 898 {
 899
 900         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 901
 902         if (led->busy)
 903                 return;
 904
 905         led->busy = 1;
 906         led->state = state;
 907
 908         AcpiOsExecute(OSL_NOTIFY_HANDLER, (void *)acpi_asus_led_task, led);
 909 }
 910
 911 static int
 912 acpi_asus_sysctl(SYSCTL_HANDLER_ARGS)
 913 {
 914         struct acpi_asus_softc  *sc;
 915         int                     arg;
 916         int                     error = 0;
 917         int                     function;
 918         int                     method;
 919
 920         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 921
 922         sc = (struct acpi_asus_softc *)oidp->oid_arg1;
 923         function = oidp->oid_arg2;
 924         method = acpi_asus_sysctls[function].method;
 925
 926         ACPI_SERIAL_BEGIN(asus);
 927         arg = acpi_asus_sysctl_get(sc, method);
 928         error = sysctl_handle_int(oidp, &arg, 0, req);
 929
 930         /* Sanity check */
 931         if (error != 0 || req->newptr == NULL)
 932                 goto out;
 933
 934         /* Update */
 935         error = acpi_asus_sysctl_set(sc, method, arg);
 936
 937 out:
 938         ACPI_SERIAL_END(asus);
 939         return (error);
 940 }
 941
 942 static int
 943 acpi_asus_sysctl_get(struct acpi_asus_softc *sc, int method)
 944 {
 945         int val = 0;
 946
 947         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 948         ACPI_SERIAL_ASSERT(asus);
 949
 950         switch (method) {
 951         case ACPI_ASUS_METHOD_BRN:
 952                 val = sc->s_brn;
 953                 break;
 954         case ACPI_ASUS_METHOD_DISP:
 955                 val = sc->s_disp;
 956                 break;
 957         case ACPI_ASUS_METHOD_LCD:
 958                 val = sc->s_lcd;
 959                 break;
 960         case ACPI_ASUS_METHOD_CAMERA:
 961                 val = sc->s_cam;
 962                 break;
 963         case ACPI_ASUS_METHOD_CARDRD:
 964                 val = sc->s_crd;
 965                 break;
 966         case ACPI_ASUS_METHOD_WLAN:
 967                 val = sc->s_wlan;
 968                 break;
 969         }
 970
 971         return (val);
 972 }
 973
 974 static int
 975 acpi_asus_sysctl_set(struct acpi_asus_softc *sc, int method, int arg)
 976 {
 977         ACPI_STATUS             status = AE_OK;
 978         ACPI_OBJECT_LIST        acpiargs;
 979         ACPI_OBJECT             acpiarg[1];
 980
 981         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
 982         ACPI_SERIAL_ASSERT(asus);
 983
 984         acpiargs.Count = 1;
 985         acpiargs.Pointer = acpiarg;
 986         acpiarg[0].Type = ACPI_TYPE_INTEGER;
 987         acpiarg[0].Integer.Value = arg;
 988
 989         switch (method) {
 990         case ACPI_ASUS_METHOD_BRN:
 991                 if (arg < 0 || arg > 15)
 992                         return (EINVAL);
 993
 994                 if (sc->model->brn_set)
 995                         status = acpi_SetInteger(sc->handle,
 996                             sc->model->brn_set, arg);
 997                 else {
 998                         while (arg != 0) {
 999                                 status = AcpiEvaluateObject(sc->handle,
1000                                     (arg > 0) ?  sc->model->brn_up :
1001                                     sc->model->brn_dn, NULL, NULL);
1002                                 (arg > 0) ? arg-- : arg++;
1003                         }
1004                 }
1005
1006                 if (ACPI_SUCCESS(status))
1007                         sc->s_brn = arg;
1008
1009                 break;
1010         case ACPI_ASUS_METHOD_DISP:
1011                 if (arg < 0 || arg > 7)
1012                         return (EINVAL);
1013
1014                 status = acpi_SetInteger(sc->handle,
1015                     sc->model->disp_set, arg);
1016
1017                 if (ACPI_SUCCESS(status))
1018                         sc->s_disp = arg;
1019
1020                 break;
1021         case ACPI_ASUS_METHOD_LCD:
1022                 if (arg < 0 || arg > 1)
1023                         return (EINVAL);
1024
1025                 if (strncmp(sc->model->name, "L3H", 3) != 0)
1026                         status = AcpiEvaluateObject(sc->handle,
1027                             sc->model->lcd_set, NULL, NULL);
1028                 else
1029                         status = acpi_SetInteger(sc->handle,
1030                             sc->model->lcd_set, 0x7);
1031
1032                 if (ACPI_SUCCESS(status))
1033                         sc->s_lcd = arg;
1034
1035                 break;
1036         case ACPI_ASUS_METHOD_CAMERA:
1037                 if (arg < 0 || arg > 1)
1038                         return (EINVAL);
1039
1040                 status = AcpiEvaluateObject(sc->handle,
1041                     sc->model->cam_set, &acpiargs, NULL);
1042
1043                 if (ACPI_SUCCESS(status))
1044                         sc->s_cam = arg;
1045                 break;
1046         case ACPI_ASUS_METHOD_CARDRD:
1047                 if (arg < 0 || arg > 1)
1048                         return (EINVAL);
1049
1050                 status = AcpiEvaluateObject(sc->handle,
1051                     sc->model->crd_set, &acpiargs, NULL);
1052
1053                 if (ACPI_SUCCESS(status))
1054                         sc->s_crd = arg;
1055                 break;
1056         case ACPI_ASUS_METHOD_WLAN:
1057                 if (arg < 0 || arg > 1)
1058                         return (EINVAL);
1059
1060                 status = AcpiEvaluateObject(sc->handle,
1061                     sc->model->wlan_set, &acpiargs, NULL);
1062
1063                 if (ACPI_SUCCESS(status))
1064                         sc->s_wlan = arg;
1065                 break;
1066         }
1067
1068         return (0);
1069 }
1070
1071 static int
1072 acpi_asus_sysctl_init(struct acpi_asus_softc *sc, int method)
1073 {
1074         ACPI_STATUS     status;
1075
1076         switch (method) {
1077         case ACPI_ASUS_METHOD_BRN:
1078                 if (sc->model->brn_get) {
1079                         /* GPLV/SPLV models */
1080                         status = acpi_GetInteger(sc->handle,
1081                             sc->model->brn_get, &sc->s_brn);
1082                         if (ACPI_SUCCESS(status))
1083                                 return (TRUE);
1084                 } else if (sc->model->brn_up) {
1085                         /* Relative models */
1086                         status = AcpiEvaluateObject(sc->handle,
1087                             sc->model->brn_up, NULL, NULL);
1088                         if (ACPI_FAILURE(status))
1089                                 return (FALSE);
1090
1091                         status = AcpiEvaluateObject(sc->handle,
1092                             sc->model->brn_dn, NULL, NULL);
1093                         if (ACPI_FAILURE(status))
1094                                 return (FALSE);
1095
1096                         return (TRUE);
1097                 }
1098                 return (FALSE);
1099         case ACPI_ASUS_METHOD_DISP:
1100                 if (sc->model->disp_get) {
1101                         status = acpi_GetInteger(sc->handle,
1102                             sc->model->disp_get, &sc->s_disp);
1103                         if (ACPI_SUCCESS(status))
1104                                 return (TRUE);
1105                 }
1106                 return (FALSE);
1107         case ACPI_ASUS_METHOD_LCD:
1108                 if (sc->model->lcd_get) {
1109                         if (strncmp(sc->model->name, "G2K", 3) == 0) {
1110                                 ACPI_BUFFER             Buf;
1111                                 ACPI_OBJECT             Arg, Obj;
1112                                 ACPI_OBJECT_LIST        Args;
1113
1114                                 Arg.Type = ACPI_TYPE_INTEGER;
1115                                 Arg.Integer.Value = 0x11;
1116                                 Args.Count = 1;
1117                                 Args.Pointer = &Arg;
1118                                 Buf.Length = sizeof(Obj);
1119                                 Buf.Pointer = &Obj;
1120
1121                                 status = AcpiEvaluateObject(sc->handle,
1122                                     sc->model->lcd_get, &Args, &Buf);
1123                                 if (ACPI_SUCCESS(status) &&
1124                                     Obj.Type == ACPI_TYPE_INTEGER) {
1125                                         sc->s_lcd = Obj.Integer.Value;
1126                                         return (TRUE);
1127                                 }
1128                         } else if (strncmp(sc->model->name, "L3H", 3) == 0) {
1129                                 ACPI_BUFFER             Buf;
1130                                 ACPI_OBJECT             Arg[2], Obj;
1131                                 ACPI_OBJECT_LIST        Args;
1132
1133                                 /* L3H is a bit special */
1134                                 Arg[0].Type = ACPI_TYPE_INTEGER;
1135                                 Arg[0].Integer.Value = 0x02;
1136                                 Arg[1].Type = ACPI_TYPE_INTEGER;
1137                                 Arg[1].Integer.Value = 0x03;
1138
1139                                 Args.Count = 2;
1140                                 Args.Pointer = Arg;
1141
1142                                 Buf.Length = sizeof(Obj);
1143                                 Buf.Pointer = &Obj;
1144
1145                                 status = AcpiEvaluateObject(sc->handle,
1146                                     sc->model->lcd_get, &Args, &Buf);
1147                                 if (ACPI_SUCCESS(status) &&
1148                                     Obj.Type == ACPI_TYPE_INTEGER) {
1149                                         sc->s_lcd = Obj.Integer.Value >> 8;
1150                                         return (TRUE);
1151                                 }
1152                         } else {
1153                                 status = acpi_GetInteger(sc->handle,
1154                                     sc->model->lcd_get, &sc->s_lcd);
1155                                 if (ACPI_SUCCESS(status))
1156                                         return (TRUE);
1157                         }
1158                 }
1159                 return (FALSE);
1160         case ACPI_ASUS_METHOD_CAMERA:
1161                 if (sc->model->cam_get) {
1162                         status = acpi_GetInteger(sc->handle,
1163                             sc->model->cam_get, &sc->s_cam);
1164                         if (ACPI_SUCCESS(status))
1165                                 return (TRUE);
1166                 }
1167                 return (FALSE);
1168         case ACPI_ASUS_METHOD_CARDRD:
1169                 if (sc->model->crd_get) {
1170                         status = acpi_GetInteger(sc->handle,
1171                             sc->model->crd_get, &sc->s_crd);
1172                         if (ACPI_SUCCESS(status))
1173                                 return (TRUE);
1174                 }
1175                 return (FALSE);
1176         case ACPI_ASUS_METHOD_WLAN:
1177                 if (sc->model->wlan_get) {
1178                         status = acpi_GetInteger(sc->handle,
1179                             sc->model->wlan_get, &sc->s_wlan);
1180                         if (ACPI_SUCCESS(status))
1181                                 return (TRUE);
1182                 }
1183                 return (FALSE);
1184         }
1185         return (FALSE);
1186 }
1187
1188 static void
1189 acpi_asus_notify(ACPI_HANDLE h, UINT32 notify, void *context)
1190 {
1191         struct acpi_asus_softc  *sc;
1192         struct acpi_softc       *acpi_sc;
1193
1194         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
1195
1196         sc = device_get_softc((device_t)context);
1197         acpi_sc = acpi_device_get_parent_softc(sc->dev);
1198
1199         ACPI_SERIAL_BEGIN(asus);
1200         if ((notify & ~0x10) <= 15) {
1201                 sc->s_brn = notify & ~0x10;
1202                 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness increased\n");
1203         } else if ((notify & ~0x20) <= 15) {
1204                 sc->s_brn = notify & ~0x20;
1205                 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness decreased\n");
1206         } else if (notify == 0x33) {
1207                 sc->s_lcd = 1;
1208                 ACPI_VPRINT(sc->dev, acpi_sc, "LCD turned on\n");
1209         } else if (notify == 0x34) {
1210                 sc->s_lcd = 0;
1211                 ACPI_VPRINT(sc->dev, acpi_sc, "LCD turned off\n");
1212         } else if (notify == 0x86) {
1213                 acpi_asus_sysctl_set(sc, ACPI_ASUS_METHOD_BRN, sc->s_brn-1);
1214                 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness decreased\n");
1215         } else if (notify == 0x87) {
1216                 acpi_asus_sysctl_set(sc, ACPI_ASUS_METHOD_BRN, sc->s_brn+1);
1217                 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness increased\n");
1218         } else {
1219                 /* Notify devd(8) */
1220                 acpi_UserNotify("ASUS", h, notify);
1221         }
1222         ACPI_SERIAL_END(asus);
1223 }
1224
1225 static void
1226 acpi_asus_lcdd_notify(ACPI_HANDLE h, UINT32 notify, void *context)
1227 {
1228         struct acpi_asus_softc  *sc;
1229         struct acpi_softc       *acpi_sc;
1230
1231         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
1232
1233         sc = device_get_softc((device_t)context);
1234         acpi_sc = acpi_device_get_parent_softc(sc->dev);
1235
1236         ACPI_SERIAL_BEGIN(asus);
1237         switch (notify) {
1238         case 0x87:
1239                 acpi_asus_sysctl_set(sc, ACPI_ASUS_METHOD_BRN, sc->s_brn-1);
1240                 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness decreased\n");
1241                 break;
1242         case 0x86:
1243                 acpi_asus_sysctl_set(sc, ACPI_ASUS_METHOD_BRN, sc->s_brn+1);
1244                 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness increased\n");
1245                 break;
1246         }
1247         ACPI_SERIAL_END(asus);
1248 }
1249
1250 static void
1251 acpi_asus_eeepc_notify(ACPI_HANDLE h, UINT32 notify, void *context)
1252 {
1253         struct acpi_asus_softc  *sc;
1254         struct acpi_softc       *acpi_sc;
1255
1256         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
1257
1258         sc = device_get_softc((device_t)context);
1259         acpi_sc = acpi_device_get_parent_softc(sc->dev);
1260
1261         ACPI_SERIAL_BEGIN(asus);
1262         if ((notify & ~0x20) <= 15) {
1263                 sc->s_brn = notify & ~0x20;
1264                 ACPI_VPRINT(sc->dev, acpi_sc,
1265                     "Brightness increased/decreased\n");
1266         } else {
1267                 /* Notify devd(8) */
1268                 acpi_UserNotify("ASUS-Eee", h, notify);
1269         }
1270         ACPI_SERIAL_END(asus);
1271 }