1 /*- 2 * Copyright (c) 2002 Sean Bullington <seanATstalker.org> 3 * 2003-2008 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 * $FreeBSD: head/sys/dev/acpi_support/acpi_fujitsu.c 246128 2013-01-30 18:01:20Z sbz $ 29 */ 30 31 #include "opt_acpi.h" 32 #include <sys/param.h> 33 #include <sys/kernel.h> 34 #include <sys/bus.h> 35 #include <sys/module.h> 36 #include <sys/sysctl.h> 37 38 #include "acpi.h" 39 #include "accommon.h" 40 41 #include <dev/acpica/acpivar.h> 42 43 /* Hooks for the ACPICA debugging infrastructure */ 44 #define _COMPONENT ACPI_OEM 45 ACPI_MODULE_NAME("Fujitsu") 46 47 /* Change and update bits for the hotkeys */ 48 #define VOLUME_MUTE_BIT 0x40000000 49 50 /* Values of settings */ 51 #define GENERAL_SETTING_BITS 0x0fffffff 52 #define MOUSE_SETTING_BITS GENERAL_SETTING_BITS 53 #define VOLUME_SETTING_BITS GENERAL_SETTING_BITS 54 #define BRIGHTNESS_SETTING_BITS GENERAL_SETTING_BITS 55 56 /* Possible state changes */ 57 /* 58 * These are NOT arbitrary values. They are the 59 * GHKS return value from the device that says which 60 * hotkey is active. They should match up with a bit 61 * from the GSIF bitmask. 62 */ 63 #define BRIGHT_CHANGED 0x01 64 #define VOLUME_CHANGED 0x04 65 #define MOUSE_CHANGED 0x08 66 /* 67 * It is unknown which hotkey this bit is supposed to indicate, but 68 * according to values from GSIF this is a valid flag. 69 */ 70 #define UNKNOWN_CHANGED 0x10 71 72 /* sysctl values */ 73 #define FN_MUTE 0 74 #define FN_POINTER_ENABLE 1 75 #define FN_LCD_BRIGHTNESS 2 76 #define FN_VOLUME 3 77 78 /* Methods */ 79 #define METHOD_GBLL 1 80 #define METHOD_GMOU 2 81 #define METHOD_GVOL 3 82 #define METHOD_MUTE 4 83 #define METHOD_RBLL 5 84 #define METHOD_RVOL 6 85 #define METHOD_GSIF 7 86 #define METHOD_GHKS 8 87 #define METHOD_GBLS 9 88 89 /* Notify event */ 90 #define ACPI_NOTIFY_STATUS_CHANGED 0x80 91 92 /* 93 * Holds a control method name and its associated integer value. 94 * Only used for no-argument control methods which return a value. 95 */ 96 struct int_nameval { 97 char *name; 98 int value; 99 int exists; 100 }; 101 102 /* 103 * Driver extension for the FUJITSU ACPI driver. 104 */ 105 struct acpi_fujitsu_softc { 106 device_t dev; 107 ACPI_HANDLE handle; 108 109 /* Control methods */ 110 struct int_nameval _sta, /* unused */ 111 gbll, /* brightness */ 112 gbls, /* get brightness state */ 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 DEVMETHOD_END 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 = "lcd_brightness", 195 .method = METHOD_GBLS, 196 .description = "Brightness level of the LCD panel" 197 }, 198 { 199 .name = "volume", 200 .method = METHOD_GVOL, 201 .description = "Speakers/headphones volume level" 202 }, 203 { 204 .name = "volume_radix", 205 .method = METHOD_RVOL, 206 .description = "Number of volume level steps" 207 }, 208 { 209 .name = "lcd_brightness_radix", 210 .method = METHOD_RBLL, 211 .description = "Number of brightness level steps" 212 }, 213 214 { NULL, 0, NULL } 215 }; 216 217 static devclass_t acpi_fujitsu_devclass; 218 DRIVER_MODULE(acpi_fujitsu, acpi, acpi_fujitsu_driver, 219 acpi_fujitsu_devclass, NULL, NULL); 220 MODULE_DEPEND(acpi_fujitsu, acpi, 1, 1, 1); 221 MODULE_VERSION(acpi_fujitsu, 1); 222 223 static int 224 acpi_fujitsu_probe(device_t dev) 225 { 226 char *name; 227 char buffer[64]; 228 229 name = ACPI_ID_PROBE(device_get_parent(dev), dev, fujitsu_ids); 230 if (acpi_disabled("fujitsu") || name == NULL || 231 device_get_unit(dev) > 1) 232 return (ENXIO); 233 234 ksprintf(buffer, "Fujitsu Function Hotkeys %s", name); 235 device_set_desc_copy(dev, buffer); 236 237 return (0); 238 } 239 240 static int 241 acpi_fujitsu_attach(device_t dev) 242 { 243 struct acpi_fujitsu_softc *sc; 244 245 ACPI_SERIAL_INIT(fujitsu); 246 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 247 248 sc = device_get_softc(dev); 249 sc->dev = dev; 250 sc->handle = acpi_get_handle(dev); 251 252 /* Install notification handler */ 253 AcpiInstallNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY, 254 acpi_fujitsu_notify_handler, sc); 255 256 /* Snag our default values for the hotkeys / hotkey states. */ 257 ACPI_SERIAL_BEGIN(fujitsu); 258 if (!acpi_fujitsu_init(sc)) 259 device_printf(dev, "Couldn't initialize hotkey states!\n"); 260 ACPI_SERIAL_END(fujitsu); 261 262 return (0); 263 } 264 265 /* 266 * Called when the system is being suspended, simply 267 * set an event to be signalled when we wake up. 268 */ 269 static int 270 acpi_fujitsu_suspend(device_t dev) 271 { 272 273 return (0); 274 } 275 276 static int 277 acpi_fujitsu_resume(device_t dev) 278 { 279 struct acpi_fujitsu_softc *sc; 280 ACPI_STATUS status; 281 282 sc = device_get_softc(dev); 283 284 /* 285 * The pointer needs to be re-enabled for 286 * some revisions of the P series (2120). 287 */ 288 ACPI_SERIAL_BEGIN(fujitsu); 289 290 if(sc->gmou.exists) { 291 status = acpi_SetInteger(sc->handle, "SMOU", 1); 292 if (ACPI_FAILURE(status)) 293 device_printf(sc->dev, "Couldn't enable pointer\n"); 294 } 295 ACPI_SERIAL_END(fujitsu); 296 297 return (0); 298 } 299 300 static void 301 acpi_fujitsu_notify_status_changed(void *arg) 302 { 303 struct acpi_fujitsu_softc *sc; 304 305 ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__); 306 307 sc = (struct acpi_fujitsu_softc *)arg; 308 309 /* 310 * Since our notify function is called, we know something has 311 * happened. So the only reason for acpi_fujitsu_update to fail 312 * is if we can't find what has changed or an error occurs. 313 */ 314 ACPI_SERIAL_BEGIN(fujitsu); 315 acpi_fujitsu_update(sc); 316 ACPI_SERIAL_END(fujitsu); 317 } 318 319 320 static void 321 acpi_fujitsu_notify_handler(ACPI_HANDLE h, uint32_t notify, void *context) 322 { 323 struct acpi_fujitsu_softc *sc; 324 325 ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, notify); 326 327 sc = (struct acpi_fujitsu_softc *)context; 328 329 switch (notify) { 330 case ACPI_NOTIFY_STATUS_CHANGED: 331 AcpiOsExecute(OSL_NOTIFY_HANDLER, 332 acpi_fujitsu_notify_status_changed, sc); 333 break; 334 default: 335 device_printf(sc->dev, "unknown notify: %#x\n", notify); 336 break; 337 } 338 } 339 340 static int 341 acpi_fujitsu_detach(device_t dev) 342 { 343 struct acpi_fujitsu_softc *sc; 344 345 sc = device_get_softc(dev); 346 AcpiRemoveNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY, 347 acpi_fujitsu_notify_handler); 348 349 sysctl_ctx_free(&sc->sysctl_ctx); 350 351 return (0); 352 } 353 354 /* 355 * Initializes the names of the ACPI control methods and grabs 356 * the current state of all of the ACPI hotkeys into the softc. 357 */ 358 static uint8_t 359 acpi_fujitsu_init(struct acpi_fujitsu_softc *sc) 360 { 361 struct acpi_softc *acpi_sc; 362 int i, exists; 363 364 ACPI_SERIAL_ASSERT(fujitsu); 365 366 /* Setup all of the names for each control method */ 367 sc->_sta.name = "_STA"; 368 sc->gbll.name = "GBLL"; 369 sc->gbls.name = "GBLS"; 370 sc->ghks.name = "GHKS"; 371 sc->gmou.name = "GMOU"; 372 sc->gsif.name = "GSIF"; 373 sc->gvol.name = "GVOL"; 374 sc->ghks.name = "GHKS"; 375 sc->gsif.name = "GSIF"; 376 sc->rbll.name = "RBLL"; 377 sc->rvol.name = "RVOL"; 378 379 /* Determine what hardware functionality is available */ 380 acpi_fujitsu_check_hardware(sc); 381 382 /* Build the sysctl tree */ 383 acpi_sc = acpi_device_get_parent_softc(sc->dev); 384 sysctl_ctx_init(&sc->sysctl_ctx); 385 sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx, 386 SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), 387 OID_AUTO, "fujitsu", CTLFLAG_RD, 0, ""); 388 389 for (i = 0; sysctl_table[i].name != NULL; i++) { 390 switch(sysctl_table[i].method) { 391 case METHOD_GMOU: 392 exists = sc->gmou.exists; 393 break; 394 case METHOD_GBLL: 395 exists = sc->gbll.exists; 396 break; 397 case METHOD_GBLS: 398 exists = sc->gbls.exists; 399 break; 400 case METHOD_GVOL: 401 case METHOD_MUTE: 402 exists = sc->gvol.exists; 403 break; 404 case METHOD_RVOL: 405 exists = sc->rvol.exists; 406 break; 407 case METHOD_RBLL: 408 exists = sc->rbll.exists; 409 break; 410 default: 411 /* Allow by default */ 412 exists = 1; 413 break; 414 } 415 if(!exists) 416 continue; 417 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 418 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 419 sysctl_table[i].name, 420 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY, 421 sc, i, acpi_fujitsu_sysctl, "I", 422 sysctl_table[i].description); 423 } 424 425 426 /* Set the hotkeys to their initial states */ 427 if (!acpi_fujitsu_update(sc)) { 428 device_printf(sc->dev, "Couldn't init hotkey states\n"); 429 return (FALSE); 430 } 431 432 return (TRUE); 433 } 434 435 static int 436 acpi_fujitsu_sysctl(SYSCTL_HANDLER_ARGS) 437 { 438 struct acpi_fujitsu_softc *sc; 439 int method; 440 int arg; 441 int function_num, error = 0; 442 443 sc = (struct acpi_fujitsu_softc *)oidp->oid_arg1; 444 function_num = oidp->oid_arg2; 445 method = sysctl_table[function_num].method; 446 447 ACPI_SERIAL_BEGIN(fujitsu); 448 449 /* Get the current value */ 450 arg = acpi_fujitsu_method_get(sc, method); 451 error = sysctl_handle_int(oidp, &arg, 0, req); 452 453 if (error != 0 || req->newptr == NULL) 454 goto out; 455 456 /* Update the value */ 457 error = acpi_fujitsu_method_set(sc, method, arg); 458 459 out: 460 ACPI_SERIAL_END(fujitsu); 461 return (error); 462 } 463 464 static int 465 acpi_fujitsu_method_get(struct acpi_fujitsu_softc *sc, int method) 466 { 467 struct int_nameval nv; 468 ACPI_STATUS status; 469 470 ACPI_SERIAL_ASSERT(fujitsu); 471 472 switch (method) { 473 case METHOD_GBLL: 474 nv = sc->gbll; 475 break; 476 case METHOD_GBLS: 477 nv = sc->gbls; 478 break; 479 case METHOD_GMOU: 480 nv = sc->gmou; 481 break; 482 case METHOD_GVOL: 483 case METHOD_MUTE: 484 nv = sc->gvol; 485 break; 486 case METHOD_GHKS: 487 nv = sc->ghks; 488 break; 489 case METHOD_GSIF: 490 nv = sc->gsif; 491 break; 492 case METHOD_RBLL: 493 nv = sc->rbll; 494 break; 495 case METHOD_RVOL: 496 nv = sc->rvol; 497 break; 498 default: 499 return (FALSE); 500 } 501 502 if(!nv.exists) 503 return (EINVAL); 504 505 status = acpi_GetInteger(sc->handle, nv.name, &nv.value); 506 if (ACPI_FAILURE(status)) { 507 device_printf(sc->dev, "Couldn't query method (%s)\n", nv.name); 508 return (FALSE); 509 } 510 511 if (method == METHOD_MUTE) { 512 sc->bIsMuted = (uint8_t)((nv.value & VOLUME_MUTE_BIT) != 0); 513 return (sc->bIsMuted); 514 } 515 516 nv.value &= GENERAL_SETTING_BITS; 517 return (nv.value); 518 } 519 520 static int 521 acpi_fujitsu_method_set(struct acpi_fujitsu_softc *sc, int method, int value) 522 { 523 struct int_nameval nv; 524 ACPI_STATUS status; 525 char *control; 526 int changed; 527 528 ACPI_SERIAL_ASSERT(fujitsu); 529 530 switch (method) { 531 case METHOD_GBLL: 532 changed = BRIGHT_CHANGED; 533 control = "SBLL"; 534 nv = sc->gbll; 535 break; 536 case METHOD_GBLS: 537 changed = BRIGHT_CHANGED; 538 control = "SBL2"; 539 nv = sc->gbls; 540 break; 541 case METHOD_GMOU: 542 changed = MOUSE_CHANGED; 543 control = "SMOU"; 544 nv = sc->gmou; 545 break; 546 case METHOD_GVOL: 547 case METHOD_MUTE: 548 changed = VOLUME_CHANGED; 549 control = "SVOL"; 550 nv = sc->gvol; 551 break; 552 default: 553 return (EINVAL); 554 } 555 556 if(!nv.exists) 557 return (EINVAL); 558 559 if (method == METHOD_MUTE) { 560 if (value == 1) 561 value = nv.value | VOLUME_MUTE_BIT; 562 else if (value == 0) 563 value = nv.value & ~VOLUME_MUTE_BIT; 564 else 565 return (EINVAL); 566 } 567 568 status = acpi_SetInteger(sc->handle, control, value); 569 if (ACPI_FAILURE(status)) { 570 device_printf(sc->dev, "Couldn't update %s\n", control); 571 return (FALSE); 572 } 573 574 sc->lastValChanged = changed; 575 return (0); 576 } 577 578 /* 579 * Query the get methods to determine what functionality is available 580 * from the hardware function hotkeys. 581 */ 582 static uint8_t 583 acpi_fujitsu_check_hardware(struct acpi_fujitsu_softc *sc) 584 { 585 int val; 586 587 ACPI_SERIAL_ASSERT(fujitsu); 588 /* save the hotkey bitmask */ 589 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 590 sc->gsif.name, &(sc->gsif.value)))) { 591 sc->gsif.exists = 0; 592 device_printf(sc->dev, "Couldn't query bitmask value\n"); 593 } else { 594 sc->gsif.exists = 1; 595 } 596 597 /* System Volume Level */ 598 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 599 sc->gvol.name, &val))) { 600 sc->gvol.exists = 0; 601 } else { 602 sc->gvol.exists = 1; 603 } 604 605 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 606 sc->gbls.name, &val))) { 607 sc->gbls.exists = 0; 608 } else { 609 sc->gbls.exists = 1; 610 } 611 612 /* don't add if we can use the new method */ 613 if (sc->gbls.exists || ACPI_FAILURE(acpi_GetInteger(sc->handle, 614 sc->gbll.name, &val))) { 615 sc->gbll.exists = 0; 616 } else { 617 sc->gbll.exists = 1; 618 } 619 620 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 621 sc->ghks.name, &val))) { 622 sc->ghks.exists = 0; 623 } else { 624 sc->ghks.exists = 1; 625 } 626 627 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 628 sc->gmou.name, &val))) { 629 sc->gmou.exists = 0; 630 } else { 631 sc->gmou.exists = 1; 632 } 633 634 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 635 sc->rbll.name, &val))) { 636 sc->rbll.exists = 0; 637 } else { 638 sc->rbll.exists = 1; 639 } 640 641 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 642 sc->rvol.name, &val))) { 643 sc->rvol.exists = 0; 644 } else { 645 sc->rvol.exists = 1; 646 } 647 648 return (TRUE); 649 } 650 651 /* 652 * Query each of the ACPI control methods that contain information we're 653 * interested in. We check the return values from the control methods and 654 * adjust any state variables if they should be adjusted. 655 */ 656 static uint8_t 657 acpi_fujitsu_update(struct acpi_fujitsu_softc *sc) 658 { 659 int changed; 660 struct acpi_softc *acpi_sc; 661 662 acpi_sc = acpi_device_get_parent_softc(sc->dev); 663 664 ACPI_SERIAL_ASSERT(fujitsu); 665 if(sc->gsif.exists) 666 changed = sc->gsif.value & acpi_fujitsu_method_get(sc,METHOD_GHKS); 667 else 668 changed = 0; 669 670 /* System Volume Level */ 671 if(sc->gvol.exists) { 672 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 673 sc->gvol.name, &(sc->gvol.value)))) { 674 device_printf(sc->dev, "Couldn't query volume level\n"); 675 return (FALSE); 676 } 677 678 if (changed & VOLUME_CHANGED) { 679 sc->bIsMuted = 680 (uint8_t)((sc->gvol.value & VOLUME_MUTE_BIT) != 0); 681 682 /* Clear the modification bit */ 683 sc->gvol.value &= VOLUME_SETTING_BITS; 684 685 if (sc->bIsMuted) { 686 acpi_UserNotify("FUJITSU", sc->handle, FN_MUTE); 687 ACPI_VPRINT(sc->dev, acpi_sc, "Volume is now mute\n"); 688 } else 689 ACPI_VPRINT(sc->dev, acpi_sc, "Volume is now %d\n", 690 sc->gvol.value); 691 692 acpi_UserNotify("FUJITSU", sc->handle, FN_VOLUME); 693 } 694 } 695 696 /* Internal mouse pointer (eraserhead) */ 697 if(sc->gmou.exists) { 698 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 699 sc->gmou.name, &(sc->gmou.value)))) { 700 device_printf(sc->dev, "Couldn't query pointer state\n"); 701 return (FALSE); 702 } 703 704 if (changed & MOUSE_CHANGED) { 705 sc->bIntPtrEnabled = (uint8_t)(sc->gmou.value & 0x1); 706 707 /* Clear the modification bit */ 708 sc->gmou.value &= MOUSE_SETTING_BITS; 709 710 /* Set the value in case it is not hardware controlled */ 711 acpi_fujitsu_method_set(sc, METHOD_GMOU, sc->gmou.value); 712 713 acpi_UserNotify("FUJITSU", sc->handle, FN_POINTER_ENABLE); 714 715 ACPI_VPRINT(sc->dev, acpi_sc, "Internal pointer is now %s\n", 716 (sc->bIntPtrEnabled) ? "enabled" : "disabled"); 717 } 718 } 719 720 /* Screen Brightness Level P8XXX */ 721 if(sc->gbls.exists) { 722 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 723 sc->gbls.name, &(sc->gbls.value)))) { 724 device_printf(sc->dev, "Couldn't query P8XXX brightness level\n"); 725 return (FALSE); 726 } 727 if (changed & BRIGHT_CHANGED) { 728 /* No state to record here. */ 729 730 /* Clear the modification bit */ 731 sc->gbls.value &= BRIGHTNESS_SETTING_BITS; 732 733 /* Set the value in case it is not hardware controlled */ 734 acpi_fujitsu_method_set(sc, METHOD_GBLS, sc->gbls.value); 735 736 acpi_UserNotify("FUJITSU", sc->handle, FN_LCD_BRIGHTNESS); 737 738 ACPI_VPRINT(sc->dev, acpi_sc, "P8XXX Brightness level is now %d\n", 739 sc->gbls.value); 740 } 741 } 742 743 /* Screen Brightness Level */ 744 if(sc->gbll.exists) { 745 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 746 sc->gbll.name, &(sc->gbll.value)))) { 747 device_printf(sc->dev, "Couldn't query brightness level\n"); 748 return (FALSE); 749 } 750 751 if (changed & BRIGHT_CHANGED) { 752 /* No state to record here. */ 753 754 /* Clear the modification bit */ 755 sc->gbll.value &= BRIGHTNESS_SETTING_BITS; 756 757 acpi_UserNotify("FUJITSU", sc->handle, FN_LCD_BRIGHTNESS); 758 759 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness level is now %d\n", 760 sc->gbll.value); 761 } 762 } 763 764 sc->lastValChanged = changed; 765 return (TRUE); 766 } 767