1 /*- 2 * Copyright (c) 2004 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 28 #include <sys/cdefs.h> 29 __FBSDID("$FreeBSD$"); 30 31 /* 32 * Driver for extra ACPI-controlled gadgets (hotkeys, leds, etc) found on 33 * recent Asus (and Medion) laptops. Inspired by the acpi4asus project which 34 * implements these features in the Linux kernel. 35 * 36 * <http://sourceforge.net/projects/acpi4asus/> 37 * 38 * Currently should support most features, but could use some more testing. 39 * Particularly the display-switching stuff is a bit hairy. If you have an 40 * Asus laptop which doesn't appear to be supported, or strange things happen 41 * when using this driver, please report to <acpi@FreeBSD.org>. 42 * 43 */ 44 45 #include "opt_acpi.h" 46 #include <sys/param.h> 47 #include <sys/kernel.h> 48 #include <sys/module.h> 49 #include <sys/bus.h> 50 #include <sys/sbuf.h> 51 52 #include "acpi.h" 53 #include <dev/acpica/acpivar.h> 54 #include <dev/led/led.h> 55 56 #define _COMPONENT ACPI_ASUS 57 ACPI_MODULE_NAME("ASUS") 58 59 struct acpi_asus_model { 60 char *name; 61 62 char *mled_set; 63 char *tled_set; 64 char *wled_set; 65 66 char *brn_get; 67 char *brn_set; 68 char *brn_up; 69 char *brn_dn; 70 71 char *lcd_get; 72 char *lcd_set; 73 74 char *disp_get; 75 char *disp_set; 76 }; 77 78 struct acpi_asus_led { 79 struct cdev *cdev; 80 device_t dev; 81 enum { 82 ACPI_ASUS_LED_MLED, 83 ACPI_ASUS_LED_TLED, 84 ACPI_ASUS_LED_WLED, 85 } type; 86 }; 87 88 struct acpi_asus_softc { 89 device_t dev; 90 ACPI_HANDLE handle; 91 92 struct acpi_asus_model *model; 93 struct sysctl_ctx_list sysctl_ctx; 94 struct sysctl_oid *sysctl_tree; 95 96 struct acpi_asus_led s_mled; 97 struct acpi_asus_led s_tled; 98 struct acpi_asus_led s_wled; 99 100 int s_brn; 101 int s_disp; 102 int s_lcd; 103 }; 104 105 /* 106 * We can identify Asus laptops from the string they return 107 * as a result of calling the ATK0100 'INIT' method. 108 */ 109 static struct acpi_asus_model acpi_asus_models[] = { 110 { 111 .name = "L2D", 112 .mled_set = "MLED", 113 .wled_set = "WLED", 114 .brn_up = "\\Q0E", 115 .brn_dn = "\\Q0F", 116 .lcd_get = "\\SGP0", 117 .lcd_set = "\\Q10" 118 }, 119 { 120 .name = "L3C", 121 .mled_set = "MLED", 122 .wled_set = "WLED", 123 .brn_get = "GPLV", 124 .brn_set = "SPLV", 125 .lcd_get = "\\GL32", 126 .lcd_set = "\\_SB.PCI0.PX40.ECD0._Q10" 127 }, 128 { 129 .name = "L3D", 130 .mled_set = "MLED", 131 .wled_set = "WLED", 132 .brn_get = "GPLV", 133 .brn_set = "SPLV", 134 .lcd_get = "\\BKLG", 135 .lcd_set = "\\Q10" 136 }, 137 { 138 .name = "L3H", 139 .mled_set = "MLED", 140 .wled_set = "WLED", 141 .brn_get = "GPLV", 142 .brn_set = "SPLV", 143 .lcd_get = "\\_SB.PCI0.PM.PBC", 144 .lcd_set = "EHK", 145 .disp_get = "\\_SB.INFB", 146 .disp_set = "SDSP" 147 }, 148 { 149 .name = "L4R", 150 .mled_set = "MLED", 151 .wled_set = "WLED", 152 .brn_get = "GPLV", 153 .brn_set = "SPLV", 154 .lcd_get = "\\_SB.PCI0.SBSM.SEO4", 155 .lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10", 156 .disp_get = "\\_SB.PCI0.P0P1.VGA.GETD", 157 .disp_set = "SDSP" 158 }, 159 { 160 .name = "L8L" 161 /* Only has hotkeys, apparantly */ 162 }, 163 { 164 .name = "M1A", 165 .mled_set = "MLED", 166 .brn_up = "\\_SB.PCI0.PX40.EC0.Q0E", 167 .brn_dn = "\\_SB.PCI0.PX40.EC0.Q0F", 168 .lcd_get = "\\PNOF", 169 .lcd_set = "\\_SB.PCI0.PX40.EC0.Q10" 170 }, 171 { 172 .name = "M2E", 173 .mled_set = "MLED", 174 .wled_set = "WLED", 175 .brn_get = "GPLV", 176 .brn_set = "SPLV", 177 .lcd_get = "\\GP06", 178 .lcd_set = "\\Q10" 179 }, 180 { 181 .name = "M6N", 182 .mled_set = "MLED", 183 .wled_set = "WLED", 184 .lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10", 185 .lcd_get = "\\_SB.BKLT", 186 .brn_set = "SPLV", 187 .brn_get = "GPLV", 188 .disp_set = "SDSP", 189 .disp_get = "\\SSTE" 190 }, 191 { 192 .name = "M6R", 193 .mled_set = "MLED", 194 .wled_set = "WLED", 195 .brn_get = "GPLV", 196 .brn_set = "SPLV", 197 .lcd_get = "\\_SB.PCI0.SBSM.SEO4", 198 .lcd_set = "\\_SB.PCI0.SBRG.EC0._Q10", 199 .disp_get = "\\SSTE", 200 .disp_set = "SDSP" 201 }, 202 203 { .name = NULL } 204 }; 205 206 /* 207 * Samsung P30/P35 laptops have an Asus ATK0100 gadget interface, 208 * but they can't be probed quite the same way as Asus laptops. 209 */ 210 static struct acpi_asus_model acpi_samsung_models[] = { 211 { 212 .name = "P30", 213 .wled_set = "WLED", 214 .brn_up = "\\_SB.PCI0.LPCB.EC0._Q68", 215 .brn_dn = "\\_SB.PCI0.LPCB.EC0._Q69", 216 .lcd_get = "\\BKLT", 217 .lcd_set = "\\_SB.PCI0.LPCB.EC0._Q0E" 218 }, 219 220 { .name = NULL } 221 }; 222 223 ACPI_SERIAL_DECL(asus, "ACPI ASUS extras"); 224 225 /* Function prototypes */ 226 static int acpi_asus_probe(device_t dev); 227 static int acpi_asus_attach(device_t dev); 228 static int acpi_asus_detach(device_t dev); 229 230 static void acpi_asus_led(struct acpi_asus_led *led, int state); 231 232 static int acpi_asus_sysctl_brn(SYSCTL_HANDLER_ARGS); 233 static int acpi_asus_sysctl_lcd(SYSCTL_HANDLER_ARGS); 234 static int acpi_asus_sysctl_disp(SYSCTL_HANDLER_ARGS); 235 236 static void acpi_asus_notify(ACPI_HANDLE h, UINT32 notify, void *context); 237 238 static device_method_t acpi_asus_methods[] = { 239 DEVMETHOD(device_probe, acpi_asus_probe), 240 DEVMETHOD(device_attach, acpi_asus_attach), 241 DEVMETHOD(device_detach, acpi_asus_detach), 242 243 { 0, 0 } 244 }; 245 246 static driver_t acpi_asus_driver = { 247 "acpi_asus", 248 acpi_asus_methods, 249 sizeof(struct acpi_asus_softc) 250 }; 251 252 static devclass_t acpi_asus_devclass; 253 254 DRIVER_MODULE(acpi_asus, acpi, acpi_asus_driver, acpi_asus_devclass, 0, 0); 255 MODULE_DEPEND(acpi_asus, acpi, 1, 1, 1); 256 257 static int 258 acpi_asus_probe(device_t dev) 259 { 260 struct acpi_asus_model *model; 261 struct acpi_asus_softc *sc; 262 struct sbuf *sb; 263 ACPI_BUFFER Buf; 264 ACPI_OBJECT Arg, *Obj; 265 ACPI_OBJECT_LIST Args; 266 static char *asus_ids[] = { "ATK0100", NULL }; 267 268 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 269 270 if (!acpi_disabled("asus") && 271 ACPI_ID_PROBE(device_get_parent(dev), dev, asus_ids)) { 272 sc = device_get_softc(dev); 273 sc->dev = dev; 274 sc->handle = acpi_get_handle(dev); 275 276 Arg.Type = ACPI_TYPE_INTEGER; 277 Arg.Integer.Value = 0; 278 279 Args.Count = 1; 280 Args.Pointer = &Arg; 281 282 Buf.Pointer = NULL; 283 Buf.Length = ACPI_ALLOCATE_BUFFER; 284 285 AcpiEvaluateObject(sc->handle, "INIT", &Args, &Buf); 286 Obj = Buf.Pointer; 287 288 /* 289 * The Samsung P30 returns a null-pointer from INIT, we 290 * can identify it from the 'ODEM' string in the DSDT. 291 */ 292 if (Obj->String.Pointer == NULL) { 293 ACPI_STATUS status; 294 ACPI_TABLE_HEADER th; 295 296 status = AcpiGetTableHeader(ACPI_TABLE_DSDT, 1, &th); 297 if (ACPI_FAILURE(status)) { 298 device_printf(dev, "Unsupported laptop\n"); 299 AcpiOsFree(Buf.Pointer); 300 return (ENXIO); 301 } 302 303 if (strncmp("ODEM", th.OemTableId, 4) == 0) { 304 sc->model = &acpi_samsung_models[0]; 305 device_set_desc(dev, 306 "Samsung P30 Laptop Extras"); 307 AcpiOsFree(Buf.Pointer); 308 return (0); 309 } 310 } 311 312 sb = sbuf_new(NULL, NULL, 0, SBUF_AUTOEXTEND); 313 314 if (sb == NULL) 315 return (ENOMEM); 316 317 /* 318 * Asus laptops are simply identified by name, easy! 319 */ 320 for (model = acpi_asus_models; model->name != NULL; model++) 321 if (strcmp(Obj->String.Pointer, model->name) == 0) { 322 sbuf_printf(sb, "Asus %s Laptop Extras", 323 Obj->String.Pointer); 324 sbuf_finish(sb); 325 326 sc->model = model; 327 device_set_desc(dev, sbuf_data(sb)); 328 329 sbuf_delete(sb); 330 AcpiOsFree(Buf.Pointer); 331 return (0); 332 } 333 334 sbuf_printf(sb, "Unsupported Asus laptop detected: %s\n", 335 Obj->String.Pointer); 336 sbuf_finish(sb); 337 338 device_printf(dev, sbuf_data(sb)); 339 340 sbuf_delete(sb); 341 AcpiOsFree(Buf.Pointer); 342 } 343 344 return (ENXIO); 345 } 346 347 static int 348 acpi_asus_attach(device_t dev) 349 { 350 struct acpi_asus_softc *sc; 351 struct acpi_softc *acpi_sc; 352 353 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 354 355 sc = device_get_softc(dev); 356 acpi_sc = acpi_device_get_parent_softc(dev); 357 358 /* Build sysctl tree */ 359 sysctl_ctx_init(&sc->sysctl_ctx); 360 sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx, 361 SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), 362 OID_AUTO, "asus", CTLFLAG_RD, 0, ""); 363 364 /* Attach leds */ 365 if (sc->model->mled_set) { 366 sc->s_mled.dev = dev; 367 sc->s_mled.type = ACPI_ASUS_LED_MLED; 368 sc->s_mled.cdev = 369 led_create((led_t *)acpi_asus_led, &sc->s_mled, "mled"); 370 } 371 372 if (sc->model->tled_set) { 373 sc->s_tled.dev = dev; 374 sc->s_tled.type = ACPI_ASUS_LED_TLED; 375 sc->s_tled.cdev = 376 led_create((led_t *)acpi_asus_led, &sc->s_tled, "tled"); 377 } 378 379 if (sc->model->wled_set) { 380 sc->s_wled.dev = dev; 381 sc->s_wled.type = ACPI_ASUS_LED_WLED; 382 sc->s_wled.cdev = 383 led_create((led_t *)acpi_asus_led, &sc->s_wled, "wled"); 384 } 385 386 /* Attach brightness for GPLV/SPLV models */ 387 if (sc->model->brn_get && ACPI_SUCCESS(acpi_GetInteger(sc->handle, 388 sc->model->brn_get, &sc->s_brn))) 389 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 390 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 391 "lcd_brightness", CTLTYPE_INT | CTLFLAG_RW, sc, 0, 392 acpi_asus_sysctl_brn, "I", "brightness of the lcd panel"); 393 394 /* Attach brightness for other models */ 395 if (sc->model->brn_up && 396 ACPI_SUCCESS(AcpiEvaluateObject(sc->handle, sc->model->brn_up, 397 NULL, NULL)) && 398 ACPI_SUCCESS(AcpiEvaluateObject(sc->handle, sc->model->brn_dn, 399 NULL, NULL))) 400 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 401 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 402 "lcd_brightness", CTLTYPE_INT | CTLFLAG_RW, sc, 0, 403 acpi_asus_sysctl_brn, "I", "brightness of the lcd panel"); 404 405 /* Attach display switching */ 406 if (sc->model->disp_get && ACPI_SUCCESS(acpi_GetInteger(sc->handle, 407 sc->model->disp_get, &sc->s_disp))) 408 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 409 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 410 "video_output", CTLTYPE_INT | CTLFLAG_RW, sc, 0, 411 acpi_asus_sysctl_disp, "I", "display output state"); 412 413 /* Attach LCD state, easy for most models... */ 414 if (sc->model->lcd_get && strncmp(sc->model->name, "L3H", 3) != 0 && 415 ACPI_SUCCESS(acpi_GetInteger(sc->handle, sc->model->lcd_get, 416 &sc->s_lcd))) { 417 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 418 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 419 "lcd_backlight", CTLTYPE_INT | CTLFLAG_RW, sc, 0, 420 acpi_asus_sysctl_lcd, "I", "state of the lcd backlight"); 421 } else if (sc->model->lcd_get) { 422 ACPI_BUFFER Buf; 423 ACPI_OBJECT Arg[2], Obj; 424 ACPI_OBJECT_LIST Args; 425 426 /* ...a nightmare for the L3H */ 427 Arg[0].Type = ACPI_TYPE_INTEGER; 428 Arg[0].Integer.Value = 0x02; 429 Arg[1].Type = ACPI_TYPE_INTEGER; 430 Arg[1].Integer.Value = 0x03; 431 432 Args.Count = 2; 433 Args.Pointer = Arg; 434 435 Buf.Length = sizeof(Obj); 436 Buf.Pointer = &Obj; 437 438 if (ACPI_SUCCESS(AcpiEvaluateObject(sc->handle, 439 sc->model->lcd_get, &Args, &Buf)) && 440 Obj.Type == ACPI_TYPE_INTEGER) { 441 sc->s_lcd = Obj.Integer.Value >> 8; 442 443 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 444 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 445 "lcd_backlight", CTLTYPE_INT | CTLFLAG_RW, sc, 0, 446 acpi_asus_sysctl_lcd, "I", 447 "state of the lcd backlight"); 448 } 449 } 450 451 /* Activate hotkeys */ 452 AcpiEvaluateObject(sc->handle, "BSTS", NULL, NULL); 453 454 /* Handle notifies */ 455 AcpiInstallNotifyHandler(sc->handle, ACPI_SYSTEM_NOTIFY, 456 acpi_asus_notify, dev); 457 458 return (0); 459 } 460 461 static int 462 acpi_asus_detach(device_t dev) 463 { 464 struct acpi_asus_softc *sc; 465 466 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 467 468 sc = device_get_softc(dev); 469 470 /* Turn the lights off */ 471 if (sc->model->mled_set) 472 led_destroy(sc->s_mled.cdev); 473 474 if (sc->model->tled_set) 475 led_destroy(sc->s_tled.cdev); 476 477 if (sc->model->wled_set) 478 led_destroy(sc->s_wled.cdev); 479 480 /* Remove notify handler */ 481 AcpiRemoveNotifyHandler(sc->handle, ACPI_SYSTEM_NOTIFY, 482 acpi_asus_notify); 483 484 /* Free sysctl tree */ 485 sysctl_ctx_free(&sc->sysctl_ctx); 486 487 return (0); 488 } 489 490 static void 491 acpi_asus_led(struct acpi_asus_led *led, int state) 492 { 493 struct acpi_asus_softc *sc; 494 char *method; 495 496 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 497 498 sc = device_get_softc(led->dev); 499 500 switch (led->type) { 501 case ACPI_ASUS_LED_MLED: 502 method = sc->model->mled_set; 503 504 /* Note: inverted */ 505 state = !state; 506 break; 507 case ACPI_ASUS_LED_TLED: 508 method = sc->model->tled_set; 509 break; 510 case ACPI_ASUS_LED_WLED: 511 method = sc->model->wled_set; 512 break; 513 default: 514 printf("acpi_asus_led: invalid LED type %d\n", 515 (int)led->type); 516 return; 517 } 518 519 acpi_SetInteger(sc->handle, method, state); 520 } 521 522 static int 523 acpi_asus_sysctl_brn(SYSCTL_HANDLER_ARGS) 524 { 525 struct acpi_asus_softc *sc; 526 int brn, err; 527 528 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 529 530 sc = (struct acpi_asus_softc *)oidp->oid_arg1; 531 ACPI_SERIAL_BEGIN(asus); 532 533 /* Sanity check */ 534 brn = sc->s_brn; 535 err = sysctl_handle_int(oidp, &brn, 0, req); 536 537 if (err != 0 || req->newptr == NULL) 538 goto out; 539 540 if (brn < 0 || brn > 15) { 541 err = EINVAL; 542 goto out; 543 } 544 545 /* Keep track and update */ 546 sc->s_brn = brn; 547 548 if (sc->model->brn_set) 549 acpi_SetInteger(sc->handle, sc->model->brn_set, brn); 550 else { 551 brn -= sc->s_brn; 552 553 while (brn != 0) { 554 AcpiEvaluateObject(sc->handle, (brn > 0) ? 555 sc->model->brn_up : sc->model->brn_dn, 556 NULL, NULL); 557 (brn > 0) ? brn-- : brn++; 558 } 559 } 560 561 out: 562 ACPI_SERIAL_END(asus); 563 return (err); 564 } 565 566 static int 567 acpi_asus_sysctl_lcd(SYSCTL_HANDLER_ARGS) 568 { 569 struct acpi_asus_softc *sc; 570 int lcd, err; 571 572 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 573 574 sc = (struct acpi_asus_softc *)oidp->oid_arg1; 575 ACPI_SERIAL_BEGIN(asus); 576 577 /* Sanity check */ 578 lcd = sc->s_lcd; 579 err = sysctl_handle_int(oidp, &lcd, 0, req); 580 581 if (err != 0 || req->newptr == NULL) 582 goto out; 583 584 if (lcd < 0 || lcd > 1) { 585 err = EINVAL; 586 goto out; 587 } 588 589 /* Keep track and update */ 590 sc->s_lcd = lcd; 591 592 /* Most models just need a lcd_set evaluated, the L3H is trickier */ 593 if (strncmp(sc->model->name, "L3H", 3) != 0) 594 AcpiEvaluateObject(sc->handle, sc->model->lcd_set, NULL, NULL); 595 else 596 acpi_SetInteger(sc->handle, sc->model->lcd_set, 0x7); 597 598 out: 599 ACPI_SERIAL_END(asus); 600 return (err); 601 } 602 603 static int 604 acpi_asus_sysctl_disp(SYSCTL_HANDLER_ARGS) 605 { 606 struct acpi_asus_softc *sc; 607 int disp, err; 608 609 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 610 611 sc = (struct acpi_asus_softc *)oidp->oid_arg1; 612 613 /* Sanity check */ 614 ACPI_SERIAL_BEGIN(asus); 615 disp = sc->s_disp; 616 err = sysctl_handle_int(oidp, &disp, 0, req); 617 618 if (err != 0 || req->newptr == NULL) 619 goto out; 620 621 if (disp < 0 || disp > 7) { 622 err = EINVAL; 623 goto out; 624 } 625 626 /* Keep track and update */ 627 sc->s_disp = disp; 628 acpi_SetInteger(sc->handle, sc->model->disp_set, disp); 629 630 out: 631 ACPI_SERIAL_END(asus); 632 return (err); 633 } 634 635 static void 636 acpi_asus_notify(ACPI_HANDLE h, UINT32 notify, void *context) 637 { 638 struct acpi_asus_softc *sc; 639 struct acpi_softc *acpi_sc; 640 641 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 642 643 sc = device_get_softc((device_t)context); 644 acpi_sc = acpi_device_get_parent_softc(sc->dev); 645 646 ACPI_SERIAL_BEGIN(asus); 647 if ((notify & ~0x10) <= 15) { 648 sc->s_brn = notify & ~0x10; 649 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness increased\n"); 650 } else if ((notify & ~0x20) <= 15) { 651 sc->s_brn = notify & ~0x20; 652 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness decreased\n"); 653 } else if (notify == 0x33) { 654 sc->s_lcd = 1; 655 ACPI_VPRINT(sc->dev, acpi_sc, "LCD turned on\n"); 656 } else if (notify == 0x34) { 657 sc->s_lcd = 0; 658 ACPI_VPRINT(sc->dev, acpi_sc, "LCD turned off\n"); 659 } else { 660 /* Notify devd(8) */ 661 acpi_UserNotify("ASUS", h, notify); 662 } 663 ACPI_SERIAL_END(asus); 664 } 665