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 */ 29 30#include <sys/cdefs.h> 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 <contrib/dev/acpica/include/acpi.h> 39#include <contrib/dev/acpica/include/accommon.h> 40 41#include <dev/acpica/acpivar.h> 42 43/* Hooks for the ACPI CA debugging infrastructure */ 44#define _COMPONENT ACPI_OEM 45ACPI_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 */ 96struct int_nameval { 97 char *name; 98 int value; 99 int exists; 100}; 101 102/* 103 * Driver extension for the FUJITSU ACPI driver. 104 */ 105struct 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. */ 132static int acpi_fujitsu_probe(device_t dev); 133static int acpi_fujitsu_attach(device_t dev); 134static int acpi_fujitsu_detach(device_t dev); 135static int acpi_fujitsu_suspend(device_t dev); 136static int acpi_fujitsu_resume(device_t dev); 137 138static void acpi_fujitsu_notify_status_changed(void *arg); 139static void acpi_fujitsu_notify_handler(ACPI_HANDLE h, uint32_t notify, void *context); 140static int acpi_fujitsu_sysctl(SYSCTL_HANDLER_ARGS); 141 142/* Utility function declarations */ 143static uint8_t acpi_fujitsu_update(struct acpi_fujitsu_softc *sc); 144static uint8_t acpi_fujitsu_init(struct acpi_fujitsu_softc *sc); 145static uint8_t acpi_fujitsu_check_hardware(struct acpi_fujitsu_softc *sc); 146 147/* Driver/Module specific structure definitions. */ 148static 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 156 DEVMETHOD_END 157}; 158 159static driver_t acpi_fujitsu_driver = { 160 "acpi_fujitsu", 161 acpi_fujitsu_methods, 162 sizeof(struct acpi_fujitsu_softc), 163}; 164 165/* Prototype for function hotkeys for getting/setting a value. */ 166static int acpi_fujitsu_method_get(struct acpi_fujitsu_softc *sc, int method); 167static int acpi_fujitsu_method_set(struct acpi_fujitsu_softc *sc, int method, int value); 168 169static char *fujitsu_ids[] = { "FUJ02B1", NULL }; 170 171ACPI_SERIAL_DECL(fujitsu, "Fujitsu Function Hotkeys"); 172 173/* sysctl names and function calls */ 174static struct { 175 char *name; 176 int method; 177 char *description; 178} sysctl_table[] = { 179 { 180 .name = "mute", 181 .method = METHOD_MUTE, 182 .description = "Speakers/headphones mute status" 183 }, 184 { 185 .name = "pointer_enable", 186 .method = METHOD_GMOU, 187 .description = "Enable and disable the internal pointer" 188 }, 189 { 190 .name = "lcd_brightness", 191 .method = METHOD_GBLL, 192 .description = "Brightness level of the LCD panel" 193 }, 194 { 195 .name = "lcd_brightness", 196 .method = METHOD_GBLS, 197 .description = "Brightness level of the LCD panel" 198 }, 199 { 200 .name = "volume", 201 .method = METHOD_GVOL, 202 .description = "Speakers/headphones volume level" 203 }, 204 { 205 .name = "volume_radix", 206 .method = METHOD_RVOL, 207 .description = "Number of volume level steps" 208 }, 209 { 210 .name = "lcd_brightness_radix", 211 .method = METHOD_RBLL, 212 .description = "Number of brightness level steps" 213 }, 214 { NULL, 0, NULL } 215}; 216 217DRIVER_MODULE(acpi_fujitsu, acpi, acpi_fujitsu_driver, 0, 0); 218MODULE_DEPEND(acpi_fujitsu, acpi, 1, 1, 1); 219MODULE_VERSION(acpi_fujitsu, 1); 220 221static int 222acpi_fujitsu_probe(device_t dev) 223{ 224 char *name; 225 int rv; 226 227 rv = ACPI_ID_PROBE(device_get_parent(dev), dev, fujitsu_ids, &name); 228 if (acpi_disabled("fujitsu") || rv > 0 || device_get_unit(dev) > 1) 229 return (ENXIO); 230 device_set_descf(dev, "Fujitsu Function Hotkeys %s", name); 231 232 return (rv); 233} 234 235static int 236acpi_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 */ 263static int 264acpi_fujitsu_suspend(device_t dev) 265{ 266 267 return (0); 268} 269 270static int 271acpi_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 294static void 295acpi_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 313static void 314acpi_fujitsu_notify_handler(ACPI_HANDLE h, uint32_t notify, void *context) 315{ 316 struct acpi_fujitsu_softc *sc; 317 318 ACPI_FUNCTION_TRACE_U32((char *)(uintptr_t)__func__, notify); 319 320 sc = (struct acpi_fujitsu_softc *)context; 321 322 switch (notify) { 323 case ACPI_NOTIFY_STATUS_CHANGED: 324 AcpiOsExecute(OSL_NOTIFY_HANDLER, 325 acpi_fujitsu_notify_status_changed, sc); 326 break; 327 default: 328 /* unknown notification value */ 329 break; 330 } 331} 332 333static int 334acpi_fujitsu_detach(device_t dev) 335{ 336 struct acpi_fujitsu_softc *sc; 337 338 sc = device_get_softc(dev); 339 AcpiRemoveNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY, 340 acpi_fujitsu_notify_handler); 341 342 sysctl_ctx_free(&sc->sysctl_ctx); 343 344 return (0); 345} 346 347/* 348 * Initializes the names of the ACPI control methods and grabs 349 * the current state of all of the ACPI hotkeys into the softc. 350 */ 351static uint8_t 352acpi_fujitsu_init(struct acpi_fujitsu_softc *sc) 353{ 354 struct acpi_softc *acpi_sc; 355 int i, exists; 356 357 ACPI_SERIAL_ASSERT(fujitsu); 358 359 /* Setup all of the names for each control method */ 360 sc->_sta.name = "_STA"; 361 sc->gbll.name = "GBLL"; 362 sc->gbls.name = "GBLS"; 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 | CTLFLAG_MPSAFE, 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_GBLS: 391 exists = sc->gbls.exists; 392 break; 393 case METHOD_GVOL: 394 case METHOD_MUTE: 395 exists = sc->gvol.exists; 396 break; 397 case METHOD_RVOL: 398 exists = sc->rvol.exists; 399 break; 400 case METHOD_RBLL: 401 exists = sc->rbll.exists; 402 break; 403 default: 404 /* Allow by default */ 405 exists = 1; 406 break; 407 } 408 if(!exists) 409 continue; 410 SYSCTL_ADD_PROC(&sc->sysctl_ctx, 411 SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO, 412 sysctl_table[i].name, 413 CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY | 414 CTLFLAG_MPSAFE, sc, i, acpi_fujitsu_sysctl, "I", 415 sysctl_table[i].description); 416 } 417 418 /* Set the hotkeys to their initial states */ 419 if (!acpi_fujitsu_update(sc)) { 420 device_printf(sc->dev, "Couldn't init hotkey states\n"); 421 return (FALSE); 422 } 423 424 return (TRUE); 425} 426 427static int 428acpi_fujitsu_sysctl(SYSCTL_HANDLER_ARGS) 429{ 430 struct acpi_fujitsu_softc *sc; 431 int method; 432 int arg; 433 int function_num, error = 0; 434 435 sc = (struct acpi_fujitsu_softc *)oidp->oid_arg1; 436 function_num = oidp->oid_arg2; 437 method = sysctl_table[function_num].method; 438 439 ACPI_SERIAL_BEGIN(fujitsu); 440 441 /* Get the current value */ 442 arg = acpi_fujitsu_method_get(sc, method); 443 error = sysctl_handle_int(oidp, &arg, 0, req); 444 445 if (error != 0 || req->newptr == NULL) 446 goto out; 447 448 /* Update the value */ 449 error = acpi_fujitsu_method_set(sc, method, arg); 450 451out: 452 ACPI_SERIAL_END(fujitsu); 453 return (error); 454} 455 456static int 457acpi_fujitsu_method_get(struct acpi_fujitsu_softc *sc, int method) 458{ 459 struct int_nameval nv; 460 ACPI_STATUS status; 461 462 ACPI_SERIAL_ASSERT(fujitsu); 463 464 switch (method) { 465 case METHOD_GBLL: 466 nv = sc->gbll; 467 break; 468 case METHOD_GBLS: 469 nv = sc->gbls; 470 break; 471 case METHOD_GMOU: 472 nv = sc->gmou; 473 break; 474 case METHOD_GVOL: 475 case METHOD_MUTE: 476 nv = sc->gvol; 477 break; 478 case METHOD_GHKS: 479 nv = sc->ghks; 480 break; 481 case METHOD_GSIF: 482 nv = sc->gsif; 483 break; 484 case METHOD_RBLL: 485 nv = sc->rbll; 486 break; 487 case METHOD_RVOL: 488 nv = sc->rvol; 489 break; 490 default: 491 return (FALSE); 492 } 493 494 if(!nv.exists) 495 return (EINVAL); 496 497 status = acpi_GetInteger(sc->handle, nv.name, &nv.value); 498 if (ACPI_FAILURE(status)) { 499 device_printf(sc->dev, "Couldn't query method (%s)\n", nv.name); 500 return (FALSE); 501 } 502 503 if (method == METHOD_MUTE) { 504 sc->bIsMuted = (uint8_t)((nv.value & VOLUME_MUTE_BIT) != 0); 505 return (sc->bIsMuted); 506 } 507 508 nv.value &= GENERAL_SETTING_BITS; 509 return (nv.value); 510} 511 512static int 513acpi_fujitsu_method_set(struct acpi_fujitsu_softc *sc, int method, int value) 514{ 515 struct int_nameval nv; 516 ACPI_STATUS status; 517 char *control; 518 int changed; 519 520 ACPI_SERIAL_ASSERT(fujitsu); 521 522 switch (method) { 523 case METHOD_GBLL: 524 changed = BRIGHT_CHANGED; 525 control = "SBLL"; 526 nv = sc->gbll; 527 break; 528 case METHOD_GBLS: 529 changed = BRIGHT_CHANGED; 530 control = "SBL2"; 531 nv = sc->gbls; 532 break; 533 case METHOD_GMOU: 534 changed = MOUSE_CHANGED; 535 control = "SMOU"; 536 nv = sc->gmou; 537 break; 538 case METHOD_GVOL: 539 case METHOD_MUTE: 540 changed = VOLUME_CHANGED; 541 control = "SVOL"; 542 nv = sc->gvol; 543 break; 544 default: 545 return (EINVAL); 546 } 547 548 if(!nv.exists) 549 return (EINVAL); 550 551 if (method == METHOD_MUTE) { 552 if (value == 1) 553 value = nv.value | VOLUME_MUTE_BIT; 554 else if (value == 0) 555 value = nv.value & ~VOLUME_MUTE_BIT; 556 else 557 return (EINVAL); 558 } 559 560 status = acpi_SetInteger(sc->handle, control, value); 561 if (ACPI_FAILURE(status)) { 562 device_printf(sc->dev, "Couldn't update %s\n", control); 563 return (FALSE); 564 } 565 566 sc->lastValChanged = changed; 567 return (0); 568} 569 570/* 571 * Query the get methods to determine what functionality is available 572 * from the hardware function hotkeys. 573 */ 574static uint8_t 575acpi_fujitsu_check_hardware(struct acpi_fujitsu_softc *sc) 576{ 577 int val; 578 579 ACPI_SERIAL_ASSERT(fujitsu); 580 /* save the hotkey bitmask */ 581 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 582 sc->gsif.name, &(sc->gsif.value)))) { 583 sc->gsif.exists = 0; 584 device_printf(sc->dev, "Couldn't query bitmask value\n"); 585 } else { 586 sc->gsif.exists = 1; 587 } 588 589 /* System Volume Level */ 590 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 591 sc->gvol.name, &val))) { 592 sc->gvol.exists = 0; 593 } else { 594 sc->gvol.exists = 1; 595 } 596 597 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 598 sc->gbls.name, &val))) { 599 sc->gbls.exists = 0; 600 } else { 601 sc->gbls.exists = 1; 602 } 603 604 // don't add if we can use the new method 605 if (sc->gbls.exists || ACPI_FAILURE(acpi_GetInteger(sc->handle, 606 sc->gbll.name, &val))) { 607 sc->gbll.exists = 0; 608 } else { 609 sc->gbll.exists = 1; 610 } 611 612 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 613 sc->ghks.name, &val))) { 614 sc->ghks.exists = 0; 615 } else { 616 sc->ghks.exists = 1; 617 } 618 619 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 620 sc->gmou.name, &val))) { 621 sc->gmou.exists = 0; 622 } else { 623 sc->gmou.exists = 1; 624 } 625 626 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 627 sc->rbll.name, &val))) { 628 sc->rbll.exists = 0; 629 } else { 630 sc->rbll.exists = 1; 631 } 632 633 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 634 sc->rvol.name, &val))) { 635 sc->rvol.exists = 0; 636 } else { 637 sc->rvol.exists = 1; 638 } 639 640 return (TRUE); 641} 642 643/* 644 * Query each of the ACPI control methods that contain information we're 645 * interested in. We check the return values from the control methods and 646 * adjust any state variables if they should be adjusted. 647 */ 648static uint8_t 649acpi_fujitsu_update(struct acpi_fujitsu_softc *sc) 650{ 651 int changed; 652 struct acpi_softc *acpi_sc; 653 654 acpi_sc = acpi_device_get_parent_softc(sc->dev); 655 656 ACPI_SERIAL_ASSERT(fujitsu); 657 if(sc->gsif.exists) 658 changed = sc->gsif.value & acpi_fujitsu_method_get(sc,METHOD_GHKS); 659 else 660 changed = 0; 661 662 /* System Volume Level */ 663 if(sc->gvol.exists) { 664 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 665 sc->gvol.name, &(sc->gvol.value)))) { 666 device_printf(sc->dev, "Couldn't query volume level\n"); 667 return (FALSE); 668 } 669 670 if (changed & VOLUME_CHANGED) { 671 sc->bIsMuted = 672 (uint8_t)((sc->gvol.value & VOLUME_MUTE_BIT) != 0); 673 674 /* Clear the modification bit */ 675 sc->gvol.value &= VOLUME_SETTING_BITS; 676 677 if (sc->bIsMuted) { 678 acpi_UserNotify("FUJITSU", sc->handle, FN_MUTE); 679 ACPI_VPRINT(sc->dev, acpi_sc, "Volume is now mute\n"); 680 } else 681 ACPI_VPRINT(sc->dev, acpi_sc, "Volume is now %d\n", 682 sc->gvol.value); 683 684 acpi_UserNotify("FUJITSU", sc->handle, FN_VOLUME); 685 } 686 } 687 688 /* Internal mouse pointer (eraserhead) */ 689 if(sc->gmou.exists) { 690 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 691 sc->gmou.name, &(sc->gmou.value)))) { 692 device_printf(sc->dev, "Couldn't query pointer state\n"); 693 return (FALSE); 694 } 695 696 if (changed & MOUSE_CHANGED) { 697 sc->bIntPtrEnabled = (uint8_t)(sc->gmou.value & 0x1); 698 699 /* Clear the modification bit */ 700 sc->gmou.value &= MOUSE_SETTING_BITS; 701 702 /* Set the value in case it is not hardware controlled */ 703 acpi_fujitsu_method_set(sc, METHOD_GMOU, sc->gmou.value); 704 705 acpi_UserNotify("FUJITSU", sc->handle, FN_POINTER_ENABLE); 706 707 ACPI_VPRINT(sc->dev, acpi_sc, "Internal pointer is now %s\n", 708 (sc->bIntPtrEnabled) ? "enabled" : "disabled"); 709 } 710 } 711 712 /* Screen Brightness Level P8XXX */ 713 if(sc->gbls.exists) { 714 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 715 sc->gbls.name, &(sc->gbls.value)))) { 716 device_printf(sc->dev, "Couldn't query P8XXX brightness level\n"); 717 return (FALSE); 718 } 719 if (changed & BRIGHT_CHANGED) { 720 /* No state to record here. */ 721 722 /* Clear the modification bit */ 723 sc->gbls.value &= BRIGHTNESS_SETTING_BITS; 724 725 /* Set the value in case it is not hardware controlled */ 726 acpi_fujitsu_method_set(sc, METHOD_GBLS, sc->gbls.value); 727 728 acpi_UserNotify("FUJITSU", sc->handle, FN_LCD_BRIGHTNESS); 729 730 ACPI_VPRINT(sc->dev, acpi_sc, "P8XXX Brightness level is now %d\n", 731 sc->gbls.value); 732 } 733 } 734 735 /* Screen Brightness Level */ 736 if(sc->gbll.exists) { 737 if (ACPI_FAILURE(acpi_GetInteger(sc->handle, 738 sc->gbll.name, &(sc->gbll.value)))) { 739 device_printf(sc->dev, "Couldn't query brightness level\n"); 740 return (FALSE); 741 } 742 743 if (changed & BRIGHT_CHANGED) { 744 /* No state to record here. */ 745 746 /* Clear the modification bit */ 747 sc->gbll.value &= BRIGHTNESS_SETTING_BITS; 748 749 acpi_UserNotify("FUJITSU", sc->handle, FN_LCD_BRIGHTNESS); 750 751 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness level is now %d\n", 752 sc->gbll.value); 753 } 754 } 755 756 sc->lastValChanged = changed; 757 return (TRUE); 758} 759