acpi_asus(4): Bring in a small fix from FreeBSD.
[dragonfly.git] / sys / dev / acpica5 / acpi_asus / acpi_asus.c
1 /*-
2  * Copyright (c) 2004, 2005 Philip Paeps <philip@FreeBSD.org>
3  * All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
24  * SUCH DAMAGE.
25  *
26  * $FreeBSD: src/sys/dev/acpi_support/acpi_asus.c,v 1.44 2010/06/11 20:08:20 jkim Exp $
27  */
28
29 /*
30  * Driver for extra ACPI-controlled gadgets (hotkeys, leds, etc) found on
31  * recent Asus (and Medion) laptops.  Inspired by the acpi4asus project which
32  * implements these features in the Linux kernel.
33  *
34  *   <http://sourceforge.net/projects/acpi4asus/>
35  *
36  * Currently should support most features, but could use some more testing.
37  * Particularly the display-switching stuff is a bit hairy.  If you have an
38  * Asus laptop which doesn't appear to be supported, or strange things happen
39  * when using this driver, please report to <acpi@FreeBSD.org>.
40  */
41
42 #include "opt_acpi.h"
43 #include <sys/param.h>
44 #include <sys/kernel.h>
45 #include <sys/module.h>
46 #include <sys/bus.h>
47 #include <sys/sbuf.h>
48
49 #include "acpi.h"
50 #include "accommon.h"
51 #include "acpivar.h"
52
53 #if defined(__FreeBSD__)
54 #include <dev/led/led.h>
55 #endif
56
57 /* Methods */
58 #define ACPI_ASUS_METHOD_BRN    1
59 #define ACPI_ASUS_METHOD_DISP   2
60 #define ACPI_ASUS_METHOD_LCD    3
61 #define ACPI_ASUS_METHOD_CAMERA 4
62 #define ACPI_ASUS_METHOD_CARDRD 5
63 #define ACPI_ASUS_METHOD_WLAN   6
64
65 #define _COMPONENT      ACPI_OEM
66 ACPI_MODULE_NAME("ASUS")
67
68 struct acpi_asus_model {
69         char    *name;
70         char    *bled_set;
71         char    *dled_set;
72         char    *gled_set;
73         char    *mled_set;
74         char    *tled_set;
75         char    *wled_set;
76
77         char    *brn_get;
78         char    *brn_set;
79         char    *brn_up;
80         char    *brn_dn;
81
82         char    *lcd_get;
83         char    *lcd_set;
84
85         char    *disp_get;
86         char    *disp_set;
87
88         char    *cam_get;
89         char    *cam_set;
90
91         char    *crd_get;
92         char    *crd_set;
93
94         char    *wlan_get;
95         char    *wlan_set;
96
97         void    (*n_func)(ACPI_HANDLE, UINT32, void *);
98
99         char    *lcdd;
100         void    (*lcdd_n_func)(ACPI_HANDLE, UINT32, void *);
101 };
102
103 struct acpi_asus_led {
104         struct acpi_asus_softc *sc;
105         struct cdev     *cdev;
106         int             busy;
107         int             state;
108         enum {
109                 ACPI_ASUS_LED_BLED,
110                 ACPI_ASUS_LED_DLED,
111                 ACPI_ASUS_LED_GLED,
112                 ACPI_ASUS_LED_MLED,
113                 ACPI_ASUS_LED_TLED,
114                 ACPI_ASUS_LED_WLED,
115         } type;
116 };
117
118 struct acpi_asus_softc {
119         device_t                dev;
120         ACPI_HANDLE             handle;
121         ACPI_HANDLE             lcdd_handle;
122
123         struct acpi_asus_model  *model;
124         struct sysctl_ctx_list  sysctl_ctx;
125         struct sysctl_oid       *sysctl_tree;
126 #if defined(__FreeBSD__)
127         struct acpi_asus_led    s_bled;
128         struct acpi_asus_led    s_dled;
129         struct acpi_asus_led    s_gled;
130         struct acpi_asus_led    s_mled;
131         struct acpi_asus_led    s_tled;
132         struct acpi_asus_led    s_wled;
133 #endif
134
135         int                     s_brn;
136         int                     s_disp;
137         int                     s_lcd;
138         int                     s_cam;
139         int                     s_crd;
140         int                     s_wlan;
141 };
142
143 static void     acpi_asus_lcdd_notify(ACPI_HANDLE h, UINT32 notify,
144     void *context);
145
146 /*
147  * We can identify Asus laptops from the string they return
148  * as a result of calling the ATK0100 'INIT' method.
149  */
150 static struct acpi_asus_model acpi_asus_models[] = {
151         {
152                 .name           = "xxN",
153                 .mled_set       = "MLED",
154                 .wled_set       = "WLED",
155                 .lcd_get        = "\\BKLT",
156                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
157                 .brn_get        = "GPLV",
158                 .brn_set        = "SPLV",
159                 .disp_get       = "\\ADVG",
160                 .disp_set       = "SDSP"
161         },
162         {
163                 .name           = "A1x",
164                 .mled_set       = "MLED",
165                 .lcd_get        = "\\BKLI",
166                 .lcd_set        = "\\_SB.PCI0.ISA.EC0._Q10",
167                 .brn_up         = "\\_SB.PCI0.ISA.EC0._Q0E",
168                 .brn_dn         = "\\_SB.PCI0.ISA.EC0._Q0F"
169         },
170         {
171                 .name           = "A2x",
172                 .mled_set       = "MLED",
173                 .wled_set       = "WLED",
174                 .lcd_get        = "\\BAOF",
175                 .lcd_set        = "\\Q10",
176                 .brn_get        = "GPLV",
177                 .brn_set        = "SPLV",
178                 .disp_get       = "\\INFB",
179                 .disp_set       = "SDSP"
180         },
181         {
182                 .name           = "A3E",
183                 .mled_set       = "MLED",
184                 .wled_set       = "WLED",
185                 .lcd_get        = "\\_SB.PCI0.SBRG.EC0.RPIN(0x67)",
186                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
187                 .brn_get        = "GPLV",
188                 .brn_set        = "SPLV",
189                 .disp_get       = "\\_SB.PCI0.P0P2.VGA.GETD",
190                 .disp_set       = "SDSP"
191         },
192         {
193                 .name           = "A3F",
194                 .mled_set       = "MLED",
195                 .wled_set       = "WLED",
196                 .bled_set       = "BLED",
197                 .lcd_get        = "\\_SB.PCI0.SBRG.EC0.RPIN(0x11)",
198                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
199                 .brn_get        = "GPLV",
200                 .brn_set        = "SPLV",
201                 .disp_get       = "\\SSTE",
202                 .disp_set       = "SDSP"
203         },
204         {
205                 .name           = "A3N",
206                 .mled_set       = "MLED",
207                 .bled_set       = "BLED",
208                 .wled_set       = "WLED",
209                 .lcd_get        = "\\BKLT",
210                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
211                 .brn_get        = "GPLV",
212                 .brn_set        = "SPLV",
213                 .disp_get       = "\\_SB.PCI0.P0P3.VGA.GETD",
214                 .disp_set       = "SDSP"
215         },
216         {
217                 .name           = "A4D",
218                 .mled_set       = "MLED",
219                 .brn_up         = "\\_SB_.PCI0.SBRG.EC0._Q0E",
220                 .brn_dn         = "\\_SB_.PCI0.SBRG.EC0._Q0F",
221                 .brn_get        = "GPLV",
222                 .brn_set        = "SPLV",
223 #ifdef notyet
224                 .disp_get       = "\\_SB_.PCI0.SBRG.EC0._Q10",
225                 .disp_set       = "\\_SB_.PCI0.SBRG.EC0._Q11"
226 #endif
227         },
228         {
229                 .name           = "A6V",
230                 .bled_set       = "BLED",
231                 .mled_set       = "MLED",
232                 .wled_set       = "WLED",
233                 .lcd_get        = NULL,
234                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
235                 .brn_get        = "GPLV",
236                 .brn_set        = "SPLV",
237                 .disp_get       = "\\_SB.PCI0.P0P3.VGA.GETD",
238                 .disp_set       = "SDSP"
239         },
240         {
241                 .name           = "A8SR",
242                 .bled_set       = "BLED",
243                 .mled_set       = "MLED",
244                 .wled_set       = "WLED",
245                 .lcd_get        = NULL,
246                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
247                 .brn_get        = "GPLV",
248                 .brn_set        = "SPLV",
249                 .disp_get       = "\\_SB.PCI0.P0P1.VGA.GETD",
250                 .disp_set       = "SDSP",
251                 .lcdd           = "\\_SB.PCI0.P0P1.VGA.LCDD",
252                 .lcdd_n_func    = acpi_asus_lcdd_notify
253         },
254         {
255                 .name           = "D1x",
256                 .mled_set       = "MLED",
257                 .lcd_get        = "\\GP11",
258                 .lcd_set        = "\\Q0D",
259                 .brn_up         = "\\Q0C",
260                 .brn_dn         = "\\Q0B",
261                 .disp_get       = "\\INFB",
262                 .disp_set       = "SDSP"
263         },
264         {
265                 .name           = "G2K",
266                 .bled_set       = "BLED",
267                 .dled_set       = "DLED",
268                 .gled_set       = "GLED",
269                 .mled_set       = "MLED",
270                 .tled_set       = "TLED",
271                 .wled_set       = "WLED",
272                 .brn_get        = "GPLV",
273                 .brn_set        = "SPLV",
274                 .lcd_get        = "GBTL",
275                 .lcd_set        = "SBTL",
276                 .disp_get       = "\\_SB.PCI0.PCE2.VGA.GETD",
277                 .disp_set       = "SDSP",
278         },
279         {
280                 .name           = "L2D",
281                 .mled_set       = "MLED",
282                 .wled_set       = "WLED",
283                 .brn_up         = "\\Q0E",
284                 .brn_dn         = "\\Q0F",
285                 .lcd_get        = "\\SGP0",
286                 .lcd_set        = "\\Q10"
287         },
288         {
289                 .name           = "L3C",
290                 .mled_set       = "MLED",
291                 .wled_set       = "WLED",
292                 .brn_get        = "GPLV",
293                 .brn_set        = "SPLV",
294                 .lcd_get        = "\\GL32",
295                 .lcd_set        = "\\_SB.PCI0.PX40.ECD0._Q10"
296         },
297         {
298                 .name           = "L3D",
299                 .mled_set       = "MLED",
300                 .wled_set       = "WLED",
301                 .brn_get        = "GPLV",
302                 .brn_set        = "SPLV",
303                 .lcd_get        = "\\BKLG",
304                 .lcd_set        = "\\Q10"
305         },
306         {
307                 .name           = "L3H",
308                 .mled_set       = "MLED",
309                 .wled_set       = "WLED",
310                 .brn_get        = "GPLV",
311                 .brn_set        = "SPLV",
312                 .lcd_get        = "\\_SB.PCI0.PM.PBC",
313                 .lcd_set        = "EHK",
314                 .disp_get       = "\\_SB.INFB",
315                 .disp_set       = "SDSP"
316         },
317         {
318                 .name           = "L4R",
319                 .mled_set       = "MLED",
320                 .wled_set       = "WLED",
321                 .brn_get        = "GPLV",
322                 .brn_set        = "SPLV",
323                 .lcd_get        = "\\_SB.PCI0.SBSM.SEO4",
324                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
325                 .disp_get       = "\\_SB.PCI0.P0P1.VGA.GETD",
326                 .disp_set       = "SDSP"
327         },
328         {
329                 .name           = "L5x",
330                 .mled_set       = "MLED",
331                 .tled_set       = "TLED",
332                 .lcd_get        = "\\BAOF",
333                 .lcd_set        = "\\Q0D",
334                 .brn_get        = "GPLV",
335                 .brn_set        = "SPLV",
336                 .disp_get       = "\\INFB",
337                 .disp_set       = "SDSP"
338         },
339         {
340                 .name           = "L8L"
341                 /* Only has hotkeys, apparently */
342         },
343         {
344                 .name           = "M1A",
345                 .mled_set       = "MLED",
346                 .brn_up         = "\\_SB.PCI0.PX40.EC0.Q0E",
347                 .brn_dn         = "\\_SB.PCI0.PX40.EC0.Q0F",
348                 .lcd_get        = "\\PNOF",
349                 .lcd_set        = "\\_SB.PCI0.PX40.EC0.Q10"
350         },
351         {
352                 .name           = "M2E",
353                 .mled_set       = "MLED",
354                 .wled_set       = "WLED",
355                 .brn_get        = "GPLV",
356                 .brn_set        = "SPLV",
357                 .lcd_get        = "\\GP06",
358                 .lcd_set        = "\\Q10"
359         },
360         {
361                 .name           = "M6N",
362                 .mled_set       = "MLED",
363                 .wled_set       = "WLED",
364                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
365                 .lcd_get        = "\\_SB.BKLT",
366                 .brn_set        = "SPLV",
367                 .brn_get        = "GPLV",
368                 .disp_set       = "SDSP",
369                 .disp_get       = "\\SSTE"
370         },
371         {
372                 .name           = "M6R",
373                 .mled_set       = "MLED",
374                 .wled_set       = "WLED",
375                 .brn_get        = "GPLV",
376                 .brn_set        = "SPLV",
377                 .lcd_get        = "\\_SB.PCI0.SBSM.SEO4",
378                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
379                 .disp_get       = "\\SSTE",
380                 .disp_set       = "SDSP"
381         },
382         {
383                 .name           = "S1x",
384                 .mled_set       = "MLED",
385                 .wled_set       = "WLED",
386                 .lcd_get        = "\\PNOF",
387                 .lcd_set        = "\\_SB.PCI0.PX40.Q10",
388                 .brn_get        = "GPLV",
389                 .brn_set        = "SPLV"
390         },
391         {
392                 .name           = "S2x",
393                 .mled_set       = "MLED",
394                 .lcd_get        = "\\BKLI",
395                 .lcd_set        = "\\_SB.PCI0.ISA.EC0._Q10",
396                 .brn_up         = "\\_SB.PCI0.ISA.EC0._Q0B",
397                 .brn_dn         = "\\_SB.PCI0.ISA.EC0._Q0A"
398         },
399         {
400                 .name           = "V6V",
401                 .bled_set       = "BLED",
402                 .tled_set       = "TLED",
403                 .wled_set       = "WLED",
404                 .lcd_get        = "\\BKLT",
405                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
406                 .brn_get        = "GPLV",
407                 .brn_set        = "SPLV",
408                 .disp_get       = "\\_SB.PCI0.P0P1.VGA.GETD",
409                 .disp_set       = "SDSP"
410         },
411         {
412                 .name           = "W5A",
413                 .bled_set       = "BLED",
414                 .lcd_get        = "\\BKLT",
415                 .lcd_set        = "\\_SB.PCI0.SBRG.EC0._Q10",
416                 .brn_get        = "GPLV",
417                 .brn_set        = "SPLV",
418                 .disp_get       = "\\_SB.PCI0.P0P2.VGA.GETD",
419                 .disp_set       = "SDSP"
420         },
421
422         { .name = NULL }
423 };
424
425 /*
426  * Samsung P30/P35 laptops have an Asus ATK0100 gadget interface,
427  * but they can't be probed quite the same way as Asus laptops.
428  */
429 static struct acpi_asus_model acpi_samsung_models[] = {
430         {
431                 .name           = "P30",
432                 .wled_set       = "WLED",
433                 .brn_up         = "\\_SB.PCI0.LPCB.EC0._Q68",
434                 .brn_dn         = "\\_SB.PCI0.LPCB.EC0._Q69",
435                 .lcd_get        = "\\BKLT",
436                 .lcd_set        = "\\_SB.PCI0.LPCB.EC0._Q0E"
437         },
438
439         { .name = NULL }
440 };
441
442 static void     acpi_asus_eeepc_notify(ACPI_HANDLE h, UINT32 notify, void *context);
443
444 /*
445  * EeePC have an Asus ASUS010 gadget interface,
446  * but they can't be probed quite the same way as Asus laptops.
447  */
448 static struct acpi_asus_model acpi_eeepc_models[] = {
449         {
450                 .name           = "EEE",
451                 .brn_get        = "\\_SB.ATKD.PBLG",
452                 .brn_set        = "\\_SB.ATKD.PBLS",
453                 .cam_get        = "\\_SB.ATKD.CAMG",
454                 .cam_set        = "\\_SB.ATKD.CAMS",
455                 .crd_set        = "\\_SB.ATKD.CRDS",
456                 .crd_get        = "\\_SB.ATKD.CRDG",
457                 .wlan_get       = "\\_SB.ATKD.WLDG",
458                 .wlan_set       = "\\_SB.ATKD.WLDS",
459                 .n_func         = acpi_asus_eeepc_notify
460         },
461
462         { .name = NULL }
463 };
464
465 static struct {
466         char    *name;
467         char    *description;
468         int     method;
469         int     flags;
470 } acpi_asus_sysctls[] = {
471         {
472                 .name           = "lcd_backlight",
473                 .method         = ACPI_ASUS_METHOD_LCD,
474                 .description    = "state of the lcd backlight",
475                 .flags          = CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY
476         },
477         {
478                 .name           = "lcd_brightness",
479                 .method         = ACPI_ASUS_METHOD_BRN,
480                 .description    = "brightness of the lcd panel",
481                 .flags          = CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY
482         },
483         {
484                 .name           = "video_output",
485                 .method         = ACPI_ASUS_METHOD_DISP,
486                 .description    = "display output state",
487                 .flags          = CTLTYPE_INT | CTLFLAG_RW
488         },
489         {
490                 .name           = "camera",
491                 .method         = ACPI_ASUS_METHOD_CAMERA,
492                 .description    = "internal camera state",  
493                 .flags          = CTLTYPE_INT | CTLFLAG_RW
494         },
495         {
496                 .name           = "cardreader",
497                 .method         = ACPI_ASUS_METHOD_CARDRD,
498                 .description    = "internal card reader state",
499                 .flags          = CTLTYPE_INT | CTLFLAG_RW
500         },
501         {
502                 .name           = "wlan",
503                 .method         = ACPI_ASUS_METHOD_WLAN,
504                 .description    = "wireless lan state",
505                 .flags          = CTLTYPE_INT | CTLFLAG_RW
506         },
507
508         { .name = NULL }
509 };
510
511 ACPI_SERIAL_DECL(asus, "ACPI ASUS extras");
512
513 /* Function prototypes */
514 static int      acpi_asus_probe(device_t dev);
515 static int      acpi_asus_attach(device_t dev);
516 static int      acpi_asus_detach(device_t dev);
517
518 #if defined(__FreeBSD__)
519 static void     acpi_asus_led(struct acpi_asus_led *led, int state);
520 static void     acpi_asus_led_task(struct acpi_asus_led *led, int pending __unused);
521 #endif
522
523 static int      acpi_asus_sysctl(SYSCTL_HANDLER_ARGS);
524 static int      acpi_asus_sysctl_init(struct acpi_asus_softc *sc, int method);
525 static int      acpi_asus_sysctl_get(struct acpi_asus_softc *sc, int method);
526 static int      acpi_asus_sysctl_set(struct acpi_asus_softc *sc, int method, int val);
527
528 static void     acpi_asus_notify(ACPI_HANDLE h, UINT32 notify, void *context);
529
530 static device_method_t acpi_asus_methods[] = {
531         DEVMETHOD(device_probe,  acpi_asus_probe),
532         DEVMETHOD(device_attach, acpi_asus_attach),
533         DEVMETHOD(device_detach, acpi_asus_detach),
534
535         { 0, 0 }
536 };
537
538 static driver_t acpi_asus_driver = {
539         "acpi_asus",
540         acpi_asus_methods,
541         sizeof(struct acpi_asus_softc)
542 };
543
544 static devclass_t acpi_asus_devclass;
545
546 DRIVER_MODULE(acpi_asus, acpi, acpi_asus_driver, acpi_asus_devclass, NULL, NULL);
547 MODULE_DEPEND(acpi_asus, acpi, 1, 1, 1);
548
549 static int
550 acpi_asus_probe(device_t dev)
551 {
552         struct acpi_asus_model  *model;
553         struct acpi_asus_softc  *sc;
554         struct sbuf             *sb;
555         ACPI_BUFFER             Buf;
556         ACPI_OBJECT             Arg, *Obj;
557         ACPI_OBJECT_LIST        Args;
558         static char             *asus_ids[] = { "ATK0100", "ASUS010", NULL };
559         char *rstr;
560
561         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
562
563         if (acpi_disabled("asus"))
564                 return (ENXIO);
565         ACPI_SERIAL_INIT(asus);
566         rstr = ACPI_ID_PROBE(device_get_parent(dev), dev, asus_ids);
567         if (rstr == NULL) {
568                 return (ENXIO);
569         }
570
571         sc = device_get_softc(dev);
572         sc->dev = dev;
573         sc->handle = acpi_get_handle(dev);
574
575         Arg.Type = ACPI_TYPE_INTEGER;
576         Arg.Integer.Value = 0;
577
578         Args.Count = 1;
579         Args.Pointer = &Arg;
580
581         Buf.Pointer = NULL;
582         Buf.Length = ACPI_ALLOCATE_BUFFER;
583
584         AcpiEvaluateObject(sc->handle, "INIT", &Args, &Buf);
585         Obj = Buf.Pointer;
586
587         /*
588          * The Samsung P30 returns a null-pointer from INIT, we
589          * can identify it from the 'ODEM' string in the DSDT.
590          */
591         if (Obj->String.Pointer == NULL) {
592                 ACPI_STATUS             status;
593                 ACPI_TABLE_HEADER       th;
594
595                 status = AcpiGetTableHeader(ACPI_SIG_DSDT, 0, &th);
596                 if (ACPI_FAILURE(status)) {
597                         device_printf(dev, "Unsupported (Samsung?) laptop\n");
598                         AcpiOsFree(Buf.Pointer);
599                         return (ENXIO);
600                 }
601
602                 if (strncmp("ODEM", th.OemTableId, 4) == 0) {
603                         sc->model = &acpi_samsung_models[0];
604                         device_set_desc(dev, "Samsung P30 Laptop Extras");
605                         AcpiOsFree(Buf.Pointer);
606                         return (0);
607                 }
608
609                 /* EeePC */
610                 if (strncmp("ASUS010", rstr, 7) == 0) {
611                         sc->model = &acpi_eeepc_models[0];
612                         device_set_desc(dev, "ASUS EeePC");
613                         AcpiOsFree(Buf.Pointer);
614                         return (0);
615                 }
616         }
617
618         sb = sbuf_new_auto();
619         if (sb == NULL)
620                 return (ENOMEM);
621
622         /*
623          * Asus laptops are simply identified by name, easy!
624          */
625         for (model = acpi_asus_models; model->name != NULL; model++) {
626                 if (strncmp(Obj->String.Pointer, model->name, 3) == 0) {
627
628 good:
629                         sbuf_printf(sb, "Asus %s Laptop Extras",
630                             Obj->String.Pointer);
631                         sbuf_finish(sb);
632
633                         sc->model = model;
634                         device_set_desc_copy(dev, sbuf_data(sb));
635
636                         sbuf_delete(sb);
637                         AcpiOsFree(Buf.Pointer);
638                         return (0);
639                 }
640                 
641                 /*
642                  * Some models look exactly the same as other models, but have
643                  * their own ids.  If we spot these, set them up with the same
644                  * details as the models they're like, possibly dealing with
645                  * small differences.
646                  *
647                  * XXX: there must be a prettier way to do this!
648                  */
649                 else if (strncmp(model->name, "xxN", 3) == 0 &&
650                     (strncmp(Obj->String.Pointer, "M3N", 3) == 0 ||
651                      strncmp(Obj->String.Pointer, "S1N", 3) == 0))
652                         goto good;
653                 else if (strncmp(model->name, "A1x", 3) == 0 &&
654                     strncmp(Obj->String.Pointer, "A1", 2) == 0)
655                         goto good;
656                 else if (strncmp(model->name, "A2x", 3) == 0 &&
657                     strncmp(Obj->String.Pointer, "A2", 2) == 0)
658                         goto good;
659                 else if (strncmp(model->name, "A3F", 3) == 0 &&
660                     strncmp(Obj->String.Pointer, "A6F", 3) == 0)
661                         goto good;
662                 else if (strncmp(model->name, "D1x", 3) == 0 &&
663                     strncmp(Obj->String.Pointer, "D1", 2) == 0)
664                         goto good;
665                 else if (strncmp(model->name, "L3H", 3) == 0 &&
666                     strncmp(Obj->String.Pointer, "L2E", 3) == 0)
667                         goto good;
668                 else if (strncmp(model->name, "L5x", 3) == 0 &&
669                     strncmp(Obj->String.Pointer, "L5", 2) == 0)
670                         goto good;
671                 else if (strncmp(model->name, "M2E", 3) == 0 &&
672                     (strncmp(Obj->String.Pointer, "M2", 2) == 0 ||
673                      strncmp(Obj->String.Pointer, "L4E", 3) == 0))
674                         goto good;
675                 else if (strncmp(model->name, "S1x", 3) == 0 &&
676                     (strncmp(Obj->String.Pointer, "L8", 2) == 0 ||
677                      strncmp(Obj->String.Pointer, "S1", 2) == 0))
678                         goto good;
679                 else if (strncmp(model->name, "S2x", 3) == 0 &&
680                     (strncmp(Obj->String.Pointer, "J1", 2) == 0 ||
681                      strncmp(Obj->String.Pointer, "S2", 2) == 0))
682                         goto good;
683
684                 /* L2B is like L3C but has no lcd_get method */
685                 else if (strncmp(model->name, "L3C", 3) == 0 &&
686                     strncmp(Obj->String.Pointer, "L2B", 3) == 0) {
687                         model->lcd_get = NULL;
688                         goto good;
689                 }
690
691                 /* A3G is like M6R but with a different lcd_get method */
692                 else if (strncmp(model->name, "M6R", 3) == 0 &&
693                     strncmp(Obj->String.Pointer, "A3G", 3) == 0) {
694                         model->lcd_get = "\\BLFG";
695                         goto good;
696                 }
697
698                 /* M2N and W1N are like xxN with added WLED */
699                 else if (strncmp(model->name, "xxN", 3) == 0 &&
700                     (strncmp(Obj->String.Pointer, "M2N", 3) == 0 ||
701                      strncmp(Obj->String.Pointer, "W1N", 3) == 0)) {
702                         model->wled_set = "WLED";
703                         goto good;
704                 }
705
706                 /* M5N and S5N are like xxN without MLED */
707                 else if (strncmp(model->name, "xxN", 3) == 0 &&
708                     (strncmp(Obj->String.Pointer, "M5N", 3) == 0 ||
709                      strncmp(Obj->String.Pointer, "S5N", 3) == 0)) {
710                         model->mled_set = NULL;
711                         goto good;
712                 }
713         }
714
715         sbuf_printf(sb, "Unsupported Asus laptop: %s\n", Obj->String.Pointer);
716         sbuf_finish(sb);
717
718         device_printf(dev, "%s", sbuf_data(sb));
719
720         sbuf_delete(sb);
721         AcpiOsFree(Buf.Pointer);
722
723         return (ENXIO);
724 }
725
726 static int
727 acpi_asus_attach(device_t dev)
728 {
729         struct acpi_asus_softc  *sc;
730         struct acpi_softc       *acpi_sc;
731
732         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
733
734         sc = device_get_softc(dev);
735         acpi_sc = acpi_device_get_parent_softc(dev);
736
737         /* Build sysctl tree */
738         sysctl_ctx_init(&sc->sysctl_ctx);
739         sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
740             SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
741             OID_AUTO, "asus", CTLFLAG_RD, 0, "");
742
743         /* Hook up nodes */
744         for (int i = 0; acpi_asus_sysctls[i].name != NULL; i++) {
745                 if (!acpi_asus_sysctl_init(sc, acpi_asus_sysctls[i].method))
746                         continue;
747
748                 SYSCTL_ADD_PROC(&sc->sysctl_ctx,
749                     SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
750                     acpi_asus_sysctls[i].name,
751                     acpi_asus_sysctls[i].flags,
752                     sc, i, acpi_asus_sysctl, "I",
753                     acpi_asus_sysctls[i].description);
754         }
755
756 #if defined(__FreeBSD__)
757         /* Attach leds */
758         if (sc->model->bled_set) {
759                 sc->s_bled.busy = 0;
760                 sc->s_bled.sc = sc;
761                 sc->s_bled.type = ACPI_ASUS_LED_BLED;
762                 sc->s_bled.cdev =
763                     led_create_state((led_t *)acpi_asus_led, &sc->s_bled,
764                         "bled", 1);
765         }
766
767         if (sc->model->dled_set) {
768                 sc->s_dled.busy = 0;
769                 sc->s_dled.sc = sc;
770                 sc->s_dled.type = ACPI_ASUS_LED_DLED;
771                 sc->s_dled.cdev =
772                     led_create((led_t *)acpi_asus_led, &sc->s_dled, "dled");
773         }
774
775         if (sc->model->gled_set) {
776                 sc->s_gled.busy = 0;
777                 sc->s_gled.sc = sc;
778                 sc->s_gled.type = ACPI_ASUS_LED_GLED;
779                 sc->s_gled.cdev =
780                     led_create((led_t *)acpi_asus_led, &sc->s_gled, "gled");
781         }
782
783         if (sc->model->mled_set) {
784                 sc->s_mled.busy = 0;
785                 sc->s_mled.sc = sc;
786                 sc->s_mled.type = ACPI_ASUS_LED_MLED;
787                 sc->s_mled.cdev =
788                     led_create((led_t *)acpi_asus_led, &sc->s_mled, "mled");
789         }
790
791         if (sc->model->tled_set) {
792                 sc->s_tled.busy = 0;
793                 sc->s_tled.sc = sc;
794                 sc->s_tled.type = ACPI_ASUS_LED_TLED;
795                 sc->s_tled.cdev =
796                     led_create_state((led_t *)acpi_asus_led, &sc->s_tled,
797                         "tled", 1);
798         }
799
800         if (sc->model->wled_set) {
801                 sc->s_wled.busy = 0;
802                 sc->s_wled.sc = sc;
803                 sc->s_wled.type = ACPI_ASUS_LED_WLED;
804                 sc->s_wled.cdev =
805                     led_create_state((led_t *)acpi_asus_led, &sc->s_wled,
806                         "wled", 1);
807         }
808 #endif
809
810         /* Activate hotkeys */
811         AcpiEvaluateObject(sc->handle, "BSTS", NULL, NULL);
812
813         /* Handle notifies */
814         if (sc->model->n_func == NULL)
815                 sc->model->n_func = acpi_asus_notify;
816
817         AcpiInstallNotifyHandler(sc->handle, ACPI_SYSTEM_NOTIFY,
818             sc->model->n_func, dev);
819
820         /* Find and hook the 'LCDD' object */
821         if (sc->model->lcdd != NULL && sc->model->lcdd_n_func != NULL) {
822                 ACPI_STATUS res;
823
824                 sc->lcdd_handle = NULL;
825                 res = AcpiGetHandle((sc->model->lcdd[0] == '\\' ?
826                     NULL : sc->handle), sc->model->lcdd, &(sc->lcdd_handle));
827                 if (ACPI_SUCCESS(res)) {
828                         AcpiInstallNotifyHandler((sc->lcdd_handle),
829                             ACPI_DEVICE_NOTIFY, sc->model->lcdd_n_func, dev);
830                 } else {
831                         kprintf("%s: unable to find LCD device '%s'\n",
832                             __func__, sc->model->lcdd);
833                 }
834         }
835
836         return (0);
837 }
838
839 static int
840 acpi_asus_detach(device_t dev)
841 {
842         struct acpi_asus_softc  *sc;
843
844         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
845
846         sc = device_get_softc(dev);
847 #if defined(__FreeBSD)
848         /* Turn the lights off */
849         if (sc->model->bled_set)
850                 led_destroy(sc->s_bled.cdev);
851
852         if (sc->model->dled_set)
853                 led_destroy(sc->s_dled.cdev);
854
855         if (sc->model->gled_set)
856                 led_destroy(sc->s_gled.cdev);
857
858         if (sc->model->mled_set)
859                 led_destroy(sc->s_mled.cdev);
860
861         if (sc->model->tled_set)
862                 led_destroy(sc->s_tled.cdev);
863
864         if (sc->model->wled_set)
865                 led_destroy(sc->s_wled.cdev);
866 #endif
867
868         /* Remove notify handler */
869         AcpiRemoveNotifyHandler(sc->handle, ACPI_SYSTEM_NOTIFY,
870             acpi_asus_notify);
871         
872         if (sc->lcdd_handle) {
873                 KASSERT(sc->model->lcdd_n_func != NULL,
874                     ("model->lcdd_n_func is NULL, but lcdd_handle is non-zero"));
875                 AcpiRemoveNotifyHandler((sc->lcdd_handle),
876                     ACPI_DEVICE_NOTIFY, sc->model->lcdd_n_func);
877         }
878
879         /* Free sysctl tree */
880         sysctl_ctx_free(&sc->sysctl_ctx);
881
882         return (0);
883 }
884
885 #if defined(__FreeBSD__)
886 static void
887 acpi_asus_led_task(struct acpi_asus_led *led, int pending __unused)
888 {
889         struct acpi_asus_softc  *sc;
890         char                    *method;
891         int                     state;
892         
893         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
894
895         sc = led->sc;
896
897         switch (led->type) {
898         case ACPI_ASUS_LED_BLED:
899                 method = sc->model->bled_set;
900                 state = led->state;
901                 break;
902         case ACPI_ASUS_LED_DLED:
903                 method = sc->model->dled_set;
904                 state = led->state;
905                 break;
906         case ACPI_ASUS_LED_GLED:
907                 method = sc->model->gled_set;
908                 state = led->state + 1; /* 1: off, 2: on */
909                 break;
910         case ACPI_ASUS_LED_MLED:
911                 method = sc->model->mled_set;
912                 state = !led->state;    /* inverted */
913                 break;
914         case ACPI_ASUS_LED_TLED:
915                 method = sc->model->tled_set;
916                 state = led->state;
917                 break;
918         case ACPI_ASUS_LED_WLED:
919                 method = sc->model->wled_set;
920                 state = led->state;
921                 break;
922         default:
923                 kprintf("acpi_asus_led: invalid LED type %d\n",
924                     (int)led->type);
925                 return;
926         }
927
928         acpi_SetInteger(sc->handle, method, state);
929         led->busy = 0;
930 }
931         
932 static void
933 acpi_asus_led(struct acpi_asus_led *led, int state)
934 {
935
936         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
937
938         if (led->busy)
939                 return;
940
941         led->busy = 1;
942         led->state = state;
943
944         AcpiOsExecute(OSL_NOTIFY_HANDLER, (void *)acpi_asus_led_task, led);
945 }
946 #endif
947
948 static int
949 acpi_asus_sysctl(SYSCTL_HANDLER_ARGS)
950 {
951         struct acpi_asus_softc  *sc;
952         int                     arg;
953         int                     error = 0;
954         int                     function;
955         int                     method;
956         
957         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
958
959         sc = (struct acpi_asus_softc *)oidp->oid_arg1;
960         function = oidp->oid_arg2;
961         method = acpi_asus_sysctls[function].method;
962
963         ACPI_SERIAL_BEGIN(asus);
964         arg = acpi_asus_sysctl_get(sc, method);
965         error = sysctl_handle_int(oidp, &arg, 0, req);
966
967         /* Sanity check */
968         if (error != 0 || req->newptr == NULL)
969                 goto out;
970
971         /* Update */
972         error = acpi_asus_sysctl_set(sc, method, arg);
973
974 out:
975         ACPI_SERIAL_END(asus);
976         return (error);
977 }
978
979 static int
980 acpi_asus_sysctl_get(struct acpi_asus_softc *sc, int method)
981 {
982         int val = 0;
983
984         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
985         ACPI_SERIAL_ASSERT(asus);
986
987         switch (method) {
988         case ACPI_ASUS_METHOD_BRN:
989                 val = sc->s_brn;
990                 break;
991         case ACPI_ASUS_METHOD_DISP:
992                 val = sc->s_disp;
993                 break;
994         case ACPI_ASUS_METHOD_LCD:
995                 val = sc->s_lcd;
996                 break;
997         case ACPI_ASUS_METHOD_CAMERA:
998                 val = sc->s_cam;
999                 break;
1000         case ACPI_ASUS_METHOD_CARDRD:
1001                 val = sc->s_crd;
1002                 break;
1003         case ACPI_ASUS_METHOD_WLAN:
1004                 val = sc->s_wlan;
1005                 break;
1006         }
1007
1008         return (val);
1009 }
1010
1011 static int
1012 acpi_asus_sysctl_set(struct acpi_asus_softc *sc, int method, int arg)
1013 {
1014         ACPI_STATUS             status = AE_OK;
1015         ACPI_OBJECT_LIST        acpiargs;
1016         ACPI_OBJECT             acpiarg[1];
1017
1018         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
1019         ACPI_SERIAL_ASSERT(asus);
1020
1021         acpiargs.Count = 1;
1022         acpiargs.Pointer = acpiarg;
1023         acpiarg[0].Type = ACPI_TYPE_INTEGER;
1024         acpiarg[0].Integer.Value = arg;
1025
1026         switch (method) {
1027         case ACPI_ASUS_METHOD_BRN:
1028                 if (arg < 0 || arg > 15)
1029                         return (EINVAL);
1030
1031                 if (sc->model->brn_set)
1032                         status = acpi_SetInteger(sc->handle,
1033                             sc->model->brn_set, arg);
1034                 else {
1035                         while (arg != 0) {
1036                                 status = AcpiEvaluateObject(sc->handle,
1037                                     (arg > 0) ?  sc->model->brn_up :
1038                                     sc->model->brn_dn, NULL, NULL);
1039                                 (arg > 0) ? arg-- : arg++;
1040                         }
1041                 }
1042
1043                 if (ACPI_SUCCESS(status))
1044                         sc->s_brn = arg;
1045
1046                 break;
1047         case ACPI_ASUS_METHOD_DISP:
1048                 if (arg < 0 || arg > 7)
1049                         return (EINVAL);
1050
1051                 status = acpi_SetInteger(sc->handle,
1052                     sc->model->disp_set, arg);
1053
1054                 if (ACPI_SUCCESS(status))
1055                         sc->s_disp = arg;
1056
1057                 break;
1058         case ACPI_ASUS_METHOD_LCD:
1059                 if (arg < 0 || arg > 1)
1060                         return (EINVAL);
1061
1062                 if (strncmp(sc->model->name, "L3H", 3) != 0)
1063                         status = AcpiEvaluateObject(sc->handle,
1064                             sc->model->lcd_set, NULL, NULL);
1065                 else
1066                         status = acpi_SetInteger(sc->handle,
1067                             sc->model->lcd_set, 0x7);
1068
1069                 if (ACPI_SUCCESS(status))
1070                         sc->s_lcd = arg;
1071
1072                 break;
1073         case ACPI_ASUS_METHOD_CAMERA:
1074                 if (arg < 0 || arg > 1)
1075                         return (EINVAL);
1076
1077                 status = AcpiEvaluateObject(sc->handle,
1078                     sc->model->cam_set, &acpiargs, NULL);
1079
1080                 if (ACPI_SUCCESS(status))
1081                         sc->s_cam = arg;
1082                 break;
1083         case ACPI_ASUS_METHOD_CARDRD:
1084                 if (arg < 0 || arg > 1)
1085                         return (EINVAL);
1086
1087                 status = AcpiEvaluateObject(sc->handle,
1088                     sc->model->crd_set, &acpiargs, NULL);
1089
1090                 if (ACPI_SUCCESS(status))
1091                         sc->s_crd = arg;
1092                 break;
1093         case ACPI_ASUS_METHOD_WLAN:
1094                 if (arg < 0 || arg > 1)
1095                         return (EINVAL);
1096
1097                 status = AcpiEvaluateObject(sc->handle,
1098                     sc->model->wlan_set, &acpiargs, NULL);
1099
1100                 if (ACPI_SUCCESS(status))
1101                         sc->s_wlan = arg;
1102                 break;
1103         }
1104
1105         return (0);
1106 }
1107
1108 static int
1109 acpi_asus_sysctl_init(struct acpi_asus_softc *sc, int method)
1110 {
1111         ACPI_STATUS     status;
1112
1113         switch (method) {
1114         case ACPI_ASUS_METHOD_BRN:
1115                 if (sc->model->brn_get) {
1116                         /* GPLV/SPLV models */
1117                         status = acpi_GetInteger(sc->handle,
1118                             sc->model->brn_get, &sc->s_brn);
1119                         if (ACPI_SUCCESS(status))
1120                                 return (TRUE);
1121                 } else if (sc->model->brn_up) {
1122                         /* Relative models */
1123                         status = AcpiEvaluateObject(sc->handle,
1124                             sc->model->brn_up, NULL, NULL);
1125                         if (ACPI_FAILURE(status))
1126                                 return (FALSE);
1127
1128                         status = AcpiEvaluateObject(sc->handle,
1129                             sc->model->brn_dn, NULL, NULL);
1130                         if (ACPI_FAILURE(status))
1131                                 return (FALSE);
1132
1133                         return (TRUE);
1134                 }
1135                 return (FALSE);
1136         case ACPI_ASUS_METHOD_DISP:
1137                 if (sc->model->disp_get) {
1138                         status = acpi_GetInteger(sc->handle,
1139                             sc->model->disp_get, &sc->s_disp);
1140                         if (ACPI_SUCCESS(status))
1141                                 return (TRUE);
1142                 }
1143                 return (FALSE);
1144         case ACPI_ASUS_METHOD_LCD:
1145                 if (sc->model->lcd_get) {
1146                         if (strncmp(sc->model->name, "L3H", 3) == 0) {
1147                                 ACPI_BUFFER             Buf;
1148                                 ACPI_OBJECT             Arg[2], Obj;
1149                                 ACPI_OBJECT_LIST        Args;
1150
1151                                 /* L3H is a bit special */
1152                                 Arg[0].Type = ACPI_TYPE_INTEGER;
1153                                 Arg[0].Integer.Value = 0x02;
1154                                 Arg[1].Type = ACPI_TYPE_INTEGER;
1155                                 Arg[1].Integer.Value = 0x03;
1156
1157                                 Args.Count = 2;
1158                                 Args.Pointer = Arg;
1159
1160                                 Buf.Length = sizeof(Obj);
1161                                 Buf.Pointer = &Obj;
1162
1163                                 status = AcpiEvaluateObject(sc->handle,
1164                                     sc->model->lcd_get, &Args, &Buf);
1165                                 if (ACPI_SUCCESS(status) &&
1166                                     Obj.Type == ACPI_TYPE_INTEGER) {
1167                                         sc->s_lcd = Obj.Integer.Value >> 8;
1168                                         return (TRUE);
1169                                 }
1170                         } else {
1171                                 status = acpi_GetInteger(sc->handle,
1172                                     sc->model->lcd_get, &sc->s_lcd);
1173                                 if (ACPI_SUCCESS(status))
1174                                         return (TRUE);
1175                         }
1176                 }
1177                 return (FALSE);
1178         case ACPI_ASUS_METHOD_CAMERA:
1179                 if (sc->model->cam_get) {
1180                         status = acpi_GetInteger(sc->handle,
1181                             sc->model->cam_get, &sc->s_cam);
1182                         if (ACPI_SUCCESS(status))
1183                                 return (TRUE);
1184                 }
1185                 return (FALSE);
1186         case ACPI_ASUS_METHOD_CARDRD:
1187                 if (sc->model->crd_get) {
1188                         status = acpi_GetInteger(sc->handle,
1189                             sc->model->crd_get, &sc->s_crd);
1190                         if (ACPI_SUCCESS(status))
1191                                 return (TRUE);
1192                 }
1193                 return (FALSE);
1194         case ACPI_ASUS_METHOD_WLAN:
1195                 if (sc->model->wlan_get) {
1196                         status = acpi_GetInteger(sc->handle,
1197                             sc->model->wlan_get, &sc->s_wlan);
1198                         if (ACPI_SUCCESS(status))
1199                                 return (TRUE);
1200                 }
1201                 return (FALSE);
1202         }
1203         return (FALSE);
1204 }
1205
1206 static void
1207 acpi_asus_notify(ACPI_HANDLE h, UINT32 notify, void *context)
1208 {
1209         struct acpi_asus_softc  *sc;
1210         struct acpi_softc       *acpi_sc;
1211
1212         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
1213
1214         sc = device_get_softc((device_t)context);
1215         acpi_sc = acpi_device_get_parent_softc(sc->dev);
1216
1217         ACPI_SERIAL_BEGIN(asus);
1218         if ((notify & ~0x10) <= 15) {
1219                 sc->s_brn = notify & ~0x10;
1220                 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness increased\n");
1221         } else if ((notify & ~0x20) <= 15) {
1222                 sc->s_brn = notify & ~0x20;
1223                 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness decreased\n");
1224         } else if (notify == 0x33) {
1225                 sc->s_lcd = 1;
1226                 ACPI_VPRINT(sc->dev, acpi_sc, "LCD turned on\n");
1227         } else if (notify == 0x34) {
1228                 sc->s_lcd = 0;
1229                 ACPI_VPRINT(sc->dev, acpi_sc, "LCD turned off\n");
1230         } else if (notify == 0x86) {
1231                 acpi_asus_sysctl_set(sc, ACPI_ASUS_METHOD_BRN, sc->s_brn-1);
1232                 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness decreased\n");
1233         } else if (notify == 0x87) {
1234                 acpi_asus_sysctl_set(sc, ACPI_ASUS_METHOD_BRN, sc->s_brn+1);
1235                 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness increased\n");
1236         } else {
1237                 /* Notify devd(8) */
1238                 acpi_UserNotify("ASUS", h, notify);
1239         }
1240         ACPI_SERIAL_END(asus);
1241 }
1242
1243 static void
1244 acpi_asus_lcdd_notify(ACPI_HANDLE h, UINT32 notify, void *context)
1245 {
1246         struct acpi_asus_softc  *sc;
1247         struct acpi_softc       *acpi_sc;
1248
1249         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
1250
1251         sc = device_get_softc((device_t)context);
1252         acpi_sc = acpi_device_get_parent_softc(sc->dev);
1253
1254         ACPI_SERIAL_BEGIN(asus);
1255         switch (notify) {
1256         case 0x87:
1257                 acpi_asus_sysctl_set(sc, ACPI_ASUS_METHOD_BRN, sc->s_brn-1);
1258                 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness decreased\n");
1259                 break;
1260         case 0x86:
1261                 acpi_asus_sysctl_set(sc, ACPI_ASUS_METHOD_BRN, sc->s_brn+1);
1262                 ACPI_VPRINT(sc->dev, acpi_sc, "Brightness increased\n");
1263                 break;
1264         }
1265         ACPI_SERIAL_END(asus);
1266 }
1267
1268 static void
1269 acpi_asus_eeepc_notify(ACPI_HANDLE h, UINT32 notify, void *context)
1270 {
1271         struct acpi_asus_softc  *sc;
1272         struct acpi_softc       *acpi_sc;
1273
1274         ACPI_FUNCTION_TRACE((char *)(uintptr_t)__func__);
1275
1276         sc = device_get_softc((device_t)context);
1277         acpi_sc = acpi_device_get_parent_softc(sc->dev);
1278
1279         ACPI_SERIAL_BEGIN(asus);
1280         if ((notify & ~0x20) <= 15) {
1281                 sc->s_brn = notify & ~0x20;
1282                 ACPI_VPRINT(sc->dev, acpi_sc,
1283                     "Brightness increased/decreased\n");
1284         } else {
1285                 /* Notify devd(8) */
1286                 acpi_UserNotify("ASUS-Eee", h, notify);
1287         }
1288         ACPI_SERIAL_END(asus);
1289 }