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