From f22e0bce3732c1fd005b7a886042394e036bc1b3 Mon Sep 17 00:00:00 2001

From: David Herrmann <dh.herrmann@gmail.com>

Date: Fri, 19 Sep 2014 14:13:06 +0200

Subject: [PATCH] terminal: add grdev DRM backend

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                              |    1 +

 src/libsystemd-terminal/grdev-drm.c      | 2957 ++++++++++++++++++++++++++++++

 src/libsystemd-terminal/grdev-internal.h |    9 +

 src/libsystemd-terminal/grdev.c          |   64 +

 src/libsystemd-terminal/grdev.h          |    5 +

 5 files changed, 3036 insertions(+)

 create mode 100644 src/libsystemd-terminal/grdev-drm.c

diff --git a/Makefile.am b/Makefile.am

index 1931c5d96b..be25023c75 100644

--- a/Makefile.am

+++ b/Makefile.am

@@ -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

index 0000000000..3481584fbf

--- /dev/null

+++ b/src/libsystemd-terminal/grdev-drm.c

@@ -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);