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 }