Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 76c6dccf authored by Dave Airlie's avatar Dave Airlie
Browse files

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
parents 5b735940 0062795e

drivers/gpu/drm/drm_crtc.c

+2 −0
Original line number Diff line number Diff line
@@ -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;

		}

drivers/gpu/drm/virtio/virtgpu_display.c

+33 −91
Original line number Diff line number Diff line
@@ -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)

drivers/gpu/drm/virtio/virtgpu_drv.h

+2 −0
Original line number Diff line number Diff line
@@ -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 */

drivers/gpu/drm/virtio/virtgpu_plane.c

+120 −22
Original line number Diff line number Diff line
@@ -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,7 +62,7 @@ static int virtio_gpu_plane_atomic_check(struct drm_plane *plane, 
	return 0;

}



static void virtio_gpu_plane_atomic_update(struct drm_plane *plane,

static void virtio_gpu_primary_plane_update(struct drm_plane *plane,

					    struct drm_plane_state *old_state)

{

	struct drm_device *dev = plane->dev;
@@ -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->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->crtc_w,

				      plane->state->crtc_h);

			  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:

include/drm/drm_crtc.h

+2 −0
Original line number Diff line number Diff line
@@ -253,6 +253,8 @@ struct drm_framebuffer { 
	int bits_per_pixel;

	int flags;

	uint32_t pixel_format; /* fourcc format */

	int hot_x;

	int hot_y;

	struct list_head filp_head;

};