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

Cache object: 0ab99d55c721e21a20ce7e76b6131801


[ 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.