Catch up with reality, this is GCC 3.4.4.
[dragonfly.git] / sys / i386 / acpica5 / acpi_toshiba.c
1 /*-
2  * Copyright (c) 2003 Hiroyuki Aizu <aizu@navi.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/i386/acpica/acpi_toshiba.c,v 1.8 2004/05/30 20:34:56 phk Exp $
27  * $DragonFly: src/sys/i386/acpica5/Attic/acpi_toshiba.c,v 1.4 2004/07/17 10:49:43 hmp Exp $
28  */
29
30 #include "opt_acpi.h"
31 #include <sys/param.h>
32 #include <sys/systm.h>
33 #include <sys/kernel.h>
34 #include <sys/module.h>
35 #include <sys/bus.h>
36 #include <stdarg.h>
37
38 #include "acpi.h"
39 #include "acpivar.h"
40
41 /*
42  * Toshiba HCI interface definitions
43  *
44  * HCI is Toshiba's "Hardware Control Interface" which is supposed to
45  * be uniform across all their models.  Ideally we would just call
46  * dedicated ACPI methods instead of using this primitive interface.
47  * However, the ACPI methods seem to be incomplete in some areas (for
48  * example they allow setting, but not reading, the LCD brightness
49  * value), so this is still useful.
50  */
51
52 #define METHOD_HCI              "GHCI"
53 #define METHOD_HCI_ENABLE       "ENAB"
54 #define METHOD_VIDEO            "DSSX"
55
56 /* Operations */
57 #define HCI_SET                         0xFF00
58 #define HCI_GET                         0xFE00
59
60 /* Return codes */
61 #define HCI_SUCCESS                     0x0000
62 #define HCI_FAILURE                     0x1000
63 #define HCI_NOT_SUPPORTED               0x8000
64 #define HCI_EMPTY                       0x8C00
65
66 /* Functions */
67 #define HCI_REG_LCD_BACKLIGHT           0x0002
68 #define HCI_REG_FAN                     0x0004
69 #define HCI_REG_SYSTEM_EVENT            0x0016
70 #define HCI_REG_VIDEO_OUTPUT            0x001C
71 #define HCI_REG_HOTKEY_EVENT            0x001E
72 #define HCI_REG_LCD_BRIGHTNESS          0x002A
73 #define HCI_REG_CPU_SPEED               0x0032
74
75 /* Field definitions */
76 #define HCI_FAN_SHIFT                   7
77 #define HCI_LCD_BRIGHTNESS_BITS         3
78 #define HCI_LCD_BRIGHTNESS_SHIFT        (16 - HCI_LCD_BRIGHTNESS_BITS)
79 #define HCI_LCD_BRIGHTNESS_MAX          ((1 << HCI_LCD_BRIGHTNESS_BITS) - 1)
80 #define HCI_VIDEO_OUTPUT_FLAG           0x0100
81 #define HCI_VIDEO_OUTPUT_LCD            0x1
82 #define HCI_VIDEO_OUTPUT_CRT            0x2
83 #define HCI_VIDEO_OUTPUT_TV             0x4
84 #define HCI_CPU_SPEED_BITS              3
85 #define HCI_CPU_SPEED_SHIFT             (16 - HCI_CPU_SPEED_BITS)
86 #define HCI_CPU_SPEED_MAX               ((1 << HCI_CPU_SPEED_BITS) - 1)
87
88 /* Key press/release events. */
89 #define FN_F1_PRESS     0x013B
90 #define FN_F1_RELEASE   0x01BB
91 #define FN_F2_PRESS     0x013C
92 #define FN_F2_RELEASE   0x01BC
93 #define FN_F3_PRESS     0x013D
94 #define FN_F3_RELEASE   0x01BD
95 #define FN_F4_PRESS     0x013E
96 #define FN_F4_RELEASE   0x01BE
97 #define FN_F5_PRESS     0x013F
98 #define FN_F5_RELEASE   0x01BF
99 #define FN_F6_PRESS     0x0140
100 #define FN_F6_RELEASE   0x01C0
101 #define FN_F7_PRESS     0x0141
102 #define FN_F7_RELEASE   0x01C1
103 #define FN_F8_PRESS     0x0142
104 #define FN_F8_RELEASE   0x01C2
105 #define FN_F9_PRESS     0x0143
106 #define FN_F9_RELEASE   0x01C3
107 #define FN_BS_PRESS     0x010E
108 #define FN_BS_RELEASE   0x018E
109 #define FN_ESC_PRESS    0x0101
110 #define FN_ESC_RELEASE  0x0181
111 #define FN_KNJ_PRESS    0x0129
112 #define FN_KNJ_RELEASE  0x01A9
113
114 /* HCI register definitions. */
115 #define HCI_WORDS       6               /* Number of registers */
116 #define HCI_REG_AX      0               /* Operation, then return value */
117 #define HCI_REG_BX      1               /* Function */
118 #define HCI_REG_CX      2               /* Argument (in or out) */
119 #define HCI_REG_DX      3               /* Unused? */
120 #define HCI_REG_SI      4               /* Unused? */
121 #define HCI_REG_DI      5               /* Unused? */
122
123 struct acpi_toshiba_softc {
124         device_t        dev;
125         ACPI_HANDLE     handle;
126         ACPI_HANDLE     video_handle;
127         struct          sysctl_ctx_list sysctl_ctx;
128         struct          sysctl_oid *sysctl_tree;
129 };
130
131 /* Prototype for HCI functions for getting/setting a value. */
132 typedef int     hci_fn_t(ACPI_HANDLE, int, UINT32 *);
133
134 static int      acpi_toshiba_probe(device_t dev);
135 static int      acpi_toshiba_attach(device_t dev);
136 static int      acpi_toshiba_detach(device_t dev);
137 static int      acpi_toshiba_sysctl(SYSCTL_HANDLER_ARGS);
138 static hci_fn_t hci_force_fan;
139 static hci_fn_t hci_video_output;
140 static hci_fn_t hci_lcd_brightness;
141 static hci_fn_t hci_lcd_backlight;
142 static hci_fn_t hci_cpu_speed;
143 static int      hci_call(ACPI_HANDLE h, int op, int function, UINT32 *arg);
144 static void     hci_key_action(struct acpi_toshiba_softc *sc, ACPI_HANDLE h,
145                     UINT32 key);
146 static void     acpi_toshiba_notify(ACPI_HANDLE h, UINT32 notify,
147                     void *context);
148 static int      acpi_toshiba_video_probe(device_t dev);
149 static int      acpi_toshiba_video_attach(device_t dev);
150
151 /* Table of sysctl names and HCI functions to call. */
152 static struct {
153         char            *name;
154         hci_fn_t        *handler;
155 } sysctl_table[] = {
156         /* name,                handler */
157         {"force_fan",           hci_force_fan},
158         {"video_output",        hci_video_output},
159         {"lcd_brightness",      hci_lcd_brightness},
160         {"lcd_backlight",       hci_lcd_backlight},
161         {"cpu_speed",           hci_cpu_speed},
162         {NULL, NULL}
163 };
164
165 static device_method_t acpi_toshiba_methods[] = {
166         DEVMETHOD(device_probe,         acpi_toshiba_probe),
167         DEVMETHOD(device_attach,        acpi_toshiba_attach),
168         DEVMETHOD(device_detach,        acpi_toshiba_detach),
169
170         {0, 0}
171 };
172
173 static driver_t acpi_toshiba_driver = {
174         "acpi_toshiba",
175         acpi_toshiba_methods,
176         sizeof(struct acpi_toshiba_softc),
177 };
178
179 static devclass_t acpi_toshiba_devclass;
180 DRIVER_MODULE(acpi_toshiba, acpi, acpi_toshiba_driver, acpi_toshiba_devclass,
181     0, 0);
182 MODULE_DEPEND(acpi_toshiba, acpi, 1, 1, 1);
183
184 static device_method_t acpi_toshiba_video_methods[] = {
185         DEVMETHOD(device_probe,         acpi_toshiba_video_probe),
186         DEVMETHOD(device_attach,        acpi_toshiba_video_attach),
187
188         {0, 0}
189 };
190
191 static driver_t acpi_toshiba_video_driver = {
192         "acpi_toshiba_video",
193         acpi_toshiba_video_methods,
194         0,
195 };
196
197 static devclass_t acpi_toshiba_video_devclass;
198 DRIVER_MODULE(acpi_toshiba_video, acpi, acpi_toshiba_video_driver,
199     acpi_toshiba_video_devclass, 0, 0);
200 MODULE_DEPEND(acpi_toshiba_video, acpi, 1, 1, 1);
201
202 static int      enable_fn_keys = 1;
203 TUNABLE_INT("hw.acpi.toshiba.enable_fn_keys", &enable_fn_keys);
204
205 /*
206  * HID      Model
207  * -------------------------------------
208  * TOS6200  Libretto L Series
209  *          Dynabook Satellite 2455
210  *          Dynabook SS 3500
211  * TOS6207  Dynabook SS2110 Series
212  */
213 static int
214 acpi_toshiba_probe(device_t dev)
215 {
216         int ret = ENXIO;
217
218         if (!acpi_disabled("toshiba") &&
219             acpi_get_type(dev) == ACPI_TYPE_DEVICE &&
220             device_get_unit(dev) == 0 &&
221             (acpi_MatchHid(dev, "TOS6200") ||
222              acpi_MatchHid(dev, "TOS6207"))) {
223                 device_set_desc(dev, "Toshiba HCI Extras");
224                 ret = 0;
225         }
226
227         return (ret);
228 }
229
230 static int
231 acpi_toshiba_attach(device_t dev)
232 {
233         struct          acpi_toshiba_softc *sc;
234         struct          acpi_softc *acpi_sc;
235         ACPI_STATUS     status;
236         int             i;
237
238         sc = device_get_softc(dev);
239         sc->dev = dev;
240         sc->handle = acpi_get_handle(dev);
241
242         acpi_sc = acpi_device_get_parent_softc(dev);
243         sysctl_ctx_init(&sc->sysctl_ctx);
244         sc->sysctl_tree = SYSCTL_ADD_NODE(&sc->sysctl_ctx,
245             SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree), OID_AUTO,
246             "toshiba", CTLFLAG_RD, 0, "");
247
248         for (i = 0; sysctl_table[i].name != NULL; i++) {
249                 SYSCTL_ADD_PROC(&sc->sysctl_ctx,
250                     SYSCTL_CHILDREN(sc->sysctl_tree), OID_AUTO,
251                     sysctl_table[i].name,
252                     CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY,
253                     sc, i, acpi_toshiba_sysctl, "I", "");
254         }
255
256         if (enable_fn_keys != 0) {
257                 status = AcpiEvaluateObject(sc->handle, METHOD_HCI_ENABLE,
258                                             NULL, NULL);
259                 if (ACPI_FAILURE(status)) {
260                         device_printf(dev, "enable FN keys failed\n");
261                         sysctl_ctx_free(&sc->sysctl_ctx);
262                         return (ENXIO);
263                 }
264                 AcpiInstallNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY,
265                                          acpi_toshiba_notify, sc);
266         }
267
268         return (0);
269 }
270
271 static int
272 acpi_toshiba_detach(device_t dev)
273 {
274         struct          acpi_toshiba_softc *sc;
275
276         sc = device_get_softc(dev);
277         if (enable_fn_keys != 0) {
278                 AcpiRemoveNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY,
279                                         acpi_toshiba_notify);
280         }
281         sysctl_ctx_free(&sc->sysctl_ctx);
282
283         return (0);
284 }
285
286 static int
287 acpi_toshiba_sysctl(SYSCTL_HANDLER_ARGS)
288 {
289         struct          acpi_toshiba_softc *sc;
290         UINT32          arg;
291         int             function, error = 0;
292         hci_fn_t        *handler;
293
294         sc = (struct acpi_toshiba_softc *)oidp->oid_arg1;
295         function = oidp->oid_arg2;
296         handler = sysctl_table[function].handler;
297
298         /* Get the current value from the appropriate function. */
299         error = handler(sc->handle, HCI_GET, &arg);
300         if (error != 0)
301                 return (error);
302
303         /* Send the current value to the user and return if no new value. */
304         error = sysctl_handle_int(oidp, &arg, 0, req);
305         if (error != 0 || req->newptr == NULL)
306                 return (error);
307
308         /* Set the new value via the appropriate function. */
309         error = handler(sc->handle, HCI_SET, &arg);
310
311         return (error);
312 }
313
314 static int
315 hci_force_fan(ACPI_HANDLE h, int op, UINT32 *state)
316 {
317         int             ret;
318
319         if (op == HCI_SET) {
320                 if (*state < 0 || *state > 1)
321                         return (EINVAL);
322                 *state <<= HCI_FAN_SHIFT;
323         }
324         ret = hci_call(h, op, HCI_REG_FAN, state);
325         if (ret == 0 && op == HCI_GET)
326                 *state >>= HCI_FAN_SHIFT;
327         return (ret);
328 }
329
330 static int
331 hci_video_output(ACPI_HANDLE h, int op, UINT32 *video_output)
332 {
333         int             ret;
334         ACPI_STATUS     status;
335
336         if (op == HCI_SET) {
337                 if (*video_output < 1 || *video_output > 7)
338                         return (EINVAL);
339                 if (h == NULL)
340                         return (ENXIO);
341                 *video_output |= HCI_VIDEO_OUTPUT_FLAG;
342                 status = acpi_SetInteger(h, METHOD_VIDEO, *video_output);
343                 if (ACPI_SUCCESS(status))
344                         ret = 0;
345                 else
346                         ret = ENXIO;
347         } else {
348                 ret = hci_call(h, op, HCI_REG_VIDEO_OUTPUT, video_output);
349                 if (ret == 0)
350                         *video_output &= 0xff;
351         }
352
353         return (ret);
354 }
355
356 static int
357 hci_lcd_brightness(ACPI_HANDLE h, int op, UINT32 *brightness)
358 {
359         int             ret;
360
361         if (op == HCI_SET) {
362                 if (*brightness < 0 || *brightness > HCI_LCD_BRIGHTNESS_MAX)
363                         return (EINVAL);
364                 *brightness <<= HCI_LCD_BRIGHTNESS_SHIFT;
365         }
366         ret = hci_call(h, op, HCI_REG_LCD_BRIGHTNESS, brightness);
367         if (ret == 0 && op == HCI_GET)
368                 *brightness >>= HCI_LCD_BRIGHTNESS_SHIFT;
369         return (ret);
370 }
371
372 static int
373 hci_lcd_backlight(ACPI_HANDLE h, int op, UINT32 *backlight)
374 {
375         if (op == HCI_SET) {
376                 if (*backlight < 0 || *backlight > 1)
377                         return (EINVAL);
378         }
379         return (hci_call(h, op, HCI_REG_LCD_BACKLIGHT, backlight));
380 }
381
382 static int
383 hci_cpu_speed(ACPI_HANDLE h, int op, UINT32 *speed)
384 {
385         int             ret;
386
387         if (op == HCI_SET) {
388                 if (*speed < 0 || *speed > HCI_CPU_SPEED_MAX)
389                         return (EINVAL);
390                 *speed <<= HCI_CPU_SPEED_SHIFT;
391         }
392         ret = hci_call(h, op, HCI_REG_CPU_SPEED, speed);
393         if (ret == 0 && op == HCI_GET)
394                 *speed >>= HCI_CPU_SPEED_SHIFT;
395         return (ret);
396 }
397
398 static int
399 hci_call(ACPI_HANDLE h, int op, int function, UINT32 *arg)
400 {
401         ACPI_OBJECT_LIST args;
402         ACPI_BUFFER     results;
403         ACPI_OBJECT     obj[HCI_WORDS];
404         ACPI_OBJECT     *res;
405         int             status, i, ret;
406
407         status = ENXIO;
408
409         for (i = 0; i < HCI_WORDS; i++) {
410                 obj[i].Type = ACPI_TYPE_INTEGER;
411                 obj[i].Integer.Value = 0;
412         }
413         obj[HCI_REG_AX].Integer.Value = op;
414         obj[HCI_REG_BX].Integer.Value = function;
415         if (op == HCI_SET)
416                 obj[HCI_REG_CX].Integer.Value = *arg;
417
418         args.Count = HCI_WORDS;
419         args.Pointer = obj;
420         results.Pointer = NULL;
421         results.Length = ACPI_ALLOCATE_BUFFER;
422         if (ACPI_FAILURE(AcpiEvaluateObject(h, METHOD_HCI, &args, &results)))
423                 goto end;
424         res = (ACPI_OBJECT *)results.Pointer;
425         if (!ACPI_PKG_VALID(res, HCI_WORDS)) {
426                 printf("toshiba: invalid package!\n");
427                 return (ENXIO);
428         }
429
430         acpi_PkgInt32(res, HCI_REG_AX, &ret);
431         if (ret == HCI_SUCCESS) {
432                 if (op == HCI_GET)
433                         acpi_PkgInt32(res, HCI_REG_CX, arg);
434                 status = 0;
435         } else if (function == HCI_REG_SYSTEM_EVENT && op == HCI_GET &&
436             ret == HCI_NOT_SUPPORTED) {
437                 /*
438                  * Sometimes system events are disabled without us requesting
439                  * it.  This workaround attempts to re-enable them.
440                  */
441                  i = 1;
442                  hci_call(h, HCI_SET, HCI_REG_SYSTEM_EVENT, &i);
443         }
444
445 end:
446         if (results.Pointer != NULL)
447                 AcpiOsFree(results.Pointer);
448
449         return (status);
450 }
451
452 /*
453  * Perform a few actions based on the keypress.  Users can extend this
454  * functionality by reading the keystrokes we send to devd(8).
455  */
456 static void
457 hci_key_action(struct acpi_toshiba_softc *sc, ACPI_HANDLE h, UINT32 key)
458 {
459         UINT32          arg;
460
461         switch (key) {
462         case FN_F6_RELEASE:
463                 /* Decrease LCD brightness. */
464                 hci_lcd_brightness(h, HCI_GET, &arg);
465                 if (arg-- == 0)
466                         arg = 0;
467                 else
468                         hci_lcd_brightness(h, HCI_SET, &arg);
469                 break;
470         case FN_F7_RELEASE:
471                 /* Increase LCD brightness. */
472                 hci_lcd_brightness(h, HCI_GET, &arg);
473                 if (arg++ == 7)
474                         arg = 7;
475                 else
476                         hci_lcd_brightness(h, HCI_SET, &arg);
477                 break;
478         case FN_F5_RELEASE:
479                 /* Cycle through video outputs. */
480                 hci_video_output(h, HCI_GET, &arg);
481                 arg = (arg + 1) % 7;
482                 hci_video_output(sc->video_handle, HCI_SET, &arg);
483                 break;
484         case FN_F8_RELEASE:
485                 /* Toggle LCD backlight. */
486                 hci_lcd_backlight(h, HCI_GET, &arg);
487                 arg = (arg != 0) ? 0 : 1;
488                 hci_lcd_backlight(h, HCI_SET, &arg);
489                 break;
490         case FN_ESC_RELEASE:
491                 /* Toggle forcing fan on. */
492                 hci_force_fan(h, HCI_GET, &arg);
493                 arg = (arg != 0) ? 0 : 1;
494                 hci_force_fan(h, HCI_SET, &arg);
495                 break;
496         }
497 }
498
499 static void
500 acpi_toshiba_notify(ACPI_HANDLE h, UINT32 notify, void *context)
501 {
502         struct          acpi_toshiba_softc *sc;
503         UINT32          key;
504
505         sc = (struct acpi_toshiba_softc *)context;
506
507         if (notify == 0x80) {
508                 while (hci_call(h, HCI_GET, HCI_REG_SYSTEM_EVENT, &key) == 0) {
509                         hci_key_action(sc, h, key);
510                         acpi_UserNotify("TOSHIBA", h, (uint8_t)key);
511                 }
512         } else
513                 device_printf(sc->dev, "unknown notify: 0x%x\n", notify);
514 }
515
516 /*
517  * Toshiba video pseudo-device to provide the DSSX method.
518  *
519  * HID      Model
520  * -------------------------------------
521  * TOS6201  Libretto L Series
522  */
523 static int
524 acpi_toshiba_video_probe(device_t dev)
525 {
526         int ret = ENXIO;
527
528         if (!acpi_disabled("toshiba") &&
529             acpi_get_type(dev) == ACPI_TYPE_DEVICE &&
530             device_get_unit(dev) == 0 &&
531              acpi_MatchHid(dev, "TOS6201")) {
532                 device_quiet(dev);
533                 device_set_desc(dev, "Toshiba Video");
534                 ret = 0;
535         }
536
537         return (ret);
538 }
539
540 static int
541 acpi_toshiba_video_attach(device_t dev)
542 {
543         struct          acpi_toshiba_softc *sc;
544
545         sc = devclass_get_softc(acpi_toshiba_devclass, 0);
546         if (sc == NULL)
547                 return (ENXIO);
548         sc->video_handle = acpi_get_handle(dev);
549         return (0);
550 }