Merge branch 'virtio-gpu-for-airlied' of git://git.kraxel.org/linux into drm-next

Virtio-gpu updates

* 'virtio-gpu-for-airlied' of git://git.kraxel.org/linux:
  virtio-gpu: use src not crtc
  virtio-gpu: pick up hotspot from framebuffer
  add cursor hotspot to drm_framebuffer
  virtio-gpu: switch to atomic cursor interfaces
  virtio-gpu: add atomic_commit function
  virtio-gpu: fix output lookup

4 files changed, 157 insertions, 113 deletions

diff --git a/drivers/gpu/drm/drm_crtc.c b/drivers/gpu/drm/drm_crtc.c
index da2f28ea5fad..a4e259524e11 100644
--- a/drivers/gpu/drm/drm_crtc.c
+++ b/drivers/gpu/drm/drm_crtc.c
@@ -2919,6 +2919,8 @@ static int drm_mode_cursor_universal(struct drm_crtc *crtc,
                                 DRM_DEBUG_KMS("failed to wrap cursor buffer in drm framebuffer\n");
                                 return PTR_ERR(fb);
                         }
+                        fb->hot_x = req->hot_x;
+                        fb->hot_y = req->hot_y;
                 } else {
                         fb = NULL;
                 }
diff --git a/drivers/gpu/drm/virtio/virtgpu_display.c b/drivers/gpu/drm/virtio/virtgpu_display.c
index ba5e11ba9f3a..d82ae1cddfcf 100644
--- a/drivers/gpu/drm/virtio/virtgpu_display.c
+++ b/drivers/gpu/drm/virtio/virtgpu_display.c
@@ -29,8 +29,8 @@
 #include <drm/drm_crtc_helper.h>
 #include <drm/drm_atomic_helper.h>
 
-#define XRES_MIN   320
-#define YRES_MIN   200
+#define XRES_MIN    32
+#define YRES_MIN    32
 
 #define XRES_DEF  1024
 #define YRES_DEF   768
@@ -38,86 +38,6 @@
 #define XRES_MAX  8192
 #define YRES_MAX  8192
 
-static void
-virtio_gpu_hide_cursor(struct virtio_gpu_device *vgdev,
-                       struct virtio_gpu_output *output)
-{
-        output->cursor.hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_UPDATE_CURSOR);
-        output->cursor.resource_id = 0;
-        virtio_gpu_cursor_ping(vgdev, output);
-}
-
-static int virtio_gpu_crtc_cursor_set(struct drm_crtc *crtc,
-                                      struct drm_file *file_priv,
-                                      uint32_t handle,
-                                      uint32_t width,
-                                      uint32_t height,
-                                      int32_t hot_x, int32_t hot_y)
-{
-        struct virtio_gpu_device *vgdev = crtc->dev->dev_private;
-        struct virtio_gpu_output *output =
-                container_of(crtc, struct virtio_gpu_output, crtc);
-        struct drm_gem_object *gobj = NULL;
-        struct virtio_gpu_object *qobj = NULL;
-        struct virtio_gpu_fence *fence = NULL;
-        int ret = 0;
-
-        if (handle == 0) {
-                virtio_gpu_hide_cursor(vgdev, output);
-                return 0;
-        }
-
-        /* lookup the cursor */
-        gobj = drm_gem_object_lookup(file_priv, handle);
-        if (gobj == NULL)
-                return -ENOENT;
-
-        qobj = gem_to_virtio_gpu_obj(gobj);
-
-        if (!qobj->hw_res_handle) {
-                ret = -EINVAL;
-                goto out;
-        }
-
-        virtio_gpu_cmd_transfer_to_host_2d(vgdev, qobj->hw_res_handle, 0,
-                                           cpu_to_le32(64),
-                                           cpu_to_le32(64),
-                                           0, 0, &fence);
-        ret = virtio_gpu_object_reserve(qobj, false);
-        if (!ret) {
-                reservation_object_add_excl_fence(qobj->tbo.resv,
-                                                  &fence->f);
-                fence_put(&fence->f);
-                virtio_gpu_object_unreserve(qobj);
-                virtio_gpu_object_wait(qobj, false);
-        }
-
-        output->cursor.hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_UPDATE_CURSOR);
-        output->cursor.resource_id = cpu_to_le32(qobj->hw_res_handle);
-        output->cursor.hot_x = cpu_to_le32(hot_x);
-        output->cursor.hot_y = cpu_to_le32(hot_y);
-        virtio_gpu_cursor_ping(vgdev, output);
-        ret = 0;
-
-out:
-        drm_gem_object_unreference_unlocked(gobj);
-        return ret;
-}
-
-static int virtio_gpu_crtc_cursor_move(struct drm_crtc *crtc,
-                                    int x, int y)
-{
-        struct virtio_gpu_device *vgdev = crtc->dev->dev_private;
-        struct virtio_gpu_output *output =
-                container_of(crtc, struct virtio_gpu_output, crtc);
-
-        output->cursor.hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_MOVE_CURSOR);
-        output->cursor.pos.x = cpu_to_le32(x);
-        output->cursor.pos.y = cpu_to_le32(y);
-        virtio_gpu_cursor_ping(vgdev, output);
-        return 0;
-}
-
 static int virtio_gpu_page_flip(struct drm_crtc *crtc,
                                 struct drm_framebuffer *fb,
                                 struct drm_pending_vblank_event *event,
@@ -164,8 +84,6 @@ static int virtio_gpu_page_flip(struct drm_crtc *crtc,
 }
 
 static const struct drm_crtc_funcs virtio_gpu_crtc_funcs = {
-        .cursor_set2            = virtio_gpu_crtc_cursor_set,
-        .cursor_move            = virtio_gpu_crtc_cursor_move,
         .set_config             = drm_atomic_helper_set_config,
         .destroy                = drm_crtc_cleanup,
 
@@ -406,7 +324,7 @@ static int vgdev_output_init(struct virtio_gpu_device *vgdev, int index)
         struct drm_connector *connector = &output->conn;
         struct drm_encoder *encoder = &output->enc;
         struct drm_crtc *crtc = &output->crtc;
-        struct drm_plane *plane;
+        struct drm_plane *primary, *cursor;
 
         output->index = index;
         if (index == 0) {
@@ -415,13 +333,17 @@ static int vgdev_output_init(struct virtio_gpu_device *vgdev, int index)
                 output->info.r.height = cpu_to_le32(YRES_DEF);
         }
 
-        plane = virtio_gpu_plane_init(vgdev, index);
-        if (IS_ERR(plane))
-                return PTR_ERR(plane);
-        drm_crtc_init_with_planes(dev, crtc, plane, NULL,
+        primary = virtio_gpu_plane_init(vgdev, DRM_PLANE_TYPE_PRIMARY, index);
+        if (IS_ERR(primary))
+                return PTR_ERR(primary);
+        cursor = virtio_gpu_plane_init(vgdev, DRM_PLANE_TYPE_CURSOR, index);
+        if (IS_ERR(cursor))
+                return PTR_ERR(cursor);
+        drm_crtc_init_with_planes(dev, crtc, primary, cursor,
                                   &virtio_gpu_crtc_funcs, NULL);
         drm_crtc_helper_add(crtc, &virtio_gpu_crtc_helper_funcs);
-        plane->crtc = crtc;
+        primary->crtc = crtc;
+        cursor->crtc = crtc;
 
         drm_connector_init(dev, connector, &virtio_gpu_connector_funcs,
                            DRM_MODE_CONNECTOR_VIRTUAL);
@@ -466,10 +388,30 @@ virtio_gpu_user_framebuffer_create(struct drm_device *dev,
         return &virtio_gpu_fb->base;
 }
 
+static int vgdev_atomic_commit(struct drm_device *dev,
+                               struct drm_atomic_state *state,
+                               bool nonblock)
+{
+        if (nonblock)
+                return -EBUSY;
+
+        drm_atomic_helper_swap_state(dev, state);
+        drm_atomic_helper_wait_for_fences(dev, state);
+
+        drm_atomic_helper_commit_modeset_disables(dev, state);
+        drm_atomic_helper_commit_modeset_enables(dev, state);
+        drm_atomic_helper_commit_planes(dev, state, true);
+
+        drm_atomic_helper_wait_for_vblanks(dev, state);
+        drm_atomic_helper_cleanup_planes(dev, state);
+        drm_atomic_state_free(state);
+        return 0;
+}
+
 static const struct drm_mode_config_funcs virtio_gpu_mode_funcs = {
         .fb_create = virtio_gpu_user_framebuffer_create,
         .atomic_check = drm_atomic_helper_check,
-        .atomic_commit = drm_atomic_helper_commit,
+        .atomic_commit = vgdev_atomic_commit,
 };
 
 int virtio_gpu_modeset_init(struct virtio_gpu_device *vgdev)
diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.h b/drivers/gpu/drm/virtio/virtgpu_drv.h
index 0a54f43f846a..acf556a35cb2 100644
--- a/drivers/gpu/drm/virtio/virtgpu_drv.h
+++ b/drivers/gpu/drm/virtio/virtgpu_drv.h
@@ -33,6 +33,7 @@
 
 #include <drm/drmP.h>
 #include <drm/drm_gem.h>
+#include <drm/drm_atomic.h>
 #include <drm/drm_crtc_helper.h>
 #include <ttm/ttm_bo_api.h>
 #include <ttm/ttm_bo_driver.h>
@@ -335,6 +336,7 @@ void virtio_gpu_modeset_fini(struct virtio_gpu_device *vgdev);
 
 /* virtio_gpu_plane.c */
 struct drm_plane *virtio_gpu_plane_init(struct virtio_gpu_device *vgdev,
+                                        enum drm_plane_type type,
                                         int index);
 
 /* virtio_gpu_ttm.c */
diff --git a/drivers/gpu/drm/virtio/virtgpu_plane.c b/drivers/gpu/drm/virtio/virtgpu_plane.c
index e50674bccb09..925ca25209df 100644
--- a/drivers/gpu/drm/virtio/virtgpu_plane.c
+++ b/drivers/gpu/drm/virtio/virtgpu_plane.c
@@ -38,6 +38,10 @@ static const uint32_t virtio_gpu_formats[] = {
         DRM_FORMAT_ABGR8888,
 };
 
+static const uint32_t virtio_gpu_cursor_formats[] = {
+        DRM_FORMAT_ARGB8888,
+};
+
 static void virtio_gpu_plane_destroy(struct drm_plane *plane)
 {
         kfree(plane);
@@ -58,8 +62,8 @@ static int virtio_gpu_plane_atomic_check(struct drm_plane *plane,
         return 0;
 }
 
-static void virtio_gpu_plane_atomic_update(struct drm_plane *plane,
-                                           struct drm_plane_state *old_state)
+static void virtio_gpu_primary_plane_update(struct drm_plane *plane,
+                                            struct drm_plane_state *old_state)
 {
         struct drm_device *dev = plane->dev;
         struct virtio_gpu_device *vgdev = dev->dev_private;
@@ -81,55 +85,149 @@ static void virtio_gpu_plane_atomic_update(struct drm_plane *plane,
                 if (bo->dumb) {
                         virtio_gpu_cmd_transfer_to_host_2d
                                 (vgdev, handle, 0,
-                                 cpu_to_le32(plane->state->crtc_w),
-                                 cpu_to_le32(plane->state->crtc_h),
-                                 plane->state->crtc_x, plane->state->crtc_y, NULL);
+                                 cpu_to_le32(plane->state->src_w >> 16),
+                                 cpu_to_le32(plane->state->src_h >> 16),
+                                 plane->state->src_x >> 16,
+                                 plane->state->src_y >> 16, NULL);
                 }
         } else {
                 handle = 0;
         }
 
-        DRM_DEBUG("handle 0x%x, crtc %dx%d+%d+%d\n", handle,
+        DRM_DEBUG("handle 0x%x, crtc %dx%d+%d+%d, src %dx%d+%d+%d\n", handle,
                   plane->state->crtc_w, plane->state->crtc_h,
-                  plane->state->crtc_x, plane->state->crtc_y);
+                  plane->state->crtc_x, plane->state->crtc_y,
+                  plane->state->src_w >> 16,
+                  plane->state->src_h >> 16,
+                  plane->state->src_x >> 16,
+                  plane->state->src_y >> 16);
         virtio_gpu_cmd_set_scanout(vgdev, output->index, handle,
-                                   plane->state->crtc_w,
-                                   plane->state->crtc_h,
-                                   plane->state->crtc_x,
-                                   plane->state->crtc_y);
+                                   plane->state->src_w >> 16,
+                                   plane->state->src_h >> 16,
+                                   plane->state->src_x >> 16,
+                                   plane->state->src_y >> 16);
         virtio_gpu_cmd_resource_flush(vgdev, handle,
-                                      plane->state->crtc_x,
-                                      plane->state->crtc_y,
-                                      plane->state->crtc_w,
-                                      plane->state->crtc_h);
+                                      plane->state->src_x >> 16,
+                                      plane->state->src_y >> 16,
+                                      plane->state->src_w >> 16,
+                                      plane->state->src_h >> 16);
+}
+
+static void virtio_gpu_cursor_plane_update(struct drm_plane *plane,
+                                           struct drm_plane_state *old_state)
+{
+        struct drm_device *dev = plane->dev;
+        struct virtio_gpu_device *vgdev = dev->dev_private;
+        struct virtio_gpu_output *output = NULL;
+        struct virtio_gpu_framebuffer *vgfb;
+        struct virtio_gpu_fence *fence = NULL;
+        struct virtio_gpu_object *bo = NULL;
+        uint32_t handle;
+        int ret = 0;
+
+        if (plane->state->crtc)
+                output = drm_crtc_to_virtio_gpu_output(plane->state->crtc);
+        if (old_state->crtc)
+                output = drm_crtc_to_virtio_gpu_output(old_state->crtc);
+        WARN_ON(!output);
+
+        if (plane->state->fb) {
+                vgfb = to_virtio_gpu_framebuffer(plane->state->fb);
+                bo = gem_to_virtio_gpu_obj(vgfb->obj);
+                handle = bo->hw_res_handle;
+        } else {
+                handle = 0;
+        }
+
+        if (bo && bo->dumb && (plane->state->fb != old_state->fb)) {
+                /* new cursor -- update & wait */
+                virtio_gpu_cmd_transfer_to_host_2d
+                        (vgdev, handle, 0,
+                         cpu_to_le32(plane->state->crtc_w),
+                         cpu_to_le32(plane->state->crtc_h),
+                         0, 0, &fence);
+                ret = virtio_gpu_object_reserve(bo, false);
+                if (!ret) {
+                        reservation_object_add_excl_fence(bo->tbo.resv,
+                                                          &fence->f);
+                        fence_put(&fence->f);
+                        fence = NULL;
+                        virtio_gpu_object_unreserve(bo);
+                        virtio_gpu_object_wait(bo, false);
+                }
+        }
+
+        if (plane->state->fb != old_state->fb) {
+                DRM_DEBUG("update, handle %d, pos +%d+%d, hot %d,%d\n", handle,
+                          plane->state->crtc_x,
+                          plane->state->crtc_y,
+                          plane->state->fb ? plane->state->fb->hot_x : 0,
+                          plane->state->fb ? plane->state->fb->hot_y : 0);
+                output->cursor.hdr.type =
+                        cpu_to_le32(VIRTIO_GPU_CMD_UPDATE_CURSOR);
+                output->cursor.resource_id = cpu_to_le32(handle);
+                if (plane->state->fb) {
+                        output->cursor.hot_x =
+                                cpu_to_le32(plane->state->fb->hot_x);
+                        output->cursor.hot_y =
+                                cpu_to_le32(plane->state->fb->hot_y);
+                } else {
+                        output->cursor.hot_x = cpu_to_le32(0);
+                        output->cursor.hot_y = cpu_to_le32(0);
+                }
+        } else {
+                DRM_DEBUG("move +%d+%d\n",
+                          plane->state->crtc_x,
+                          plane->state->crtc_y);
+                output->cursor.hdr.type =
+                        cpu_to_le32(VIRTIO_GPU_CMD_MOVE_CURSOR);
+        }
+        output->cursor.pos.x = cpu_to_le32(plane->state->crtc_x);
+        output->cursor.pos.y = cpu_to_le32(plane->state->crtc_y);
+        virtio_gpu_cursor_ping(vgdev, output);
 }
 
+static const struct drm_plane_helper_funcs virtio_gpu_primary_helper_funcs = {
+        .atomic_check           = virtio_gpu_plane_atomic_check,
+        .atomic_update          = virtio_gpu_primary_plane_update,
+};
 
-static const struct drm_plane_helper_funcs virtio_gpu_plane_helper_funcs = {
+static const struct drm_plane_helper_funcs virtio_gpu_cursor_helper_funcs = {
         .atomic_check           = virtio_gpu_plane_atomic_check,
-        .atomic_update          = virtio_gpu_plane_atomic_update,
+        .atomic_update          = virtio_gpu_cursor_plane_update,
 };
 
 struct drm_plane *virtio_gpu_plane_init(struct virtio_gpu_device *vgdev,
+                                        enum drm_plane_type type,
                                         int index)
 {
         struct drm_device *dev = vgdev->ddev;
+        const struct drm_plane_helper_funcs *funcs;
         struct drm_plane *plane;
-        int ret;
+        const uint32_t *formats;
+        int ret, nformats;
 
         plane = kzalloc(sizeof(*plane), GFP_KERNEL);
         if (!plane)
                 return ERR_PTR(-ENOMEM);
 
+        if (type == DRM_PLANE_TYPE_CURSOR) {
+                formats = virtio_gpu_cursor_formats;
+                nformats = ARRAY_SIZE(virtio_gpu_cursor_formats);
+                funcs = &virtio_gpu_cursor_helper_funcs;
+        } else {
+                formats = virtio_gpu_formats;
+                nformats = ARRAY_SIZE(virtio_gpu_formats);
+                funcs = &virtio_gpu_primary_helper_funcs;
+        }
         ret = drm_universal_plane_init(dev, plane, 1 << index,
                                        &virtio_gpu_plane_funcs,
-                                       virtio_gpu_formats,
-                                       ARRAY_SIZE(virtio_gpu_formats),
-                                       DRM_PLANE_TYPE_PRIMARY, NULL);
+                                       formats, nformats,
+                                       type, NULL);
         if (ret)
                 goto err_plane_init;
 
-        drm_plane_helper_add(plane, &virtio_gpu_plane_helper_funcs);
+        drm_plane_helper_add(plane, funcs);
         return plane;
 
 err_plane_init: