***/
#include <inttypes.h>
+#include <libudev.h>
#include <stdbool.h>
#include <stdlib.h>
#include <systemd/sd-bus.h>
#include "hashmap.h"
#include "login-shared.h"
#include "macro.h"
+#include "udev-util.h"
#include "util.h"
static void pipe_enable(grdev_pipe *pipe);
}
#define TILE_FOREACH(_root, _i) \
- for (_i = tile_leftmost(_root); _i; _i = tile_leftmost(_i->childs_by_node_next) ? : _i->parent)
+ for (_i = tile_leftmost(_root); _i; _i = tile_leftmost(_i->children_by_node_next) ? : _i->parent)
#define TILE_FOREACH_SAFE(_root, _i, _next) \
- for (_i = tile_leftmost(_root); _i && ((_next = tile_leftmost(_i->childs_by_node_next) ? : _i->parent), true); _i = _next)
+ for (_i = tile_leftmost(_root); _i && ((_next = tile_leftmost(_i->children_by_node_next) ? : _i->parent), true); _i = _next)
static void tile_link(grdev_tile *tile, grdev_tile *parent) {
grdev_display *display;
assert(!display || !display->enabled);
- ++parent->node.n_childs;
- LIST_PREPEND(childs_by_node, parent->node.child_list, tile);
+ ++parent->node.n_children;
+ LIST_PREPEND(children_by_node, parent->node.child_list, tile);
tile->parent = parent;
if (display) {
assert(parent->type == GRDEV_TILE_NODE);
assert(parent->display == display);
- assert(parent->node.n_childs > 0);
+ assert(parent->node.n_children > 0);
- --parent->node.n_childs;
- LIST_REMOVE(childs_by_node, parent->node.child_list, tile);
+ --parent->node.n_children;
+ LIST_REMOVE(children_by_node, parent->node.child_list, tile);
tile->parent = NULL;
if (display) {
* we must take care to not leave them around. Therefore, whenever we
* unlink any part of a tree, we also destroy the parent, in case it's
* now stale.
- * Parents are stale if they have no childs and either have no display
+ * Parents are stale if they have no children and either have no display
* or if they are intermediate nodes (i.e, they have a parent).
* This means, you can easily create trees, but you can never partially
* move or destruct them so far. They're always reduced to minimal form
* if you cut them. This might change later, but so far we didn't need
* partial destruction or the ability to move whole trees. */
- if (parent->node.n_childs < 1 && (parent->parent || !parent->display))
+ if (parent->node.n_children < 1 && (parent->parent || !parent->display))
grdev_tile_free(parent);
}
_cleanup_(grdev_tile_freep) grdev_tile *tile = NULL;
int r;
+ assert_return(out, -EINVAL);
assert_return(pipe, -EINVAL);
assert_return(!pipe->tile, -EINVAL);
case GRDEV_TILE_NODE:
assert(!tile->parent);
assert(!tile->display);
- assert(tile->node.n_childs == 0);
+ assert(tile->node.n_children == 0);
break;
}
return NULL;
}
+void grdev_display_set_userdata(grdev_display *display, void *userdata) {
+ assert(display);
+
+ display->userdata = userdata;
+}
+
+void *grdev_display_get_userdata(grdev_display *display) {
+ assert_return(display, NULL);
+
+ return display->userdata;
+}
+
+const char *grdev_display_get_name(grdev_display *display) {
+ assert_return(display, NULL);
+
+ return display->name;
+}
+
bool grdev_display_is_enabled(grdev_display *display) {
return display && display->enabled;
}
assert(cache->pipe->tile->display == display);
assert(display->pipes >= cache);
- idx = (cache - display->pipes) / sizeof(*cache) + 1;
+ idx = cache - display->pipes + 1;
} else {
idx = 0;
}
assert(display);
- /* depth-first with childs before parent */
+ /* depth-first with children before parent */
for (tile = tile_leftmost(display->tile);
tile;
- tile = tile_leftmost(tile->childs_by_node_next) ? : tile->parent) {
+ tile = tile_leftmost(tile->children_by_node_next) ? : tile->parent) {
if (tile->type == GRDEV_TILE_LEAF) {
grdev_pipe *p;
} else {
grdev_tile *child, *l;
- /* We're now at a node with all it's childs already
+ /* We're now at a node with all its children already
* computed (depth-first, child before parent). We
* first need to know the size of our tile, then we
* recurse into all leafs and update their cache. */
tile->cache_w = 0;
tile->cache_h = 0;
- LIST_FOREACH(childs_by_node, child, tile->node.child_list) {
+ LIST_FOREACH(children_by_node, child, tile->node.child_list) {
if (child->x + child->cache_w > tile->cache_w)
tile->cache_w = child->x + child->cache_w;
if (child->y + child->cache_h > tile->cache_h)
return hashmap_get(card->pipe_map, name);
}
+static int pipe_vsync_fn(sd_event_source *src, uint64_t usec, void *userdata) {
+ grdev_pipe *pipe = userdata;
+
+ grdev_pipe_frame(pipe);
+ return 0;
+}
+
int grdev_pipe_add(grdev_pipe *pipe, const char *name, size_t n_fbs) {
int r;
assert_return(!pipe->cache, -EINVAL);
assert_return(pipe->width > 0, -EINVAL);
assert_return(pipe->height > 0, -EINVAL);
+ assert_return(pipe->vrefresh > 0, -EINVAL);
assert_return(!pipe->enabled, -EINVAL);
assert_return(!pipe->running, -EINVAL);
assert_return(name, -EINVAL);
if (r < 0)
return r;
+ r = sd_event_add_time(pipe->card->session->context->event,
+ &pipe->vsync_src,
+ CLOCK_MONOTONIC,
+ 0,
+ 10 * USEC_PER_MSEC,
+ pipe_vsync_fn,
+ pipe);
+ if (r < 0)
+ return r;
+
+ r = sd_event_source_set_enabled(pipe->vsync_src, SD_EVENT_OFF);
+ if (r < 0)
+ return r;
+
r = hashmap_put(pipe->card->pipe_map, pipe->name, pipe);
if (r < 0)
return r;
tmp = *pipe;
pipe->vtable->free(pipe);
+ sd_event_source_unref(tmp.vsync_src);
grdev_tile_free(tmp.tile);
card_modified(tmp.card);
free(tmp.fbs);
pipe->running = running;
/* runtime events for unused pipes are not interesting */
- if (pipe->cache) {
+ if (pipe->cache && pipe->enabled) {
grdev_display *display = pipe->tile->display;
assert(display);
- if (running) {
- if (pipe->enabled)
- session_frame(display->session, display);
- } else {
+ if (running)
+ session_frame(display->session, display);
+ else
pipe->cache->incomplete = true;
- }
}
}
assert(pipe);
/* if pipe is unused, ignore any frame events */
- if (!pipe->cache)
+ if (!pipe->cache || !pipe->enabled)
return;
display = pipe->tile->display;
assert(display);
- if (pipe->enabled)
- session_frame(display->session, display);
+ grdev_pipe_schedule(pipe, 0);
+ session_frame(display->session, display);
+}
+
+void grdev_pipe_schedule(grdev_pipe *pipe, uint64_t frames) {
+ int r;
+ uint64_t ts;
+
+ if (!frames) {
+ sd_event_source_set_enabled(pipe->vsync_src, SD_EVENT_OFF);
+ return;
+ }
+
+ r = sd_event_now(pipe->card->session->context->event, CLOCK_MONOTONIC, &ts);
+ if (r < 0)
+ goto error;
+
+ ts += frames * USEC_PER_MSEC * 1000ULL / pipe->vrefresh;
+
+ r = sd_event_source_set_time(pipe->vsync_src, ts);
+ if (r < 0)
+ goto error;
+
+ r = sd_event_source_set_enabled(pipe->vsync_src, SD_EVENT_ONESHOT);
+ if (r < 0)
+ goto error;
+
+ return;
+
+error:
+ log_debug("grdev: %s/%s/%s: cannot schedule vsync timer: %s",
+ pipe->card->session->name, pipe->card->name, pipe->name, strerror(-r));
}
/*
changed = display_cache(display);
- if (display->n_leafs == 0)
+ if (display->n_leafs == 0) {
session_remove_display(session, display);
- else if (!display->public)
+ } else if (!display->public) {
session_add_display(session, display);
- else if (changed)
+ session_frame(session, display);
+ } else if (changed) {
session_raise_display_change(session, display);
- else if (display->framed)
session_frame(session, display);
+ } else if (display->framed) {
+ session_frame(session, display);
+ }
}
static void session_frame(grdev_session *session, grdev_display *display) {
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 grdev_session_hotplug_drm(session, ud);
+
+ 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 grdev_session_hotplug_drm(session, ud);
+
+ 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 = NULL;
+ struct udev_device *p;
+ dev_t devnum;
+
+ assert(session);
+ assert(ud);
+
+ for (p = ud; p; p = udev_device_get_parent_with_subsystem_devtype(p, "drm", NULL)) {
+ devnum = udev_device_get_devnum(ud);
+ if (devnum == 0)
+ continue;
+
+ card = grdev_find_drm_card(session, devnum);
+ if (card)
+ break;
+ }
+
+ if (!card)
+ return;
+
+ grdev_drm_card_hotplug(card, ud);
+}
+
static void session_configure(grdev_session *session) {
grdev_display *display;
grdev_tile *tile;
~ianmdlvl / elogind.git / blobdiff