diff --git a/qxl-fixes.patch b/qxl-fixes.patch index c8bd4b9..5572266 100644 --- a/qxl-fixes.patch +++ b/qxl-fixes.patch @@ -1,3 +1,90 @@ +From c463b4ad6b2ac5a40c959e6c636eafc7edb1a63b Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Wed, 6 Sep 2017 11:31:51 +0200 +Subject: qxl: fix primary surface handling + +The atomic conversion of the qxl driver didn't got the primary surface +handling completely right. It works in the common simple cases, but +fails for example when changing the display resolution using xrandr or +in multihead setups. + +The rules are simple: There is one primary surface. Before defining a +new one you have to destroy the old one. + +This patch makes qxl_primary_atomic_update() destroy the primary surface +before defining a new one. It fixes is_primary flag updates. It adds +is_primary checks so we don't try to update the primary surface in case +it already has the state we want it being in. + +Signed-off-by: Gerd Hoffmann +--- + drivers/gpu/drm/qxl/qxl_display.c | 34 +++++++++++++++++++--------------- + 1 file changed, 19 insertions(+), 15 deletions(-) + +diff --git a/drivers/gpu/drm/qxl/qxl_display.c b/drivers/gpu/drm/qxl/qxl_display.c +index 03fe182..7babdd8f 100644 +--- a/drivers/gpu/drm/qxl/qxl_display.c ++++ b/drivers/gpu/drm/qxl/qxl_display.c +@@ -512,23 +512,25 @@ static void qxl_primary_atomic_update(struct drm_plane *plane, + .y2 = qfb->base.height + }; + +- if (!old_state->fb) { +- qxl_io_log(qdev, +- "create primary fb: %dx%d,%d,%d\n", +- bo->surf.width, bo->surf.height, +- bo->surf.stride, bo->surf.format); ++ if (old_state->fb) { ++ qfb_old = to_qxl_framebuffer(old_state->fb); ++ bo_old = gem_to_qxl_bo(qfb_old->obj); ++ } else { ++ bo_old = NULL; ++ } + +- qxl_io_create_primary(qdev, 0, bo); +- bo->is_primary = true; ++ if (bo == bo_old) + return; + +- } else { +- qfb_old = to_qxl_framebuffer(old_state->fb); +- bo_old = gem_to_qxl_bo(qfb_old->obj); ++ if (bo_old && bo_old->is_primary) { ++ qxl_io_destroy_primary(qdev); + bo_old->is_primary = false; + } + +- bo->is_primary = true; ++ if (!bo->is_primary) { ++ qxl_io_create_primary(qdev, 0, bo); ++ bo->is_primary = true; ++ } + qxl_draw_dirty_fb(qdev, qfb, bo, 0, 0, &norect, 1, 1); + } + +@@ -537,13 +539,15 @@ static void qxl_primary_atomic_disable(struct drm_plane *plane, + { + struct qxl_device *qdev = plane->dev->dev_private; + +- if (old_state->fb) +- { struct qxl_framebuffer *qfb = ++ if (old_state->fb) { ++ struct qxl_framebuffer *qfb = + to_qxl_framebuffer(old_state->fb); + struct qxl_bo *bo = gem_to_qxl_bo(qfb->obj); + +- qxl_io_destroy_primary(qdev); +- bo->is_primary = false; ++ if (bo->is_primary) { ++ qxl_io_destroy_primary(qdev); ++ bo->is_primary = false; ++ } + } + } + +-- +cgit v0.12 + From 05026e6e19b29104ddba4e8979e6c7af17944695 Mon Sep 17 00:00:00 2001 From: Gerd Hoffmann Date: Fri, 15 Sep 2017 12:46:15 +0200 @@ -37,3 +124,183 @@ index 7babdd8f..afc2272 100644 -- cgit v0.12 +From 7a39a01887acc66d9b318d5e5898cf00d323eb8f Mon Sep 17 00:00:00 2001 +From: Gerd Hoffmann +Date: Wed, 18 Oct 2017 13:18:40 +0200 +Subject: qxl: alloc & use shadow for dumb buffers + +This patch changes the way the primary surface is used for dumb +framebuffers. Instead of configuring the bo itself as primary surface +a shadow bo is created and used instead. Framebuffers can share the +shadow bo in case they have the same format and resolution. + +On atomic plane updates we don't have to update the primary surface in +case we pageflip from one framebuffer to another framebuffer which +shares the same shadow. This in turn avoids the flicker caused by the +primary-destroy + primary-create cycle, which is very annonying when +running wayland on qxl. + +The qxl driver never actually writes to the shadow bo. It sends qxl +blit commands which update it though, and the spice server might +actually execute them (and thereby write to the shadow) in case the +local rendering is kicked for some reason. This happens for example in +case qemu is asked to write out a dump of the guest display (screendump +monitor command). + +Signed-off-by: Gerd Hoffmann +--- + drivers/gpu/drm/qxl/qxl_cmd.c | 6 ++++- + drivers/gpu/drm/qxl/qxl_display.c | 49 ++++++++++++++++++++++++++++++++++++--- + drivers/gpu/drm/qxl/qxl_drv.h | 2 ++ + drivers/gpu/drm/qxl/qxl_dumb.c | 1 + + 4 files changed, 54 insertions(+), 4 deletions(-) + +diff --git a/drivers/gpu/drm/qxl/qxl_cmd.c b/drivers/gpu/drm/qxl/qxl_cmd.c +index 8ec53d5..c0fb52c 100644 +--- a/drivers/gpu/drm/qxl/qxl_cmd.c ++++ b/drivers/gpu/drm/qxl/qxl_cmd.c +@@ -387,7 +387,11 @@ void qxl_io_create_primary(struct qxl_device *qdev, + create->width = bo->surf.width; + create->height = bo->surf.height; + create->stride = bo->surf.stride; +- create->mem = qxl_bo_physical_address(qdev, bo, offset); ++ if (bo->shadow) { ++ create->mem = qxl_bo_physical_address(qdev, bo->shadow, offset); ++ } else { ++ create->mem = qxl_bo_physical_address(qdev, bo, offset); ++ } + + DRM_DEBUG_DRIVER("mem = %llx, from %p\n", create->mem, bo->kptr); + +diff --git a/drivers/gpu/drm/qxl/qxl_display.c b/drivers/gpu/drm/qxl/qxl_display.c +index afbf50d..4756b3c 100644 +--- a/drivers/gpu/drm/qxl/qxl_display.c ++++ b/drivers/gpu/drm/qxl/qxl_display.c +@@ -305,7 +305,9 @@ static const struct drm_crtc_funcs qxl_crtc_funcs = { + void qxl_user_framebuffer_destroy(struct drm_framebuffer *fb) + { + struct qxl_framebuffer *qxl_fb = to_qxl_framebuffer(fb); ++ struct qxl_bo *bo = gem_to_qxl_bo(qxl_fb->obj); + ++ WARN_ON(bo->shadow); + drm_gem_object_unreference_unlocked(qxl_fb->obj); + drm_framebuffer_cleanup(fb); + kfree(qxl_fb); +@@ -508,6 +510,7 @@ static void qxl_primary_atomic_update(struct drm_plane *plane, + .x2 = qfb->base.width, + .y2 = qfb->base.height + }; ++ bool same_shadow = false; + + if (old_state->fb) { + qfb_old = to_qxl_framebuffer(old_state->fb); +@@ -519,15 +522,23 @@ static void qxl_primary_atomic_update(struct drm_plane *plane, + if (bo == bo_old) + return; + ++ if (bo_old && bo_old->shadow && bo->shadow && ++ bo_old->shadow == bo->shadow) { ++ same_shadow = true; ++ } ++ + if (bo_old && bo_old->is_primary) { +- qxl_io_destroy_primary(qdev); ++ if (!same_shadow) ++ qxl_io_destroy_primary(qdev); + bo_old->is_primary = false; + } + + if (!bo->is_primary) { +- qxl_io_create_primary(qdev, 0, bo); ++ if (!same_shadow) ++ qxl_io_create_primary(qdev, 0, bo); + bo->is_primary = true; + } ++ + qxl_draw_dirty_fb(qdev, qfb, bo, 0, 0, &norect, 1, 1); + } + +@@ -679,8 +690,9 @@ static void qxl_cursor_atomic_disable(struct drm_plane *plane, + static int qxl_plane_prepare_fb(struct drm_plane *plane, + struct drm_plane_state *new_state) + { ++ struct qxl_device *qdev = plane->dev->dev_private; + struct drm_gem_object *obj; +- struct qxl_bo *user_bo; ++ struct qxl_bo *user_bo, *old_bo = NULL; + int ret; + + if (!new_state->fb) +@@ -689,6 +701,32 @@ static int qxl_plane_prepare_fb(struct drm_plane *plane, + obj = to_qxl_framebuffer(new_state->fb)->obj; + user_bo = gem_to_qxl_bo(obj); + ++ if (plane->type == DRM_PLANE_TYPE_PRIMARY && ++ user_bo->is_dumb && !user_bo->shadow) { ++ if (plane->state->fb) { ++ obj = to_qxl_framebuffer(plane->state->fb)->obj; ++ old_bo = gem_to_qxl_bo(obj); ++ } ++ if (old_bo && old_bo->shadow && ++ user_bo->gem_base.size == old_bo->gem_base.size && ++ plane->state->crtc == new_state->crtc && ++ plane->state->crtc_w == new_state->crtc_w && ++ plane->state->crtc_h == new_state->crtc_h && ++ plane->state->src_x == new_state->src_x && ++ plane->state->src_y == new_state->src_y && ++ plane->state->src_w == new_state->src_w && ++ plane->state->src_h == new_state->src_h && ++ plane->state->rotation == new_state->rotation && ++ plane->state->zpos == new_state->zpos) { ++ drm_gem_object_get(&old_bo->shadow->gem_base); ++ user_bo->shadow = old_bo->shadow; ++ } else { ++ qxl_bo_create(qdev, user_bo->gem_base.size, ++ true, true, QXL_GEM_DOMAIN_VRAM, NULL, ++ &user_bo->shadow); ++ } ++ } ++ + ret = qxl_bo_pin(user_bo, QXL_GEM_DOMAIN_CPU, NULL); + if (ret) + return ret; +@@ -713,6 +751,11 @@ static void qxl_plane_cleanup_fb(struct drm_plane *plane, + obj = to_qxl_framebuffer(old_state->fb)->obj; + user_bo = gem_to_qxl_bo(obj); + qxl_bo_unpin(user_bo); ++ ++ if (user_bo->shadow && !user_bo->is_primary) { ++ drm_gem_object_put_unlocked(&user_bo->shadow->gem_base); ++ user_bo->shadow = NULL; ++ } + } + + static const uint32_t qxl_cursor_plane_formats[] = { +diff --git a/drivers/gpu/drm/qxl/qxl_drv.h b/drivers/gpu/drm/qxl/qxl_drv.h +index d707b35..08752c0 100644 +--- a/drivers/gpu/drm/qxl/qxl_drv.h ++++ b/drivers/gpu/drm/qxl/qxl_drv.h +@@ -89,6 +89,8 @@ struct qxl_bo { + /* Constant after initialization */ + struct drm_gem_object gem_base; + bool is_primary; /* is this now a primary surface */ ++ bool is_dumb; ++ struct qxl_bo *shadow; + bool hw_surf_alloc; + struct qxl_surface surf; + uint32_t surface_id; +diff --git a/drivers/gpu/drm/qxl/qxl_dumb.c b/drivers/gpu/drm/qxl/qxl_dumb.c +index 5e65d5d..11085ab 100644 +--- a/drivers/gpu/drm/qxl/qxl_dumb.c ++++ b/drivers/gpu/drm/qxl/qxl_dumb.c +@@ -63,6 +63,7 @@ int qxl_mode_dumb_create(struct drm_file *file_priv, + &handle); + if (r) + return r; ++ qobj->is_dumb = true; + args->pitch = pitch; + args->handle = handle; + return 0; +-- +cgit v0.12 +