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