src/libsystemd-terminal/grdev.h

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com>
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 /*
  23  * Graphics Devices
  24  * The grdev layer provides generic access to graphics devices. The device
  25  * types are hidden in the implementation and exported in a generic way. The
  26  * grdev_session object forms the base layer. It loads, configures and prepares
  27  * any graphics devices associated with that session. Each session is totally
  28  * independent of other sessions and can be controlled separately.
  29  * The target devices on a session are called display. A display always
  30  * corresponds to a real display regardless how many pipes are needed to drive
  31  * that display. That is, an exported display might internally be created out
  32  * of arbitrary combinations of target pipes. However, this is meant as
  33  * implementation detail and API users must never assume details below the
  34  * display-level. That is, a display is the most low-level object exported.
  35  * Therefore, pipe-configuration and any low-level modesetting is hidden from
  36  * the public API. It is provided by the implementation, and it is the
  37  * implementation that decides how pipes are driven.
  38  *
  39  * The API users are free to ignore specific displays or combine them to create
  40  * larger screens. This often requires user-configuration so is dictated by
  41  * policy. The underlying pipe-configuration might be affected by these
  42  * high-level policies, but is never directly controlled by those. That means,
  43  * depending on the displays you use, it might affect how underlying resources
  44  * are assigned. However, users can never directly apply policies to the pipes,
  45  * but only to displays. In case specific hardware needs quirks on the pipe
  46  * level, we support that via hwdb, not via public user configuration.
  47  *
  48  * Right now, displays are limited to rgb32 memory-mapped framebuffers on the
  49  * primary plane. However, the grdev implementation can be easily extended to
  50  * allow more powerful access (including hardware-acceleration for 2D and 3D
  51  * compositing). So far, this wasn't needed so it is not exposed.
  52  */
  53
  54 #pragma once
  55
  56 #include <drm_fourcc.h>
  57 #include <inttypes.h>
  58 #include <libudev.h>
  59 #include <stdbool.h>
  60 #include <stdlib.h>
  61 #include <systemd/sd-bus.h>
  62 #include <systemd/sd-event.h>
  63 #include "util.h"
  64
  65 typedef struct grdev_fb                 grdev_fb;
  66 typedef struct grdev_display_target     grdev_display_target;
  67 typedef struct grdev_display            grdev_display;
  68
  69 typedef struct grdev_event              grdev_event;
  70 typedef struct grdev_session            grdev_session;
  71 typedef struct grdev_context            grdev_context;
  72
  73 enum {
  74         /* clockwise rotation; we treat this is abelian group Z4 with ADD */
  75         GRDEV_ROTATE_0                  = 0,
  76         GRDEV_ROTATE_90                 = 1,
  77         GRDEV_ROTATE_180                = 2,
  78         GRDEV_ROTATE_270                = 3,
  79 };
  80
  81 enum {
  82         /* flip states; we treat this as abelian group V4 with XOR */
  83         GRDEV_FLIP_NONE                 = 0x0,
  84         GRDEV_FLIP_HORIZONTAL           = 0x1,
  85         GRDEV_FLIP_VERTICAL             = 0x2,
  86 };
  87
  88 /*
  89  * Displays
  90  */
  91
  92 struct grdev_fb {
  93         uint32_t width;
  94         uint32_t height;
  95         uint32_t format;
  96         uint64_t age;
  97         int32_t strides[4];
  98         void *maps[4];
  99 };
 100
 101 struct grdev_display_target {
 102         uint32_t x;
 103         uint32_t y;
 104         uint32_t width;
 105         uint32_t height;
 106         unsigned int rotate;
 107         unsigned int flip;
 108         const grdev_fb *fb;
 109 };
 110
 111 bool grdev_display_is_enabled(grdev_display *display);
 112 void grdev_display_enable(grdev_display *display);
 113 void grdev_display_disable(grdev_display *display);
 114
 115 const grdev_display_target *grdev_display_next_target(grdev_display *display, const grdev_display_target *prev, uint64_t minage);
 116 void grdev_display_flip_target(grdev_display *display, const grdev_display_target *target, uint64_t age);
 117
 118 #define GRDEV_DISPLAY_FOREACH_TARGET(_display, _t, _minage)                     \
 119         for ((_t) = grdev_display_next_target((_display), NULL, (_minage));     \
 120              (_t);                                                              \
 121              (_t) = grdev_display_next_target((_display), (_t), (_minage)))
 122
 123 /*
 124  * Events
 125  */
 126
 127 enum {
 128         GRDEV_EVENT_DISPLAY_ADD,
 129         GRDEV_EVENT_DISPLAY_REMOVE,
 130         GRDEV_EVENT_DISPLAY_CHANGE,
 131         GRDEV_EVENT_DISPLAY_FRAME,
 132 };
 133
 134 typedef void (*grdev_event_fn) (grdev_session *session, void *userdata, grdev_event *ev);
 135
 136 struct grdev_event {
 137         unsigned int type;
 138         union {
 139                 struct {
 140                         grdev_display *display;
 141                 } display_add, display_remove, display_change;
 142
 143                 struct {
 144                         grdev_display *display;
 145                 } display_frame;
 146         };
 147 };
 148
 149 /*
 150  * Sessions
 151  */
 152
 153 enum {
 154         GRDEV_SESSION_CUSTOM                    = (1 << 0),
 155         GRDEV_SESSION_MANAGED                   = (1 << 1),
 156 };
 157
 158 int grdev_session_new(grdev_session **out,
 159                       grdev_context *context,
 160                       unsigned int flags,
 161                       const char *name,
 162                       grdev_event_fn event_fn,
 163                       void *userdata);
 164 grdev_session *grdev_session_free(grdev_session *session);
 165
 166 DEFINE_TRIVIAL_CLEANUP_FUNC(grdev_session*, grdev_session_free);
 167
 168 bool grdev_session_is_enabled(grdev_session *session);
 169 void grdev_session_enable(grdev_session *session);
 170 void grdev_session_disable(grdev_session *session);
 171
 172 void grdev_session_commit(grdev_session *session);
 173 void grdev_session_restore(grdev_session *session);
 174
 175 void grdev_session_add_drm(grdev_session *session, struct udev_device *ud);
 176 void grdev_session_remove_drm(grdev_session *session, struct udev_device *ud);
 177 void grdev_session_hotplug_drm(grdev_session *session, struct udev_device *ud);
 178
 179 /*
 180  * Contexts
 181  */
 182
 183 int grdev_context_new(grdev_context **out, sd_event *event, sd_bus *sysbus);
 184 grdev_context *grdev_context_ref(grdev_context *context);
 185 grdev_context *grdev_context_unref(grdev_context *context);
 186
 187 DEFINE_TRIVIAL_CLEANUP_FUNC(grdev_context*, grdev_context_unref);