diff options
Diffstat (limited to 'src')
| -rw-r--r-- | src/libsystemd-terminal/grdev-internal.h | 237 | ||||
| -rw-r--r-- | src/libsystemd-terminal/grdev.c | 1219 | ||||
| -rw-r--r-- | src/libsystemd-terminal/grdev.h | 182 |
3 files changed, 1638 insertions, 0 deletions
diff --git a/src/libsystemd-terminal/grdev-internal.h b/src/libsystemd-terminal/grdev-internal.h new file mode 100644 index 0000000000..7e69c49b63 --- /dev/null +++ b/src/libsystemd-terminal/grdev-internal.h @@ -0,0 +1,237 @@ +/*-*- 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/>. +***/ + +#pragma once + +#include <inttypes.h> +#include <stdbool.h> +#include <stdlib.h> +#include <systemd/sd-bus.h> +#include <systemd/sd-event.h> +#include "grdev.h" +#include "hashmap.h" +#include "list.h" +#include "util.h" + +typedef struct grdev_tile grdev_tile; +typedef struct grdev_display_cache grdev_display_cache; + +typedef struct grdev_pipe_vtable grdev_pipe_vtable; +typedef struct grdev_pipe grdev_pipe; +typedef struct grdev_card_vtable grdev_card_vtable; +typedef struct grdev_card grdev_card; + +/* + * Displays + */ + +enum { + GRDEV_TILE_LEAF, + GRDEV_TILE_NODE, + GRDEV_TILE_CNT +}; + +struct grdev_tile { + LIST_FIELDS(grdev_tile, childs_by_node); + grdev_tile *parent; + grdev_display *display; + + uint32_t x; + uint32_t y; + unsigned int rotate; + unsigned int flip; + uint32_t cache_w; + uint32_t cache_h; + + unsigned int type; + + union { + struct { + grdev_pipe *pipe; + } leaf; + + struct { + size_t n_childs; + LIST_HEAD(grdev_tile, child_list); + } node; + }; +}; + +int grdev_tile_new_leaf(grdev_tile **out, grdev_pipe *pipe); +int grdev_tile_new_node(grdev_tile **out); +grdev_tile *grdev_tile_free(grdev_tile *tile); + +DEFINE_TRIVIAL_CLEANUP_FUNC(grdev_tile*, grdev_tile_free); + +struct grdev_display { + grdev_session *session; + char *name; + + size_t n_leafs; + grdev_tile *tile; + + size_t n_pipes; + size_t max_pipes; + + uint32_t width; + uint32_t height; + + struct grdev_display_cache { + grdev_pipe *pipe; + grdev_display_target target; + + bool incomplete : 1; + } *pipes; + + bool enabled : 1; + bool public : 1; + bool modified : 1; + bool framed : 1; +}; + +grdev_display *grdev_find_display(grdev_session *session, const char *name); + +int grdev_display_new(grdev_display **out, grdev_session *session, const char *name); +grdev_display *grdev_display_free(grdev_display *display); + +DEFINE_TRIVIAL_CLEANUP_FUNC(grdev_display*, grdev_display_free); + +/* + * Pipes + */ + +struct grdev_pipe_vtable { + void (*free) (grdev_pipe *pipe); + void (*enable) (grdev_pipe *pipe); + void (*disable) (grdev_pipe *pipe); + grdev_fb *(*target) (grdev_pipe *pipe); +}; + +struct grdev_pipe { + const grdev_pipe_vtable *vtable; + grdev_card *card; + char *name; + + grdev_tile *tile; + grdev_display_cache *cache; + + uint32_t width; + uint32_t height; + + size_t max_fbs; + grdev_fb *front; + grdev_fb *back; + grdev_fb **fbs; + + bool enabled : 1; + bool running : 1; + bool flip : 1; + bool flipping : 1; +}; + +#define GRDEV_PIPE_INIT(_vtable, _card) ((grdev_pipe){ \ + .vtable = (_vtable), \ + .card = (_card), \ + }) + +grdev_pipe *grdev_find_pipe(grdev_card *card, const char *name); + +int grdev_pipe_add(grdev_pipe *pipe, const char *name, size_t n_fbs); +grdev_pipe *grdev_pipe_free(grdev_pipe *pipe); + +DEFINE_TRIVIAL_CLEANUP_FUNC(grdev_pipe*, grdev_pipe_free); + +void grdev_pipe_ready(grdev_pipe *pipe, bool running); +void grdev_pipe_frame(grdev_pipe *pipe); + +/* + * Cards + */ + +struct grdev_card_vtable { + void (*free) (grdev_card *card); + void (*enable) (grdev_card *card); + void (*disable) (grdev_card *card); + void (*commit) (grdev_card *card); + void (*restore) (grdev_card *card); +}; + +struct grdev_card { + const grdev_card_vtable *vtable; + grdev_session *session; + char *name; + + Hashmap *pipe_map; + + bool enabled : 1; + bool modified : 1; +}; + +#define GRDEV_CARD_INIT(_vtable, _session) ((grdev_card){ \ + .vtable = (_vtable), \ + .session = (_session), \ + }) + +grdev_card *grdev_find_card(grdev_session *session, const char *name); + +int grdev_card_add(grdev_card *card, const char *name); +grdev_card *grdev_card_free(grdev_card *card); + +DEFINE_TRIVIAL_CLEANUP_FUNC(grdev_card*, grdev_card_free); + +/* + * Sessions + */ + +struct grdev_session { + grdev_context *context; + char *name; + char *path; + grdev_event_fn event_fn; + void *userdata; + + unsigned long n_pins; + + Hashmap *card_map; + Hashmap *display_map; + + bool custom : 1; + bool managed : 1; + bool enabled : 1; + bool modified : 1; +}; + +grdev_session *grdev_session_pin(grdev_session *session); +grdev_session *grdev_session_unpin(grdev_session *session); + +DEFINE_TRIVIAL_CLEANUP_FUNC(grdev_session*, grdev_session_unpin); + +/* + * Contexts + */ + +struct grdev_context { + unsigned long ref; + sd_event *event; + sd_bus *sysbus; + + Hashmap *session_map; +}; diff --git a/src/libsystemd-terminal/grdev.c b/src/libsystemd-terminal/grdev.c new file mode 100644 index 0000000000..ab1c407ecb --- /dev/null +++ b/src/libsystemd-terminal/grdev.c @@ -0,0 +1,1219 @@ +/*-*- 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 <inttypes.h> +#include <stdbool.h> +#include <stdlib.h> +#include <systemd/sd-bus.h> +#include <systemd/sd-event.h> +#include <systemd/sd-login.h> +#include "grdev.h" +#include "grdev-internal.h" +#include "hashmap.h" +#include "login-shared.h" +#include "macro.h" +#include "util.h" + +static void pipe_enable(grdev_pipe *pipe); +static void pipe_disable(grdev_pipe *pipe); +static void card_modified(grdev_card *card); +static void session_frame(grdev_session *session, grdev_display *display); + +/* + * Displays + */ + +static inline grdev_tile *tile_leftmost(grdev_tile *tile) { + if (!tile) + return NULL; + + while (tile->type == GRDEV_TILE_NODE && tile->node.child_list) + tile = tile->node.child_list; + + return tile; +} + +#define TILE_FOREACH(_root, _i) \ + for (_i = tile_leftmost(_root); _i; _i = tile_leftmost(_i->childs_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) + +static void tile_link(grdev_tile *tile, grdev_tile *parent) { + grdev_display *display; + grdev_tile *t; + + assert(tile); + assert(!tile->parent); + assert(!tile->display); + assert(parent); + assert(parent->type == GRDEV_TILE_NODE); + + display = parent->display; + + assert(!display || !display->enabled); + + ++parent->node.n_childs; + LIST_PREPEND(childs_by_node, parent->node.child_list, tile); + tile->parent = parent; + + if (display) { + display->modified = true; + TILE_FOREACH(tile, t) { + t->display = display; + if (t->type == GRDEV_TILE_LEAF) { + ++display->n_leafs; + if (display->enabled) + pipe_enable(t->leaf.pipe); + } + } + } +} + +static void tile_unlink(grdev_tile *tile) { + grdev_tile *parent, *t; + grdev_display *display; + + assert(tile); + + display = tile->display; + parent = tile->parent; + if (!parent) { + assert(!display); + return; + } + + assert(parent->type == GRDEV_TILE_NODE); + assert(parent->display == display); + assert(parent->node.n_childs > 0); + + --parent->node.n_childs; + LIST_REMOVE(childs_by_node, parent->node.child_list, tile); + tile->parent = NULL; + + if (display) { + display->modified = true; + TILE_FOREACH(tile, t) { + t->display = NULL; + if (t->type == GRDEV_TILE_LEAF) { + --display->n_leafs; + t->leaf.pipe->cache = NULL; + pipe_disable(t->leaf.pipe); + } + } + } + + /* Tile trees are driven by leafs. Internal nodes have no owner, thus, + * 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 + * 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)) + grdev_tile_free(parent); +} + +static int tile_new(grdev_tile **out) { + _cleanup_(grdev_tile_freep) grdev_tile *tile = NULL; + + assert(out); + + tile = new0(grdev_tile, 1); + if (!tile) + return -ENOMEM; + + tile->type = (unsigned)-1; + + *out = tile; + tile = NULL; + return 0; +} + +int grdev_tile_new_leaf(grdev_tile **out, grdev_pipe *pipe) { + _cleanup_(grdev_tile_freep) grdev_tile *tile = NULL; + int r; + + assert_return(pipe, -EINVAL); + assert_return(!pipe->tile, -EINVAL); + + r = tile_new(&tile); + if (r < 0) + return r; + + tile->type = GRDEV_TILE_LEAF; + tile->leaf.pipe = pipe; + + if (out) + *out = tile; + tile = NULL; + return 0; +} + +int grdev_tile_new_node(grdev_tile **out) { + _cleanup_(grdev_tile_freep) grdev_tile *tile = NULL; + int r; + + assert_return(out, -EINVAL); + + r = tile_new(&tile); + if (r < 0) + return r; + + tile->type = GRDEV_TILE_NODE; + + *out = tile; + tile = NULL; + return 0; +} + +grdev_tile *grdev_tile_free(grdev_tile *tile) { + if (!tile) + return NULL; + + tile_unlink(tile); + + switch (tile->type) { + case GRDEV_TILE_LEAF: + assert(!tile->parent); + assert(!tile->display); + assert(tile->leaf.pipe); + + break; + case GRDEV_TILE_NODE: + assert(!tile->parent); + assert(!tile->display); + assert(tile->node.n_childs == 0); + + break; + } + + free(tile); + + return NULL; +} + +grdev_display *grdev_find_display(grdev_session *session, const char *name) { + assert_return(session, NULL); + assert_return(name, NULL); + + return hashmap_get(session->display_map, name); +} + +int grdev_display_new(grdev_display **out, grdev_session *session, const char *name) { + _cleanup_(grdev_display_freep) grdev_display *display = NULL; + int r; + + assert(session); + assert(name); + + display = new0(grdev_display, 1); + if (!display) + return -ENOMEM; + + display->session = session; + + display->name = strdup(name); + if (!display->name) + return -ENOMEM; + + r = grdev_tile_new_node(&display->tile); + if (r < 0) + return r; + + display->tile->display = display; + + r = hashmap_put(session->display_map, display->name, display); + if (r < 0) + return r; + + if (out) + *out = display; + display = NULL; + return 0; +} + +grdev_display *grdev_display_free(grdev_display *display) { + if (!display) + return NULL; + + assert(!display->public); + assert(!display->enabled); + assert(!display->modified); + assert(display->n_leafs == 0); + assert(display->n_pipes == 0); + + if (display->name) + hashmap_remove_value(display->session->display_map, display->name, display); + + if (display->tile) { + display->tile->display = NULL; + grdev_tile_free(display->tile); + } + + free(display->pipes); + free(display->name); + free(display); + + return NULL; +} + +bool grdev_display_is_enabled(grdev_display *display) { + return display && display->enabled; +} + +void grdev_display_enable(grdev_display *display) { + grdev_tile *t; + + assert(display); + + if (!display->enabled) { + display->enabled = true; + TILE_FOREACH(display->tile, t) + if (t->type == GRDEV_TILE_LEAF) + pipe_enable(t->leaf.pipe); + } +} + +void grdev_display_disable(grdev_display *display) { + grdev_tile *t; + + assert(display); + + if (display->enabled) { + display->enabled = false; + TILE_FOREACH(display->tile, t) + if (t->type == GRDEV_TILE_LEAF) + pipe_disable(t->leaf.pipe); + } +} + +const grdev_display_target *grdev_display_next_target(grdev_display *display, const grdev_display_target *prev, uint64_t minage) { + grdev_display_cache *cache; + size_t idx; + + assert_return(display, NULL); + assert_return(!display->modified, NULL); + assert_return(display->enabled, NULL); + + if (prev) { + cache = container_of(prev, grdev_display_cache, target); + + assert(cache->pipe); + assert(cache->pipe->tile->display == display); + assert(display->pipes >= cache); + + idx = (cache - display->pipes) / sizeof(*cache) + 1; + } else { + idx = 0; + } + + for (cache = display->pipes + idx; idx < display->n_pipes; ++idx, ++cache) { + grdev_display_target *target; + grdev_pipe *pipe; + grdev_fb *fb; + + pipe = cache->pipe; + target = &cache->target; + + if (!pipe->running || !pipe->enabled) + continue; + + /* if front-buffer is up-to-date, there's nothing to do */ + if (minage > 0 && pipe->front && pipe->front->age >= minage) + continue; + + /* find suitable back-buffer */ + if (!(fb = pipe->back)) { + if (!pipe->vtable->target || !(fb = pipe->vtable->target(pipe))) + continue; + } + + /* if back-buffer is up-to-date, schedule flip */ + if (minage > 0 && fb->age >= minage) { + grdev_display_flip_target(display, target, fb->age); + continue; + } + + /* we have an out-of-date back-buffer; return for redraw */ + target->fb = fb; + return target; + } + + return NULL; +} + +void grdev_display_flip_target(grdev_display *display, const grdev_display_target *target, uint64_t age) { + grdev_display_cache *cache; + size_t i; + + assert(display); + assert(!display->modified); + assert(display->enabled); + assert(target); + assert(target->fb); + + cache = container_of(target, grdev_display_cache, target); + + assert(cache->pipe); + assert(cache->pipe->tile->display == display); + + /* reset age of all FB on overflow */ + if (age < target->fb->age) + for (i = 0; i < cache->pipe->max_fbs; ++i) + if (cache->pipe->fbs[i]) + cache->pipe->fbs[i]->age = 0; + + ((grdev_fb*)target->fb)->age = age; + cache->pipe->flip = true; +} + +static void display_cache_apply(grdev_display_cache *c, grdev_tile *l) { + uint32_t x, y, width, height; + grdev_display_target *t; + + assert(c); + assert(l); + assert(l->cache_w >= c->target.width + c->target.x); + assert(l->cache_h >= c->target.height + c->target.y); + + t = &c->target; + + /* rotate child */ + + t->rotate = (t->rotate + l->rotate) & 0x3; + + x = t->x; + y = t->y; + width = t->width; + height = t->height; + + switch (l->rotate) { + case GRDEV_ROTATE_0: + break; + case GRDEV_ROTATE_90: + t->x = l->cache_h - (height + y); + t->y = x; + t->width = height; + t->height = width; + break; + case GRDEV_ROTATE_180: + t->x = l->cache_w - (width + x); + t->y = l->cache_h - (height + y); + break; + case GRDEV_ROTATE_270: + t->x = y; + t->y = l->cache_w - (width + x); + t->width = height; + t->height = width; + break; + } + + /* flip child */ + + t->flip ^= l->flip; + + if (l->flip & GRDEV_FLIP_HORIZONTAL) + t->x = l->cache_w - (t->width + t->x); + if (l->flip & GRDEV_FLIP_VERTICAL) + t->y = l->cache_h - (t->height + t->y); + + /* move child */ + + t->x += l->x; + t->y += l->y; +} + +static void display_cache_targets(grdev_display *display) { + grdev_display_cache *c; + grdev_tile *tile; + + assert(display); + + /* depth-first with childs before parent */ + for (tile = tile_leftmost(display->tile); + tile; + tile = tile_leftmost(tile->childs_by_node_next) ? : tile->parent) { + if (tile->type == GRDEV_TILE_LEAF) { + grdev_pipe *p; + + /* We're at a leaf and no parent has been cached, yet. + * Copy the pipe information into the target cache and + * update our global pipe-caches if required. */ + + assert(tile->leaf.pipe); + assert(display->n_pipes + 1 <= display->max_pipes); + + p = tile->leaf.pipe; + c = &display->pipes[display->n_pipes++]; + + zero(*c); + c->pipe = p; + c->pipe->cache = c; + c->target.width = p->width; + c->target.height = p->height; + tile->cache_w = p->width; + tile->cache_h = p->height; + + /* all new tiles are incomplete due to geometry changes */ + c->incomplete = true; + + display_cache_apply(c, tile); + } else { + grdev_tile *child, *l; + + /* We're now at a node with all it's childs 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) { + 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) + tile->cache_h = child->y + child->cache_h; + } + + assert(tile->cache_w > 0); + assert(tile->cache_h > 0); + + TILE_FOREACH(tile, l) + if (l->type == GRDEV_TILE_LEAF) + display_cache_apply(l->leaf.pipe->cache, tile); + } + } +} + +static bool display_cache(grdev_display *display) { + grdev_tile *tile; + size_t n; + void *t; + int r; + + assert(display); + + if (!display->modified) + return false; + + display->modified = false; + display->framed = false; + display->n_pipes = 0; + display->width = 0; + display->height = 0; + + if (display->n_leafs < 1) + return false; + + TILE_FOREACH(display->tile, tile) + if (tile->type == GRDEV_TILE_LEAF) + tile->leaf.pipe->cache = NULL; + + if (display->n_leafs > display->max_pipes) { + n = ALIGN_POWER2(display->n_leafs); + if (!n) { + r = -ENOMEM; + goto out; + } + + t = realloc_multiply(display->pipes, sizeof(*display->pipes), n); + if (!t) { + r = -ENOMEM; + goto out; + } + + display->pipes = t; + display->max_pipes = n; + } + + display_cache_targets(display); + + r = 0; + +out: + if (r < 0) + log_debug("grdev: %s/%s: cannot cache pipes: %s", + display->session->name, display->name, strerror(-r)); + return true; +} + +/* + * Pipes + */ + +grdev_pipe *grdev_find_pipe(grdev_card *card, const char *name) { + assert_return(card, NULL); + assert_return(name, NULL); + + return hashmap_get(card->pipe_map, name); +} + +int grdev_pipe_add(grdev_pipe *pipe, const char *name, size_t n_fbs) { + int r; + + assert_return(pipe, -EINVAL); + assert_return(pipe->vtable, -EINVAL); + assert_return(pipe->vtable->free, -EINVAL); + assert_return(pipe->card, -EINVAL); + assert_return(pipe->card->session, -EINVAL); + assert_return(!pipe->cache, -EINVAL); + assert_return(pipe->width > 0, -EINVAL); + assert_return(pipe->height > 0, -EINVAL); + assert_return(!pipe->enabled, -EINVAL); + assert_return(!pipe->running, -EINVAL); + assert_return(name, -EINVAL); + + pipe->name = strdup(name); + if (!pipe->name) + return -ENOMEM; + + if (n_fbs > 0) { + pipe->fbs = new0(grdev_fb*, n_fbs); + if (!pipe->fbs) + return -ENOMEM; + + pipe->max_fbs = n_fbs; + } + + r = grdev_tile_new_leaf(&pipe->tile, pipe); + if (r < 0) + return r; + + r = hashmap_put(pipe->card->pipe_map, pipe->name, pipe); + if (r < 0) + return r; + + card_modified(pipe->card); + return 0; +} + +grdev_pipe *grdev_pipe_free(grdev_pipe *pipe) { + grdev_pipe tmp; + + if (!pipe) + return NULL; + + assert(pipe->card); + assert(pipe->vtable); + assert(pipe->vtable->free); + + if (pipe->name) + hashmap_remove_value(pipe->card->pipe_map, pipe->name, pipe); + if (pipe->tile) + tile_unlink(pipe->tile); + + assert(!pipe->cache); + + tmp = *pipe; + pipe->vtable->free(pipe); + + grdev_tile_free(tmp.tile); + card_modified(tmp.card); + free(tmp.fbs); + free(tmp.name); + + return NULL; +} + +static void pipe_enable(grdev_pipe *pipe) { + assert(pipe); + + if (!pipe->enabled) { + pipe->enabled = true; + if (pipe->vtable->enable) + pipe->vtable->enable(pipe); + } +} + +static void pipe_disable(grdev_pipe *pipe) { + assert(pipe); + + if (pipe->enabled) { + pipe->enabled = false; + if (pipe->vtable->disable) + pipe->vtable->disable(pipe); + } +} + +void grdev_pipe_ready(grdev_pipe *pipe, bool running) { + assert(pipe); + + /* grdev_pipe_ready() is used by backends to notify about pipe state + * changed. If a pipe is ready, it can be fully used by us (available, + * enabled and accessable). Backends can disable pipes at any time + * (like for async revocation), but can only enable them from parent + * context. Otherwise, we might call user-callbacks recursively. */ + + if (pipe->running == running) + return; + + pipe->running = running; + + /* runtime events for unused pipes are not interesting */ + if (pipe->cache) { + grdev_display *display = pipe->tile->display; + + assert(display); + + if (running) { + if (pipe->enabled) + session_frame(display->session, display); + } else { + pipe->cache->incomplete = true; + } + } +} + +void grdev_pipe_frame(grdev_pipe *pipe) { + grdev_display *display; + + assert(pipe); + + /* if pipe is unused, ignore any frame events */ + if (!pipe->cache) + return; + + display = pipe->tile->display; + assert(display); + + if (pipe->enabled) + session_frame(display->session, display); +} + +/* + * Cards + */ + +grdev_card *grdev_find_card(grdev_session *session, const char *name) { + assert_return(session, NULL); + assert_return(name, NULL); + + return hashmap_get(session->card_map, name); +} + +int grdev_card_add(grdev_card *card, const char *name) { + int r; + + assert_return(card, -EINVAL); + assert_return(card->vtable, -EINVAL); + assert_return(card->vtable->free, -EINVAL); + assert_return(card->session, -EINVAL); + assert_return(name, -EINVAL); + + card->name = strdup(name); + if (!card->name) + return -ENOMEM; + + card->pipe_map = hashmap_new(&string_hash_ops); + if (!card->pipe_map) + return -ENOMEM; + + r = hashmap_put(card->session->card_map, card->name, card); + if (r < 0) + return r; + + return 0; +} + +grdev_card *grdev_card_free(grdev_card *card) { + grdev_card tmp; + + if (!card) + return NULL; + + assert(!card->enabled); + assert(card->vtable); + assert(card->vtable->free); + + if (card->name) + hashmap_remove_value(card->session->card_map, card->name, card); + + tmp = *card; + card->vtable->free(card); + + assert(hashmap_size(tmp.pipe_map) == 0); + + hashmap_free(tmp.pipe_map); + free(tmp.name); + + return NULL; +} + +static void card_modified(grdev_card *card) { + assert(card); + assert(card->session->n_pins > 0); + + card->modified = true; +} + +static void grdev_card_enable(grdev_card *card) { + assert(card); + + if (!card->enabled) { + card->enabled = true; + if (card->vtable->enable) + card->vtable->enable(card); + } +} + +static void grdev_card_disable(grdev_card *card) { + assert(card); + + if (card->enabled) { + card->enabled = false; + if (card->vtable->disable) + card->vtable->disable(card); + } +} + +/* + * Sessions + */ + +static void session_raise(grdev_session *session, grdev_event *event) { + session->event_fn(session, session->userdata, event); +} + +static void session_raise_display_add(grdev_session *session, grdev_display *display) { + grdev_event event = { + .type = GRDEV_EVENT_DISPLAY_ADD, + .display_add = { + .display = display, + }, + }; + + session_raise(session, &event); +} + +static void session_raise_display_remove(grdev_session *session, grdev_display *display) { + grdev_event event = { + .type = GRDEV_EVENT_DISPLAY_REMOVE, + .display_remove = { + .display = display, + }, + }; + + session_raise(session, &event); +} + +static void session_raise_display_change(grdev_session *session, grdev_display *display) { + grdev_event event = { + .type = GRDEV_EVENT_DISPLAY_CHANGE, + .display_change = { + .display = display, + }, + }; + + session_raise(session, &event); +} + +static void session_raise_display_frame(grdev_session *session, grdev_display *display) { + grdev_event event = { + .type = GRDEV_EVENT_DISPLAY_FRAME, + .display_frame = { + .display = display, + }, + }; + + session_raise(session, &event); +} + +static void session_add_card(grdev_session *session, grdev_card *card) { + assert(session); + assert(card); + + log_debug("grdev: %s: add card '%s'", session->name, card->name); + + /* Cards are not exposed to users, but managed internally. Cards are + * enabled if the session is enabled, and will track that state. The + * backend can probe the card at any time, but only if enabled. It + * will then add pipes according to hardware state. + * That is, the card may create pipes as soon as we enable it here. */ + + if (session->enabled) + grdev_card_enable(card); +} + +static void session_remove_card(grdev_session *session, grdev_card *card) { + assert(session); + assert(card); + + log_debug("grdev: %s: remove card '%s'", session->name, card->name); + + /* As cards are not exposed, it can never be accessed by outside + * users and we can simply remove it. Disabling the card does not + * necessarily drop all pipes of the card. This is usually deferred + * to card destruction (as pipes are cached as long as FDs remain + * open). Therefore, the card destruction might cause pipes, and thus + * visible displays, to be removed. */ + + grdev_card_disable(card); + grdev_card_free(card); +} + +static void session_add_display(grdev_session *session, grdev_display *display) { + assert(session); + assert(display); + assert(!display->enabled); + + log_debug("grdev: %s: add display '%s'", session->name, display->name); + + /* Displays are the main entity for public API users. We create them + * independent of card backends and they wrap any underlying display + * architecture. Displays are public at all times, thus, may be entered + * by outside users at any time. */ + + display->public = true; + session_raise_display_add(session, display); +} + +static void session_remove_display(grdev_session *session, grdev_display *display) { + assert(session); + assert(display); + + log_debug("grdev: %s: remove display '%s'", session->name, display->name); + + /* Displays are public, so we have to be careful when removing them. + * We first tell users about their removal, disable them and then drop + * them. We now, after the notification, no external access will + * happen. Therefore, we can release the tiles afterwards safely. */ + + if (display->public) { + display->public = false; + session_raise_display_remove(session, display); + } + + grdev_display_disable(display); + grdev_display_free(display); +} + +static void session_change_display(grdev_session *session, grdev_display *display) { + bool changed; + + assert(session); + assert(display); + + changed = display_cache(display); + + if (display->n_leafs == 0) + session_remove_display(session, display); + else if (!display->public) + session_add_display(session, display); + else if (changed) + session_raise_display_change(session, display); + else if (display->framed) + session_frame(session, display); +} + +static void session_frame(grdev_session *session, grdev_display *display) { + assert(session); + assert(display); + + display->framed = false; + + if (!display->enabled || !session->enabled) + return; + + if (session->n_pins > 0) + display->framed = true; + else + session_raise_display_frame(session, display); +} + +int grdev_session_new(grdev_session **out, + grdev_context *context, + unsigned int flags, + const char *name, + grdev_event_fn event_fn, + void *userdata) { + _cleanup_(grdev_session_freep) grdev_session *session = NULL; + int r; + + assert(out); + assert(context); + assert(name); + assert(event_fn); + assert_return(session_id_valid(name) == !(flags & GRDEV_SESSION_CUSTOM), -EINVAL); + assert_return(!(flags & GRDEV_SESSION_CUSTOM) || !(flags & GRDEV_SESSION_MANAGED), -EINVAL); + assert_return(!(flags & GRDEV_SESSION_MANAGED) || context->sysbus, -EINVAL); + + session = new0(grdev_session, 1); + if (!session) + return -ENOMEM; + + session->context = grdev_context_ref(context); + session->custom = flags & GRDEV_SESSION_CUSTOM; + session->managed = flags & GRDEV_SESSION_MANAGED; + session->event_fn = event_fn; + session->userdata = userdata; + + session->name = strdup(name); + if (!session->name) + return -ENOMEM; + + if (session->managed) { + r = sd_bus_path_encode("/org/freedesktop/login1/session", + session->name, &session->path); + if (r < 0) + return r; + } + + session->card_map = hashmap_new(&string_hash_ops); + if (!session->card_map) + return -ENOMEM; + + session->display_map = hashmap_new(&string_hash_ops); + if (!session->display_map) + return -ENOMEM; + + r = hashmap_put(context->session_map, session->name, session); + if (r < 0) + return r; + + *out = session; + session = NULL; + return 0; +} + +grdev_session *grdev_session_free(grdev_session *session) { + grdev_card *card; + + if (!session) + return NULL; + + grdev_session_disable(session); + + while ((card = hashmap_first(session->card_map))) + session_remove_card(session, card); + + assert(hashmap_size(session->display_map) == 0); + + if (session->name) + hashmap_remove_value(session->context->session_map, session->name, session); + + hashmap_free(session->display_map); + hashmap_free(session->card_map); + session->context = grdev_context_unref(session->context); + free(session->path); + free(session->name); + free(session); + + return NULL; +} + +bool grdev_session_is_enabled(grdev_session *session) { + return session && session->enabled; +} + +void grdev_session_enable(grdev_session *session) { + grdev_card *card; + Iterator iter; + + assert(session); + + if (!session->enabled) { + session->enabled = true; + HASHMAP_FOREACH(card, session->card_map, iter) + grdev_card_enable(card); + } +} + +void grdev_session_disable(grdev_session *session) { + grdev_card *card; + Iterator iter; + + assert(session); + + if (session->enabled) { + session->enabled = false; + HASHMAP_FOREACH(card, session->card_map, iter) + grdev_card_disable(card); + } +} + +void grdev_session_commit(grdev_session *session) { + grdev_card *card; + Iterator iter; + + assert(session); + + if (!session->enabled) + return; + + HASHMAP_FOREACH(card, session->card_map, iter) + if (card->vtable->commit) + card->vtable->commit(card); +} + +void grdev_session_restore(grdev_session *session) { + grdev_card *card; + Iterator iter; + + assert(session); + + if (!session->enabled) + return; + + HASHMAP_FOREACH(card, session->card_map, iter) + if (card->vtable->restore) + card->vtable->restore(card); +} + +static void session_configure(grdev_session *session) { + grdev_display *display; + grdev_tile *tile; + grdev_card *card; + grdev_pipe *pipe; + Iterator i, j; + int r; + + assert(session); + + /* + * Whenever backends add or remove pipes, we set session->modified and + * require them to pin the session while modifying it. On release, we + * reconfigure the device and re-assign displays to all modified pipes. + * + * So far, we configure each pipe as a separate display. We do not + * support user-configuration, nor have we gotten any reports from + * users with multi-pipe monitors (4k on DP-1.2 MST and so on). Until + * we get reports, we keep the logic to a minimum. + */ + + /* create new displays for all unconfigured pipes */ + HASHMAP_FOREACH(card, session->card_map, i) { + if (!card->modified) + continue; + + card->modified = false; + + HASHMAP_FOREACH(pipe, card->pipe_map, j) { + tile = pipe->tile; + if (tile->display) + continue; + + assert(!tile->parent); + + display = grdev_find_display(session, pipe->name); + if (display && display->tile) { + log_debug("grdev: %s/%s: occupied display for pipe %s", + session->name, card->name, pipe->name); + continue; + } else if (!display) { + r = grdev_display_new(&display, session, pipe->name); + if (r < 0) { + log_debug("grdev: %s/%s: cannot create display for pipe %s: %s", + session->name, card->name, pipe->name, strerror(-r)); + continue; + } + } + + tile_link(pipe->tile, display->tile); + } + } + + /* update displays */ + HASHMAP_FOREACH(display, session->display_map, i) + session_change_display(session, display); +} + +grdev_session *grdev_session_pin(grdev_session *session) { + assert(session); + + ++session->n_pins; + return session; +} + +grdev_session *grdev_session_unpin(grdev_session *session) { + if (!session) + return NULL; + + assert(session->n_pins > 0); + + if (--session->n_pins == 0) + session_configure(session); + + return NULL; +} + +/* + * Contexts + */ + +int grdev_context_new(grdev_context **out, sd_event *event, sd_bus *sysbus) { + _cleanup_(grdev_context_unrefp) grdev_context *context = NULL; + + assert_return(out, -EINVAL); + assert_return(event, -EINVAL); + + context = new0(grdev_context, 1); + if (!context) + return -ENOMEM; + + context->ref = 1; + context->event = sd_event_ref(event); + + if (sysbus) + context->sysbus = sd_bus_ref(sysbus); + + context->session_map = hashmap_new(&string_hash_ops); + if (!context->session_map) + return -ENOMEM; + + *out = context; + context = NULL; + return 0; +} + +static void context_cleanup(grdev_context *context) { + assert(hashmap_size(context->session_map) == 0); + + hashmap_free(context->session_map); + context->sysbus = sd_bus_unref(context->sysbus); + context->event = sd_event_unref(context->event); + free(context); +} + +grdev_context *grdev_context_ref(grdev_context *context) { + assert_return(context, NULL); + assert_return(context->ref > 0, NULL); + + ++context->ref; + return context; +} + +grdev_context *grdev_context_unref(grdev_context *context) { + if (!context) + return NULL; + + assert_return(context->ref > 0, NULL); + + if (--context->ref == 0) + context_cleanup(context); + + return NULL; +} diff --git a/src/libsystemd-terminal/grdev.h b/src/libsystemd-terminal/grdev.h new file mode 100644 index 0000000000..2645b12113 --- /dev/null +++ b/src/libsystemd-terminal/grdev.h @@ -0,0 +1,182 @@ +/*-*- 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/>. +***/ + +/* + * Graphics Devices + * The grdev layer provides generic access to graphics devices. The device + * types are hidden in the implementation and exported in a generic way. The + * grdev_session object forms the base layer. It loads, configures and prepares + * any graphics devices associated with that session. Each session is totally + * independent of other sessions and can be controlled separately. + * The target devices on a session are called display. A display always + * corresponds to a real display regardless how many pipes are needed to drive + * that display. That is, an exported display might internally be created out + * of arbitrary combinations of target pipes. However, this is meant as + * implementation detail and API users must never assume details below the + * display-level. That is, a display is the most low-level object exported. + * Therefore, pipe-configuration and any low-level modesetting is hidden from + * the public API. It is provided by the implementation, and it is the + * implementation that decides how pipes are driven. + * + * The API users are free to ignore specific displays or combine them to create + * larger screens. This often requires user-configuration so is dictated by + * policy. The underlying pipe-configuration might be affected by these + * high-level policies, but is never directly controlled by those. That means, + * depending on the displays you use, it might affect how underlying resources + * are assigned. However, users can never directly apply policies to the pipes, + * but only to displays. In case specific hardware needs quirks on the pipe + * level, we support that via hwdb, not via public user configuration. + * + * Right now, displays are limited to rgb32 memory-mapped framebuffers on the + * primary plane. However, the grdev implementation can be easily extended to + * allow more powerful access (including hardware-acceleration for 2D and 3D + * compositing). So far, this wasn't needed so it is not exposed. + */ + +#pragma once + +#include <drm_fourcc.h> +#include <inttypes.h> +#include <stdbool.h> +#include <stdlib.h> +#include <systemd/sd-bus.h> +#include <systemd/sd-event.h> +#include "util.h" + +typedef struct grdev_fb grdev_fb; +typedef struct grdev_display_target grdev_display_target; +typedef struct grdev_display grdev_display; + +typedef struct grdev_event grdev_event; +typedef struct grdev_session grdev_session; +typedef struct grdev_context grdev_context; + +enum { + /* clockwise rotation; we treat this is abelian group Z4 with ADD */ + GRDEV_ROTATE_0 = 0, + GRDEV_ROTATE_90 = 1, + GRDEV_ROTATE_180 = 2, + GRDEV_ROTATE_270 = 3, +}; + +enum { + /* flip states; we treat this as abelian group V4 with XOR */ + GRDEV_FLIP_NONE = 0x0, + GRDEV_FLIP_HORIZONTAL = 0x1, + GRDEV_FLIP_VERTICAL = 0x2, +}; + +/* + * Displays + */ + +struct grdev_fb { + uint32_t width; + uint32_t height; + uint32_t format; + uint64_t age; + int32_t strides[4]; + void *maps[4]; +}; + +struct grdev_display_target { + uint32_t x; + uint32_t y; + uint32_t width; + uint32_t height; + unsigned int rotate; + unsigned int flip; + const grdev_fb *fb; +}; + +bool grdev_display_is_enabled(grdev_display *display); +void grdev_display_enable(grdev_display *display); +void grdev_display_disable(grdev_display *display); + +const grdev_display_target *grdev_display_next_target(grdev_display *display, const grdev_display_target *prev, uint64_t minage); +void grdev_display_flip_target(grdev_display *display, const grdev_display_target *target, uint64_t age); + +#define GRDEV_DISPLAY_FOREACH_TARGET(_display, _t, _minage) \ + for ((_t) = grdev_display_next_target((_display), NULL, (_minage)); \ + (_t); \ + (_t) = grdev_display_next_target((_display), (_t), (_minage))) + +/* + * Events + */ + +enum { + GRDEV_EVENT_DISPLAY_ADD, + GRDEV_EVENT_DISPLAY_REMOVE, + GRDEV_EVENT_DISPLAY_CHANGE, + GRDEV_EVENT_DISPLAY_FRAME, +}; + +typedef void (*grdev_event_fn) (grdev_session *session, void *userdata, grdev_event *ev); + +struct grdev_event { + unsigned int type; + union { + struct { + grdev_display *display; + } display_add, display_remove, display_change; + + struct { + grdev_display *display; + } display_frame; + }; +}; + +/* + * Sessions + */ + +enum { + GRDEV_SESSION_CUSTOM = (1 << 0), + GRDEV_SESSION_MANAGED = (1 << 1), +}; + +int grdev_session_new(grdev_session **out, + grdev_context *context, + unsigned int flags, + const char *name, + grdev_event_fn event_fn, + void *userdata); +grdev_session *grdev_session_free(grdev_session *session); + +DEFINE_TRIVIAL_CLEANUP_FUNC(grdev_session*, grdev_session_free); + +bool grdev_session_is_enabled(grdev_session *session); +void grdev_session_enable(grdev_session *session); +void grdev_session_disable(grdev_session *session); + +void grdev_session_commit(grdev_session *session); +void grdev_session_restore(grdev_session *session); + +/* + * Contexts + */ + +int grdev_context_new(grdev_context **out, sd_event *event, sd_bus *sysbus); +grdev_context *grdev_context_ref(grdev_context *context); +grdev_context *grdev_context_unref(grdev_context *context); + +DEFINE_TRIVIAL_CLEANUP_FUNC(grdev_context*, grdev_context_unref); |