sys/dev/acpica/acpi_video.c

   1 /*-
   2  * Copyright (c) 2002-2003 Taku YAMAMOTO <taku@cent.saitama-u.ac.jp>
   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  *      $Id: acpi_vid.c,v 1.4 2003/10/13 10:07:36 taku Exp $
  27  */
  28
  29 #include <sys/cdefs.h>
  30 __FBSDID("$FreeBSD$");
  31
  32 #include <sys/param.h>
  33 #include <sys/kernel.h>
  34 #include <sys/malloc.h>
  35 #include <sys/module.h>
  36 #include <sys/bus.h>
  37 #include <sys/power.h>
  38 #include <sys/queue.h>
  39 #include <sys/sysctl.h>
  40
  41 #include <contrib/dev/acpica/include/acpi.h>
  42
  43 #include <dev/acpica/acpivar.h>
  44
  45 /* ACPI video extension driver. */
  46 struct acpi_video_output {
  47         ACPI_HANDLE     handle;
  48         UINT32          adr;
  49         STAILQ_ENTRY(acpi_video_output) vo_next;
  50         struct {
  51                 int     num;
  52                 STAILQ_ENTRY(acpi_video_output) next;
  53         } vo_unit;
  54         int             vo_brightness;
  55         int             vo_fullpower;
  56         int             vo_economy;
  57         int             vo_numlevels;
  58         int             *vo_levels;
  59         struct sysctl_ctx_list vo_sysctl_ctx;
  60         struct sysctl_oid *vo_sysctl_tree;
  61 };
  62
  63 STAILQ_HEAD(acpi_video_output_queue, acpi_video_output);
  64
  65 struct acpi_video_softc {
  66         device_t                device;
  67         ACPI_HANDLE             handle;
  68         struct acpi_video_output_queue vid_outputs;
  69         eventhandler_tag        vid_pwr_evh;
  70 };
  71
  72 /* interfaces */
  73 static int      acpi_video_modevent(struct module*, int, void *);
  74 static void     acpi_video_identify(driver_t *driver, device_t parent);
  75 static int      acpi_video_probe(device_t);
  76 static int      acpi_video_attach(device_t);
  77 static int      acpi_video_detach(device_t);
  78 static int      acpi_video_resume(device_t);
  79 static int      acpi_video_shutdown(device_t);
  80 static void     acpi_video_notify_handler(ACPI_HANDLE, UINT32, void *);
  81 static void     acpi_video_power_profile(void *);
  82 static void     acpi_video_bind_outputs(struct acpi_video_softc *);
  83 static struct acpi_video_output *acpi_video_vo_init(UINT32);
  84 static void     acpi_video_vo_bind(struct acpi_video_output *, ACPI_HANDLE);
  85 static void     acpi_video_vo_destroy(struct acpi_video_output *);
  86 static int      acpi_video_vo_check_level(struct acpi_video_output *, int);
  87 static void     acpi_video_vo_notify_handler(ACPI_HANDLE, UINT32, void *);
  88 static int      acpi_video_vo_active_sysctl(SYSCTL_HANDLER_ARGS);
  89 static int      acpi_video_vo_bright_sysctl(SYSCTL_HANDLER_ARGS);
  90 static int      acpi_video_vo_presets_sysctl(SYSCTL_HANDLER_ARGS);
  91 static int      acpi_video_vo_levels_sysctl(SYSCTL_HANDLER_ARGS);
  92
  93 /* operations */
  94 static void     vid_set_switch_policy(ACPI_HANDLE, UINT32);
  95 static int      vid_enum_outputs(ACPI_HANDLE,
  96                     void(*)(ACPI_HANDLE, UINT32, void *), void *);
  97 static int      vo_get_brightness_levels(ACPI_HANDLE, int **);
  98 static int      vo_get_brightness(ACPI_HANDLE);
  99 static void     vo_set_brightness(ACPI_HANDLE, int);
 100 static UINT32   vo_get_device_status(ACPI_HANDLE);
 101 static UINT32   vo_get_graphics_state(ACPI_HANDLE);
 102 static void     vo_set_device_state(ACPI_HANDLE, UINT32);
 103
 104 /* events */
 105 #define VID_NOTIFY_SWITCHED     0x80
 106 #define VID_NOTIFY_REPROBE      0x81
 107 #define VID_NOTIFY_CYCLE_BRN    0x85
 108 #define VID_NOTIFY_INC_BRN      0x86
 109 #define VID_NOTIFY_DEC_BRN      0x87
 110 #define VID_NOTIFY_ZERO_BRN     0x88
 111
 112 /* _DOS (Enable/Disable Output Switching) argument bits */
 113 #define DOS_SWITCH_MASK         3
 114 #define DOS_SWITCH_BY_OSPM      0
 115 #define DOS_SWITCH_BY_BIOS      1
 116 #define DOS_SWITCH_LOCKED       2
 117 #define DOS_BRIGHTNESS_BY_OSPM  (1 << 2)
 118
 119 /* _DOD and subdev's _ADR */
 120 #define DOD_DEVID_MASK          0x0f00
 121 #define DOD_DEVID_MASK_FULL     0xffff
 122 #define DOD_DEVID_MASK_DISPIDX  0x000f
 123 #define DOD_DEVID_MASK_DISPPORT 0x00f0
 124 #define DOD_DEVID_MONITOR       0x0100
 125 #define DOD_DEVID_LCD           0x0110
 126 #define DOD_DEVID_TV            0x0200
 127 #define DOD_DEVID_EXT           0x0300
 128 #define DOD_DEVID_INTDFP        0x0400
 129 #define DOD_BIOS                (1 << 16)
 130 #define DOD_NONVGA              (1 << 17)
 131 #define DOD_HEAD_ID_SHIFT       18
 132 #define DOD_HEAD_ID_BITS        3
 133 #define DOD_HEAD_ID_MASK \
 134                 (((1 << DOD_HEAD_ID_BITS) - 1) << DOD_HEAD_ID_SHIFT)
 135 #define DOD_DEVID_SCHEME_STD    (1U << 31)
 136
 137 /* _BCL related constants */
 138 #define BCL_FULLPOWER           0
 139 #define BCL_ECONOMY             1
 140
 141 /* _DCS (Device Currrent Status) value bits and masks. */
 142 #define DCS_EXISTS              (1 << 0)
 143 #define DCS_ACTIVE              (1 << 1)
 144 #define DCS_READY               (1 << 2)
 145 #define DCS_FUNCTIONAL          (1 << 3)
 146 #define DCS_ATTACHED            (1 << 4)
 147
 148 /* _DSS (Device Set Status) argument bits and masks. */
 149 #define DSS_INACTIVE            0
 150 #define DSS_ACTIVE              (1 << 0)
 151 #define DSS_SETNEXT             (1 << 30)
 152 #define DSS_COMMIT              (1U << 31)
 153
 154 static device_method_t acpi_video_methods[] = {
 155         DEVMETHOD(device_identify, acpi_video_identify),
 156         DEVMETHOD(device_probe, acpi_video_probe),
 157         DEVMETHOD(device_attach, acpi_video_attach),
 158         DEVMETHOD(device_detach, acpi_video_detach),
 159         DEVMETHOD(device_resume, acpi_video_resume),
 160         DEVMETHOD(device_shutdown, acpi_video_shutdown),
 161         { 0, 0 }
 162 };
 163
 164 static driver_t acpi_video_driver = {
 165         "acpi_video",
 166         acpi_video_methods,
 167         sizeof(struct acpi_video_softc),
 168 };
 169
 170 static devclass_t acpi_video_devclass;
 171
 172 DRIVER_MODULE(acpi_video, vgapci, acpi_video_driver, acpi_video_devclass,
 173               acpi_video_modevent, NULL);
 174 MODULE_DEPEND(acpi_video, acpi, 1, 1, 1);
 175
 176 static struct sysctl_ctx_list   acpi_video_sysctl_ctx;
 177 static struct sysctl_oid        *acpi_video_sysctl_tree;
 178 static struct acpi_video_output_queue crt_units, tv_units,
 179     ext_units, lcd_units, other_units;
 180
 181 /*
 182  * The 'video' lock protects the hierarchy of video output devices
 183  * (the video "bus").  The 'video_output' lock protects per-output
 184  * data is equivalent to a softc lock for each video output.
 185  */
 186 ACPI_SERIAL_DECL(video, "ACPI video");
 187 ACPI_SERIAL_DECL(video_output, "ACPI video output");
 188 static MALLOC_DEFINE(M_ACPIVIDEO, "acpivideo", "ACPI video extension");
 189
 190 static int
 191 acpi_video_modevent(struct module *mod __unused, int evt, void *cookie __unused)
 192 {
 193         int err;
 194
 195         err = 0;
 196         switch (evt) {
 197         case MOD_LOAD:
 198                 sysctl_ctx_init(&acpi_video_sysctl_ctx);
 199                 STAILQ_INIT(&crt_units);
 200                 STAILQ_INIT(&tv_units);
 201                 STAILQ_INIT(&ext_units);
 202                 STAILQ_INIT(&lcd_units);
 203                 STAILQ_INIT(&other_units);
 204                 break;
 205         case MOD_UNLOAD:
 206                 sysctl_ctx_free(&acpi_video_sysctl_ctx);
 207                 acpi_video_sysctl_tree = NULL;
 208                 break;
 209         default:
 210                 err = EINVAL;
 211         }
 212
 213         return (err);
 214 }
 215
 216 static void
 217 acpi_video_identify(driver_t *driver, device_t parent)
 218 {
 219
 220         if (device_find_child(parent, "acpi_video", -1) == NULL)
 221                 device_add_child(parent, "acpi_video", -1);
 222 }
 223
 224 static int
 225 acpi_video_probe(device_t dev)
 226 {
 227         ACPI_HANDLE devh, h;
 228         ACPI_OBJECT_TYPE t_dos;
 229
 230         devh = acpi_get_handle(dev);
 231         if (acpi_disabled("video") ||
 232             ACPI_FAILURE(AcpiGetHandle(devh, "_DOD", &h)) ||
 233             ACPI_FAILURE(AcpiGetHandle(devh, "_DOS", &h)) ||
 234             ACPI_FAILURE(AcpiGetType(h, &t_dos)) ||
 235             t_dos != ACPI_TYPE_METHOD)
 236                 return (ENXIO);
 237
 238         device_set_desc(dev, "ACPI video extension");
 239         return (0);
 240 }
 241
 242 static int
 243 acpi_video_attach(device_t dev)
 244 {
 245         struct acpi_softc *acpi_sc;
 246         struct acpi_video_softc *sc;
 247
 248         sc = device_get_softc(dev);
 249
 250         acpi_sc = devclass_get_softc(devclass_find("acpi"), 0);
 251         if (acpi_sc == NULL)
 252                 return (ENXIO);
 253         ACPI_SERIAL_BEGIN(video);
 254         if (acpi_video_sysctl_tree == NULL) {
 255                 acpi_video_sysctl_tree = SYSCTL_ADD_NODE(&acpi_video_sysctl_ctx,
 256                                     SYSCTL_CHILDREN(acpi_sc->acpi_sysctl_tree),
 257                                     OID_AUTO, "video", CTLFLAG_RD, 0,
 258                                     "video extension control");
 259         }
 260         ACPI_SERIAL_END(video);
 261
 262         sc->device = dev;
 263         sc->handle = acpi_get_handle(dev);
 264         STAILQ_INIT(&sc->vid_outputs);
 265
 266         AcpiInstallNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY,
 267                                  acpi_video_notify_handler, sc);
 268         sc->vid_pwr_evh = EVENTHANDLER_REGISTER(power_profile_change,
 269                                  acpi_video_power_profile, sc, 0);
 270
 271         ACPI_SERIAL_BEGIN(video);
 272         acpi_video_bind_outputs(sc);
 273         ACPI_SERIAL_END(video);
 274
 275         /*
 276          * Notify the BIOS that we want to switch both active outputs and
 277          * brightness levels.
 278          */
 279         vid_set_switch_policy(sc->handle, DOS_SWITCH_BY_OSPM |
 280             DOS_BRIGHTNESS_BY_OSPM);
 281
 282         acpi_video_power_profile(sc);
 283
 284         return (0);
 285 }
 286
 287 static int
 288 acpi_video_detach(device_t dev)
 289 {
 290         struct acpi_video_softc *sc;
 291         struct acpi_video_output *vo, *vn;
 292
 293         sc = device_get_softc(dev);
 294
 295         vid_set_switch_policy(sc->handle, DOS_SWITCH_BY_BIOS);
 296         EVENTHANDLER_DEREGISTER(power_profile_change, sc->vid_pwr_evh);
 297         AcpiRemoveNotifyHandler(sc->handle, ACPI_DEVICE_NOTIFY,
 298                                 acpi_video_notify_handler);
 299
 300         ACPI_SERIAL_BEGIN(video);
 301         STAILQ_FOREACH_SAFE(vo, &sc->vid_outputs, vo_next, vn) {
 302                 acpi_video_vo_destroy(vo);
 303         }
 304         ACPI_SERIAL_END(video);
 305
 306         return (0);
 307 }
 308
 309 static int
 310 acpi_video_resume(device_t dev)
 311 {
 312         struct acpi_video_softc *sc;
 313         struct acpi_video_output *vo, *vn;
 314         int level;
 315
 316         sc = device_get_softc(dev);
 317
 318         /* Restore brightness level */
 319         ACPI_SERIAL_BEGIN(video);
 320         ACPI_SERIAL_BEGIN(video_output);
 321         STAILQ_FOREACH_SAFE(vo, &sc->vid_outputs, vo_next, vn) {
 322                 if ((vo->adr & DOD_DEVID_MASK_FULL) != DOD_DEVID_LCD &&
 323                     (vo->adr & DOD_DEVID_MASK) != DOD_DEVID_INTDFP)
 324                         continue;
 325
 326                 if ((vo_get_device_status(vo->handle) & DCS_ACTIVE) == 0)
 327                         continue;
 328
 329                 level = vo_get_brightness(vo->handle);
 330                 if (level != -1)
 331                         vo_set_brightness(vo->handle, level);
 332         }
 333         ACPI_SERIAL_END(video_output);
 334         ACPI_SERIAL_END(video);
 335
 336         return (0);
 337 }
 338
 339 static int
 340 acpi_video_shutdown(device_t dev)
 341 {
 342         struct acpi_video_softc *sc;
 343
 344         sc = device_get_softc(dev);
 345         vid_set_switch_policy(sc->handle, DOS_SWITCH_BY_BIOS);
 346
 347         return (0);
 348 }
 349
 350 static void
 351 acpi_video_notify_handler(ACPI_HANDLE handle, UINT32 notify, void *context)
 352 {
 353         struct acpi_video_softc *sc;
 354         struct acpi_video_output *vo, *vo_tmp;
 355         ACPI_HANDLE lasthand;
 356         UINT32 dcs, dss, dss_p;
 357
 358         sc = (struct acpi_video_softc *)context;
 359
 360         switch (notify) {
 361         case VID_NOTIFY_SWITCHED:
 362                 dss_p = 0;
 363                 lasthand = NULL;
 364                 ACPI_SERIAL_BEGIN(video);
 365                 ACPI_SERIAL_BEGIN(video_output);
 366                 STAILQ_FOREACH(vo, &sc->vid_outputs, vo_next) {
 367                         dss = vo_get_graphics_state(vo->handle);
 368                         dcs = vo_get_device_status(vo->handle);
 369                         if (!(dcs & DCS_READY))
 370                                 dss = DSS_INACTIVE;
 371                         if (((dcs & DCS_ACTIVE) && dss == DSS_INACTIVE) ||
 372                             (!(dcs & DCS_ACTIVE) && dss == DSS_ACTIVE)) {
 373                                 if (lasthand != NULL)
 374                                         vo_set_device_state(lasthand, dss_p);
 375                                 dss_p = dss;
 376                                 lasthand = vo->handle;
 377                         }
 378                 }
 379                 if (lasthand != NULL)
 380                         vo_set_device_state(lasthand, dss_p|DSS_COMMIT);
 381                 ACPI_SERIAL_END(video_output);
 382                 ACPI_SERIAL_END(video);
 383                 break;
 384         case VID_NOTIFY_REPROBE:
 385                 ACPI_SERIAL_BEGIN(video);
 386                 STAILQ_FOREACH(vo, &sc->vid_outputs, vo_next)
 387                         vo->handle = NULL;
 388                 acpi_video_bind_outputs(sc);
 389                 STAILQ_FOREACH_SAFE(vo, &sc->vid_outputs, vo_next, vo_tmp) {
 390                         if (vo->handle == NULL) {
 391                                 STAILQ_REMOVE(&sc->vid_outputs, vo,
 392                                     acpi_video_output, vo_next);
 393                                 acpi_video_vo_destroy(vo);
 394                         }
 395                 }
 396                 ACPI_SERIAL_END(video);
 397                 break;
 398         default:
 399                 device_printf(sc->device, "unknown notify event 0x%x\n",
 400                     notify);
 401         }
 402 }
 403
 404 static void
 405 acpi_video_power_profile(void *context)
 406 {
 407         int state;
 408         struct acpi_video_softc *sc;
 409         struct acpi_video_output *vo;
 410
 411         sc = context;
 412         state = power_profile_get_state();
 413         if (state != POWER_PROFILE_PERFORMANCE &&
 414             state != POWER_PROFILE_ECONOMY)
 415                 return;
 416
 417         ACPI_SERIAL_BEGIN(video);
 418         ACPI_SERIAL_BEGIN(video_output);
 419         STAILQ_FOREACH(vo, &sc->vid_outputs, vo_next) {
 420                 if (vo->vo_levels != NULL && vo->vo_brightness == -1)
 421                         vo_set_brightness(vo->handle,
 422                             state == POWER_PROFILE_ECONOMY ?
 423                             vo->vo_economy : vo->vo_fullpower);
 424         }
 425         ACPI_SERIAL_END(video_output);
 426         ACPI_SERIAL_END(video);
 427 }
 428
 429 static void
 430 acpi_video_bind_outputs_subr(ACPI_HANDLE handle, UINT32 adr, void *context)
 431 {
 432         struct acpi_video_softc *sc;
 433         struct acpi_video_output *vo;
 434
 435         ACPI_SERIAL_ASSERT(video);
 436         sc = context;
 437
 438         STAILQ_FOREACH(vo, &sc->vid_outputs, vo_next) {
 439                 if (vo->adr == adr) {
 440                         acpi_video_vo_bind(vo, handle);
 441                         return;
 442                 }
 443         }
 444         vo = acpi_video_vo_init(adr);
 445         if (vo != NULL) {
 446                 acpi_video_vo_bind(vo, handle);
 447                 STAILQ_INSERT_TAIL(&sc->vid_outputs, vo, vo_next);
 448         }
 449 }
 450
 451 static void
 452 acpi_video_bind_outputs(struct acpi_video_softc *sc)
 453 {
 454
 455         ACPI_SERIAL_ASSERT(video);
 456         vid_enum_outputs(sc->handle, acpi_video_bind_outputs_subr, sc);
 457 }
 458
 459 static struct acpi_video_output *
 460 acpi_video_vo_init(UINT32 adr)
 461 {
 462         struct acpi_video_output *vn, *vo, *vp;
 463         int n, x;
 464         char name[8], env[32];
 465         const char *type, *desc;
 466         struct acpi_video_output_queue *voqh;
 467
 468         ACPI_SERIAL_ASSERT(video);
 469
 470         switch (adr & DOD_DEVID_MASK) {
 471         case DOD_DEVID_MONITOR:
 472                 if ((adr & DOD_DEVID_MASK_FULL) == DOD_DEVID_LCD) {
 473                         /* DOD_DEVID_LCD is a common, backward compatible ID */
 474                         desc = "Internal/Integrated Digital Flat Panel";
 475                         type = "lcd";
 476                         voqh = &lcd_units;
 477                 } else {
 478                         desc = "VGA CRT or VESA Compatible Analog Monitor";
 479                         type = "crt";
 480                         voqh = &crt_units;
 481                 }
 482                 break;
 483         case DOD_DEVID_TV:
 484                 desc = "TV/HDTV or Analog-Video Monitor";
 485                 type = "tv";
 486                 voqh = &tv_units;
 487                 break;
 488         case DOD_DEVID_EXT:
 489                 desc = "External Digital Monitor";
 490                 type = "ext";
 491                 voqh = &ext_units;
 492                 break;
 493         case DOD_DEVID_INTDFP:
 494                 desc = "Internal/Integrated Digital Flat Panel";
 495                 type = "lcd";
 496                 voqh = &lcd_units;
 497                 break;
 498         default:
 499                 desc = "unknown output";
 500                 type = "out";
 501                 voqh = &other_units;
 502         }
 503
 504         n = 0;
 505         vp = NULL;
 506         STAILQ_FOREACH(vn, voqh, vo_unit.next) {
 507                 if (vn->vo_unit.num != n)
 508                         break;
 509                 vp = vn;
 510                 n++;
 511         }
 512
 513         snprintf(name, sizeof(name), "%s%d", type, n);
 514
 515         vo = malloc(sizeof(*vo), M_ACPIVIDEO, M_NOWAIT);
 516         if (vo != NULL) {
 517                 vo->handle = NULL;
 518                 vo->adr = adr;
 519                 vo->vo_unit.num = n;
 520                 vo->vo_brightness = -1;
 521                 vo->vo_fullpower = -1;  /* TODO: override with tunables */
 522                 vo->vo_economy = -1;
 523                 vo->vo_numlevels = 0;
 524                 vo->vo_levels = NULL;
 525                 snprintf(env, sizeof(env), "hw.acpi.video.%s.fullpower", name);
 526                 if (getenv_int(env, &x))
 527                         vo->vo_fullpower = x;
 528                 snprintf(env, sizeof(env), "hw.acpi.video.%s.economy", name);
 529                 if (getenv_int(env, &x))
 530                         vo->vo_economy = x;
 531
 532                 sysctl_ctx_init(&vo->vo_sysctl_ctx);
 533                 if (vp != NULL)
 534                         STAILQ_INSERT_AFTER(voqh, vp, vo, vo_unit.next);
 535                 else
 536                         STAILQ_INSERT_TAIL(voqh, vo, vo_unit.next);
 537                 if (acpi_video_sysctl_tree != NULL)
 538                         vo->vo_sysctl_tree =
 539                             SYSCTL_ADD_NODE(&vo->vo_sysctl_ctx,
 540                                 SYSCTL_CHILDREN(acpi_video_sysctl_tree),
 541                                 OID_AUTO, name, CTLFLAG_RD, 0, desc);
 542                 if (vo->vo_sysctl_tree != NULL) {
 543                         SYSCTL_ADD_PROC(&vo->vo_sysctl_ctx,
 544                             SYSCTL_CHILDREN(vo->vo_sysctl_tree),
 545                             OID_AUTO, "active",
 546                             CTLTYPE_INT|CTLFLAG_RW, vo, 0,
 547                             acpi_video_vo_active_sysctl, "I",
 548                             "current activity of this device");
 549                         SYSCTL_ADD_PROC(&vo->vo_sysctl_ctx,
 550                             SYSCTL_CHILDREN(vo->vo_sysctl_tree),
 551                             OID_AUTO, "brightness",
 552                             CTLTYPE_INT|CTLFLAG_RW, vo, 0,
 553                             acpi_video_vo_bright_sysctl, "I",
 554                             "current brightness level");
 555                         SYSCTL_ADD_PROC(&vo->vo_sysctl_ctx,
 556                             SYSCTL_CHILDREN(vo->vo_sysctl_tree),
 557                             OID_AUTO, "fullpower",
 558                             CTLTYPE_INT|CTLFLAG_RW, vo,
 559                             POWER_PROFILE_PERFORMANCE,
 560                             acpi_video_vo_presets_sysctl, "I",
 561                             "preset level for full power mode");
 562                         SYSCTL_ADD_PROC(&vo->vo_sysctl_ctx,
 563                             SYSCTL_CHILDREN(vo->vo_sysctl_tree),
 564                             OID_AUTO, "economy",
 565                             CTLTYPE_INT|CTLFLAG_RW, vo,
 566                             POWER_PROFILE_ECONOMY,
 567                             acpi_video_vo_presets_sysctl, "I",
 568                             "preset level for economy mode");
 569                         SYSCTL_ADD_PROC(&vo->vo_sysctl_ctx,
 570                             SYSCTL_CHILDREN(vo->vo_sysctl_tree),
 571                             OID_AUTO, "levels",
 572                             CTLTYPE_INT | CTLFLAG_RD, vo, 0,
 573                             acpi_video_vo_levels_sysctl, "I",
 574                             "supported brightness levels");
 575                 } else
 576                         printf("%s: sysctl node creation failed\n", type);
 577         } else
 578                 printf("%s: softc allocation failed\n", type);
 579
 580         if (bootverbose) {
 581                 printf("found %s(%x)", desc, adr & DOD_DEVID_MASK_FULL);
 582                 printf(", idx#%x", adr & DOD_DEVID_MASK_DISPIDX);
 583                 printf(", port#%x", (adr & DOD_DEVID_MASK_DISPPORT) >> 4);
 584                 if (adr & DOD_BIOS)
 585                         printf(", detectable by BIOS");
 586                 if (adr & DOD_NONVGA)
 587                         printf(" (Non-VGA output device whose power "
 588                             "is related to the VGA device)");
 589                 printf(", head #%d\n",
 590                         (adr & DOD_HEAD_ID_MASK) >> DOD_HEAD_ID_SHIFT);
 591         }
 592         return (vo);
 593 }
 594
 595 static void
 596 acpi_video_vo_bind(struct acpi_video_output *vo, ACPI_HANDLE handle)
 597 {
 598
 599         ACPI_SERIAL_BEGIN(video_output);
 600         if (vo->vo_levels != NULL) {
 601                 AcpiRemoveNotifyHandler(vo->handle, ACPI_DEVICE_NOTIFY,
 602                     acpi_video_vo_notify_handler);
 603                 AcpiOsFree(vo->vo_levels);
 604                 vo->vo_levels = NULL;
 605         }
 606         vo->handle = handle;
 607         vo->vo_numlevels = vo_get_brightness_levels(handle, &vo->vo_levels);
 608         if (vo->vo_numlevels >= 2) {
 609                 if (vo->vo_fullpower == -1 ||
 610                     acpi_video_vo_check_level(vo, vo->vo_fullpower) != 0) {
 611                         /* XXX - can't deal with rebinding... */
 612                         vo->vo_fullpower = vo->vo_levels[BCL_FULLPOWER];
 613                 }
 614                 if (vo->vo_economy == -1 ||
 615                     acpi_video_vo_check_level(vo, vo->vo_economy) != 0) {
 616                         /* XXX - see above. */
 617                         vo->vo_economy = vo->vo_levels[BCL_ECONOMY];
 618                 }
 619                 AcpiInstallNotifyHandler(handle, ACPI_DEVICE_NOTIFY,
 620                     acpi_video_vo_notify_handler, vo);
 621         }
 622         ACPI_SERIAL_END(video_output);
 623 }
 624
 625 static void
 626 acpi_video_vo_destroy(struct acpi_video_output *vo)
 627 {
 628         struct acpi_video_output_queue *voqh;
 629
 630         ACPI_SERIAL_ASSERT(video);
 631         if (vo->vo_sysctl_tree != NULL) {
 632                 vo->vo_sysctl_tree = NULL;
 633                 sysctl_ctx_free(&vo->vo_sysctl_ctx);
 634         }
 635         if (vo->vo_levels != NULL) {
 636                 AcpiRemoveNotifyHandler(vo->handle, ACPI_DEVICE_NOTIFY,
 637                     acpi_video_vo_notify_handler);
 638                 AcpiOsFree(vo->vo_levels);
 639         }
 640
 641         switch (vo->adr & DOD_DEVID_MASK) {
 642         case DOD_DEVID_MONITOR:
 643                 voqh = &crt_units;
 644                 break;
 645         case DOD_DEVID_TV:
 646                 voqh = &tv_units;
 647                 break;
 648         case DOD_DEVID_EXT:
 649                 voqh = &ext_units;
 650                 break;
 651         case DOD_DEVID_INTDFP:
 652                 voqh = &lcd_units;
 653                 break;
 654         default:
 655                 voqh = &other_units;
 656         }
 657         STAILQ_REMOVE(voqh, vo, acpi_video_output, vo_unit.next);
 658         free(vo, M_ACPIVIDEO);
 659 }
 660
 661 static int
 662 acpi_video_vo_check_level(struct acpi_video_output *vo, int level)
 663 {
 664         int i;
 665
 666         ACPI_SERIAL_ASSERT(video_output);
 667         if (vo->vo_levels == NULL)
 668                 return (ENODEV);
 669         for (i = 0; i < vo->vo_numlevels; i++)
 670                 if (vo->vo_levels[i] == level)
 671                         return (0);
 672         return (EINVAL);
 673 }
 674
 675 static void
 676 acpi_video_vo_notify_handler(ACPI_HANDLE handle, UINT32 notify, void *context)
 677 {
 678         struct acpi_video_output *vo;
 679         int i, j, level, new_level;
 680
 681         vo = context;
 682         ACPI_SERIAL_BEGIN(video_output);
 683         if (vo->handle != handle)
 684                 goto out;
 685
 686         switch (notify) {
 687         case VID_NOTIFY_CYCLE_BRN:
 688                 if (vo->vo_numlevels <= 3)
 689                         goto out;
 690                 /* FALLTHROUGH */
 691         case VID_NOTIFY_INC_BRN:
 692         case VID_NOTIFY_DEC_BRN:
 693         case VID_NOTIFY_ZERO_BRN:
 694                 if (vo->vo_levels == NULL)
 695                         goto out;
 696                 level = vo_get_brightness(handle);
 697                 if (level < 0)
 698                         goto out;
 699                 break;
 700         default:
 701                 printf("unknown notify event 0x%x from %s\n",
 702                     notify, acpi_name(handle));
 703                 goto out;
 704         }
 705
 706         new_level = level;
 707         switch (notify) {
 708         case VID_NOTIFY_CYCLE_BRN:
 709                 for (i = 2; i < vo->vo_numlevels; i++)
 710                         if (vo->vo_levels[i] == level) {
 711                                 new_level = vo->vo_numlevels > i + 1 ?
 712                                      vo->vo_levels[i + 1] : vo->vo_levels[2];
 713                                 break;
 714                         }
 715                 break;
 716         case VID_NOTIFY_INC_BRN:
 717         case VID_NOTIFY_DEC_BRN:
 718                 for (i = 0; i < vo->vo_numlevels; i++) {
 719                         j = vo->vo_levels[i];
 720                         if (notify == VID_NOTIFY_INC_BRN) {
 721                                 if (j > level &&
 722                                     (j < new_level || level == new_level))
 723                                         new_level = j;
 724                         } else {
 725                                 if (j < level &&
 726                                     (j > new_level || level == new_level))
 727                                         new_level = j;
 728                         }
 729                 }
 730                 break;
 731         case VID_NOTIFY_ZERO_BRN:
 732                 for (i = 0; i < vo->vo_numlevels; i++)
 733                         if (vo->vo_levels[i] == 0) {
 734                                 new_level = 0;
 735                                 break;
 736                         }
 737                 break;
 738         }
 739         if (new_level != level) {
 740                 vo_set_brightness(handle, new_level);
 741                 vo->vo_brightness = new_level;
 742         }
 743
 744 out:
 745         ACPI_SERIAL_END(video_output);
 746 }
 747
 748 /* ARGSUSED */
 749 static int
 750 acpi_video_vo_active_sysctl(SYSCTL_HANDLER_ARGS)
 751 {
 752         struct acpi_video_output *vo;
 753         int state, err;
 754
 755         vo = (struct acpi_video_output *)arg1;
 756         if (vo->handle == NULL)
 757                 return (ENXIO);
 758         ACPI_SERIAL_BEGIN(video_output);
 759         state = (vo_get_device_status(vo->handle) & DCS_ACTIVE) ? 1 : 0;
 760         err = sysctl_handle_int(oidp, &state, 0, req);
 761         if (err != 0 || req->newptr == NULL)
 762                 goto out;
 763         vo_set_device_state(vo->handle,
 764             DSS_COMMIT | (state ? DSS_ACTIVE : DSS_INACTIVE));
 765 out:
 766         ACPI_SERIAL_END(video_output);
 767         return (err);
 768 }
 769
 770 /* ARGSUSED */
 771 static int
 772 acpi_video_vo_bright_sysctl(SYSCTL_HANDLER_ARGS)
 773 {
 774         struct acpi_video_output *vo;
 775         int level, preset, err;
 776
 777         vo = (struct acpi_video_output *)arg1;
 778         ACPI_SERIAL_BEGIN(video_output);
 779         if (vo->handle == NULL) {
 780                 err = ENXIO;
 781                 goto out;
 782         }
 783         if (vo->vo_levels == NULL) {
 784                 err = ENODEV;
 785                 goto out;
 786         }
 787
 788         preset = (power_profile_get_state() == POWER_PROFILE_ECONOMY) ?
 789                   vo->vo_economy : vo->vo_fullpower;
 790         level = vo->vo_brightness;
 791         if (level == -1)
 792                 level = preset;
 793
 794         err = sysctl_handle_int(oidp, &level, 0, req);
 795         if (err != 0 || req->newptr == NULL)
 796                 goto out;
 797         if (level < -1 || level > 100) {
 798                 err = EINVAL;
 799                 goto out;
 800         }
 801
 802         if (level != -1 && (err = acpi_video_vo_check_level(vo, level)))
 803                 goto out;
 804         vo->vo_brightness = level;
 805         vo_set_brightness(vo->handle, (level == -1) ? preset : level);
 806
 807 out:
 808         ACPI_SERIAL_END(video_output);
 809         return (err);
 810 }
 811
 812 static int
 813 acpi_video_vo_presets_sysctl(SYSCTL_HANDLER_ARGS)
 814 {
 815         struct acpi_video_output *vo;
 816         int i, level, *preset, err;
 817
 818         vo = (struct acpi_video_output *)arg1;
 819         ACPI_SERIAL_BEGIN(video_output);
 820         if (vo->handle == NULL) {
 821                 err = ENXIO;
 822                 goto out;
 823         }
 824         if (vo->vo_levels == NULL) {
 825                 err = ENODEV;
 826                 goto out;
 827         }
 828         preset = (arg2 == POWER_PROFILE_ECONOMY) ?
 829                   &vo->vo_economy : &vo->vo_fullpower;
 830         level = *preset;
 831         err = sysctl_handle_int(oidp, &level, 0, req);
 832         if (err != 0 || req->newptr == NULL)
 833                 goto out;
 834         if (level < -1 || level > 100) {
 835                 err = EINVAL;
 836                 goto out;
 837         }
 838         if (level == -1) {
 839                 i = (arg2 == POWER_PROFILE_ECONOMY) ?
 840                     BCL_ECONOMY : BCL_FULLPOWER;
 841                 level = vo->vo_levels[i];
 842         } else if ((err = acpi_video_vo_check_level(vo, level)) != 0)
 843                 goto out;
 844
 845         if (vo->vo_brightness == -1 && (power_profile_get_state() == arg2))
 846                 vo_set_brightness(vo->handle, level);
 847         *preset = level;
 848
 849 out:
 850         ACPI_SERIAL_END(video_output);
 851         return (err);
 852 }
 853
 854 /* ARGSUSED */
 855 static int
 856 acpi_video_vo_levels_sysctl(SYSCTL_HANDLER_ARGS)
 857 {
 858         struct acpi_video_output *vo;
 859         int err;
 860
 861         vo = (struct acpi_video_output *)arg1;
 862         ACPI_SERIAL_BEGIN(video_output);
 863         if (vo->vo_levels == NULL) {
 864                 err = ENODEV;
 865                 goto out;
 866         }
 867         if (req->newptr != NULL) {
 868                 err = EPERM;
 869                 goto out;
 870         }
 871         err = sysctl_handle_opaque(oidp, vo->vo_levels,
 872             vo->vo_numlevels * sizeof(*vo->vo_levels), req);
 873
 874 out:
 875         ACPI_SERIAL_END(video_output);
 876         return (err);
 877 }
 878
 879 static void
 880 vid_set_switch_policy(ACPI_HANDLE handle, UINT32 policy)
 881 {
 882         ACPI_STATUS status;
 883
 884         status = acpi_SetInteger(handle, "_DOS", policy);
 885         if (ACPI_FAILURE(status))
 886                 printf("can't evaluate %s._DOS - %s\n",
 887                        acpi_name(handle), AcpiFormatException(status));
 888 }
 889
 890 struct enum_callback_arg {
 891         void (*callback)(ACPI_HANDLE, UINT32, void *);
 892         void *context;
 893         ACPI_OBJECT *dod_pkg;
 894         int count;
 895 };
 896
 897 static ACPI_STATUS
 898 vid_enum_outputs_subr(ACPI_HANDLE handle, UINT32 level __unused,
 899                       void *context, void **retp __unused)
 900 {
 901         ACPI_STATUS status;
 902         UINT32 adr, val;
 903         struct enum_callback_arg *argset;
 904         size_t i;
 905
 906         ACPI_SERIAL_ASSERT(video);
 907         argset = context;
 908         status = acpi_GetInteger(handle, "_ADR", &adr);
 909         if (ACPI_FAILURE(status))
 910                 return (AE_OK);
 911
 912         for (i = 0; i < argset->dod_pkg->Package.Count; i++) {
 913                 if (acpi_PkgInt32(argset->dod_pkg, i, &val) == 0 &&
 914                     (val & DOD_DEVID_MASK_FULL) ==
 915                     (adr & DOD_DEVID_MASK_FULL)) {
 916                         argset->callback(handle, val, argset->context);
 917                         argset->count++;
 918                 }
 919         }
 920
 921         return (AE_OK);
 922 }
 923
 924 static int
 925 vid_enum_outputs(ACPI_HANDLE handle,
 926                  void (*callback)(ACPI_HANDLE, UINT32, void *), void *context)
 927 {
 928         ACPI_STATUS status;
 929         ACPI_BUFFER dod_buf;
 930         ACPI_OBJECT *res;
 931         struct enum_callback_arg argset;
 932
 933         ACPI_SERIAL_ASSERT(video);
 934         dod_buf.Length = ACPI_ALLOCATE_BUFFER;
 935         dod_buf.Pointer = NULL;
 936         status = AcpiEvaluateObject(handle, "_DOD", NULL, &dod_buf);
 937         if (ACPI_FAILURE(status)) {
 938                 if (status != AE_NOT_FOUND)
 939                         printf("can't evaluate %s._DOD - %s\n",
 940                                acpi_name(handle), AcpiFormatException(status));
 941                 argset.count = -1;
 942                 goto out;
 943         }
 944         res = (ACPI_OBJECT *)dod_buf.Pointer;
 945         if (!ACPI_PKG_VALID(res, 1)) {
 946                 printf("evaluation of %s._DOD makes no sense\n",
 947                        acpi_name(handle));
 948                 argset.count = -1;
 949                 goto out;
 950         }
 951         if (callback == NULL) {
 952                 argset.count = res->Package.Count;
 953                 goto out;
 954         }
 955         argset.callback = callback;
 956         argset.context  = context;
 957         argset.dod_pkg  = res;
 958         argset.count    = 0;
 959         status = AcpiWalkNamespace(ACPI_TYPE_DEVICE, handle, 1,
 960             vid_enum_outputs_subr, NULL, &argset, NULL);
 961         if (ACPI_FAILURE(status))
 962                 printf("failed walking down %s - %s\n",
 963                        acpi_name(handle), AcpiFormatException(status));
 964 out:
 965         if (dod_buf.Pointer != NULL)
 966                 AcpiOsFree(dod_buf.Pointer);
 967         return (argset.count);
 968 }
 969
 970 static int
 971 vo_get_brightness_levels(ACPI_HANDLE handle, int **levelp)
 972 {
 973         ACPI_STATUS status;
 974         ACPI_BUFFER bcl_buf;
 975         ACPI_OBJECT *res;
 976         int num, i, n, *levels;
 977
 978         bcl_buf.Length = ACPI_ALLOCATE_BUFFER;
 979         bcl_buf.Pointer = NULL;
 980         status = AcpiEvaluateObject(handle, "_BCL", NULL, &bcl_buf);
 981         if (ACPI_FAILURE(status)) {
 982                 if (status != AE_NOT_FOUND)
 983                         printf("can't evaluate %s._BCL - %s\n",
 984                                acpi_name(handle), AcpiFormatException(status));
 985                 goto out;
 986         }
 987         res = (ACPI_OBJECT *)bcl_buf.Pointer;
 988         if (!ACPI_PKG_VALID(res, 2)) {
 989                 printf("evaluation of %s._BCL makes no sense\n",
 990                        acpi_name(handle));
 991                 goto out;
 992         }
 993         num = res->Package.Count;
 994         if (num < 2 || levelp == NULL)
 995                 goto out;
 996         levels = AcpiOsAllocate(num * sizeof(*levels));
 997         if (levels == NULL)
 998                 goto out;
 999         for (i = 0, n = 0; i < num; i++)
1000                 if (acpi_PkgInt32(res, i, &levels[n]) == 0)
1001                         n++;
1002         if (n < 2) {
1003                 AcpiOsFree(levels);
1004                 goto out;
1005         }
1006         *levelp = levels;
1007         return (n);
1008
1009 out:
1010         if (bcl_buf.Pointer != NULL)
1011                 AcpiOsFree(bcl_buf.Pointer);
1012         return (0);
1013 }
1014
1015 static int
1016 vo_get_brightness(ACPI_HANDLE handle)
1017 {
1018         UINT32 level;
1019         ACPI_STATUS status;
1020
1021         ACPI_SERIAL_ASSERT(video_output);
1022         status = acpi_GetInteger(handle, "_BQC", &level);
1023         if (ACPI_FAILURE(status)) {
1024                 printf("can't evaluate %s._BQC - %s\n", acpi_name(handle),
1025                     AcpiFormatException(status));
1026                 return (-1);
1027         }
1028         if (level > 100)
1029                 return (-1);
1030
1031         return (level);
1032 }
1033
1034 static void
1035 vo_set_brightness(ACPI_HANDLE handle, int level)
1036 {
1037         ACPI_STATUS status;
1038
1039         ACPI_SERIAL_ASSERT(video_output);
1040         status = acpi_SetInteger(handle, "_BCM", level);
1041         if (ACPI_FAILURE(status))
1042                 printf("can't evaluate %s._BCM - %s\n",
1043                        acpi_name(handle), AcpiFormatException(status));
1044 }
1045
1046 static UINT32
1047 vo_get_device_status(ACPI_HANDLE handle)
1048 {
1049         UINT32 dcs;
1050         ACPI_STATUS status;
1051
1052         ACPI_SERIAL_ASSERT(video_output);
1053         dcs = 0;
1054         status = acpi_GetInteger(handle, "_DCS", &dcs);
1055         if (ACPI_FAILURE(status))
1056                 printf("can't evaluate %s._DCS - %s\n",
1057                        acpi_name(handle), AcpiFormatException(status));
1058
1059         return (dcs);
1060 }
1061
1062 static UINT32
1063 vo_get_graphics_state(ACPI_HANDLE handle)
1064 {
1065         UINT32 dgs;
1066         ACPI_STATUS status;
1067
1068         dgs = 0;
1069         status = acpi_GetInteger(handle, "_DGS", &dgs);
1070         if (ACPI_FAILURE(status))
1071                 printf("can't evaluate %s._DGS - %s\n",
1072                        acpi_name(handle), AcpiFormatException(status));
1073
1074         return (dgs);
1075 }
1076
1077 static void
1078 vo_set_device_state(ACPI_HANDLE handle, UINT32 state)
1079 {
1080         ACPI_STATUS status;
1081
1082         ACPI_SERIAL_ASSERT(video_output);
1083         status = acpi_SetInteger(handle, "_DSS", state);
1084         if (ACPI_FAILURE(status))
1085                 printf("can't evaluate %s._DSS - %s\n",
1086                        acpi_name(handle), AcpiFormatException(status));
1087 }