The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/dev/acpica/acpi_video.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: 26bdea4ae646c1e03feee0e81e2ee6eb


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.