sys/dev/acpi_support/acpi_fujitsu.c

   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 }