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