sys/dev/acpica/acpi_fujitsu/acpi_fujitsu.c

   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->rbll.name = "RBLL";
 375         sc->rvol.name = "RVOL";
 376
 377         /* Determine what hardware functionality is available */
 378         acpi_fujitsu_check_hardware(sc);
 379
 380         /* Build the sysctl tree */
 381         acpi_sc = acpi_device_get_parent_softc(sc->dev);
 382         sysctl_ctx_init(&sc->sysctl_ctx);
 383         sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
 384             SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
 385             OID_AUTO, "fujitsu", CTLFLAG_RD, 0, "");
 386
 387         for (i = 0; sysctl_table[i].name != NULL; i++) {
 388                 switch(sysctl_table[i].method) {
 389                         case METHOD_GMOU:
 390                                 exists = sc->gmou.exists;
 391                                 break;
 392                         case METHOD_GBLL:
 393                                 exists = sc->gbll.exists;
 394                                 break;
 395                         case METHOD_GBLS:
 396                                 exists = sc->gbls.exists;
 397                                 break;
 398                         case METHOD_GVOL:
 399                         case METHOD_MUTE:
 400                                 exists = sc->gvol.exists;
 401                                 break;
 402                         case METHOD_RVOL:
 403                                 exists = sc->rvol.exists;
 404                                 break;
 405                         case METHOD_RBLL:
 406                                 exists = sc->rbll.exists;
 407                                 break;
 408                         default:
 409                                 /* Allow by default */
 410                                 exists = 1;
 411                                 break;
 412                 }
 413                 if(!exists)
 414                         continue;
 415                 SYSCTL_ADD_PROC(&sc->sysctl_ctx,
 416                     SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
 417                     sysctl_table[i].name,
 418                     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
 419                     sc, i, acpi_fujitsu_sysctl, "I",
 420                     sysctl_table[i].description);
 421         }
 422
 423
 424         /* Set the hotkeys to their initial states */
 425         if (!acpi_fujitsu_update(sc)) {
 426                 device_printf(sc->dev, "Couldn't init hotkey states\n");
 427                 return (FALSE);
 428         }
 429
 430         return (TRUE);
 431 }
 432
 433 static int
 434 acpi_fujitsu_sysctl(SYSCTL_HANDLER_ARGS)
 435 {
 436         struct acpi_fujitsu_softc       *sc;
 437         int                             method;
 438         int                             arg;
 439         int                             function_num, error = 0;
 440
 441         sc = (struct acpi_fujitsu_softc *)oidp->oid_arg1;
 442         function_num = oidp->oid_arg2;
 443         method = sysctl_table[function_num].method;
 444
 445         ACPI_SERIAL_BEGIN(fujitsu);
 446
 447         /* Get the current value */
 448         arg = acpi_fujitsu_method_get(sc, method);
 449         error = sysctl_handle_int(oidp, &arg, 0, req);
 450
 451         if (error != 0 || req->newptr == NULL)
 452                 goto out;
 453
 454         /* Update the value */
 455         error = acpi_fujitsu_method_set(sc, method, arg);
 456
 457 out:
 458         ACPI_SERIAL_END(fujitsu);
 459         return (error);
 460 }
 461
 462 static int
 463 acpi_fujitsu_method_get(struct acpi_fujitsu_softc *sc, int method)
 464 {
 465         struct int_nameval      nv;
 466         ACPI_STATUS             status;
 467
 468         ACPI_SERIAL_ASSERT(fujitsu);
 469
 470         switch (method) {
 471                 case METHOD_GBLL:
 472                         nv = sc->gbll;
 473                         break;
 474                 case METHOD_GBLS:
 475                         nv = sc->gbls;
 476                         break;
 477                 case METHOD_GMOU:
 478                         nv = sc->gmou;
 479                         break;
 480                 case METHOD_GVOL:
 481                 case METHOD_MUTE:
 482                         nv = sc->gvol;
 483                         break;
 484                 case METHOD_GHKS:
 485                         nv = sc->ghks;
 486                         break;
 487                 case METHOD_GSIF:
 488                         nv = sc->gsif;
 489                         break;
 490                 case METHOD_RBLL:
 491                         nv = sc->rbll;
 492                         break;
 493                 case METHOD_RVOL:
 494                         nv = sc->rvol;
 495                         break;
 496                 default:
 497                         return (FALSE);
 498         }
 499
 500         if(!nv.exists)
 501                 return (EINVAL);
 502
 503         status = acpi_GetInteger(sc->handle, nv.name, &nv.value);
 504         if (ACPI_FAILURE(status)) {
 505                 device_printf(sc->dev, "Couldn't query method (%s)\n", nv.name);
 506                 return (FALSE);
 507         }
 508
 509         if (method == METHOD_MUTE) {
 510                 sc->bIsMuted = (uint8_t)((nv.value & VOLUME_MUTE_BIT) != 0);
 511                 return (sc->bIsMuted);
 512         }
 513
 514         nv.value &= GENERAL_SETTING_BITS;
 515         return (nv.value);
 516 }
 517
 518 static int
 519 acpi_fujitsu_method_set(struct acpi_fujitsu_softc *sc, int method, int value)
 520 {
 521         struct int_nameval      nv;
 522         ACPI_STATUS             status;
 523         char                    *control;
 524         int                     changed;
 525
 526         ACPI_SERIAL_ASSERT(fujitsu);
 527
 528         switch (method) {
 529                 case METHOD_GBLL:
 530                         changed = BRIGHT_CHANGED;
 531                         control = "SBLL";
 532                         nv = sc->gbll;
 533                         break;
 534                 case METHOD_GBLS:
 535                         changed = BRIGHT_CHANGED;
 536                         control = "SBL2";
 537                         nv = sc->gbls;
 538                         break;
 539                 case METHOD_GMOU:
 540                         changed = MOUSE_CHANGED;
 541                         control = "SMOU";
 542                         nv = sc->gmou;
 543                         break;
 544                 case METHOD_GVOL:
 545                 case METHOD_MUTE:
 546                         changed = VOLUME_CHANGED;
 547                         control = "SVOL";
 548                         nv = sc->gvol;
 549                         break;
 550                 default:
 551                         return (EINVAL);
 552         }
 553
 554         if(!nv.exists)
 555                 return (EINVAL);
 556
 557         if (method == METHOD_MUTE) {
 558                 if (value == 1)
 559                         value = nv.value | VOLUME_MUTE_BIT;
 560                 else if (value == 0)
 561                         value = nv.value & ~VOLUME_MUTE_BIT;
 562                 else
 563                         return (EINVAL);
 564         }
 565
 566         status = acpi_SetInteger(sc->handle, control, value);
 567         if (ACPI_FAILURE(status)) {
 568                 device_printf(sc->dev, "Couldn't update %s\n", control);
 569                 return (FALSE);
 570         }
 571
 572         sc->lastValChanged = changed;
 573         return (0);
 574 }
 575
 576 /*
 577  * Query the get methods to determine what functionality is available
 578  * from the hardware function hotkeys.
 579  */
 580 static uint8_t
 581 acpi_fujitsu_check_hardware(struct acpi_fujitsu_softc *sc)
 582 {
 583         int val;
 584
 585         ACPI_SERIAL_ASSERT(fujitsu);
 586         /* save the hotkey bitmask */
 587         if (ACPI_FAILURE(acpi_GetInteger(sc->handle,
 588         sc->gsif.name, &(sc->gsif.value)))) {
 589                 sc->gsif.exists = 0;
 590                 device_printf(sc->dev, "Couldn't query bitmask value\n");
 591         } else {
 592                 sc->gsif.exists = 1;
 593         }
 594
 595         /* System Volume Level */
 596         if (ACPI_FAILURE(acpi_GetInteger(sc->handle,
 597             sc->gvol.name, &val))) {
 598                 sc->gvol.exists = 0;
 599         } else {
 600                 sc->gvol.exists = 1;
 601         }
 602
 603         if (ACPI_FAILURE(acpi_GetInteger(sc->handle,
 604                 sc->gbls.name, &val))) {
 605                 sc->gbls.exists = 0;
 606         } else {
 607                 sc->gbls.exists = 1;
 608         }
 609
 610         /* don't add if we can use the new method */
 611         if (sc->gbls.exists || ACPI_FAILURE(acpi_GetInteger(sc->handle,
 612             sc->gbll.name, &val))) {
 613                 sc->gbll.exists = 0;
 614         } else {
 615                 sc->gbll.exists = 1;
 616         }
 617
 618         if (ACPI_FAILURE(acpi_GetInteger(sc->handle,
 619             sc->ghks.name, &val))) {
 620                 sc->ghks.exists = 0;
 621         } else {
 622                 sc->ghks.exists = 1;
 623         }
 624
 625         if (ACPI_FAILURE(acpi_GetInteger(sc->handle,
 626             sc->gmou.name, &val))) {
 627                 sc->gmou.exists = 0;
 628         } else {
 629                 sc->gmou.exists = 1;
 630         }
 631
 632         if (ACPI_FAILURE(acpi_GetInteger(sc->handle,
 633             sc->rbll.name, &val))) {
 634                 sc->rbll.exists = 0;
 635         } else {
 636                 sc->rbll.exists = 1;
 637         }
 638
 639         if (ACPI_FAILURE(acpi_GetInteger(sc->handle,
 640             sc->rvol.name, &val))) {
 641                 sc->rvol.exists = 0;
 642         } else {
 643                 sc->rvol.exists = 1;
 644         }
 645
 646         return (TRUE);
 647 }
 648
 649 /*
 650  * Query each of the ACPI control methods that contain information we're
 651  * interested in. We check the return values from the control methods and
 652  * adjust any state variables if they should be adjusted.
 653  */
 654 static uint8_t
 655 acpi_fujitsu_update(struct acpi_fujitsu_softc *sc)
 656 {
 657         int changed;
 658         struct acpi_softc *acpi_sc;
 659
 660         acpi_sc = acpi_device_get_parent_softc(sc->dev);
 661
 662         ACPI_SERIAL_ASSERT(fujitsu);
 663         if(sc->gsif.exists)
 664                 changed = sc->gsif.value & acpi_fujitsu_method_get(sc,METHOD_GHKS);
 665         else
 666                 changed = 0;
 667
 668         /* System Volume Level */
 669         if(sc->gvol.exists) {
 670                 if (ACPI_FAILURE(acpi_GetInteger(sc->handle,
 671                 sc->gvol.name, &(sc->gvol.value)))) {
 672                         device_printf(sc->dev, "Couldn't query volume level\n");
 673                         return (FALSE);
 674                 }
 675
 676                 if (changed & VOLUME_CHANGED) {
 677                         sc->bIsMuted =
 678                         (uint8_t)((sc->gvol.value & VOLUME_MUTE_BIT) != 0);
 679
 680                         /* Clear the modification bit */
 681                         sc->gvol.value &= VOLUME_SETTING_BITS;
 682
 683                         if (sc->bIsMuted) {
 684                                 acpi_UserNotify("FUJITSU", sc->handle, FN_MUTE);
 685                                 ACPI_VPRINT(sc->dev, acpi_sc, "Volume is now mute\n");
 686                         } else
 687                                 ACPI_VPRINT(sc->dev, acpi_sc, "Volume is now %d\n",
 688                                 sc->gvol.value);
 689
 690                         acpi_UserNotify("FUJITSU", sc->handle, FN_VOLUME);
 691                 }
 692         }
 693
 694         /* Internal mouse pointer (eraserhead) */
 695         if(sc->gmou.exists) {
 696                 if (ACPI_FAILURE(acpi_GetInteger(sc->handle,
 697                 sc->gmou.name, &(sc->gmou.value)))) {
 698                         device_printf(sc->dev, "Couldn't query pointer state\n");
 699                         return (FALSE);
 700                 }
 701
 702                 if (changed & MOUSE_CHANGED) {
 703                         sc->bIntPtrEnabled = (uint8_t)(sc->gmou.value & 0x1);
 704
 705                         /* Clear the modification bit */
 706                         sc->gmou.value &= MOUSE_SETTING_BITS;
 707
 708                         /* Set the value in case it is not hardware controlled */
 709                         acpi_fujitsu_method_set(sc, METHOD_GMOU, sc->gmou.value);
 710
 711                         acpi_UserNotify("FUJITSU", sc->handle, FN_POINTER_ENABLE);
 712
 713                         ACPI_VPRINT(sc->dev, acpi_sc, "Internal pointer is now %s\n",
 714                         (sc->bIntPtrEnabled) ? "enabled" : "disabled");
 715                 }
 716         }
 717
 718         /* Screen Brightness Level P8XXX */
 719         if(sc->gbls.exists) {
 720                 if (ACPI_FAILURE(acpi_GetInteger(sc->handle,
 721                 sc->gbls.name, &(sc->gbls.value)))) {
 722                         device_printf(sc->dev, "Couldn't query P8XXX brightness level\n");
 723                         return (FALSE);
 724                 }
 725                 if (changed & BRIGHT_CHANGED) {
 726                         /* No state to record here. */
 727
 728                         /* Clear the modification bit */
 729                         sc->gbls.value &= BRIGHTNESS_SETTING_BITS;
 730
 731                         /* Set the value in case it is not hardware controlled */
 732                         acpi_fujitsu_method_set(sc, METHOD_GBLS, sc->gbls.value);
 733
 734                         acpi_UserNotify("FUJITSU", sc->handle, FN_LCD_BRIGHTNESS);
 735
 736                         ACPI_VPRINT(sc->dev, acpi_sc, "P8XXX Brightness level is now %d\n",
 737                         sc->gbls.value);
 738                 }
 739         }
 740
 741         /* Screen Brightness Level */
 742         if(sc->gbll.exists) {
 743                 if (ACPI_FAILURE(acpi_GetInteger(sc->handle,
 744                 sc->gbll.name, &(sc->gbll.value)))) {
 745                         device_printf(sc->dev, "Couldn't query brightness level\n");
 746                         return (FALSE);
 747                 }
 748
 749                 if (changed & BRIGHT_CHANGED) {
 750                         /* No state to record here. */
 751
 752                         /* Clear the modification bit */
 753                         sc->gbll.value &= BRIGHTNESS_SETTING_BITS;
 754
 755                         acpi_UserNotify("FUJITSU", sc->handle, FN_LCD_BRIGHTNESS);
 756
 757                         ACPI_VPRINT(sc->dev, acpi_sc, "Brightness level is now %d\n",
 758                         sc->gbll.value);
 759                 }
 760         }
 761
 762         sc->lastValChanged = changed;
 763         return (TRUE);
 764 }