1 /*- 2 * Copyright (c) 2002 Sean Bullington <seanATstalker.org> 3 * 2003-2006 Anish Mistry <amistry@am-productions.biz> 4 * 2004 Mark Santcroos <marks@ripe.net> 5 * All Rights Reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 17 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 18 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 19 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 20 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 21 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 22 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 23 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 24 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 25 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 26 * SUCH DAMAGE. 27 * 28 */ 29 30 #include <sys/cdefs.h> 31 __FBSDID("$FreeBSD$"); 32 33 #include "opt_acpi.h" 34 #include <sys/param.h> 35 #include <sys/kernel.h> 36 #include <sys/bus.h> 37 #include <sys/module.h> 38 #include <sys/sysctl.h> 39 40 #include <contrib/dev/acpica/include/acpi.h> 41 #include <contrib/dev/acpica/include/accommon.h> 42 43 #include <dev/acpica/acpivar.h> 44 45 /* Hooks for the ACPI CA debugging infrastructure */ 46 #define _COMPONENT ACPI_OEM 47 ACPI_MODULE_NAME("Fujitsu") 48 49 /* Change and update bits for the hotkeys */ 50 #define VOLUME_MUTE_BIT 0x40000000 51 52 /* Values of settings */ 53 #define GENERAL_SETTING_BITS 0x0fffffff 54 #define MOUSE_SETTING_BITS GENERAL_SETTING_BITS 55 #define VOLUME_SETTING_BITS GENERAL_SETTING_BITS 56 #define BRIGHTNESS_SETTING_BITS GENERAL_SETTING_BITS 57 58 /* Possible state changes */ 59 /* 60 * These are NOT arbitrary values. They are the 61 * GHKS return value from the device that says which 62 * hotkey is active. They should match up with a bit 63 * from the GSIF bitmask. 64 */ 65 #define BRIGHT_CHANGED 0x01 66 #define VOLUME_CHANGED 0x04 67 #define MOUSE_CHANGED 0x08 68 /* 69 * It is unknown which hotkey this bit is supposed to indicate, but 70 * according to values from GSIF this is a valid flag. 71 */ 72 #define UNKNOWN_CHANGED 0x10 73 74 /* sysctl values */ 75 #define FN_MUTE 0 76 #define FN_POINTER_ENABLE 1 77 #define FN_LCD_BRIGHTNESS 2 78 #define FN_VOLUME 3 79 80 /* Methods */ 81 #define METHOD_GBLL 1 82 #define METHOD_GMOU 2 83 #define METHOD_GVOL 3 84 #define METHOD_MUTE 4 85 #define METHOD_RBLL 5 86 #define METHOD_RVOL 6 87 #define METHOD_GSIF 7 88 #define METHOD_GHKS 8 89 90 /* Notify event */ 91 #define ACPI_NOTIFY_STATUS_CHANGED 0x80 92 93 /* 94 * Holds a control method name and its associated integer value. 95 * Only used for no-argument control methods which return a value. 96 */ 97 struct int_nameval { 98 char *name; 99 int value; 100 int exists; 101 }; 102 103 /* 104 * Driver extension for the FUJITSU ACPI driver. 105 */ 106 struct acpi_fujitsu_softc { 107 device_t dev; 108 ACPI_HANDLE handle; 109 110 /* Control methods */ 111 struct int_nameval _sta, /* unused */ 112 gbll, /* brightness */ 113 ghks, /* hotkey selector */ 114 gbuf, /* unused (buffer?) */ 115 gmou, /* mouse */ 116 gsif, /* function key bitmask */ 117 gvol, /* volume */ 118 rbll, /* number of brightness levels (radix) */ 119 rvol; /* number of volume levels (radix) */ 120 121 /* State variables */ 122 uint8_t bIsMuted; /* Is volume muted */ 123 uint8_t bIntPtrEnabled; /* Is internal ptr enabled */ 124 uint32_t lastValChanged; /* The last value updated */ 125 126 /* sysctl tree */ 127 struct sysctl_ctx_list sysctl_ctx; 128 struct sysctl_oid *sysctl_tree; 129 }; 130 131 /* Driver entry point forward declarations. */ 132 static int acpi_fujitsu_probe(device_t dev); 133 static int acpi_fujitsu_attach(device_t dev); 134 static int acpi_fujitsu_detach(device_t dev); 135 static int acpi_fujitsu_suspend(device_t dev); 136 static int acpi_fujitsu_resume(device_t dev); 137 138 static void acpi_fujitsu_notify_status_changed(void *arg); 139 static void acpi_fujitsu_notify_handler(ACPI_HANDLE h, uint32_t notify, void *context); 140 static int acpi_fujitsu_sysctl(SYSCTL_HANDLER_ARGS); 141 142 /* Utility function declarations */ 143 static uint8_t acpi_fujitsu_update(struct acpi_fujitsu_softc *sc); 144 static uint8_t acpi_fujitsu_init(struct acpi_fujitsu_softc *sc); 145 static uint8_t acpi_fujitsu_check_hardware(struct acpi_fujitsu_softc *sc); 146 147 /* Driver/Module specific structure definitions. */ 148 static device_method_t acpi_fujitsu_methods[] = { 149 /* Device interface */ 150 DEVMETHOD(device_probe, acpi_fujitsu_probe), 151 DEVMETHOD(device_attach, acpi_fujitsu_attach), 152 DEVMETHOD(device_detach, acpi_fujitsu_detach), 153 DEVMETHOD(device_suspend, acpi_fujitsu_suspend), 154 DEVMETHOD(device_resume, acpi_fujitsu_resume), 155 {0, 0} 156 }; 157 158 static driver_t acpi_fujitsu_driver = { 159 "acpi_fujitsu", 160 acpi_fujitsu_methods, 161 sizeof(struct acpi_fujitsu_softc), 162 }; 163 164 /* Prototype for function hotkeys for getting/setting a value. */ 165 static int acpi_fujitsu_method_get(struct acpi_fujitsu_softc *sc, int method); 166 static int acpi_fujitsu_method_set(struct acpi_fujitsu_softc *sc, int method, int value); 167 168 static char *fujitsu_ids[] = { "FUJ02B1", NULL }; 169 170 ACPI_SERIAL_DECL(fujitsu, "Fujitsu Function Hotkeys"); 171 172 /* sysctl names and function calls */ 173 static struct { 174 char *name; 175 int method; 176 char *description; 177 } sysctl_table[] = { 178 { 179 .name = "mute", 180 .method = METHOD_MUTE, 181 .description = "Speakers/headphones mute status" 182 }, 183 { 184 .name = "pointer_enable", 185 .method = METHOD_GMOU, 186 .description = "Enable and disable the internal pointer" 187 }, 188 { 189 .name = "lcd_brightness", 190 .method = METHOD_GBLL, 191 .description = "Brightness level of the LCD panel" 192 }, 193 { 194 .name = "volume", 195 .method = METHOD_GVOL, 196 .description = "Speakers/headphones volume level" 197 }, 198 { 199 .name = "volume_radix", 200 .method = METHOD_RVOL, 201 .description = "Number of volume level steps" 202 }, 203 { 204 .name = "lcd_brightness_radix", 205 .method = METHOD_RBLL, 206 .description = "Number of brightness level steps" 207 }, 208 209 { NULL, 0, NULL } 210 }; 211 212 static devclass_t acpi_fujitsu_devclass; 213 DRIVER_MODULE(acpi_fujitsu, acpi, acpi_fujitsu_driver, 214 acpi_fujitsu_devclass, 0, 0); 215 MODULE_DEPEND(acpi_fujitsu, acpi, 1, 1, 1); 216 MODULE_VERSION(acpi_fujitsu, 1); 217 218 static int 219 acpi_fujitsu_probe(device_t dev) 220 { 221 char *name; 222 char buffer[64]; 223 224 name = ACPI_ID_PROBE(device_get_parent(dev), dev, fujitsu_ids); 225 if (acpi_disabled("fujitsu") || name == NULL || 226 device_get_unit(dev) > 1) 227 return (ENXIO); 228 229 sprintf(buffer, "Fujitsu Function Hotkeys %s", name); 230 device_set_desc_copy(dev, buffer); 231 232 return (0); 233 } 234 235 static int 236 acpi_fujitsu_attach(device_t dev) 237 { 238 struct acpi_fujitsu_softc *sc; 239 240 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 241 242 sc = device_get_softc(dev); 243 sc->dev = dev; 244 sc->handle = acpi_get_handle(dev); 245 246 /* Install notification handler */ 247 AcpiInstallNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY, 248 acpi_fujitsu_notify_handler, sc); 249 250 /* Snag our default values for the hotkeys / hotkey states. */ 251 ACPI_SERIAL_BEGIN(fujitsu); 252 if (!acpi_fujitsu_init(sc)) 253 device_printf(dev, "Couldn't initialize hotkey states!\n"); 254 ACPI_SERIAL_END(fujitsu); 255 256 return (0); 257 } 258 259 /* 260 * Called when the system is being suspended, simply 261 * set an event to be signalled when we wake up. 262 */ 263 static int 264 acpi_fujitsu_suspend(device_t dev) 265 { 266 267 return (0); 268 } 269 270 static int 271 acpi_fujitsu_resume(device_t dev) 272 { 273 struct acpi_fujitsu_softc *sc; 274 ACPI_STATUS status; 275 276 sc = device_get_softc(dev); 277 278 /* 279 * The pointer needs to be re-enabled for 280 * some revisions of the P series (2120). 281 */ 282 ACPI_SERIAL_BEGIN(fujitsu); 283 284 if(sc->gmou.exists) { 285 status = acpi_SetInteger(sc->handle, "SMOU", 1); 286 if (ACPI_FAILURE(status)) 287 device_printf(sc->dev, "Couldn't enable pointer\n"); 288 } 289 ACPI_SERIAL_END(fujitsu); 290 291 return (0); 292 } 293 294 static void 295 acpi_fujitsu_notify_status_changed(void *arg) 296 { 297 struct acpi_fujitsu_softc *sc; 298 299 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 300 301 sc = (struct acpi_fujitsu_softc *)arg; 302 303 /* 304 * Since our notify function is called, we know something has 305 * happened. So the only reason for acpi_fujitsu_update to fail 306 * is if we can't find what has changed or an error occurs. 307 */ 308 ACPI_SERIAL_BEGIN(fujitsu); 309 acpi_fujitsu_update(sc); 310 ACPI_SERIAL_END(fujitsu); 311 } 312 313 314 static void 315 acpi_fujitsu_notify_handler(ACPI_HANDLE h, uint32_t notify, void *context) 316 { 317 struct acpi_fujitsu_softc *sc; 318 319 ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, notify); 320 321 sc = (struct acpi_fujitsu_softc *)context; 322 323 switch (notify) { 324 case ACPI_NOTIFY_STATUS_CHANGED: 325 AcpiOsExecute(OSL_NOTIFY_HANDLER, 326 acpi_fujitsu_notify_status_changed, sc); 327 break; 328 default: 329 /* unknown notification value */ 330 break; 331 } 332 } 333 334 static int 335 acpi_fujitsu_detach(device_t dev) 336 { 337 struct acpi_fujitsu_softc *sc; 338 339 sc = device_get_softc(dev); 340 AcpiRemoveNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY, 341 acpi_fujitsu_notify_handler); 342 343 sysctl_ctx_free(&sc->sysctl_ctx); 344 345 return (0); 346 } 347 348 /* 349 * Initializes the names of the ACPI control methods and grabs 350 * the current state of all of the ACPI hotkeys into the softc. 351 */ 352 static uint8_t 353 acpi_fujitsu_init(struct acpi_fujitsu_softc *sc) 354 { 355 struct acpi_softc *acpi_sc; 356 int i, exists; 357 358 ACPI_SERIAL_ASSERT(fujitsu); 359 360 /* Setup all of the names for each control method */ 361 sc->_sta.name = "_STA"; 362 sc->gbll.name = "GBLL"; 363 sc->ghks.name = "GHKS"; 364 sc->gmou.name = "GMOU"; 365 sc->gsif.name = "GSIF"; 366 sc->gvol.name = "GVOL"; 367 sc->ghks.name = "GHKS"; 368 sc->gsif.name = "GSIF"; 369 sc->rbll.name = "RBLL"; 370 sc->rvol.name = "RVOL"; 371 372 /* Determine what hardware functionality is available */ 373 acpi_fujitsu_check_hardware(sc); 374 375 /* Build the sysctl tree */ 376 acpi_sc = acpi_device_get_parent_softc(sc->dev); 377 sysctl_ctx_init(&sc->sysctl_ctx); 378 sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx, 379 SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), 380 OID_AUTO, "fujitsu", CTLFLAG_RD, 0, ""); 381 382 for (i = 0; sysctl_table[i].name != NULL; i++) { 383 switch(sysctl_table[i].method) { 384 case METHOD_GMOU: 385 exists = sc->gmou.exists; 386 break; 387 case METHOD_GBLL: 388 exists = sc->gbll.exists; 389 break; 390 case METHOD_GVOL: 391 case METHOD_MUTE: 392 exists = sc->gvol.exists; 393 break; 394 case METHOD_RVOL: 395 exists = sc->rvol.exists; 396 break; 397 case METHOD_RBLL: 398 exists = sc->rbll.exists; 399 break; 400 default: 401 /* Allow by default */ 402 exists = 1; 403 break; 404 } 405 if(!exists) 406 continue; 407 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 408 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 409 sysctl_table[i].name, 410 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY, 411 sc, i, acpi_fujitsu_sysctl, "I", 412 sysctl_table[i].description); 413 } 414 415 416 /* Set the hotkeys to their initial states */ 417 if (!acpi_fujitsu_update(sc)) { 418 device_printf(sc->dev, "Couldn't init hotkey states\n"); 419 return (FALSE); 420 } 421 422 return (TRUE); 423 } 424 425 static int 426 acpi_fujitsu_sysctl(SYSCTL_HANDLER_ARGS) 427 { 428 struct acpi_fujitsu_softc *sc; 429 int method; 430 int arg; 431 int function_num, error = 0; 432 433 sc = (struct acpi_fujitsu_softc *)oidp->oid_arg1; 434 function_num = oidp->oid_arg2; 435 method = sysctl_table[function_num].method; 436 437 ACPI_SERIAL_BEGIN(fujitsu); 438 439 /* Get the current value */ 440 arg = acpi_fujitsu_method_get(sc, method); 441 error = sysctl_handle_int(oidp, &arg, 0, req); 442 443 if (error != 0 || req->newptr == NULL) 444 goto out; 445 446 /* Update the value */ 447 error = acpi_fujitsu_method_set(sc, method, arg); 448 449 out: 450 ACPI_SERIAL_END(fujitsu); 451 return (error); 452 } 453 454 static int 455 acpi_fujitsu_method_get(struct acpi_fujitsu_softc *sc, int method) 456 { 457 struct int_nameval nv; 458 ACPI_STATUS status; 459 460 ACPI_SERIAL_ASSERT(fujitsu); 461 462 switch (method) { 463 case METHOD_GBLL: 464 nv = sc->gbll; 465 break; 466 case METHOD_GMOU: 467 nv = sc->gmou; 468 break; 469 case METHOD_GVOL: 470 case METHOD_MUTE: 471 nv = sc->gvol; 472 break; 473 case METHOD_GHKS: 474 nv = sc->ghks; 475 break; 476 case METHOD_GSIF: 477 nv = sc->gsif; 478 break; 479 case METHOD_RBLL: 480 nv = sc->rbll; 481 break; 482 case METHOD_RVOL: 483 nv = sc->rvol; 484 break; 485 default: 486 return (FALSE); 487 } 488 489 if(!nv.exists) 490 return (EINVAL); 491 492 status = acpi_GetInteger(sc->handle, nv.name, &nv.value); 493 if (ACPI_FAILURE(status)) { 494 device_printf(sc->dev, "Couldn't query method (%s)\n", nv.name); 495 return (FALSE); 496 } 497 498 if (method == METHOD_MUTE) { 499 sc->bIsMuted = (uint8_t)((nv.value & VOLUME_MUTE_BIT) != 0); 500 return (sc->bIsMuted); 501 } 502 503 nv.value &= GENERAL_SETTING_BITS; 504 return (nv.value); 505 } 506 507 static int 508 acpi_fujitsu_method_set(struct acpi_fujitsu_softc *sc, int method, int value) 509 { 510 struct int_nameval nv; 511 ACPI_STATUS status; 512 char *control; 513 int changed; 514 515 ACPI_SERIAL_ASSERT(fujitsu); 516 517 switch (method) { 518 case METHOD_GBLL: 519 changed = BRIGHT_CHANGED; 520 control = "SBLL"; 521 nv = sc->gbll; 522 break; 523 case METHOD_GMOU: 524 changed = MOUSE_CHANGED; 525 control = "SMOU"; 526 nv = sc->gmou; 527 break; 528 case METHOD_GVOL: 529 case METHOD_MUTE: 530 changed = VOLUME_CHANGED; 531 control = "SVOL"; 532 nv = sc->gvol; 533 break; 534 default: 535 return (EINVAL); 536 } 537 538 if(!nv.exists) 539 return (EINVAL); 540 541 if (method == METHOD_MUTE) { 542 if (value == 1) 543 value = nv.value | VOLUME_MUTE_BIT; 544 else if (value == 0) 545 value = nv.value & ~VOLUME_MUTE_BIT; 546 else 547 return (EINVAL); 548 } 549 550 status = acpi_SetInteger(sc->handle, control, value); 551 if (ACPI_FAILURE(status)) { 552 device_printf(sc->dev, "Couldn't update %s\n", control); 553 return (FALSE); 554 } 555 556 sc->lastValChanged = changed; 557 return (0); 558 } 559 560 /* 561 * Query the get methods to determine what functionality is available 562 * from the hardware function hotkeys. 563 */ 564 static uint8_t 565 acpi_fujitsu_check_hardware(struct acpi_fujitsu_softc *sc) 566 { 567 int val; 568 569 ACPI_SERIAL_ASSERT(fujitsu); 570 /* save the hotkey bitmask */ 571 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 572 sc->gsif.name, &(sc->gsif.value)))) { 573 sc->gsif.exists = 0; 574 device_printf(sc->dev, "Couldn't query bitmask value\n"); 575 } else { 576 sc->gsif.exists = 1; 577 } 578 579 /* System Volume Level */ 580 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 581 sc->gvol.name, &val))) { 582 sc->gvol.exists = 0; 583 } else { 584 sc->gvol.exists = 1; 585 } 586 587 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 588 sc->gbll.name, &val))) { 589 sc->gbll.exists = 0; 590 } else { 591 sc->gbll.exists = 1; 592 } 593 594 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 595 sc->ghks.name, &val))) { 596 sc->ghks.exists = 0; 597 } else { 598 sc->ghks.exists = 1; 599 } 600 601 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 602 sc->gmou.name, &val))) { 603 sc->gmou.exists = 0; 604 } else { 605 sc->gmou.exists = 1; 606 } 607 608 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 609 sc->rbll.name, &val))) { 610 sc->rbll.exists = 0; 611 } else { 612 sc->rbll.exists = 1; 613 } 614 615 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 616 sc->rvol.name, &val))) { 617 sc->rvol.exists = 0; 618 } else { 619 sc->rvol.exists = 1; 620 } 621 622 return (TRUE); 623 } 624 625 /* 626 * Query each of the ACPI control methods that contain information we're 627 * interested in. We check the return values from the control methods and 628 * adjust any state variables if they should be adjusted. 629 */ 630 static uint8_t 631 acpi_fujitsu_update(struct acpi_fujitsu_softc *sc) 632 { 633 int changed; 634 struct acpi_softc *acpi_sc; 635 636 acpi_sc = acpi_device_get_parent_softc(sc->dev); 637 638 ACPI_SERIAL_ASSERT(fujitsu); 639 if(sc->gsif.exists) 640 changed = sc->gsif.value & acpi_fujitsu_method_get(sc,METHOD_GHKS); 641 else 642 changed = 0; 643 644 /* System Volume Level */ 645 if(sc->gvol.exists) { 646 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 647 sc->gvol.name, &(sc->gvol.value)))) { 648 device_printf(sc->dev, "Couldn't query volume level\n"); 649 return (FALSE); 650 } 651 652 if (changed & VOLUME_CHANGED) { 653 sc->bIsMuted = 654 (uint8_t)((sc->gvol.value & VOLUME_MUTE_BIT) != 0); 655 656 /* Clear the modification bit */ 657 sc->gvol.value &= VOLUME_SETTING_BITS; 658 659 if (sc->bIsMuted) { 660 acpi_UserNotify("FUJITSU", sc->handle, FN_MUTE); 661 ACPI_VPRINT(sc->dev, acpi_sc, "Volume is now mute\n"); 662 } else 663 ACPI_VPRINT(sc->dev, acpi_sc, "Volume is now %d\n", 664 sc->gvol.value); 665 666 acpi_UserNotify("FUJITSU", sc->handle, FN_VOLUME); 667 } 668 } 669 670 /* Internal mouse pointer (eraserhead) */ 671 if(sc->gmou.exists) { 672 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 673 sc->gmou.name, &(sc->gmou.value)))) { 674 device_printf(sc->dev, "Couldn't query pointer state\n"); 675 return (FALSE); 676 } 677 678 if (changed & MOUSE_CHANGED) { 679 sc->bIntPtrEnabled = (uint8_t)(sc->gmou.value & 0x1); 680 681 /* Clear the modification bit */ 682 sc->gmou.value &= MOUSE_SETTING_BITS; 683 684 acpi_UserNotify("FUJITSU", sc->handle, FN_POINTER_ENABLE); 685 686 ACPI_VPRINT(sc->dev, acpi_sc, "Internal pointer is now %s\n", 687 (sc->bIntPtrEnabled) ? "enabled" : "disabled"); 688 } 689 } 690 691 /* Screen Brightness Level */ 692 if(sc->gbll.exists) { 693 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 694 sc->gbll.name, &(sc->gbll.value)))) { 695 device_printf(sc->dev, "Couldn't query brightness level\n"); 696 return (FALSE); 697 } 698 699 if (changed & BRIGHT_CHANGED) { 700 /* No state to record here. */ 701 702 /* Clear the modification bit */ 703 sc->gbll.value &= BRIGHTNESS_SETTING_BITS; 704 705 acpi_UserNotify("FUJITSU", sc->handle, FN_LCD_BRIGHTNESS); 706 707 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness level is now %d\n", 708 sc->gbll.value); 709 } 710 } 711 712 sc->lastValChanged = changed; 713 return (TRUE); 714 } 715