chiark / gitweb /
terminal: add grdev DRM backend
authorDavid Herrmann <dh.herrmann@gmail.com>
Fri, 19 Sep 2014 12:13:06 +0000 (14:13 +0200)
committerDavid Herrmann <dh.herrmann@gmail.com>
Fri, 19 Sep 2014 12:13:06 +0000 (14:13 +0200)
The grdev-drm backend manages DRM cards for grdev. Any DRM card with
DUMB_BUFFER support can be used. So far, our policy is to configure all
available connectors, but keep pipes inactive as long as users don't
enable the displays on top.

We hard-code double-buffering so far, but can easily support
single-buffering or n-buffering. We also require XRGB8888 as format as
this is required to be supported by all DRM drivers and it is what VTs
use. This allows us to switch from VTs to grdev via page-flips instead of
deep modesets.

There is still a lot room for improvements in this backend, but it works
smoothly so far so more enhanced features can be added later.

Makefile.am
src/libsystemd-terminal/grdev-drm.c [new file with mode: 0644]
src/libsystemd-terminal/grdev-internal.h
src/libsystemd-terminal/grdev.c
src/libsystemd-terminal/grdev.h

index 1931c5d..be25023 100644 (file)
@@ -3008,6 +3008,7 @@ libsystemd_terminal_la_SOURCES = \
        src/libsystemd-terminal/grdev.h \
        src/libsystemd-terminal/grdev-internal.h \
        src/libsystemd-terminal/grdev.c \
+       src/libsystemd-terminal/grdev-drm.c \
        src/libsystemd-terminal/idev.h \
        src/libsystemd-terminal/idev-internal.h \
        src/libsystemd-terminal/idev.c \
diff --git a/src/libsystemd-terminal/grdev-drm.c b/src/libsystemd-terminal/grdev-drm.c
new file mode 100644 (file)
index 0000000..3481584
--- /dev/null
@@ -0,0 +1,2957 @@
+/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
+
+/***
+  This file is part of systemd.
+
+  Copyright (C) 2014 David Herrmann <dh.herrmann@gmail.com>
+
+  systemd is free software; you can redistribute it and/or modify it
+  under the terms of the GNU Lesser General Public License as published by
+  the Free Software Foundation; either version 2.1 of the License, or
+  (at your option) any later version.
+
+  systemd is distributed in the hope that it will be useful, but
+  WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+  Lesser General Public License for more details.
+
+  You should have received a copy of the GNU Lesser General Public License
+  along with systemd; If not, see <http://www.gnu.org/licenses/>.
+***/
+
+#include <fcntl.h>
+#include <inttypes.h>
+#include <libudev.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+#include <sys/types.h>
+#include <systemd/sd-bus.h>
+#include <systemd/sd-event.h>
+#include <unistd.h>
+
+/* Yuck! DRM headers need system headers included first.. but we have to
+ * include it before shared/missing.h to avoid redefining ioctl bits */
+#include <drm.h>
+#include <drm_fourcc.h>
+#include <drm_mode.h>
+
+#include "bus-util.h"
+#include "hashmap.h"
+#include "grdev.h"
+#include "grdev-internal.h"
+#include "macro.h"
+#include "udev-util.h"
+#include "util.h"
+
+#define GRDRM_MAX_TRIES (16)
+
+typedef struct grdrm_object grdrm_object;
+typedef struct grdrm_plane grdrm_plane;
+typedef struct grdrm_connector grdrm_connector;
+typedef struct grdrm_encoder grdrm_encoder;
+typedef struct grdrm_crtc grdrm_crtc;
+
+typedef struct grdrm_fb grdrm_fb;
+typedef struct grdrm_pipe grdrm_pipe;
+typedef struct grdrm_card grdrm_card;
+typedef struct unmanaged_card unmanaged_card;
+typedef struct managed_card managed_card;
+
+/*
+ * Objects
+ */
+
+enum {
+        GRDRM_TYPE_CRTC,
+        GRDRM_TYPE_ENCODER,
+        GRDRM_TYPE_CONNECTOR,
+        GRDRM_TYPE_PLANE,
+        GRDRM_TYPE_CNT
+};
+
+struct grdrm_object {
+        grdrm_card *card;
+        uint32_t id;
+        uint32_t index;
+        unsigned int type;
+        void (*free_fn) (grdrm_object *object);
+
+        bool present : 1;
+        bool assigned : 1;
+};
+
+struct grdrm_plane {
+        grdrm_object object;
+
+        struct {
+                uint32_t used_crtc;
+                uint32_t used_fb;
+                uint32_t gamma_size;
+
+                uint32_t n_crtcs;
+                uint32_t max_crtcs;
+                uint32_t *crtcs;
+                uint32_t n_formats;
+                uint32_t max_formats;
+                uint32_t *formats;
+        } kern;
+};
+
+struct grdrm_connector {
+        grdrm_object object;
+
+        struct {
+                uint32_t type;
+                uint32_t type_id;
+                uint32_t used_encoder;
+                uint32_t connection;
+                uint32_t mm_width;
+                uint32_t mm_height;
+                uint32_t subpixel;
+
+                uint32_t n_encoders;
+                uint32_t max_encoders;
+                uint32_t *encoders;
+                uint32_t n_modes;
+                uint32_t max_modes;
+                struct drm_mode_modeinfo *modes;
+                uint32_t n_props;
+                uint32_t max_props;
+                uint32_t *prop_ids;
+                uint64_t *prop_values;
+        } kern;
+};
+
+struct grdrm_encoder {
+        grdrm_object object;
+
+        struct {
+                uint32_t type;
+                uint32_t used_crtc;
+
+                uint32_t n_crtcs;
+                uint32_t max_crtcs;
+                uint32_t *crtcs;
+                uint32_t n_clones;
+                uint32_t max_clones;
+                uint32_t *clones;
+        } kern;
+};
+
+struct grdrm_crtc {
+        grdrm_object object;
+
+        struct {
+                uint32_t used_fb;
+                uint32_t fb_offset_x;
+                uint32_t fb_offset_y;
+                uint32_t gamma_size;
+
+                uint32_t n_used_connectors;
+                uint32_t max_used_connectors;
+                uint32_t *used_connectors;
+
+                bool mode_set;
+                struct drm_mode_modeinfo mode;
+        } kern;
+
+        struct {
+                bool set;
+                uint32_t fb;
+                uint32_t fb_x;
+                uint32_t fb_y;
+                uint32_t gamma;
+
+                uint32_t n_connectors;
+                uint32_t *connectors;
+
+                bool mode_set;
+                struct drm_mode_modeinfo mode;
+        } old;
+
+        struct {
+                struct drm_mode_modeinfo mode;
+                uint32_t n_connectors;
+                uint32_t max_connectors;
+                uint32_t *connectors;
+        } set;
+
+        grdrm_pipe *pipe;
+
+        bool applied : 1;
+};
+
+#define GRDRM_OBJECT_INIT(_card, _id, _index, _type, _free_fn) ((grdrm_object){ \
+                .card = (_card), \
+                .id = (_id), \
+                .index = (_index), \
+                .type = (_type), \
+                .free_fn = (_free_fn), \
+        })
+
+grdrm_object *grdrm_find_object(grdrm_card *card, uint32_t id);
+int grdrm_object_add(grdrm_object *object);
+grdrm_object *grdrm_object_free(grdrm_object *object);
+
+DEFINE_TRIVIAL_CLEANUP_FUNC(grdrm_object*, grdrm_object_free);
+
+int grdrm_plane_new(grdrm_plane **out, grdrm_card *card, uint32_t id, uint32_t index);
+int grdrm_connector_new(grdrm_connector **out, grdrm_card *card, uint32_t id, uint32_t index);
+int grdrm_encoder_new(grdrm_encoder **out, grdrm_card *card, uint32_t id, uint32_t index);
+int grdrm_crtc_new(grdrm_crtc **out, grdrm_card *card, uint32_t id, uint32_t index);
+
+#define plane_from_object(_obj) container_of((_obj), grdrm_plane, object)
+#define connector_from_object(_obj) container_of((_obj), grdrm_connector, object)
+#define encoder_from_object(_obj) container_of((_obj), grdrm_encoder, object)
+#define crtc_from_object(_obj) container_of((_obj), grdrm_crtc, object)
+
+/*
+ * Framebuffers
+ */
+
+struct grdrm_fb {
+        grdev_fb base;
+        grdrm_card *card;
+        uint32_t id;
+        uint32_t handles[4];
+        uint32_t offsets[4];
+        uint32_t sizes[4];
+        uint32_t flipid;
+};
+
+static int grdrm_fb_new(grdrm_fb **out, grdrm_card *card, const struct drm_mode_modeinfo *mode);
+grdrm_fb *grdrm_fb_free(grdrm_fb *fb);
+
+DEFINE_TRIVIAL_CLEANUP_FUNC(grdrm_fb*, grdrm_fb_free);
+
+#define fb_from_base(_fb) container_of((_fb), grdrm_fb, base)
+
+/*
+ * Pipes
+ */
+
+struct grdrm_pipe {
+        grdev_pipe base;
+        grdrm_crtc *crtc;
+        uint32_t counter;
+};
+
+#define grdrm_pipe_from_base(_e) container_of((_e), grdrm_pipe, base)
+
+#define GRDRM_PIPE_NAME_MAX (GRDRM_CARD_NAME_MAX + 1 + DECIMAL_STR_MAX(uint32_t))
+
+static const grdev_pipe_vtable grdrm_pipe_vtable;
+
+static int grdrm_pipe_new(grdrm_pipe **out, grdrm_crtc *crtc, struct drm_mode_modeinfo *mode, size_t n_fbs);
+
+/*
+ * Cards
+ */
+
+struct grdrm_card {
+        grdev_card base;
+
+        int fd;
+        sd_event_source *fd_src;
+
+        uint32_t n_crtcs;
+        uint32_t n_encoders;
+        uint32_t n_connectors;
+        uint32_t n_planes;
+        uint32_t max_ids;
+        Hashmap *object_map;
+
+        bool async_hotplug : 1;
+        bool running : 1;
+        bool ready : 1;
+        bool cap_dumb : 1;
+        bool cap_monotonic : 1;
+};
+
+struct unmanaged_card {
+        grdrm_card card;
+        char *devnode;
+};
+
+struct managed_card {
+        grdrm_card card;
+        dev_t devnum;
+
+        sd_bus_slot *slot_pause_device;
+        sd_bus_slot *slot_resume_device;
+        sd_bus_slot *slot_take_device;
+
+        bool requested : 1;             /* TakeDevice() was sent */
+        bool acquired : 1;              /* TakeDevice() was successful */
+        bool master : 1;                /* we are DRM-Master */
+};
+
+#define grdrm_card_from_base(_e) container_of((_e), grdrm_card, base)
+#define unmanaged_card_from_base(_e) \
+        container_of(grdrm_card_from_base(_e), unmanaged_card, card)
+#define managed_card_from_base(_e) \
+        container_of(grdrm_card_from_base(_e), managed_card, card)
+
+#define GRDRM_CARD_INIT(_vtable, _session) ((grdrm_card){ \
+                .base = GRDEV_CARD_INIT((_vtable), (_session)), \
+                .fd = -1, \
+                .max_ids = 32, \
+        })
+
+#define GRDRM_CARD_NAME_MAX (6 + DECIMAL_STR_MAX(unsigned) * 2)
+
+static const grdev_card_vtable unmanaged_card_vtable;
+static const grdev_card_vtable managed_card_vtable;
+
+static int grdrm_card_open(grdrm_card *card, int dev_fd);
+static void grdrm_card_close(grdrm_card *card);
+static bool grdrm_card_async(grdrm_card *card, int r);
+
+/*
+ * The page-flip event of the kernel provides 64bit of arbitrary user-data. As
+ * drivers tend to drop events on intermediate deep mode-sets or because we
+ * might receive events during session activation, we try to avoid allocaing
+ * dynamic data on those events. Instead, we safe the CRTC id plus a 32bit
+ * counter in there. This way, we only get 32bit counters, not 64bit, but that
+ * should be more than enough. On the bright side, we no longer care whether we
+ * lose events. No memory leaks will occur.
+ * Modern DRM drivers might be fixed to no longer leak events, but we want to
+ * be safe. And associating dynamically allocated data with those events is
+ * kinda ugly, anyway.
+ */
+
+static uint64_t grdrm_encode_vblank_data(uint32_t id, uint32_t counter) {
+        return id | ((uint64_t)counter << 32);
+}
+
+static void grdrm_decode_vblank_data(uint64_t data, uint32_t *out_id, uint32_t *out_counter) {
+        if (out_id)
+                *out_id = data & 0xffffffffU;
+        if (out_counter)
+                *out_counter = (data >> 32) & 0xffffffffU;
+}
+
+static bool grdrm_modes_compatible(const struct drm_mode_modeinfo *a, const struct drm_mode_modeinfo *b) {
+        assert(a);
+        assert(b);
+
+        /* Test whether both modes are compatible according to our internal
+         * assumptions on modes. This comparison is highly dependent on how
+         * we treat modes in grdrm. If we export mode details, we need to
+         * make this comparison much stricter. */
+
+        if (a->hdisplay != b->hdisplay)
+                return false;
+        if (a->vdisplay != b->vdisplay)
+                return false;
+
+        return true;
+}
+
+/*
+ * Objects
+ */
+
+grdrm_object *grdrm_find_object(grdrm_card *card, uint32_t id) {
+        assert_return(card, NULL);
+
+        return id > 0 ? hashmap_get(card->object_map, UINT32_TO_PTR(id)) : NULL;
+}
+
+int grdrm_object_add(grdrm_object *object) {
+        int r;
+
+        assert(object);
+        assert(object->card);
+        assert(object->id > 0);
+        assert(IN_SET(object->type, GRDRM_TYPE_CRTC, GRDRM_TYPE_ENCODER, GRDRM_TYPE_CONNECTOR, GRDRM_TYPE_PLANE));
+        assert(object->free_fn);
+
+        if (object->index >= 32)
+                log_debug("grdrm: %s: object index exceeds 32bit masks: type=%u, index=%" PRIu32,
+                          object->card->base.name, object->type, object->index);
+
+        r = hashmap_put(object->card->object_map, UINT32_TO_PTR(object->id), object);
+        if (r < 0)
+                return r;
+
+        return 0;
+}
+
+grdrm_object *grdrm_object_free(grdrm_object *object) {
+        if (!object)
+                return NULL;
+
+        assert(object->card);
+        assert(object->id > 0);
+        assert(IN_SET(object->type, GRDRM_TYPE_CRTC, GRDRM_TYPE_ENCODER, GRDRM_TYPE_CONNECTOR, GRDRM_TYPE_PLANE));
+        assert(object->free_fn);
+
+        hashmap_remove_value(object->card->object_map, UINT32_TO_PTR(object->id), object);
+
+        object->free_fn(object);
+        return NULL;
+}
+
+/*
+ * Planes
+ */
+
+static void plane_free(grdrm_object *object) {
+        grdrm_plane *plane = plane_from_object(object);
+
+        free(plane->kern.formats);
+        free(plane->kern.crtcs);
+        free(plane);
+}
+
+int grdrm_plane_new(grdrm_plane **out, grdrm_card *card, uint32_t id, uint32_t index) {
+        _cleanup_(grdrm_object_freep) grdrm_object *object = NULL;
+        grdrm_plane *plane;
+        int r;
+
+        assert(card);
+
+        plane = new0(grdrm_plane, 1);
+        if (!plane)
+                return -ENOMEM;
+
+        object = &plane->object;
+        *object = GRDRM_OBJECT_INIT(card, id, index, GRDRM_TYPE_PLANE, plane_free);
+
+        plane->kern.max_crtcs = 32;
+        plane->kern.crtcs = new0(uint32_t, plane->kern.max_crtcs);
+        if (!plane->kern.crtcs)
+                return -ENOMEM;
+
+        plane->kern.max_formats = 32;
+        plane->kern.formats = new0(uint32_t, plane->kern.max_formats);
+        if (!plane->kern.formats)
+                return -ENOMEM;
+
+        r = grdrm_object_add(object);
+        if (r < 0)
+                return r;
+
+        if (out)
+                *out = plane;
+        object = NULL;
+        return 0;
+}
+
+static int grdrm_plane_resync(grdrm_plane *plane) {
+        grdrm_card *card = plane->object.card;
+        size_t tries;
+        int r;
+
+        assert(plane);
+
+        for (tries = 0; tries < GRDRM_MAX_TRIES; ++tries) {
+                struct drm_mode_get_plane res;
+                grdrm_object *object;
+                bool resized = false;
+                Iterator iter;
+
+                zero(res);
+                res.plane_id = plane->object.id;
+                res.format_type_ptr = PTR_TO_UINT64(plane->kern.formats);
+                res.count_format_types = plane->kern.max_formats;
+
+                r = ioctl(card->fd, DRM_IOCTL_MODE_GETPLANE, &res);
+                if (r < 0) {
+                        r = -errno;
+                        if (r == -ENOENT) {
+                                card->async_hotplug = true;
+                                r = 0;
+                                log_debug("grdrm: %s: plane %u removed during resync", card->base.name, plane->object.id);
+                        } else {
+                                log_debug("grdrm: %s: cannot retrieve plane %u: %m", card->base.name, plane->object.id);
+                        }
+
+                        return r;
+                }
+
+                plane->kern.n_crtcs = 0;
+                memzero(plane->kern.crtcs, sizeof(uint32_t) * plane->kern.max_crtcs);
+
+                HASHMAP_FOREACH(object, card->object_map, iter) {
+                        if (object->type != GRDRM_TYPE_CRTC || object->index >= 32)
+                                continue;
+                        if (!(res.possible_crtcs & (1 << object->index)))
+                                continue;
+                        if (plane->kern.n_crtcs >= 32) {
+                                log_debug("grdrm: %s: possible_crtcs of plane %" PRIu32 " exceeds 32bit mask",
+                                          card->base.name, plane->object.id);
+                                continue;
+                        }
+
+                        plane->kern.crtcs[plane->kern.n_crtcs++] = object->id;
+                }
+
+                if (res.count_format_types > plane->kern.max_formats) {
+                        uint32_t max, *t;
+
+                        max = ALIGN_POWER2(res.count_format_types);
+                        if (!max || max > UINT16_MAX) {
+                                log_debug("grdrm: %s: excessive plane resource limit: %" PRIu32, card->base.name, max);
+                                return -ERANGE;
+                        }
+
+                        t = realloc(plane->kern.formats, sizeof(*t) * max);
+                        if (!t)
+                                return -ENOMEM;
+
+                        plane->kern.formats = t;
+                        plane->kern.max_formats = max;
+                        resized = true;
+                }
+
+                if (resized)
+                        continue;
+
+                plane->kern.n_formats = res.count_format_types;
+                plane->kern.used_crtc = res.crtc_id;
+                plane->kern.used_fb = res.fb_id;
+                plane->kern.gamma_size = res.gamma_size;
+
+                break;
+        }
+
+        if (tries >= GRDRM_MAX_TRIES) {
+                log_debug("grdrm: %s: plane %u not settled for retrieval", card->base.name, plane->object.id);
+                return -EFAULT;
+        }
+
+        return 0;
+}
+
+/*
+ * Connectors
+ */
+
+static void connector_free(grdrm_object *object) {
+        grdrm_connector *connector = connector_from_object(object);
+
+        free(connector->kern.prop_values);
+        free(connector->kern.prop_ids);
+        free(connector->kern.modes);
+        free(connector->kern.encoders);
+        free(connector);
+}
+
+int grdrm_connector_new(grdrm_connector **out, grdrm_card *card, uint32_t id, uint32_t index) {
+        _cleanup_(grdrm_object_freep) grdrm_object *object = NULL;
+        grdrm_connector *connector;
+        int r;
+
+        assert(card);
+
+        connector = new0(grdrm_connector, 1);
+        if (!connector)
+                return -ENOMEM;
+
+        object = &connector->object;
+        *object = GRDRM_OBJECT_INIT(card, id, index, GRDRM_TYPE_CONNECTOR, connector_free);
+
+        connector->kern.max_encoders = 32;
+        connector->kern.encoders = new0(uint32_t, connector->kern.max_encoders);
+        if (!connector->kern.encoders)
+                return -ENOMEM;
+
+        connector->kern.max_modes = 32;
+        connector->kern.modes = new0(struct drm_mode_modeinfo, connector->kern.max_modes);
+        if (!connector->kern.modes)
+                return -ENOMEM;
+
+        connector->kern.max_props = 32;
+        connector->kern.prop_ids = new0(uint32_t, connector->kern.max_props);
+        connector->kern.prop_values = new0(uint64_t, connector->kern.max_props);
+        if (!connector->kern.prop_ids || !connector->kern.prop_values)
+                return -ENOMEM;
+
+        r = grdrm_object_add(object);
+        if (r < 0)
+                return r;
+
+        if (out)
+                *out = connector;
+        object = NULL;
+        return 0;
+}
+
+static int grdrm_connector_resync(grdrm_connector *connector) {
+        grdrm_card *card = connector->object.card;
+        size_t tries;
+        int r;
+
+        assert(connector);
+
+        for (tries = 0; tries < GRDRM_MAX_TRIES; ++tries) {
+                struct drm_mode_get_connector res;
+                bool resized = false;
+                uint32_t max;
+
+                zero(res);
+                res.connector_id = connector->object.id;
+                res.encoders_ptr = PTR_TO_UINT64(connector->kern.encoders);
+                res.props_ptr = PTR_TO_UINT64(connector->kern.prop_ids);
+                res.prop_values_ptr = PTR_TO_UINT64(connector->kern.prop_values);
+                res.count_encoders = connector->kern.max_encoders;
+                res.count_props = connector->kern.max_props;
+
+                /* Retrieve modes only if we have none. This avoids expensive
+                 * EDID reads in the kernel, that can slow down resyncs
+                 * considerably! */
+                if (connector->kern.n_modes == 0) {
+                        res.modes_ptr = PTR_TO_UINT64(connector->kern.modes);
+                        res.count_modes = connector->kern.max_modes;
+                }
+
+                r = ioctl(card->fd, DRM_IOCTL_MODE_GETCONNECTOR, &res);
+                if (r < 0) {
+                        r = -errno;
+                        if (r == -ENOENT) {
+                                card->async_hotplug = true;
+                                r = 0;
+                                log_debug("grdrm: %s: connector %u removed during resync", card->base.name, connector->object.id);
+                        } else {
+                                log_debug("grdrm: %s: cannot retrieve connector %u: %m", card->base.name, connector->object.id);
+                        }
+
+                        return r;
+                }
+
+                if (res.count_encoders > connector->kern.max_encoders) {
+                        uint32_t *t;
+
+                        max = ALIGN_POWER2(res.count_encoders);
+                        if (!max || max > UINT16_MAX) {
+                                log_debug("grdrm: %s: excessive connector resource limit: %" PRIu32, card->base.name, max);
+                                return -ERANGE;
+                        }
+
+                        t = realloc(connector->kern.encoders, sizeof(*t) * max);
+                        if (!t)
+                                return -ENOMEM;
+
+                        connector->kern.encoders = t;
+                        connector->kern.max_encoders = max;
+                        resized = true;
+                }
+
+                if (res.count_modes > connector->kern.max_modes) {
+                        struct drm_mode_modeinfo *t;
+
+                        max = ALIGN_POWER2(res.count_modes);
+                        if (!max || max > UINT16_MAX) {
+                                log_debug("grdrm: %s: excessive connector resource limit: %" PRIu32, card->base.name, max);
+                                return -ERANGE;
+                        }
+
+                        t = realloc(connector->kern.modes, sizeof(*t) * max);
+                        if (!t)
+                                return -ENOMEM;
+
+                        connector->kern.modes = t;
+                        connector->kern.max_modes = max;
+                        resized = true;
+                }
+
+                if (res.count_props > connector->kern.max_props) {
+                        uint32_t *tids;
+                        uint64_t *tvals;
+
+                        max = ALIGN_POWER2(res.count_props);
+                        if (!max || max > UINT16_MAX) {
+                                log_debug("grdrm: %s: excessive connector resource limit: %" PRIu32, card->base.name, max);
+                                return -ERANGE;
+                        }
+
+                        tids = realloc(connector->kern.prop_ids, sizeof(*tids) * max);
+                        if (!tids)
+                                return -ENOMEM;
+                        connector->kern.prop_ids = tids;
+
+                        tvals = realloc(connector->kern.prop_values, sizeof(*tvals) * max);
+                        if (!tvals)
+                                return -ENOMEM;
+                        connector->kern.prop_values = tvals;
+
+                        connector->kern.max_props = max;
+                        resized = true;
+                }
+
+                if (resized)
+                        continue;
+
+                connector->kern.n_encoders = res.count_encoders;
+                connector->kern.n_modes = res.count_modes;
+                connector->kern.n_props = res.count_props;
+                connector->kern.type = res.connector_type;
+                connector->kern.type_id = res.connector_type_id;
+                connector->kern.used_encoder = res.encoder_id;
+                connector->kern.connection = res.connection;
+                connector->kern.mm_width = res.mm_width;
+                connector->kern.mm_height = res.mm_height;
+                connector->kern.subpixel = res.subpixel;
+
+                break;
+        }
+
+        if (tries >= GRDRM_MAX_TRIES) {
+                log_debug("grdrm: %s: connector %u not settled for retrieval", card->base.name, connector->object.id);
+                return -EFAULT;
+        }
+
+        return 0;
+}
+
+/*
+ * Encoders
+ */
+
+static void encoder_free(grdrm_object *object) {
+        grdrm_encoder *encoder = encoder_from_object(object);
+
+        free(encoder->kern.clones);
+        free(encoder->kern.crtcs);
+        free(encoder);
+}
+
+int grdrm_encoder_new(grdrm_encoder **out, grdrm_card *card, uint32_t id, uint32_t index) {
+        _cleanup_(grdrm_object_freep) grdrm_object *object = NULL;
+        grdrm_encoder *encoder;
+        int r;
+
+        assert(card);
+
+        encoder = new0(grdrm_encoder, 1);
+        if (!encoder)
+                return -ENOMEM;
+
+        object = &encoder->object;
+        *object = GRDRM_OBJECT_INIT(card, id, index, GRDRM_TYPE_ENCODER, encoder_free);
+
+        encoder->kern.max_crtcs = 32;
+        encoder->kern.crtcs = new0(uint32_t, encoder->kern.max_crtcs);
+        if (!encoder->kern.crtcs)
+                return -ENOMEM;
+
+        encoder->kern.max_clones = 32;
+        encoder->kern.clones = new0(uint32_t, encoder->kern.max_clones);
+        if (!encoder->kern.clones)
+                return -ENOMEM;
+
+        r = grdrm_object_add(object);
+        if (r < 0)
+                return r;
+
+        if (out)
+                *out = encoder;
+        object = NULL;
+        return 0;
+}
+
+static int grdrm_encoder_resync(grdrm_encoder *encoder) {
+        grdrm_card *card = encoder->object.card;
+        struct drm_mode_get_encoder res;
+        grdrm_object *object;
+        Iterator iter;
+        int r;
+
+        assert(encoder);
+
+        zero(res);
+        res.encoder_id = encoder->object.id;
+
+        r = ioctl(card->fd, DRM_IOCTL_MODE_GETENCODER, &res);
+        if (r < 0) {
+                r = -errno;
+                if (r == -ENOENT) {
+                        card->async_hotplug = true;
+                        r = 0;
+                        log_debug("grdrm: %s: encoder %u removed during resync", card->base.name, encoder->object.id);
+                } else {
+                        log_debug("grdrm: %s: cannot retrieve encoder %u: %m", card->base.name, encoder->object.id);
+                }
+
+                return r;
+        }
+
+        encoder->kern.type = res.encoder_type;
+        encoder->kern.used_crtc = res.crtc_id;
+
+        encoder->kern.n_crtcs = 0;
+        memzero(encoder->kern.crtcs, sizeof(uint32_t) * encoder->kern.max_crtcs);
+
+        HASHMAP_FOREACH(object, card->object_map, iter) {
+                if (object->type != GRDRM_TYPE_CRTC || object->index >= 32)
+                        continue;
+                if (!(res.possible_crtcs & (1 << object->index)))
+                        continue;
+                if (encoder->kern.n_crtcs >= 32) {
+                        log_debug("grdrm: %s: possible_crtcs exceeds 32bit mask", card->base.name);
+                        continue;
+                }
+
+                encoder->kern.crtcs[encoder->kern.n_crtcs++] = object->id;
+        }
+
+        encoder->kern.n_clones = 0;
+        memzero(encoder->kern.clones, sizeof(uint32_t) * encoder->kern.max_clones);
+
+        HASHMAP_FOREACH(object, card->object_map, iter) {
+                if (object->type != GRDRM_TYPE_ENCODER || object->index >= 32)
+                        continue;
+                if (!(res.possible_clones & (1 << object->index)))
+                        continue;
+                if (encoder->kern.n_clones >= 32) {
+                        log_debug("grdrm: %s: possible_encoders exceeds 32bit mask", card->base.name);
+                        continue;
+                }
+
+                encoder->kern.clones[encoder->kern.n_clones++] = object->id;
+        }
+
+        return 0;
+}
+
+/*
+ * Crtcs
+ */
+
+static void crtc_free(grdrm_object *object) {
+        grdrm_crtc *crtc = crtc_from_object(object);
+
+        if (crtc->pipe)
+                grdev_pipe_free(&crtc->pipe->base);
+        free(crtc->set.connectors);
+        free(crtc->old.connectors);
+        free(crtc->kern.used_connectors);
+        free(crtc);
+}
+
+int grdrm_crtc_new(grdrm_crtc **out, grdrm_card *card, uint32_t id, uint32_t index) {
+        _cleanup_(grdrm_object_freep) grdrm_object *object = NULL;
+        grdrm_crtc *crtc;
+        int r;
+
+        assert(card);
+
+        crtc = new0(grdrm_crtc, 1);
+        if (!crtc)
+                return -ENOMEM;
+
+        object = &crtc->object;
+        *object = GRDRM_OBJECT_INIT(card, id, index, GRDRM_TYPE_CRTC, crtc_free);
+
+        crtc->kern.max_used_connectors = 32;
+        crtc->kern.used_connectors = new0(uint32_t, crtc->kern.max_used_connectors);
+        if (!crtc->kern.used_connectors)
+                return -ENOMEM;
+
+        crtc->old.connectors = new0(uint32_t, crtc->kern.max_used_connectors);
+        if (!crtc->old.connectors)
+                return -ENOMEM;
+
+        r = grdrm_object_add(object);
+        if (r < 0)
+                return r;
+
+        if (out)
+                *out = crtc;
+        object = NULL;
+        return 0;
+}
+
+static int grdrm_crtc_resync(grdrm_crtc *crtc) {
+        grdrm_card *card = crtc->object.card;
+        struct drm_mode_crtc res = { .crtc_id = crtc->object.id };
+        int r;
+
+        assert(crtc);
+
+        /* make sure we can cache any combination later */
+        if (card->n_connectors > crtc->kern.max_used_connectors) {
+                uint32_t max, *t;
+
+                max = ALIGN_POWER2(card->n_connectors);
+                if (!max)
+                        return -ENOMEM;
+
+                t = realloc_multiply(crtc->kern.used_connectors, sizeof(*t), max);
+                if (!t)
+                        return -ENOMEM;
+
+                crtc->kern.used_connectors = t;
+                crtc->kern.max_used_connectors = max;
+
+                if (!crtc->old.set) {
+                        crtc->old.connectors = calloc(sizeof(*t), max);
+                        if (!crtc->old.connectors)
+                                return -ENOMEM;
+                }
+        }
+
+        /* GETCRTC doesn't return connectors. We have to read all
+         * encoder-state and deduce the setup ourselves.. */
+        crtc->kern.n_used_connectors = 0;
+
+        r = ioctl(card->fd, DRM_IOCTL_MODE_GETCRTC, &res);
+        if (r < 0) {
+                r = -errno;
+                if (r == -ENOENT) {
+                        card->async_hotplug = true;
+                        r = 0;
+                        log_debug("grdrm: %s: crtc %u removed during resync", card->base.name, crtc->object.id);
+                } else {
+                        log_debug("grdrm: %s: cannot retrieve crtc %u: %m", card->base.name, crtc->object.id);
+                }
+
+                return r;
+        }
+
+        crtc->kern.used_fb = res.fb_id;
+        crtc->kern.fb_offset_x = res.x;
+        crtc->kern.fb_offset_y = res.y;
+        crtc->kern.gamma_size = res.gamma_size;
+        crtc->kern.mode_set = res.mode_valid;
+        crtc->kern.mode = res.mode;
+
+        return 0;
+}
+
+static void grdrm_crtc_assign(grdrm_crtc *crtc, grdrm_connector *connector) {
+        uint32_t n_connectors;
+        int r;
+
+        assert(crtc);
+        assert(!crtc->object.assigned);
+        assert(!connector || !connector->object.assigned);
+
+        /* always mark both as assigned; even if assignments cannot be set */
+        crtc->object.assigned = true;
+        if (connector)
+                connector->object.assigned = true;
+
+        /* we will support hw clone mode in the future */
+        n_connectors = connector ? 1 : 0;
+
+        /* bail out if configuration is preserved */
+        if (crtc->set.n_connectors == n_connectors &&
+            (n_connectors == 0 || crtc->set.connectors[0] == connector->object.id))
+                return;
+
+        crtc->applied = false;
+        crtc->set.n_connectors = 0;
+
+        if (n_connectors > crtc->set.max_connectors) {
+                uint32_t max, *t;
+
+                max = ALIGN_POWER2(n_connectors);
+                if (!max) {
+                        r = -ENOMEM;
+                        goto error;
+                }
+
+                t = realloc(crtc->set.connectors, sizeof(*t) * max);
+                if (!t) {
+                        r = -ENOMEM;
+                        goto error;
+                }
+
+                crtc->set.connectors = t;
+                crtc->set.max_connectors = max;
+        }
+
+        if (connector) {
+                struct drm_mode_modeinfo *m, *pref = NULL;
+                uint32_t i;
+
+                for (i = 0; i < connector->kern.n_modes; ++i) {
+                        m = &connector->kern.modes[i];
+
+                        /* ignore 3D modes by default */
+                        if (m->flags & DRM_MODE_FLAG_3D_MASK)
+                                continue;
+
+                        if (!pref) {
+                                pref = m;
+                                continue;
+                        }
+
+                        /* use PREFERRED over non-PREFERRED */
+                        if ((pref->type & DRM_MODE_TYPE_PREFERRED) &&
+                            !(m->type & DRM_MODE_TYPE_PREFERRED))
+                                continue;
+
+                        /* use DRIVER over non-PREFERRED|DRIVER */
+                        if ((pref->type & DRM_MODE_TYPE_DRIVER) &&
+                            !(m->type & (DRM_MODE_TYPE_DRIVER | DRM_MODE_TYPE_PREFERRED)))
+                                continue;
+
+                        /* always prefer higher resolution */
+                        if (pref->hdisplay > m->hdisplay ||
+                            (pref->hdisplay == m->hdisplay && pref->vdisplay > m->vdisplay))
+                                continue;
+
+                        pref = m;
+                }
+
+                if (pref) {
+                        crtc->set.mode = *pref;
+                        crtc->set.n_connectors = 1;
+                        crtc->set.connectors[0] = connector->object.id;
+                        log_debug("grdrm: %s: assigned connector %" PRIu32 " to crtc %" PRIu32 " with mode %s",
+                                  crtc->object.card->base.name, connector->object.id, crtc->object.id, pref->name);
+                } else {
+                        log_debug("grdrm: %s: connector %" PRIu32 " to be assigned but has no valid mode",
+                                  crtc->object.card->base.name, connector->object.id);
+                }
+        }
+
+        return;
+
+error:
+        log_debug("grdrm: %s: cannot assign crtc %" PRIu32 ": %s",
+                  crtc->object.card->base.name, crtc->object.id, strerror(-r));
+}
+
+static void grdrm_crtc_expose(grdrm_crtc *crtc) {
+        grdrm_pipe *pipe;
+        grdrm_fb *fb;
+        size_t i;
+        int r;
+
+        assert(crtc);
+        assert(crtc->object.assigned);
+
+        if (crtc->set.n_connectors < 1) {
+                if (crtc->pipe)
+                        grdev_pipe_free(&crtc->pipe->base);
+                crtc->pipe = NULL;
+                return;
+        }
+
+        pipe = crtc->pipe;
+        if (pipe) {
+                if (pipe->base.width != crtc->set.mode.hdisplay ||
+                    pipe->base.height != crtc->set.mode.vdisplay) {
+                        grdev_pipe_free(&pipe->base);
+                        crtc->pipe = NULL;
+                        pipe = NULL;
+                }
+        }
+
+        if (crtc->pipe) {
+                pipe->base.front = NULL;
+                pipe->base.back = NULL;
+                for (i = 0; i < pipe->base.max_fbs; ++i) {
+                        fb = fb_from_base(pipe->base.fbs[i]);
+                        if (fb->id == crtc->kern.used_fb)
+                                pipe->base.front = &fb->base;
+                        else if (!fb->flipid)
+                                pipe->base.back = &fb->base;
+                }
+        } else {
+                r = grdrm_pipe_new(&pipe, crtc, &crtc->set.mode, 2);
+                if (r < 0) {
+                        log_debug("grdrm: %s: cannot create pipe for crtc %" PRIu32 ": %s",
+                                  crtc->object.card->base.name, crtc->object.id, strerror(-r));
+                        return;
+                }
+
+                for (i = 0; i < pipe->base.max_fbs; ++i) {
+                        r = grdrm_fb_new(&fb, crtc->object.card, &crtc->set.mode);
+                        if (r < 0) {
+                                log_debug("grdrm: %s: cannot allocate framebuffer for crtc %" PRIu32 ": %s",
+                                          crtc->object.card->base.name, crtc->object.id, strerror(-r));
+                                grdev_pipe_free(&pipe->base);
+                                return;
+                        }
+
+                        pipe->base.fbs[i] = &fb->base;
+                }
+
+                pipe->base.front = NULL;
+                pipe->base.back = pipe->base.fbs[0];
+                crtc->pipe = pipe;
+        }
+
+        grdev_pipe_ready(&crtc->pipe->base, true);
+}
+
+static void grdrm_crtc_commit(grdrm_crtc *crtc) {
+        struct drm_mode_crtc_page_flip page_flip = { .crtc_id = crtc->object.id };
+        struct drm_mode_crtc set_crtc = { .crtc_id = crtc->object.id };
+        grdrm_card *card = crtc->object.card;
+        grdrm_pipe *pipe;
+        grdev_fb **slot;
+        grdrm_fb *fb;
+        uint32_t cnt;
+        size_t i;
+        int r;
+
+        assert(crtc);
+        assert(crtc->object.assigned);
+
+        pipe = crtc->pipe;
+        if (!pipe) {
+                /* If a crtc is not assigned any connector, we want any
+                 * previous setup to be cleared, so make sure the CRTC is
+                 * disabled. Otherwise, there might be content on the CRTC
+                 * while we run, which is not what we want.
+                 * If you want to avoid modesets on specific CRTCs, you should
+                 * still keep their assignment, but never enable the resulting
+                 * pipe. This way, we wouldn't touch it at all. */
+                if (!crtc->applied) {
+                        crtc->applied = true;
+                        r = ioctl(card->fd, DRM_IOCTL_MODE_SETCRTC, &set_crtc);
+                        if (r < 0) {
+                                r = -errno;
+                                log_debug("grdrm: %s: cannot shutdown crtc %" PRIu32 ": %m",
+                                          card->base.name, crtc->object.id);
+
+                                grdrm_card_async(card, r);
+                                return;
+                        }
+
+                        log_debug("grdrm: %s: crtc %" PRIu32 " applied via shutdown",
+                                  card->base.name, crtc->object.id);
+                }
+
+                return;
+        }
+
+        /* we always fully ignore disabled pipes */
+        if (!pipe->base.enabled)
+                return;
+
+        assert(crtc->set.n_connectors > 0);
+
+        if (pipe->base.flip)
+                slot = &pipe->base.back;
+        else if (!crtc->applied)
+                slot = &pipe->base.front;
+        else
+                return;
+
+        if (!*slot)
+                return;
+
+        fb = fb_from_base(*slot);
+
+        if (crtc->applied || grdrm_modes_compatible(&crtc->kern.mode, &crtc->set.mode)) {
+                cnt = ++pipe->counter ? : ++pipe->counter;
+                page_flip.fb_id = fb->id;
+                page_flip.flags = DRM_MODE_PAGE_FLIP_EVENT;
+                page_flip.user_data = grdrm_encode_vblank_data(crtc->object.id, cnt);
+
+                r = ioctl(card->fd, DRM_IOCTL_MODE_PAGE_FLIP, &page_flip);
+                if (r < 0) {
+                        r = -errno;
+                        log_debug("grdrm: %s: cannot schedule page-flip on crtc %" PRIu32 ": %m",
+                                  card->base.name, crtc->object.id);
+
+                        if (grdrm_card_async(card, r))
+                                return;
+
+                        /* fall through to deep modeset */
+                } else {
+                        if (!crtc->applied) {
+                                log_debug("grdrm: %s: crtc %" PRIu32 " applied via page flip",
+                                          card->base.name, crtc->object.id);
+                                crtc->applied = true;
+                        }
+
+                        pipe->base.flipping = true;
+                        pipe->counter = cnt;
+                        fb->flipid = cnt;
+                        *slot = NULL;
+
+                        if (!pipe->base.back) {
+                                for (i = 0; i < pipe->base.max_fbs; ++i) {
+                                        if (!pipe->base.fbs[i])
+                                                continue;
+
+                                        fb = fb_from_base(pipe->base.fbs[i]);
+                                        if (&fb->base == pipe->base.front)
+                                                continue;
+                                        if (fb->flipid)
+                                                continue;
+
+                                        pipe->base.back = &fb->base;
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        if (!crtc->applied) {
+                set_crtc.set_connectors_ptr = PTR_TO_UINT64(crtc->set.connectors);
+                set_crtc.count_connectors = crtc->set.n_connectors;
+                set_crtc.fb_id = fb->id;
+                set_crtc.x = 0;
+                set_crtc.y = 0;
+                set_crtc.mode_valid = 1;
+                set_crtc.mode = crtc->set.mode;
+
+                r = ioctl(card->fd, DRM_IOCTL_MODE_SETCRTC, &set_crtc);
+                if (r < 0) {
+                        r = -errno;
+                        log_debug("grdrm: %s: cannot set crtc %" PRIu32 ": %m",
+                                  card->base.name, crtc->object.id);
+
+                        grdrm_card_async(card, r);
+                        return;
+                }
+
+                if (!crtc->applied) {
+                        log_debug("grdrm: %s: crtc %" PRIu32 " applied via deep modeset",
+                                  card->base.name, crtc->object.id);
+                        crtc->applied = true;
+                }
+
+                *slot = NULL;
+                pipe->base.front = &fb->base;
+                fb->flipid = 0;
+                ++pipe->counter;
+                pipe->base.flipping = false;
+
+                if (!pipe->base.back) {
+                        for (i = 0; i < pipe->base.max_fbs; ++i) {
+                                if (!pipe->base.fbs[i])
+                                        continue;
+
+                                fb = fb_from_base(pipe->base.fbs[i]);
+                                if (&fb->base == pipe->base.front)
+                                        continue;
+
+                                fb->flipid = 0;
+                                pipe->base.back = &fb->base;
+                                break;
+                        }
+                }
+        }
+
+        pipe->base.flip = false;
+}
+
+static void grdrm_crtc_restore(grdrm_crtc *crtc) {
+        struct drm_mode_crtc set_crtc = { .crtc_id = crtc->object.id };
+        grdrm_card *card = crtc->object.card;
+        int r;
+
+        if (!crtc->old.set)
+                return;
+
+        set_crtc.set_connectors_ptr = PTR_TO_UINT64(crtc->old.connectors);
+        set_crtc.count_connectors = crtc->old.n_connectors;
+        set_crtc.fb_id = crtc->old.fb;
+        set_crtc.x = crtc->old.fb_x;
+        set_crtc.y = crtc->old.fb_y;
+        set_crtc.gamma_size = crtc->old.gamma;
+        set_crtc.mode_valid = crtc->old.mode_set;
+        set_crtc.mode = crtc->old.mode;
+
+        r = ioctl(card->fd, DRM_IOCTL_MODE_SETCRTC, &set_crtc);
+        if (r < 0) {
+                r = -errno;
+                log_debug("grdrm: %s: cannot restore crtc %" PRIu32 ": %m",
+                          card->base.name, crtc->object.id);
+
+                grdrm_card_async(card, r);
+                return;
+        }
+
+        if (crtc->pipe) {
+                ++crtc->pipe->counter;
+                crtc->pipe->base.front = NULL;
+                crtc->pipe->base.flipping = false;
+        }
+
+        log_debug("grdrm: %s: crtc %" PRIu32 " restored", card->base.name, crtc->object.id);
+}
+
+static void grdrm_crtc_flip_complete(grdrm_crtc *crtc, uint32_t counter, struct drm_event_vblank *event) {
+        bool flipped = false;
+        grdrm_pipe *pipe;
+        grdrm_fb *back = NULL;
+        size_t i;
+
+        assert(crtc);
+        assert(event);
+
+        pipe = crtc->pipe;
+        if (!pipe)
+                return;
+
+        /* We got a page-flip event. To be safe, we reset all FBs on the same
+         * pipe that have smaller flipids than the flip we got as we know they
+         * are executed in order. We need to do this to guarantee
+         * queue-overflows or other missed events don't cause starvation.
+         * Furthermore, if we find the exact FB this event is for, *and* this
+         * is the most recent event, we mark it as front FB and raise a
+         * frame event. */
+
+        for (i = 0; i < pipe->base.max_fbs; ++i) {
+                grdrm_fb *fb;
+
+                if (!pipe->base.fbs[i])
+                        continue;
+
+                fb = fb_from_base(pipe->base.fbs[i]);
+                if (counter != 0 && counter == pipe->counter && fb->flipid == counter) {
+                        pipe->base.front = &fb->base;
+                        flipped = true;
+                }
+
+                if (counter - fb->flipid < UINT16_MAX) {
+                        fb->flipid = 0;
+                        back = fb;
+                } else if (fb->flipid == 0) {
+                        back = fb;
+                }
+        }
+
+        if (!pipe->base.back)
+                pipe->base.back = &back->base;
+
+        if (flipped) {
+                crtc->pipe->base.flipping = false;
+                grdev_pipe_frame(&pipe->base);
+        }
+}
+
+/*
+ * Framebuffers
+ */
+
+static int grdrm_fb_new(grdrm_fb **out, grdrm_card *card, const struct drm_mode_modeinfo *mode) {
+        _cleanup_(grdrm_fb_freep) grdrm_fb *fb = NULL;
+        struct drm_mode_create_dumb create_dumb = { };
+        struct drm_mode_map_dumb map_dumb = { };
+        struct drm_mode_fb_cmd2 add_fb = { };
+        unsigned int i;
+        int r;
+
+        assert_return(out, -EINVAL);
+        assert_return(card, -EINVAL);
+
+        fb = new0(grdrm_fb, 1);
+        if (!fb)
+                return -ENOMEM;
+
+        /* TODO: we should choose a compatible format of the previous CRTC
+         * setting to allow page-flip to it. Only choose fallback if the
+         * previous setting was crap (non xrgb32'ish). */
+
+        fb->card = card;
+        fb->base.format = DRM_FORMAT_XRGB8888;
+        fb->base.width = mode->hdisplay;
+        fb->base.height = mode->vdisplay;
+
+        for (i = 0; i < ELEMENTSOF(fb->base.maps); ++i)
+                fb->base.maps[i] = MAP_FAILED;
+
+        create_dumb.width = fb->base.width;
+        create_dumb.height = fb->base.height;
+        create_dumb.bpp = 32;
+
+        r = ioctl(card->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb);
+        if (r < 0) {
+                r = -errno;
+                log_debug("grdrm: %s: cannot create dumb buffer %" PRIu32 "x%" PRIu32": %m",
+                          card->base.name, fb->base.width, fb->base.height);
+                return r;
+        }
+
+        fb->handles[0] = create_dumb.handle;
+        fb->base.strides[0] = create_dumb.pitch;
+        fb->sizes[0] = create_dumb.size;
+
+        map_dumb.handle = fb->handles[0];
+
+        r = ioctl(card->fd, DRM_IOCTL_MODE_MAP_DUMB, &map_dumb);
+        if (r < 0) {
+                r = -errno;
+                log_debug("grdrm: %s: cannot map dumb buffer %" PRIu32 "x%" PRIu32": %m",
+                          card->base.name, fb->base.width, fb->base.height);
+                return r;
+        }
+
+        fb->base.maps[0] = mmap(0, fb->sizes[0], PROT_WRITE, MAP_SHARED, card->fd, map_dumb.offset);
+        if (fb->base.maps[0] == MAP_FAILED) {
+                r = -errno;
+                log_debug("grdrm: %s: cannot memory-map dumb buffer %" PRIu32 "x%" PRIu32": %m",
+                          card->base.name, fb->base.width, fb->base.height);
+                return r;
+        }
+
+        memzero(fb->base.maps[0], fb->sizes[0]);
+
+        add_fb.width = fb->base.width;
+        add_fb.height = fb->base.height;
+        add_fb.pixel_format = fb->base.format;
+        add_fb.flags = 0;
+        memcpy(add_fb.handles, fb->handles, sizeof(fb->handles));
+        memcpy(add_fb.pitches, fb->base.strides, sizeof(fb->base.strides));
+        memcpy(add_fb.offsets, fb->offsets, sizeof(fb->offsets));
+
+        r = ioctl(card->fd, DRM_IOCTL_MODE_ADDFB2, &add_fb);
+        if (r < 0) {
+                r = -errno;
+                log_debug("grdrm: %s: cannot add framebuffer %" PRIu32 "x%" PRIu32": %m",
+                          card->base.name, fb->base.width, fb->base.height);
+                return r;
+        }
+
+        fb->id = add_fb.fb_id;
+
+        *out = fb;
+        fb = NULL;
+        return 0;
+}
+
+grdrm_fb *grdrm_fb_free(grdrm_fb *fb) {
+        unsigned int i;
+
+        if (!fb)
+                return NULL;
+
+        assert(fb->card);
+
+        if (fb->id > 0 && fb->card->fd >= 0)
+                ioctl(fb->card->fd, DRM_IOCTL_MODE_RMFB, fb->id);
+
+        for (i = 0; i < ELEMENTSOF(fb->handles); ++i) {
+                struct drm_mode_destroy_dumb destroy_dumb = { };
+
+                if (fb->base.maps[i] != MAP_FAILED)
+                        munmap(fb->base.maps[i], fb->sizes[i]);
+
+                if (fb->handles[i] > 0 && fb->card->fd >= 0) {
+                        destroy_dumb.handle = fb->handles[i];
+                        ioctl(fb->card->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
+                }
+        }
+
+        free(fb);
+
+        return NULL;
+}
+
+/*
+ * Pipes
+ */
+
+static void grdrm_pipe_name(char *out, grdrm_crtc *crtc) {
+        /* @out must be at least of size GRDRM_PIPE_NAME_MAX */
+        sprintf(out, "%s/%" PRIu32, crtc->object.card->base.name, crtc->object.id);
+}
+
+static int grdrm_pipe_new(grdrm_pipe **out, grdrm_crtc *crtc, struct drm_mode_modeinfo *mode, size_t n_fbs) {
+        _cleanup_(grdev_pipe_freep) grdev_pipe *basepipe = NULL;
+        grdrm_card *card = crtc->object.card;
+        char name[GRDRM_PIPE_NAME_MAX];
+        grdrm_pipe *pipe;
+        int r;
+
+        assert_return(crtc, -EINVAL);
+        assert_return(grdev_is_drm_card(&card->base), -EINVAL);
+
+        pipe = new0(grdrm_pipe, 1);
+        if (!pipe)
+                return -ENOMEM;
+
+        basepipe = &pipe->base;
+        pipe->base = GRDEV_PIPE_INIT(&grdrm_pipe_vtable, &card->base);
+        pipe->crtc = crtc;
+        pipe->base.width = mode->hdisplay;
+        pipe->base.height = mode->vdisplay;
+
+        grdrm_pipe_name(name, crtc);
+        r = grdev_pipe_add(&pipe->base, name, n_fbs);
+        if (r < 0)
+                return r;
+
+        if (out)
+                *out = pipe;
+        basepipe = NULL;
+        return 0;
+}
+
+static void grdrm_pipe_free(grdev_pipe *basepipe) {
+        grdrm_pipe *pipe = grdrm_pipe_from_base(basepipe);
+        size_t i;
+
+        assert(pipe->crtc);
+
+        for (i = 0; i < pipe->base.max_fbs; ++i)
+                if (pipe->base.fbs[i])
+                        grdrm_fb_free(fb_from_base(pipe->base.fbs[i]));
+
+        free(pipe);
+}
+
+static const grdev_pipe_vtable grdrm_pipe_vtable = {
+        .free                   = grdrm_pipe_free,
+};
+
+/*
+ * Cards
+ */
+
+static void grdrm_name(char *out, dev_t devnum) {
+        /* @out must be at least of size GRDRM_CARD_NAME_MAX */
+        sprintf(out, "drm/%u:%u", major(devnum), minor(devnum));
+}
+
+static void grdrm_card_print(grdrm_card *card) {
+        grdrm_object *object;
+        grdrm_crtc *crtc;
+        grdrm_encoder *encoder;
+        grdrm_connector *connector;
+        grdrm_plane *plane;
+        Iterator iter;
+        uint32_t i;
+        char *p, *buf;
+
+        log_debug("grdrm: %s: state dump", card->base.name);
+
+        log_debug("  crtcs:");
+        HASHMAP_FOREACH(object, card->object_map, iter) {
+                if (object->type != GRDRM_TYPE_CRTC)
+                        continue;
+
+                crtc = crtc_from_object(object);
+                log_debug("    (id: %u index: %d)", object->id, object->index);
+
+                if (crtc->kern.mode_set)
+                        log_debug("      mode: %dx%d", crtc->kern.mode.hdisplay, crtc->kern.mode.vdisplay);
+                else
+                        log_debug("      mode: <none>");
+        }
+
+        log_debug("  encoders:");
+        HASHMAP_FOREACH(object, card->object_map, iter) {
+                if (object->type != GRDRM_TYPE_ENCODER)
+                        continue;
+
+                encoder = encoder_from_object(object);
+                log_debug("    (id: %u index: %d)", object->id, object->index);
+
+                if (encoder->kern.used_crtc)
+                        log_debug("      crtc: %u", encoder->kern.used_crtc);
+                else
+                        log_debug("      crtc: <none>");
+
+                buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * encoder->kern.n_crtcs + 1);
+                if (buf) {
+                        buf[0] = 0;
+                        p = buf;
+
+                        for (i = 0; i < encoder->kern.n_crtcs; ++i)
+                                p += sprintf(p, " %" PRIu32, encoder->kern.crtcs[i]);
+
+                        log_debug("      possible crtcs:%s", buf);
+                        free(buf);
+                }
+
+                buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * encoder->kern.n_clones + 1);
+                if (buf) {
+                        buf[0] = 0;
+                        p = buf;
+
+                        for (i = 0; i < encoder->kern.n_clones; ++i)
+                                p += sprintf(p, " %" PRIu32, encoder->kern.clones[i]);
+
+                        log_debug("      possible clones:%s", buf);
+                        free(buf);
+                }
+        }
+
+        log_debug("  connectors:");
+        HASHMAP_FOREACH(object, card->object_map, iter) {
+                if (object->type != GRDRM_TYPE_CONNECTOR)
+                        continue;
+
+                connector = connector_from_object(object);
+                log_debug("    (id: %u index: %d)", object->id, object->index);
+                log_debug("      type: %" PRIu32 "-%" PRIu32 " connection: %" PRIu32 " subpixel: %" PRIu32 " extents: %" PRIu32 "x%" PRIu32,
+                          connector->kern.type, connector->kern.type_id, connector->kern.connection, connector->kern.subpixel,
+                          connector->kern.mm_width, connector->kern.mm_height);
+
+                if (connector->kern.used_encoder)
+                        log_debug("      encoder: %" PRIu32, connector->kern.used_encoder);
+                else
+                        log_debug("      encoder: <none>");
+
+                buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * connector->kern.n_encoders + 1);
+                if (buf) {
+                        buf[0] = 0;
+                        p = buf;
+
+                        for (i = 0; i < connector->kern.n_encoders; ++i)
+                                p += sprintf(p, " %" PRIu32, connector->kern.encoders[i]);
+
+                        log_debug("      possible encoders:%s", buf);
+                        free(buf);
+                }
+
+                for (i = 0; i < connector->kern.n_modes; ++i) {
+                        struct drm_mode_modeinfo *mode = &connector->kern.modes[i];
+                        log_debug("      mode: %" PRIu32 "x%" PRIu32, mode->hdisplay, mode->vdisplay);
+                }
+        }
+
+        log_debug("  planes:");
+        HASHMAP_FOREACH(object, card->object_map, iter) {
+                if (object->type != GRDRM_TYPE_PLANE)
+                        continue;
+
+                plane = plane_from_object(object);
+                log_debug("    (id: %u index: %d)", object->id, object->index);
+                log_debug("      gamma-size: %" PRIu32, plane->kern.gamma_size);
+
+                if (plane->kern.used_crtc)
+                        log_debug("      crtc: %" PRIu32, plane->kern.used_crtc);
+                else
+                        log_debug("      crtc: <none>");
+
+                buf = malloc((DECIMAL_STR_MAX(uint32_t) + 1) * plane->kern.n_crtcs + 1);
+                if (buf) {
+                        buf[0] = 0;
+                        p = buf;
+
+                        for (i = 0; i < plane->kern.n_crtcs; ++i)
+                                p += sprintf(p, " %" PRIu32, plane->kern.crtcs[i]);
+
+                        log_debug("      possible crtcs:%s", buf);
+                        free(buf);
+                }
+
+                buf = malloc((DECIMAL_STR_MAX(unsigned int) + 3) * plane->kern.n_formats + 1);
+                if (buf) {
+                        buf[0] = 0;
+                        p = buf;
+
+                        for (i = 0; i < plane->kern.n_formats; ++i)
+                                p += sprintf(p, " 0x%x", (unsigned int)plane->kern.formats[i]);
+
+                        log_debug("      possible formats:%s", buf);
+                        free(buf);
+                }
+        }
+}
+
+static int grdrm_card_resync(grdrm_card *card) {
+        _cleanup_free_ uint32_t *crtc_ids = NULL, *encoder_ids = NULL, *connector_ids = NULL, *plane_ids = NULL;
+        uint32_t allocated = 0;
+        grdrm_object *object;
+        Iterator iter;
+        size_t tries;
+        int r;
+
+        assert(card);
+
+        card->async_hotplug = false;
+        allocated = 0;
+
+        /* mark existing objects for possible removal */
+        HASHMAP_FOREACH(object, card->object_map, iter)
+                object->present = false;
+
+        for (tries = 0; tries < GRDRM_MAX_TRIES; ++tries) {
+                struct drm_mode_get_plane_res pres;
+                struct drm_mode_card_res res;
+                uint32_t i, max;
+
+                if (allocated < card->max_ids) {
+                        free(crtc_ids);
+                        free(encoder_ids);
+                        free(connector_ids);
+                        free(plane_ids);
+                        crtc_ids = new0(uint32_t, card->max_ids);
+                        encoder_ids = new0(uint32_t, card->max_ids);
+                        connector_ids = new0(uint32_t, card->max_ids);
+                        plane_ids = new0(uint32_t, card->max_ids);
+
+                        if (!crtc_ids || !encoder_ids || !connector_ids || !plane_ids)
+                                return -ENOMEM;
+
+                        allocated = card->max_ids;
+                }
+
+                zero(res);
+                res.crtc_id_ptr = PTR_TO_UINT64(crtc_ids);
+                res.connector_id_ptr = PTR_TO_UINT64(connector_ids);
+                res.encoder_id_ptr = PTR_TO_UINT64(encoder_ids);
+                res.count_crtcs = allocated;
+                res.count_encoders = allocated;
+                res.count_connectors = allocated;
+
+                r = ioctl(card->fd, DRM_IOCTL_MODE_GETRESOURCES, &res);
+                if (r < 0) {
+                        r = -errno;
+                        log_debug("grdrm: %s: cannot retrieve drm resources: %m", card->base.name);
+                        return r;
+                }
+
+                zero(pres);
+                pres.plane_id_ptr = PTR_TO_UINT64(plane_ids);
+                pres.count_planes = allocated;
+
+                r = ioctl(card->fd, DRM_IOCTL_MODE_GETPLANERESOURCES, &pres);
+                if (r < 0) {
+                        r = -errno;
+                        log_debug("grdrm: %s: cannot retrieve drm plane-resources: %m", card->base.name);
+                        return r;
+                }
+
+                max = MAX(MAX(res.count_crtcs, res.count_encoders),
+                          MAX(res.count_connectors, pres.count_planes));
+                if (max > allocated) {
+                        uint32_t n;
+
+                        n = ALIGN_POWER2(max);
+                        if (!n || n > UINT16_MAX) {
+                                log_debug("grdrm: %s: excessive DRM resource limit: %" PRIu32, card->base.name, max);
+                                return -ERANGE;
+                        }
+
+                        /* retry with resized buffers */
+                        card->max_ids = n;
+                        continue;
+                }
+
+                /* mark available objects as present */
+
+                for (i = 0; i < res.count_crtcs; ++i) {
+                        object = grdrm_find_object(card, crtc_ids[i]);
+                        if (object && object->type == GRDRM_TYPE_CRTC) {
+                                object->present = true;
+                                object->index = i;
+                                crtc_ids[i] = 0;
+                        }
+                }
+
+                for (i = 0; i < res.count_encoders; ++i) {
+                        object = grdrm_find_object(card, encoder_ids[i]);
+                        if (object && object->type == GRDRM_TYPE_ENCODER) {
+                                object->present = true;
+                                object->index = i;
+                                encoder_ids[i] = 0;
+                        }
+                }
+
+                for (i = 0; i < res.count_connectors; ++i) {
+                        object = grdrm_find_object(card, connector_ids[i]);
+                        if (object && object->type == GRDRM_TYPE_CONNECTOR) {
+                                object->present = true;
+                                object->index = i;
+                                connector_ids[i] = 0;
+                        }
+                }
+
+                for (i = 0; i < pres.count_planes; ++i) {
+                        object = grdrm_find_object(card, plane_ids[i]);
+                        if (object && object->type == GRDRM_TYPE_PLANE) {
+                                object->present = true;
+                                object->index = i;
+                                plane_ids[i] = 0;
+                        }
+                }
+
+                /* drop removed objects */
+
+                HASHMAP_FOREACH(object, card->object_map, iter)
+                        if (!object->present)
+                                grdrm_object_free(object);
+
+                /* add new objects */
+
+                card->n_crtcs = res.count_crtcs;
+                for (i = 0; i < res.count_crtcs; ++i) {
+                        if (crtc_ids[i] < 1)
+                                continue;
+
+                        r = grdrm_crtc_new(NULL, card, crtc_ids[i], i);
+                        if (r < 0)
+                                return r;
+                }
+
+                card->n_encoders = res.count_encoders;
+                for (i = 0; i < res.count_encoders; ++i) {
+                        if (encoder_ids[i] < 1)
+                                continue;
+
+                        r = grdrm_encoder_new(NULL, card, encoder_ids[i], i);
+                        if (r < 0)
+                                return r;
+                }
+
+                card->n_connectors = res.count_connectors;
+                for (i = 0; i < res.count_connectors; ++i) {
+                        if (connector_ids[i] < 1)
+                                continue;
+
+                        r = grdrm_connector_new(NULL, card, connector_ids[i], i);
+                        if (r < 0)
+                                return r;
+                }
+
+                card->n_planes = pres.count_planes;
+                for (i = 0; i < pres.count_planes; ++i) {
+                        if (plane_ids[i] < 1)
+                                continue;
+
+                        r = grdrm_plane_new(NULL, card, plane_ids[i], i);
+                        if (r < 0)
+                                return r;
+                }
+
+                /* re-sync objects after object_map is synced */
+
+                HASHMAP_FOREACH(object, card->object_map, iter) {
+                        switch (object->type) {
+                        case GRDRM_TYPE_CRTC:
+                                r = grdrm_crtc_resync(crtc_from_object(object));
+                                break;
+                        case GRDRM_TYPE_ENCODER:
+                                r = grdrm_encoder_resync(encoder_from_object(object));
+                                break;
+                        case GRDRM_TYPE_CONNECTOR:
+                                r = grdrm_connector_resync(connector_from_object(object));
+                                break;
+                        case GRDRM_TYPE_PLANE:
+                                r = grdrm_plane_resync(plane_from_object(object));
+                                break;
+                        default:
+                                assert_not_reached("grdrm: invalid object type");
+                                r = 0;
+                        }
+
+                        if (r < 0)
+                                return r;
+
+                        if (card->async_hotplug)
+                                break;
+                }
+
+                /* if modeset objects change during sync, start over */
+                if (card->async_hotplug) {
+                        card->async_hotplug = false;
+                        continue;
+                }
+
+                /* cache crtc/connector relationship */
+                HASHMAP_FOREACH(object, card->object_map, iter) {
+                        grdrm_connector *connector;
+                        grdrm_encoder *encoder;
+                        grdrm_crtc *crtc;
+
+                        if (object->type != GRDRM_TYPE_CONNECTOR)
+                                continue;
+
+                        connector = connector_from_object(object);
+                        if (connector->kern.connection != 1 || connector->kern.used_encoder < 1)
+                                continue;
+
+                        object = grdrm_find_object(card, connector->kern.used_encoder);
+                        if (!object || object->type != GRDRM_TYPE_ENCODER)
+                                continue;
+
+                        encoder = encoder_from_object(object);
+                        if (encoder->kern.used_crtc < 1)
+                                continue;
+
+                        object = grdrm_find_object(card, encoder->kern.used_crtc);
+                        if (!object || object->type != GRDRM_TYPE_CRTC)
+                                continue;
+
+                        crtc = crtc_from_object(object);
+                        assert(crtc->kern.n_used_connectors < crtc->kern.max_used_connectors);
+                        crtc->kern.used_connectors[crtc->kern.n_used_connectors++] = connector->object.id;
+                }
+
+                /* cache old crtc settings for later restore */
+                HASHMAP_FOREACH(object, card->object_map, iter) {
+                        grdrm_crtc *crtc;
+
+                        if (object->type != GRDRM_TYPE_CRTC)
+                                continue;
+
+                        crtc = crtc_from_object(object);
+
+                        /* Save data if it is the first time we refresh the CRTC. This data can
+                         * be used optionally to restore any previous configuration. For
+                         * instance, it allows us to restore VT configurations after we close
+                         * our session again. */
+                        if (!crtc->old.set) {
+                                crtc->old.fb = crtc->kern.used_fb;
+                                crtc->old.fb_x = crtc->kern.fb_offset_x;
+                                crtc->old.fb_y = crtc->kern.fb_offset_y;
+                                crtc->old.gamma = crtc->kern.gamma_size;
+                                crtc->old.n_connectors = crtc->kern.n_used_connectors;
+                                if (crtc->old.n_connectors)
+                                        memcpy(crtc->old.connectors, crtc->kern.used_connectors, sizeof(uint32_t) * crtc->old.n_connectors);
+                                crtc->old.mode_set = crtc->kern.mode_set;
+                                crtc->old.mode = crtc->kern.mode;
+                                crtc->old.set = true;
+                        }
+                }
+
+                /* everything synced */
+                break;
+        }
+
+        if (tries >= GRDRM_MAX_TRIES) {
+                /*
+                 * Ugh! We were unable to sync the DRM card state due to heavy
+                 * hotplugging. This should never happen, so print a debug
+                 * message and bail out. The next uevent will trigger
+                 * this again.
+                 */
+
+                log_debug("grdrm: %s: hotplug-storm when syncing card", card->base.name);
+                return -EFAULT;
+        }
+
+        return 0;
+}
+
+static bool card_configure_crtc(grdrm_crtc *crtc, grdrm_connector *connector) {
+        grdrm_card *card = crtc->object.card;
+        grdrm_encoder *encoder;
+        grdrm_object *object;
+        uint32_t i, j;
+
+        if (crtc->object.assigned || connector->object.assigned)
+                return false;
+        if (connector->kern.connection != 1)
+                return false;
+
+        for (i = 0; i < connector->kern.n_encoders; ++i) {
+                object = grdrm_find_object(card, connector->kern.encoders[i]);
+                if (!object || object->type != GRDRM_TYPE_ENCODER)
+                        continue;
+
+                encoder = encoder_from_object(object);
+                for (j = 0; j < encoder->kern.n_crtcs; ++j) {
+                        if (encoder->kern.crtcs[j] == crtc->object.id) {
+                                grdrm_crtc_assign(crtc, connector);
+                                return true;
+                        }
+                }
+        }
+
+        return false;
+}
+
+static void grdrm_card_configure(grdrm_card *card) {
+        /*
+         * Modeset Configuration
+         * This is where we update our modeset configuration and assign
+         * connectors to CRTCs. This means, each connector that we want to
+         * enable needs a CRTC, disabled (or unavailable) connectors are left
+         * alone in the dark. Once all CRTCs are assigned, the remaining CRTCs
+         * are disabled.
+         * Sounds trivial, but there're several caveats:
+         *
+         *   * Multiple connectors can be driven by the same CRTC. This is
+         *     known as 'hardware clone mode'. Advantage over software clone
+         *     mode is that only a single CRTC is needed to drive multiple
+         *     displays. However, few hardware supports this and it's a huge
+         *     headache to configure on dynamic demands. Therefore, we only
+         *     support it if configured statically beforehand.
+         *
+         *   * CRTCs are not created equal. Some might be much more poweful
+         *     than others, including more advanced plane support. So far, our
+         *     CRTC selection is random. You need to supply static
+         *     configuration if you want special setups. So far, there is no
+         *     proper way to do advanced CRTC selection on dynamic demands. It
+         *     is not really clear which demands require what CRTC, so, like
+         *     everyone else, we do random CRTC selection unless explicitly
+         *     states otherwise.
+         *
+         *   * Each Connector has a list of possible encoders that can drive
+         *     it, and each encoder has a list of possible CRTCs. If this graph
+         *     is a tree, assignment is trivial. However, if not, we cannot
+         *     reliably decide on configurations beforehand. The encoder is
+         *     always selected by the kernel, so we have to actually set a mode
+         *     to know which encoder is used. There is no way to ask the kernel
+         *     whether a given configuration is possible. This will change with
+         *     atomic-modesetting, but until then, we keep our configurations
+         *     simple and assume they work all just fine. If one fails
+         *     unexpectedly, we print a warning and disable it.
+         *
+         * Configuring a card consists of several steps:
+         *
+         *  1) First of all, we apply any user-configuration. If a user wants
+         *     a fixed configuration, we apply it and preserve it.
+         *     So far, we don't support user configuration files, so this step
+         *     is skipped.
+         *
+         *  2) Secondly, we need to apply any quirks from hwdb. Some hardware
+         *     might only support limited configurations or require special
+         *     CRTC/Connector mappings. We read this from hwdb and apply it, if
+         *     present.
+         *     So far, we don't support this as there is no known quirk, so
+         *     this step is skipped.
+         *
+         *  3) As deep modesets are expensive, we try to avoid them if
+         *     possible. Therefore, we read the current configuration from the
+         *     kernel and try to preserve it, if compatible with our demands.
+         *     If not, we break it and reassign it in a following step.
+         *
+         *  4) The main step involves configuring all remaining objects. By
+         *     default, all available connectors are enabled, except for those
+         *     disabled by user-configuration. We lookup a suitable CRTC for
+         *     each connector and assign them. As there might be more
+         *     connectors than CRTCs, we apply some ordering so users can
+         *     select which connectors are more important right now.
+         *     So far, we only apply the default ordering, more might be added
+         *     in the future.
+         */
+
+        grdrm_object *object;
+        grdrm_crtc *crtc;
+        Iterator i, j;
+
+        /* clear assignments */
+        HASHMAP_FOREACH(object, card->object_map, i)
+                object->assigned = false;
+
+        /* preserve existing configurations */
+        HASHMAP_FOREACH(object, card->object_map, i) {
+                if (object->type != GRDRM_TYPE_CRTC || object->assigned)
+                        continue;
+
+                crtc = crtc_from_object(object);
+
+                if (crtc->applied) {
+                        /* If our mode is set, preserve it. If no connector is
+                         * set, modeset either failed or the pipe is unused. In
+                         * both cases, leave it alone. It might be tried again
+                         * below in case there're remaining connectors.
+                         * Otherwise, try restoring the assignments. If they
+                         * are no longer valid, leave the pipe untouched. */
+
+                        if (crtc->set.n_connectors < 1)
+                                continue;
+
+                        assert(crtc->set.n_connectors == 1);
+
+                        object = grdrm_find_object(card, crtc->set.connectors[0]);
+                        if (!object || object->type != GRDRM_TYPE_CONNECTOR)
+                                continue;
+
+                        card_configure_crtc(crtc, connector_from_object(object));
+                } else if (crtc->kern.mode_set && crtc->kern.n_used_connectors != 1) {
+                        /* If our mode is not set on the pipe, we know the kern
+                         * information is valid. Try keeping it. If it's not
+                         * possible, leave the pipe untouched for later
+                         * assignements. */
+
+                        object = grdrm_find_object(card, crtc->kern.used_connectors[0]);
+                        if (!object || object->type != GRDRM_TYPE_CONNECTOR)
+                                continue;
+
+                        card_configure_crtc(crtc, connector_from_object(object));
+                }
+        }
+
+        /* assign remaining objects */
+        HASHMAP_FOREACH(object, card->object_map, i) {
+                if (object->type != GRDRM_TYPE_CRTC || object->assigned)
+                        continue;
+
+                crtc = crtc_from_object(object);
+
+                HASHMAP_FOREACH(object, card->object_map, j) {
+                        if (object->type != GRDRM_TYPE_CONNECTOR)
+                                continue;
+
+                        if (card_configure_crtc(crtc, connector_from_object(object)))
+                                break;
+                }
+
+                if (!crtc->object.assigned)
+                        grdrm_crtc_assign(crtc, NULL);
+        }
+
+        /* expose configuration */
+        HASHMAP_FOREACH(object, card->object_map, i) {
+                if (object->type != GRDRM_TYPE_CRTC)
+                        continue;
+
+                grdrm_crtc_expose(crtc_from_object(object));
+        }
+}
+
+static void grdrm_card_hotplug(grdrm_card *card) {
+        int r;
+
+        assert(card);
+        assert(!card->ready);
+
+        r = grdrm_card_resync(card);
+        if (r < 0) {
+                log_debug("grdrm: %s/%s: cannot re-sync card: %s",
+                          card->base.session->name, card->base.name, strerror(-r));
+                return;
+        }
+
+        grdev_session_pin(card->base.session);
+
+        grdrm_card_print(card);
+        grdrm_card_configure(card);
+        card->ready = true;
+
+        grdev_session_unpin(card->base.session);
+}
+
+static int grdrm_card_io_fn(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+        grdrm_card *card = userdata;
+        struct drm_event_vblank *vblank;
+        struct drm_event *event;
+        uint32_t id, counter;
+        grdrm_object *object;
+        char buf[4096];
+        ssize_t l, i;
+
+        if (revents & (EPOLLHUP | EPOLLERR)) {
+                /* Immediately close device on HUP; no need to flush pending
+                 * data.. there're no events we care about here. */
+                log_debug("grdrm: %s/%s: HUP", card->base.session->name, card->base.name);
+                grdrm_card_close(card);
+                return 0;
+        }
+
+        if (revents & (EPOLLIN)) {
+                l = read(card->fd, buf, sizeof(buf));
+                if (l < 0) {
+                        if (errno == EAGAIN || errno == EINTR)
+                                return 0;
+
+                        log_debug("grdrm: %s/%s: read error: %m", card->base.session->name, card->base.name);
+                        grdrm_card_close(card);
+                        return 0;
+                } else if ((size_t)l < sizeof(*event)) {
+                        log_debug("grdrm: %s/%s: short read of %zd bytes", card->base.session->name, card->base.name, l);
+                        return 0;
+                }
+
+                for (i = 0; i < l; i += event->length) {
+                        event = (void*)&buf[i];
+
+                        if (i + event->length > l) {
+                                log_debug("grdrm: %s/%s: truncated event", card->base.session->name, card->base.name);
+                                break;
+                        }
+
+                        switch (event->type) {
+                        case DRM_EVENT_FLIP_COMPLETE:
+                                vblank = (void*)event;
+                                if (event->length < sizeof(*vblank)) {
+                                        log_debug("grdrm: %s/%s: truncated vblank event", card->base.session->name, card->base.name);
+                                        break;
+                                }
+
+                                grdrm_decode_vblank_data(vblank->user_data, &id, &counter);
+                                object = grdrm_find_object(card, id);
+                                if (!object || object->type != GRDRM_TYPE_CRTC)
+                                        break;
+
+                                grdrm_crtc_flip_complete(crtc_from_object(object), counter, vblank);
+                                break;
+                        }
+                }
+        }
+
+        return 0;
+}
+
+static int grdrm_card_add(grdrm_card *card, const char *name) {
+        assert(card);
+        assert(card->fd < 0);
+
+        card->object_map = hashmap_new(&trivial_hash_ops);
+        if (!card->object_map)
+                return -ENOMEM;
+
+        return grdev_card_add(&card->base, name);
+}
+
+static void grdrm_card_destroy(grdrm_card *card) {
+        assert(card);
+        assert(!card->running);
+        assert(card->fd < 0);
+        assert(hashmap_size(card->object_map) == 0);
+
+        hashmap_free(card->object_map);
+}
+
+static void grdrm_card_commit(grdev_card *basecard) {
+        grdrm_card *card = grdrm_card_from_base(basecard);
+        grdrm_object *object;
+        Iterator iter;
+
+        HASHMAP_FOREACH(object, card->object_map, iter) {
+                if (!card->ready)
+                        break;
+
+                if (object->type != GRDRM_TYPE_CRTC)
+                        continue;
+
+                grdrm_crtc_commit(crtc_from_object(object));
+        }
+}
+
+static void grdrm_card_restore(grdev_card *basecard) {
+        grdrm_card *card = grdrm_card_from_base(basecard);
+        grdrm_object *object;
+        Iterator iter;
+
+        HASHMAP_FOREACH(object, card->object_map, iter) {
+                if (!card->ready)
+                        break;
+
+                if (object->type != GRDRM_TYPE_CRTC)
+                        continue;
+
+                grdrm_crtc_restore(crtc_from_object(object));
+        }
+}
+
+static void grdrm_card_enable(grdrm_card *card) {
+        assert(card);
+
+        if (card->fd < 0 || card->running)
+                return;
+
+        /* ignore cards without DUMB_BUFFER capability */
+        if (!card->cap_dumb)
+                return;
+
+        assert(card->fd_src);
+
+        log_debug("grdrm: %s/%s: enable", card->base.session->name, card->base.name);
+
+        card->running = true;
+        sd_event_source_set_enabled(card->fd_src, SD_EVENT_ON);
+        grdrm_card_hotplug(card);
+}
+
+static void grdrm_card_disable(grdrm_card *card) {
+        grdrm_object *object;
+        Iterator iter;
+
+        assert(card);
+
+        if (card->fd < 0 || !card->running)
+                return;
+
+        assert(card->fd_src);
+
+        log_debug("grdrm: %s/%s: disable", card->base.session->name, card->base.name);
+
+        card->running = false;
+        card->ready = false;
+        sd_event_source_set_enabled(card->fd_src, SD_EVENT_OFF);
+
+        /* stop all pipes */
+        HASHMAP_FOREACH(object, card->object_map, iter) {
+                grdrm_crtc *crtc;
+
+                if (object->type != GRDRM_TYPE_CRTC)
+                        continue;
+
+                crtc = crtc_from_object(object);
+                crtc->applied = false;
+                if (crtc->pipe)
+                        grdev_pipe_ready(&crtc->pipe->base, false);
+        }
+}
+
+static int grdrm_card_open(grdrm_card *card, int dev_fd) {
+        _cleanup_(grdev_session_unpinp) grdev_session *pin = NULL;
+        _cleanup_close_ int fd = dev_fd;
+        struct drm_get_cap cap;
+        int r, flags;
+
+        assert(card);
+        assert(dev_fd >= 0);
+        assert(card->fd != dev_fd);
+
+        pin = grdev_session_pin(card->base.session);
+        grdrm_card_close(card);
+
+        log_debug("grdrm: %s/%s: open", card->base.session->name, card->base.name);
+
+        r = fd_nonblock(fd, true);
+        if (r < 0)
+                return r;
+
+        r = fd_cloexec(fd, true);
+        if (r < 0)
+                return r;
+
+        flags = fcntl(fd, F_GETFL, 0);
+        if (flags < 0)
+                return -errno;
+        if ((flags & O_ACCMODE) != O_RDWR)
+                return -EACCES;
+
+        r = sd_event_add_io(card->base.session->context->event,
+                            &card->fd_src,
+                            fd,
+                            EPOLLHUP | EPOLLERR | EPOLLIN,
+                            grdrm_card_io_fn,
+                            card);
+        if (r < 0)
+                return r;
+
+        sd_event_source_set_enabled(card->fd_src, SD_EVENT_OFF);
+
+        card->fd = fd;
+        fd = -1;
+
+        /* cache DUMB_BUFFER capability */
+        cap.capability = DRM_CAP_DUMB_BUFFER;
+        cap.value = 0;
+        r = ioctl(card->fd, DRM_IOCTL_GET_CAP, &cap);
+        card->cap_dumb = r >= 0 && cap.value;
+        if (r < 0)
+                log_debug("grdrm: %s/%s: cannot retrieve DUMB_BUFFER capability: %s",
+                          card->base.session->name, card->base.name, strerror(-r));
+        else if (!card->cap_dumb)
+                log_debug("grdrm: %s/%s: DUMB_BUFFER capability not supported",
+                          card->base.session->name, card->base.name);
+
+        /* cache TIMESTAMP_MONOTONIC capability */
+        cap.capability = DRM_CAP_TIMESTAMP_MONOTONIC;
+        cap.value = 0;
+        r = ioctl(card->fd, DRM_IOCTL_GET_CAP, &cap);
+        card->cap_monotonic = r >= 0 && cap.value;
+        if (r < 0)
+                log_debug("grdrm: %s/%s: cannot retrieve TIMESTAMP_MONOTONIC capability: %s",
+                          card->base.session->name, card->base.name, strerror(-r));
+        else if (!card->cap_monotonic)
+                log_debug("grdrm: %s/%s: TIMESTAMP_MONOTONIC is disabled globally, fix this NOW!",
+                          card->base.session->name, card->base.name);
+
+        return 0;
+}
+
+static void grdrm_card_close(grdrm_card *card) {
+        grdrm_object *object;
+
+        if (card->fd < 0)
+                return;
+
+        log_debug("grdrm: %s/%s: close", card->base.session->name, card->base.name);
+
+        grdrm_card_disable(card);
+
+        card->fd_src = sd_event_source_unref(card->fd_src);
+        card->fd = safe_close(card->fd);
+
+        grdev_session_pin(card->base.session);
+        while ((object = hashmap_first(card->object_map)))
+                grdrm_object_free(object);
+        grdev_session_unpin(card->base.session);
+}
+
+static bool grdrm_card_async(grdrm_card *card, int r) {
+        switch (r) {
+        case -EACCES:
+                /* If we get EACCES on runtime DRM calls, we lost DRM-Master
+                 * (or we did something terribly wrong). Immediately disable
+                 * the card, so we stop all pipes and wait to be activated
+                 * again. */
+                grdrm_card_disable(card);
+                break;
+        case -ENOENT:
+                /* DRM objects can be hotplugged at any time. If an object is
+                 * removed that we use, we remember that state so a following
+                 * call can test for this.
+                 * Note that we also get a uevent as followup, this will resync
+                 * the whole device. */
+                card->async_hotplug = true;
+                break;
+        }
+
+        return !card->ready;
+}
+
+/*
+ * Unmanaged Cards
+ * The unmanaged DRM card opens the device node for a given DRM device
+ * directly (/dev/dri/cardX) and thus needs sufficient privileges. It opens
+ * the device only if we really require it and releases it as soon as we're
+ * disabled or closed.
+ * The unmanaged element can be used in all situations where you have direct
+ * access to DRM device nodes. Unlike managed DRM elements, it can be used
+ * outside of user sessions and in emergency situations where logind is not
+ * available.
+ */
+
+static void unmanaged_card_enable(grdev_card *basecard) {
+        unmanaged_card *cu = unmanaged_card_from_base(basecard);
+        int r, fd;
+
+        if (cu->card.fd < 0) {
+                /* try open on activation if it failed during allocation */
+                fd = open(cu->devnode, O_RDWR | O_CLOEXEC | O_NOCTTY | O_NONBLOCK);
+                if (fd < 0) {
+                        /* not fatal; simply ignore the device */
+                        log_debug("grdrm: %s/%s: cannot open node %s: %m",
+                                  basecard->session->name, basecard->name, cu->devnode);
+                        return;
+                }
+
+                /* we might already be DRM-Master by open(); that's fine */
+
+                r = grdrm_card_open(&cu->card, fd);
+                if (r < 0) {
+                        log_debug("grdrm: %s/%s: cannot open: %s",
+                                  basecard->session->name, basecard->name, strerror(-r));
+                        return;
+                }
+        }
+
+        r = ioctl(cu->card.fd, DRM_IOCTL_SET_MASTER, 0);
+        if (r < 0) {
+                log_debug("grdrm: %s/%s: cannot acquire DRM-Master: %m",
+                          basecard->session->name, basecard->name);
+                return;
+        }
+
+        grdrm_card_enable(&cu->card);
+}
+
+static void unmanaged_card_disable(grdev_card *basecard) {
+        unmanaged_card *cu = unmanaged_card_from_base(basecard);
+
+        grdrm_card_disable(&cu->card);
+}
+
+static int unmanaged_card_new(grdev_card **out, grdev_session *session, struct udev_device *ud) {
+        _cleanup_(grdev_card_freep) grdev_card *basecard = NULL;
+        char name[GRDRM_CARD_NAME_MAX];
+        unmanaged_card *cu;
+        const char *devnode;
+        dev_t devnum;
+        int r, fd;
+
+        assert_return(session, -EINVAL);
+        assert_return(ud, -EINVAL);
+
+        devnode = udev_device_get_devnode(ud);
+        devnum = udev_device_get_devnum(ud);
+        if (!devnode || devnum == 0)
+                return -ENODEV;
+
+        grdrm_name(name, devnum);
+
+        cu = new0(unmanaged_card, 1);
+        if (!cu)
+                return -ENOMEM;
+
+        basecard = &cu->card.base;
+        cu->card = GRDRM_CARD_INIT(&unmanaged_card_vtable, session);
+
+        cu->devnode = strdup(devnode);
+        if (!cu->devnode)
+                return -ENOMEM;
+
+        r = grdrm_card_add(&cu->card, name);
+        if (r < 0)
+                return r;
+
+        /* try to open but ignore errors */
+        fd = open(cu->devnode, O_RDWR | O_CLOEXEC | O_NOCTTY | O_NONBLOCK);
+        if (fd < 0) {
+                /* not fatal; allow uaccess based control on activation */
+                log_debug("grdrm: %s/%s: cannot open node %s: %m",
+                          basecard->session->name, basecard->name, cu->devnode);
+        } else {
+                /* We might get DRM-Master implicitly on open(); drop it immediately
+                 * so we acquire it only once we're actually enabled. */
+                ioctl(fd, DRM_IOCTL_DROP_MASTER, 0);
+
+                r = grdrm_card_open(&cu->card, fd);
+                if (r < 0)
+                        log_debug("grdrm: %s/%s: cannot open: %s",
+                                  basecard->session->name, basecard->name, strerror(-r));
+        }
+
+        if (out)
+                *out = basecard;
+        basecard = NULL;
+        return 0;
+}
+
+static void unmanaged_card_free(grdev_card *basecard) {
+        unmanaged_card *cu = unmanaged_card_from_base(basecard);
+
+        assert(!basecard->enabled);
+
+        grdrm_card_close(&cu->card);
+        grdrm_card_destroy(&cu->card);
+        free(cu->devnode);
+        free(cu);
+}
+
+static const grdev_card_vtable unmanaged_card_vtable = {
+        .free                   = unmanaged_card_free,
+        .enable                 = unmanaged_card_enable,
+        .disable                = unmanaged_card_disable,
+        .commit                 = grdrm_card_commit,
+        .restore                = grdrm_card_restore,
+};
+
+/*
+ * Managed Cards
+ * The managed DRM card uses systemd-logind to acquire DRM devices. This
+ * means, we do not open the device node /dev/dri/cardX directly. Instead,
+ * logind passes us a file-descriptor whenever our session is activated. Thus,
+ * we don't need access to the device node directly.
+ * Furthermore, whenever the session is put asleep, logind revokes the
+ * file-descriptor so we loose access to the device.
+ * Managed DRM cards should be preferred over unmanaged DRM cards whenever
+ * you run inside a user session with exclusive device access.
+ */
+
+static void managed_card_enable(grdev_card *card) {
+        managed_card *cm = managed_card_from_base(card);
+
+        /* If the device is manually re-enabled, we try to resume our card
+         * management. Note that we have no control over DRM-Master and the fd,
+         * so we have to take over the state from the last logind event. */
+
+        if (cm->master)
+                grdrm_card_enable(&cm->card);
+}
+
+static void managed_card_disable(grdev_card *card) {
+        managed_card *cm = managed_card_from_base(card);
+
+        /* If the device is manually disabled, we keep the FD but put our card
+         * management asleep. This way, we can wake up at any time, but don't
+         * touch the device while asleep. */
+
+        grdrm_card_disable(&cm->card);
+}
+
+static int managed_card_pause_device_fn(sd_bus *bus,
+                                        sd_bus_message *signal,
+                                        void *userdata,
+                                        sd_bus_error *ret_error) {
+        managed_card *cm = userdata;
+        grdev_session *session = cm->card.base.session;
+        uint32_t major, minor;
+        const char *mode;
+        int r;
+
+        /*
+         * We get PauseDevice() signals from logind whenever a device we
+         * requested was, or is about to be, paused. Arguments are major/minor
+         * number of the device and the mode of the operation.
+         * In case the event is not about our device, we ignore it. Otherwise,
+         * we treat it as asynchronous DRM-DROP-MASTER. Note that we might have
+         * already handled an EACCES error from a modeset ioctl, in which case
+         * we already disabled the device.
+         *
+         * @mode can be one of the following:
+         *   "pause": The device is about to be paused. We must react
+         *            immediately and respond with PauseDeviceComplete(). Once
+         *            we replied, logind will pause the device. Note that
+         *            logind might apply any kind of timeout and force pause
+         *            the device if we don't respond in a timely manner. In
+         *            this case, we will receive a second PauseDevice event
+         *            with @mode set to "force" (or similar).
+         *   "force": The device was disabled forecfully by logind. DRM-Master
+         *            was already dropped. This is just an asynchronous
+         *            notification so we can put the device asleep (in case
+         *            we didn't already notice the dropped DRM-Master).
+         *    "gone": This is like "force" but is sent if the device was
+         *            paused due to a device-removal event.
+         *
+         * We always handle PauseDevice signals as "force" as we properly
+         * support asynchronously dropping DRM-Master, anyway. But in case
+         * logind sent mode "pause", we also call PauseDeviceComplete() to
+         * immediately acknowledge the request.
+         */
+
+        r = sd_bus_message_read(signal, "uus", &major, &minor, &mode);
+        if (r < 0) {
+                log_debug("grdrm: %s/%s: erroneous PauseDevice signal",
+                          session->name, cm->card.base.name);
+                return 0;
+        }
+
+        /* not our device? */
+        if (makedev(major, minor) != cm->devnum)
+                return 0;
+
+        cm->master = false;
+        grdrm_card_disable(&cm->card);
+
+        if (streq(mode, "pause")) {
+                _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
+
+                /*
+                 * Sending PauseDeviceComplete() is racy if logind triggers the
+                 * timeout. That is, if we take too long and logind pauses the
+                 * device by sending a forced PauseDevice, our
+                 * PauseDeviceComplete call will be stray. That's fine, though.
+                 * logind ignores such stray calls. Only if logind also sent a
+                 * further PauseDevice() signal, it might match our call
+                 * incorrectly to the newer PauseDevice(). That's fine, too, as
+                 * we handle that event asynchronously, anyway. Therefore,
+                 * whatever happens, we're fine. Yay!
+                 */
+
+                r = sd_bus_message_new_method_call(session->context->sysbus,
+                                                   &m,
+                                                   "org.freedesktop.login1",
+                                                   session->path,
+                                                   "org.freedesktop.login1.Session",
+                                                   "PauseDeviceComplete");
+                if (r >= 0) {
+                        r = sd_bus_message_append(m, "uu", major, minor);
+                        if (r >= 0)
+                                r = sd_bus_send(session->context->sysbus, m, NULL);
+                }
+
+                if (r < 0)
+                        log_debug("grdrm: %s/%s: cannot send PauseDeviceComplete: %s",
+                                  session->name, cm->card.base.name, strerror(-r));
+        }
+
+        return 0;
+}
+
+static int managed_card_resume_device_fn(sd_bus *bus,
+                                         sd_bus_message *signal,
+                                         void *userdata,
+                                         sd_bus_error *ret_error) {
+        managed_card *cm = userdata;
+        grdev_session *session = cm->card.base.session;
+        uint32_t major, minor;
+        int r, fd;
+
+        /*
+         * We get ResumeDevice signals whenever logind resumed a previously
+         * paused device. The arguments contain the major/minor number of the
+         * related device and a new file-descriptor for the freshly opened
+         * device-node.
+         * If the signal is not about our device, we simply ignore it.
+         * Otherwise, we immediately resume the device. Note that we drop the
+         * new file-descriptor as we already have one from TakeDevice(). logind
+         * preserves the file-context across pause/resume for DRM but only
+         * drops/acquires DRM-Master accordingly. This way, our context (like
+         * DRM-FBs and BOs) is preserved.
+         */
+
+        r = sd_bus_message_read(signal, "uuh", &major, &minor, &fd);
+        if (r < 0) {
+                log_debug("grdrm: %s/%s: erroneous ResumeDevice signal",
+                          session->name, cm->card.base.name);
+                return 0;
+        }
+
+        /* not our device? */
+        if (makedev(major, minor) != cm->devnum)
+                return 0;
+
+        if (cm->card.fd < 0) {
+                /* This shouldn't happen. We should already own an FD from
+                 * TakeDevice(). However, lets be safe and use this FD in case
+                 * we really don't have one. There is no harm in doing this
+                 * and our code works fine this way. */
+                fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
+                if (fd < 0) {
+                        log_debug("grdrm: %s/%s: cannot duplicate fd: %m",
+                                  session->name, cm->card.base.name);
+                        return 0;
+                }
+
+                r = grdrm_card_open(&cm->card, fd);
+                if (r < 0) {
+                        log_debug("grdrm: %s/%s: cannot open: %s",
+                                  session->name, cm->card.base.name, strerror(-r));
+                        return 0;
+                }
+        }
+
+        cm->master = true;
+        if (cm->card.base.enabled)
+                grdrm_card_enable(&cm->card);
+
+        return 0;
+}
+
+static int managed_card_setup_bus(managed_card *cm) {
+        grdev_session *session = cm->card.base.session;
+        _cleanup_free_ char *match = NULL;
+        int r;
+
+        match = strjoin("type='signal',"
+                        "sender='org.freedesktop.login1',"
+                        "interface='org.freedesktop.login1.Session',"
+                        "member='PauseDevice',"
+                        "path='", session->path, "'",
+                        NULL);
+        if (!match)
+                return -ENOMEM;
+
+        r = sd_bus_add_match(session->context->sysbus,
+                             &cm->slot_pause_device,
+                             match,
+                             managed_card_pause_device_fn,
+                             cm);
+        if (r < 0)
+                return r;
+
+        free(match);
+        match = strjoin("type='signal',"
+                        "sender='org.freedesktop.login1',"
+                        "interface='org.freedesktop.login1.Session',"
+                        "member='ResumeDevice',"
+                        "path='", session->path, "'",
+                        NULL);
+        if (!match)
+                return -ENOMEM;
+
+        r = sd_bus_add_match(session->context->sysbus,
+                             &cm->slot_resume_device,
+                             match,
+                             managed_card_resume_device_fn,
+                             cm);
+        if (r < 0)
+                return r;
+
+        return 0;
+}
+
+static int managed_card_take_device_fn(sd_bus *bus,
+                                       sd_bus_message *reply,
+                                       void *userdata,
+                                       sd_bus_error *ret_error) {
+        managed_card *cm = userdata;
+        grdev_session *session = cm->card.base.session;
+        int r, paused, fd;
+
+        cm->slot_take_device = sd_bus_slot_unref(cm->slot_take_device);
+
+        if (sd_bus_message_is_method_error(reply, NULL)) {
+                const sd_bus_error *error = sd_bus_message_get_error(reply);
+
+                log_debug("grdrm: %s/%s: TakeDevice failed: %s: %s",
+                          session->name, cm->card.base.name, error->name, error->message);
+                return 0;
+        }
+
+        cm->acquired = true;
+
+        r = sd_bus_message_read(reply, "hb", &fd, &paused);
+        if (r < 0) {
+                log_debug("grdrm: %s/%s: erroneous TakeDevice reply",
+                          session->name, cm->card.base.name);
+                return 0;
+        }
+
+        fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
+        if (fd < 0) {
+                log_debug("grdrm: %s/%s: cannot duplicate fd: %m",
+                          session->name, cm->card.base.name);
+                return 0;
+        }
+
+        r = grdrm_card_open(&cm->card, fd);
+        if (r < 0) {
+                log_debug("grdrm: %s/%s: cannot open: %s",
+                          session->name, cm->card.base.name, strerror(-r));
+                return 0;
+        }
+
+        if (!paused && cm->card.base.enabled)
+                grdrm_card_enable(&cm->card);
+
+        return 0;
+}
+
+static void managed_card_take_device(managed_card *cm) {
+        _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
+        grdev_session *session = cm->card.base.session;
+        int r;
+
+        r = sd_bus_message_new_method_call(session->context->sysbus,
+                                           &m,
+                                           "org.freedesktop.login1",
+                                           session->path,
+                                           "org.freedesktop.login1.Session",
+                                           "TakeDevice");
+        if (r < 0)
+                goto error;
+
+        r = sd_bus_message_append(m, "uu", major(cm->devnum), minor(cm->devnum));
+        if (r < 0)
+                goto error;
+
+        r = sd_bus_call_async(session->context->sysbus,
+                              &cm->slot_take_device,
+                              m,
+                              managed_card_take_device_fn,
+                              cm,
+                              0);
+        if (r < 0)
+                goto error;
+
+        cm->requested = true;
+        return;
+
+error:
+        log_debug("grdrm: %s/%s: cannot send TakeDevice request: %s",
+                  session->name, cm->card.base.name, strerror(-r));
+}
+
+static void managed_card_release_device(managed_card *cm) {
+        _cleanup_bus_message_unref_ sd_bus_message *m = NULL;
+        grdev_session *session = cm->card.base.session;
+        int r;
+
+        /*
+         * If TakeDevice() is pending or was successful, make sure to
+         * release the device again. We don't care for return-values,
+         * so send it without waiting or callbacks.
+         * If a failed TakeDevice() is pending, but someone else took
+         * the device on the same bus-connection, we might incorrectly
+         * release their device. This is an unlikely race, though.
+         * Furthermore, you really shouldn't have two users of the
+         * controller-API on the same session, on the same devices, *AND* on
+         * the same bus-connection. So we don't care for that race..
+         */
+
+        grdrm_card_close(&cm->card);
+        cm->requested = false;
+
+        if (!cm->acquired && !cm->slot_take_device)
+                return;
+
+        cm->slot_take_device = sd_bus_slot_unref(cm->slot_take_device);
+        cm->acquired = false;
+
+        r = sd_bus_message_new_method_call(session->context->sysbus,
+                                           &m,
+                                           "org.freedesktop.login1",
+                                           session->path,
+                                           "org.freedesktop.login1.Session",
+                                           "ReleaseDevice");
+        if (r >= 0) {
+                r = sd_bus_message_append(m, "uu", major(cm->devnum), minor(cm->devnum));
+                if (r >= 0)
+                        r = sd_bus_send(session->context->sysbus, m, NULL);
+        }
+
+        if (r < 0 && r != -ENOTCONN)
+                log_debug("grdrm: %s/%s: cannot send ReleaseDevice: %s",
+                          session->name, cm->card.base.name, strerror(-r));
+}
+
+static int managed_card_new(grdev_card **out, grdev_session *session, struct udev_device *ud) {
+        _cleanup_(grdev_card_freep) grdev_card *basecard = NULL;
+        char name[GRDRM_CARD_NAME_MAX];
+        managed_card *cm;
+        dev_t devnum;
+        int r;
+
+        assert_return(session, -EINVAL);
+        assert_return(session->managed, -EINVAL);
+        assert_return(session->context->sysbus, -EINVAL);
+        assert_return(ud, -EINVAL);
+
+        devnum = udev_device_get_devnum(ud);
+        if (devnum == 0)
+                return -ENODEV;
+
+        grdrm_name(name, devnum);
+
+        cm = new0(managed_card, 1);
+        if (!cm)
+                return -ENOMEM;
+
+        basecard = &cm->card.base;
+        cm->card = GRDRM_CARD_INIT(&managed_card_vtable, session);
+        cm->devnum = devnum;
+
+        r = managed_card_setup_bus(cm);
+        if (r < 0)
+                return r;
+
+        r = grdrm_card_add(&cm->card, name);
+        if (r < 0)
+                return r;
+
+        managed_card_take_device(cm);
+
+        if (out)
+                *out = basecard;
+        basecard = NULL;
+        return 0;
+}
+
+static void managed_card_free(grdev_card *basecard) {
+        managed_card *cm = managed_card_from_base(basecard);
+
+        assert(!basecard->enabled);
+
+        managed_card_release_device(cm);
+        cm->slot_resume_device = sd_bus_slot_unref(cm->slot_resume_device);
+        cm->slot_pause_device = sd_bus_slot_unref(cm->slot_pause_device);
+        grdrm_card_destroy(&cm->card);
+        free(cm);
+}
+
+static const grdev_card_vtable managed_card_vtable = {
+        .free                   = managed_card_free,
+        .enable                 = managed_card_enable,
+        .disable                = managed_card_disable,
+        .commit                 = grdrm_card_commit,
+        .restore                = grdrm_card_restore,
+};
+
+/*
+ * Generic Constructor
+ * Instead of relying on the caller to choose between managed and unmanaged
+ * DRM devices, the grdev_drm_new() constructor does that for you (by
+ * looking at session->managed).
+ */
+
+bool grdev_is_drm_card(grdev_card *basecard) {
+        return basecard && (basecard->vtable == &unmanaged_card_vtable ||
+                            basecard->vtable == &managed_card_vtable);
+}
+
+grdev_card *grdev_find_drm_card(grdev_session *session, dev_t devnum) {
+        char name[GRDRM_CARD_NAME_MAX];
+
+        assert_return(session, NULL);
+        assert_return(devnum != 0, NULL);
+
+        grdrm_name(name, devnum);
+        return grdev_find_card(session, name);
+}
+
+int grdev_drm_card_new(grdev_card **out, grdev_session *session, struct udev_device *ud) {
+        assert_return(session, -EINVAL);
+        assert_return(ud, -EINVAL);
+
+        return session->managed ? managed_card_new(out, session, ud) : unmanaged_card_new(out, session, ud);
+}
index 7e69c49..0064f0b 100644 (file)
@@ -22,6 +22,7 @@
 #pragma once
 
 #include <inttypes.h>
+#include <libudev.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <systemd/sd-bus.h>
@@ -40,6 +41,14 @@ typedef struct grdev_card_vtable        grdev_card_vtable;
 typedef struct grdev_card               grdev_card;
 
 /*
+ * DRM cards
+ */
+
+bool grdev_is_drm_card(grdev_card *card);
+grdev_card *grdev_find_drm_card(grdev_session *session, dev_t devnum);
+int grdev_drm_card_new(grdev_card **out, grdev_session *session, struct udev_device *ud);
+
+/*
  * Displays
  */
 
index ab1c407..1e02a67 100644 (file)
@@ -20,6 +20,7 @@
 ***/
 
 #include <inttypes.h>
+#include <libudev.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <systemd/sd-bus.h>
@@ -30,6 +31,7 @@
 #include "hashmap.h"
 #include "login-shared.h"
 #include "macro.h"
+#include "udev-util.h"
 #include "util.h"
 
 static void pipe_enable(grdev_pipe *pipe);
@@ -1083,6 +1085,68 @@ void grdev_session_restore(grdev_session *session) {
                         card->vtable->restore(card);
 }
 
+void grdev_session_add_drm(grdev_session *session, struct udev_device *ud) {
+        grdev_card *card;
+        dev_t devnum;
+        int r;
+
+        assert(session);
+        assert(ud);
+
+        devnum = udev_device_get_devnum(ud);
+        if (devnum == 0)
+                return;
+
+        card = grdev_find_drm_card(session, devnum);
+        if (card)
+                return;
+
+        r = grdev_drm_card_new(&card, session, ud);
+        if (r < 0) {
+                log_debug("grdev: %s: cannot add DRM device for %s: %s",
+                          session->name, udev_device_get_syspath(ud), strerror(-r));
+                return;
+        }
+
+        session_add_card(session, card);
+}
+
+void grdev_session_remove_drm(grdev_session *session, struct udev_device *ud) {
+        grdev_card *card;
+        dev_t devnum;
+
+        assert(session);
+        assert(ud);
+
+        devnum = udev_device_get_devnum(ud);
+        if (devnum == 0)
+                return;
+
+        card = grdev_find_drm_card(session, devnum);
+        if (!card)
+                return;
+
+        session_remove_card(session, card);
+}
+
+void grdev_session_hotplug_drm(grdev_session *session, struct udev_device *ud) {
+        grdev_card *card;
+        dev_t devnum;
+
+        assert(session);
+        assert(ud);
+
+        devnum = udev_device_get_devnum(ud);
+        if (devnum == 0)
+                return;
+
+        card = grdev_find_drm_card(session, devnum);
+        if (!card)
+                return;
+
+        /* TODO: hotplug card */
+}
+
 static void session_configure(grdev_session *session) {
         grdev_display *display;
         grdev_tile *tile;
index 2645b12..9924a25 100644 (file)
@@ -55,6 +55,7 @@
 
 #include <drm_fourcc.h>
 #include <inttypes.h>
+#include <libudev.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <systemd/sd-bus.h>
@@ -171,6 +172,10 @@ void grdev_session_disable(grdev_session *session);
 void grdev_session_commit(grdev_session *session);
 void grdev_session_restore(grdev_session *session);
 
+void grdev_session_add_drm(grdev_session *session, struct udev_device *ud);
+void grdev_session_remove_drm(grdev_session *session, struct udev_device *ud);
+void grdev_session_hotplug_drm(grdev_session *session, struct udev_device *ud);
+
 /*
  * Contexts
  */