[PATCH weston 33/68] compositor-drm: Introduce drm_output_state structure
Daniel Stone
daniels at collabora.com
Fri Dec 9 19:57:48 UTC 2016
Currently this doesn't actually really do anything, but will be used in
the future to track the state for both modeset and repaint requests.
Completion of the request gives us a single request-completion path for
both pageflip and vblank events.
Differential Revision: https://phabricator.freedesktop.org/D1497
Signed-off-by: Daniel Stone <daniels at collabora.com>
---
libweston/compositor-drm.c | 229 ++++++++++++++++++++++++++++++++++++++-------
1 file changed, 196 insertions(+), 33 deletions(-)
diff --git a/libweston/compositor-drm.c b/libweston/compositor-drm.c
index 3dd2924..106d851 100644
--- a/libweston/compositor-drm.c
+++ b/libweston/compositor-drm.c
@@ -121,6 +121,19 @@ struct plane_properties {
uint64_t value;
};
+/**
+ * Mode for drm_output_state_duplicate.
+ */
+enum drm_output_state_duplicate_mode {
+ DRM_OUTPUT_STATE_CLEAR_PLANES, /**< reset all planes to off */
+ DRM_OUTPUT_STATE_PRESERVE_PLANES, /**< preserve plane state */
+};
+
+enum drm_output_state_update_mode {
+ DRM_OUTPUT_STATE_UPDATE_SYNCHRONOUS, /**< state already applied */
+ DRM_OUTPUT_STATE_UPDATE_ASYNCHRONOUS, /**< pending event delivery */
+};
+
struct drm_backend {
struct weston_backend base;
struct weston_compositor *compositor;
@@ -210,6 +223,16 @@ struct drm_edid {
};
/**
+ * Output state holds the dynamic state for one Weston output, i.e. a KMS CRTC,
+ * plus >= 1 each of encoder/connector/plane. Since everything but the planes
+ * is currently statically assigned per-output, we mainly use this to track
+ * plane state.
+ */
+struct drm_output_state {
+ struct drm_output *output;
+};
+
+/**
* A plane represents one buffer, positioned within a CRTC, and stacked
* relative to other planes on the same CRTC.
*
@@ -278,6 +301,10 @@ struct drm_output {
struct drm_fb *fb_current, *fb_pending, *fb_last;
struct backlight *backlight;
+ struct drm_output_state *state_last;
+ struct drm_output_state *state_cur;
+ struct drm_output_state *state_pending;
+
struct drm_fb *dumb[2];
pixman_image_t *image[2];
int current_image;
@@ -645,6 +672,9 @@ drm_output_set_cursor(struct drm_output *output);
static void
drm_output_update_msc(struct drm_output *output, unsigned int seq);
+static void
+drm_output_destroy(struct weston_output *output_base);
+
static int
drm_plane_crtc_supported(struct drm_output *output, struct drm_plane *plane)
{
@@ -905,6 +935,112 @@ drm_fb_unref(struct drm_fb *fb)
}
}
+/**
+ * Allocate a new, empty drm_output_state. This should not generally be used
+ * in the repaint cycle; see drm_output_state_duplicate.
+ */
+static struct drm_output_state *
+drm_output_state_alloc(struct drm_output *output)
+{
+ struct drm_output_state *state = calloc(1, sizeof(*state));
+
+ state->output = output;
+
+ return state;
+}
+
+/**
+ * Duplicate an existing drm_output_state into a new one. This is generally
+ * used during the repaint cycle, to capture the existing state of an output
+ * and modify it to create a new state to be used.
+ *
+ * The mode determines whether the output will be reset to an a blank state,
+ * or an exact mirror of the current state.
+ */
+static struct drm_output_state *
+drm_output_state_duplicate(struct drm_output_state *src,
+ enum drm_output_state_duplicate_mode plane_mode)
+{
+ struct drm_output_state *dst = malloc(sizeof(*dst));
+
+ assert(dst);
+ memcpy(dst, src, sizeof(*dst));
+
+ return dst;
+}
+
+/**
+ * Free an unused drm_output_state.
+ */
+static void
+drm_output_state_free(struct drm_output_state *state)
+{
+ if (!state)
+ return;
+
+ free(state);
+}
+
+/**
+ * Mark a drm_output_state (the output's last state) as complete. This handles
+ * any post-completion actions such as updating the repaint timer, disabling the
+ * output, and finally freeing the state.
+ */
+static void
+drm_output_update_complete(struct drm_output *output, uint32_t flags,
+ unsigned int sec, unsigned int usec)
+{
+ struct timespec ts;
+
+ drm_output_state_free(output->state_last);
+ output->state_last = NULL;
+
+ if (output->destroy_pending) {
+ drm_output_destroy(&output->base);
+ goto out;
+ } else if (output->disable_pending) {
+ weston_output_disable(&output->base);
+ goto out;
+ }
+
+ ts.tv_sec = sec;
+ ts.tv_nsec = usec * 1000;
+ weston_output_finish_frame(&output->base, &ts, flags);
+
+ /* We can't call this from frame_notify, because the output's
+ * repaint needed flag is cleared just after that */
+ if (output->recorder)
+ weston_output_schedule_repaint(&output->base);
+
+out:
+ output->destroy_pending = 0;
+ output->disable_pending = 0;
+}
+
+/**
+ * Mark an output state as current on the output, i.e. it has been
+ * submitted to the kernel. The mode argument determines whether this
+ * update will be applied synchronously (e.g. when calling drmModeSetCrtc),
+ * or asynchronously (in which case we wait for events to complete).
+ */
+static void
+drm_output_assign_state(struct drm_output_state *state,
+ enum drm_output_state_update_mode mode)
+{
+ struct drm_output *output = state->output;
+
+ assert(!output->state_last);
+
+ if (mode == DRM_OUTPUT_STATE_UPDATE_ASYNCHRONOUS)
+ output->state_last = output->state_cur;
+ else
+ drm_output_state_free(output->state_cur);
+
+ output->state_cur = state;
+ output->state_pending = NULL;
+}
+
+
static int
drm_view_transform_supported(struct weston_view *ev)
{
@@ -943,9 +1079,10 @@ drm_output_check_scanout_format(struct drm_output *output,
}
static struct weston_plane *
-drm_output_prepare_scanout_view(struct drm_output *output,
+drm_output_prepare_scanout_view(struct drm_output_state *output_state,
struct weston_view *ev)
{
+ struct drm_output *output = output_state->output;
struct drm_backend *b = to_drm_backend(output->base.compositor);
struct weston_buffer *buffer = ev->surface->buffer_ref.buffer;
struct weston_buffer_viewport *viewport = &ev->surface->buffer_viewport;
@@ -1149,13 +1286,19 @@ drm_output_repaint(struct weston_output *output_base,
int ret = 0;
if (output->disable_pending || output->destroy_pending)
- return -1;
+ goto err;
+
+ assert(!output->state_last);
+ if (!output->state_pending)
+ output->state_pending =
+ drm_output_state_duplicate(output->state_cur,
+ DRM_OUTPUT_STATE_CLEAR_PLANES);
assert(!output->fb_last);
drm_output_render(output, damage);
if (!output->fb_pending)
- return -1;
+ goto err;
mode = container_of(output->base.current_mode, struct drm_mode, base);
if (!output->fb_current ||
@@ -1166,7 +1309,7 @@ drm_output_repaint(struct weston_output *output_base,
&mode->mode_info);
if (ret) {
weston_log("set mode failed: %m\n");
- goto err_pageflip;
+ goto err;
}
output_base->set_dpms(output_base, WESTON_DPMS_ON);
}
@@ -1175,7 +1318,7 @@ drm_output_repaint(struct weston_output *output_base,
output->fb_pending->fb_id,
DRM_MODE_PAGE_FLIP_EVENT, output) < 0) {
weston_log("queueing pageflip failed: %m\n");
- goto err_pageflip;
+ goto err;
}
output->fb_last = output->fb_current;
@@ -1239,14 +1382,19 @@ drm_output_repaint(struct weston_output *output_base,
output->vblank_pending++;
}
+ drm_output_assign_state(output->state_pending,
+ DRM_OUTPUT_STATE_UPDATE_ASYNCHRONOUS);
+
return 0;
-err_pageflip:
+err:
output->cursor_view = NULL;
if (output->fb_pending) {
drm_fb_unref(output->fb_pending);
output->fb_pending = NULL;
}
+ drm_output_state_free(output->state_pending);
+ output->state_pending = NULL;
return -1;
}
@@ -1255,6 +1403,7 @@ static void
drm_output_start_repaint_loop(struct weston_output *output_base)
{
struct drm_output *output = to_drm_output(output_base);
+ struct drm_output_state *output_state;
struct drm_backend *backend =
to_drm_backend(output_base->compositor);
uint32_t fb_id;
@@ -1309,15 +1458,24 @@ drm_output_start_repaint_loop(struct weston_output *output_base)
assert(!output->page_flip_pending);
assert(!output->fb_last);
+ assert(!output->state_last);
+ assert(!output->state_pending);
+
+ output_state =
+ drm_output_state_duplicate(output->state_cur,
+ DRM_OUTPUT_STATE_PRESERVE_PLANES);
if (drmModePageFlip(backend->drm.fd, output->crtc_id, fb_id,
DRM_MODE_PAGE_FLIP_EVENT, output) < 0) {
weston_log("queueing pageflip failed: %m\n");
+ drm_output_state_free(output_state);
goto finish_frame;
}
output->fb_last = drm_fb_ref(output->fb_current);
output->page_flip_pending = 1;
+ drm_output_assign_state(output_state,
+ DRM_OUTPUT_STATE_UPDATE_ASYNCHRONOUS);
return;
@@ -1345,7 +1503,6 @@ vblank_handler(int fd, unsigned int frame, unsigned int sec, unsigned int usec,
{
struct drm_plane *s = (struct drm_plane *)data;
struct drm_output *output = s->output;
- struct timespec ts;
uint32_t flags = WP_PRESENTATION_FEEDBACK_KIND_HW_COMPLETION |
WP_PRESENTATION_FEEDBACK_KIND_HW_CLOCK;
@@ -1357,11 +1514,10 @@ vblank_handler(int fd, unsigned int frame, unsigned int sec, unsigned int usec,
drm_fb_unref(s->fb_last);
s->fb_last = NULL;
- if (!output->page_flip_pending && !output->vblank_pending) {
- ts.tv_sec = sec;
- ts.tv_nsec = usec * 1000;
- weston_output_finish_frame(&output->base, &ts, flags);
- }
+ if (output->page_flip_pending || output->vblank_pending)
+ return;
+
+ drm_output_update_complete(output, flags, sec, usec);
}
static void
@@ -1372,7 +1528,6 @@ page_flip_handler(int fd, unsigned int frame,
unsigned int sec, unsigned int usec, void *data)
{
struct drm_output *output = data;
- struct timespec ts;
uint32_t flags = WP_PRESENTATION_FEEDBACK_KIND_VSYNC |
WP_PRESENTATION_FEEDBACK_KIND_HW_COMPLETION |
WP_PRESENTATION_FEEDBACK_KIND_HW_CLOCK;
@@ -1385,20 +1540,10 @@ page_flip_handler(int fd, unsigned int frame,
drm_fb_unref(output->fb_last);
output->fb_last = NULL;
- if (output->destroy_pending)
- drm_output_destroy(&output->base);
- else if (output->disable_pending)
- weston_output_disable(&output->base);
- else if (!output->vblank_pending) {
- ts.tv_sec = sec;
- ts.tv_nsec = usec * 1000;
- weston_output_finish_frame(&output->base, &ts, flags);
+ if (output->vblank_pending)
+ return;
- /* We can't call this from frame_notify, because the output's
- * repaint needed flag is cleared just after that */
- if (output->recorder)
- weston_output_schedule_repaint(&output->base);
- }
+ drm_output_update_complete(output, flags, sec, usec);
}
static uint32_t
@@ -1431,9 +1576,10 @@ drm_output_check_plane_format(struct drm_plane *p,
}
static struct weston_plane *
-drm_output_prepare_overlay_view(struct drm_output *output,
+drm_output_prepare_overlay_view(struct drm_output_state *output_state,
struct weston_view *ev)
{
+ struct drm_output *output = output_state->output;
struct weston_compositor *ec = output->base.compositor;
struct drm_backend *b = to_drm_backend(ec);
struct weston_buffer_viewport *viewport = &ev->surface->buffer_viewport;
@@ -1606,9 +1752,10 @@ drm_output_prepare_overlay_view(struct drm_output *output,
}
static struct weston_plane *
-drm_output_prepare_cursor_view(struct drm_output *output,
+drm_output_prepare_cursor_view(struct drm_output_state *output_state,
struct weston_view *ev)
{
+ struct drm_output *output = output_state->output;
struct drm_backend *b = to_drm_backend(output->base.compositor);
struct weston_buffer_viewport *viewport = &ev->surface->buffer_viewport;
struct wl_shm_buffer *shmbuf;
@@ -1740,10 +1887,16 @@ drm_assign_planes(struct weston_output *output_base)
{
struct drm_backend *b = to_drm_backend(output_base->compositor);
struct drm_output *output = to_drm_output(output_base);
+ struct drm_output_state *state;
struct weston_view *ev, *next;
pixman_region32_t overlap, surface_overlap;
struct weston_plane *primary, *next_plane;
+ assert(!output->state_last);
+ assert(!output->state_pending);
+ state = drm_output_state_duplicate(output->state_cur,
+ DRM_OUTPUT_STATE_CLEAR_PLANES);
+
/*
* Find a surface for each sprite in the output using some heuristics:
* 1) size
@@ -1792,11 +1945,11 @@ drm_assign_planes(struct weston_output *output_base)
if (pixman_region32_not_empty(&surface_overlap))
next_plane = primary;
if (next_plane == NULL)
- next_plane = drm_output_prepare_cursor_view(output, ev);
+ next_plane = drm_output_prepare_cursor_view(state, ev);
if (next_plane == NULL)
- next_plane = drm_output_prepare_scanout_view(output, ev);
+ next_plane = drm_output_prepare_scanout_view(state, ev);
if (next_plane == NULL)
- next_plane = drm_output_prepare_overlay_view(output, ev);
+ next_plane = drm_output_prepare_overlay_view(state, ev);
if (next_plane == NULL)
next_plane = primary;
@@ -1820,6 +1973,8 @@ drm_assign_planes(struct weston_output *output_base)
pixman_region32_fini(&surface_overlap);
}
pixman_region32_fini(&overlap);
+
+ output->state_pending = state;
}
/**
@@ -3120,7 +3275,7 @@ drm_output_destroy(struct weston_output *base)
struct drm_backend *b = to_drm_backend(base->compositor);
drmModeCrtcPtr origcrtc = output->original_crtc;
- if (output->page_flip_pending) {
+ if (output->page_flip_pending || output->vblank_pending) {
output->destroy_pending = 1;
weston_log("destroy output while page flip pending\n");
return;
@@ -3147,6 +3302,10 @@ drm_output_destroy(struct weston_output *base)
b->crtc_allocator &= ~(1 << output->crtc_id);
b->connector_allocator &= ~(1 << output->connector_id);
+ assert(!output->state_last);
+ drm_output_state_free(output->state_cur);
+ assert(!output->state_pending);
+
free(output);
}
@@ -3156,7 +3315,7 @@ drm_output_disable(struct weston_output *base)
struct drm_output *output = to_drm_output(base);
struct drm_backend *b = to_drm_backend(base->compositor);
- if (output->page_flip_pending) {
+ if (output->page_flip_pending || output->vblank_pending) {
output->disable_pending = 1;
return -1;
}
@@ -3169,6 +3328,8 @@ drm_output_disable(struct weston_output *base)
weston_log("Disabling output %s\n", output->base.name);
drmModeSetCrtc(b->drm.fd, output->crtc_id,
0, 0, 0, 0, 0, NULL);
+ drm_output_state_free(output->state_cur);
+ output->state_cur = NULL;
return 0;
}
@@ -3222,6 +3383,8 @@ create_output_for_connector(struct drm_backend *b,
output->disable_pending = 0;
output->original_crtc = NULL;
+ output->state_cur = drm_output_state_alloc(output);
+
b->crtc_allocator |= (1 << output->crtc_id);
b->connector_allocator |= (1 << output->connector_id);
--
2.9.3
More information about the wayland-devel
mailing list