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