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