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