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

Commit 31875672 authored by Dave Airlie's avatar Dave Airlie
Browse files

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

Add 3D support to the virtio-gpu.

* 'virtio-gpu-for-drm-next' of git://git.kraxel.org/linux:
  virtio-gpu: add page flip support
  virtio-gpu: mark as a render gpu
  virtio-gpu: add basic prime support
  virtio-gpu: add 3d/virgl support
  virtio-gpu: don't free things on ttm_bo_init failure
  virtio-gpu: wait for cursor updates finish
  virtio-gpu: add & use virtio_gpu_queue_fenced_ctrl_buffer
  virtio-gpu: add virtio_gpu_queue_ctrl_buffer_locked
parents c76af02d d24796a4

drivers/gpu/drm/virtio/Makefile

+2 −1
Original line number Diff line number Diff line
@@ -6,6 +6,7 @@ ccflags-y := -Iinclude/drm 


virtio-gpu-y := virtgpu_drv.o virtgpu_kms.o virtgpu_drm_bus.o virtgpu_gem.o \

	virtgpu_fb.o virtgpu_display.o virtgpu_vq.o virtgpu_ttm.o \

	virtgpu_fence.o virtgpu_object.o virtgpu_debugfs.o virtgpu_plane.o

	virtgpu_fence.o virtgpu_object.o virtgpu_debugfs.o virtgpu_plane.o \

	virtgpu_ioctl.o virtgpu_prime.o



obj-$(CONFIG_DRM_VIRTIO_GPU) += virtio-gpu.o

drivers/gpu/drm/virtio/virtgpu_display.c

+54 −3
Original line number Diff line number Diff line
@@ -90,6 +90,14 @@ static int virtio_gpu_crtc_cursor_set(struct drm_crtc *crtc, 
					   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);
@@ -117,6 +125,51 @@ static int virtio_gpu_crtc_cursor_move(struct drm_crtc *crtc, 
	return 0;

}



static int virtio_gpu_page_flip(struct drm_crtc *crtc,

				struct drm_framebuffer *fb,

				struct drm_pending_vblank_event *event,

				uint32_t flags)

{

	struct virtio_gpu_device *vgdev = crtc->dev->dev_private;

	struct virtio_gpu_output *output =

		container_of(crtc, struct virtio_gpu_output, crtc);

	struct drm_plane *plane = crtc->primary;

	struct virtio_gpu_framebuffer *vgfb;

	struct virtio_gpu_object *bo;

	unsigned long irqflags;

	uint32_t handle;



	plane->fb = fb;

	vgfb = to_virtio_gpu_framebuffer(plane->fb);

	bo = gem_to_virtio_gpu_obj(vgfb->obj);

	handle = bo->hw_res_handle;



	DRM_DEBUG("handle 0x%x%s, crtc %dx%d\n", handle,

		  bo->dumb ? ", dumb" : "",

		  crtc->mode.hdisplay, crtc->mode.vdisplay);

	if (bo->dumb) {

		virtio_gpu_cmd_transfer_to_host_2d

			(vgdev, handle, 0,

			 cpu_to_le32(crtc->mode.hdisplay),

			 cpu_to_le32(crtc->mode.vdisplay),

			 0, 0, NULL);

	}

	virtio_gpu_cmd_set_scanout(vgdev, output->index, handle,

				   crtc->mode.hdisplay,

				   crtc->mode.vdisplay, 0, 0);

	virtio_gpu_cmd_resource_flush(vgdev, handle, 0, 0,

				      crtc->mode.hdisplay,

				      crtc->mode.vdisplay);



	if (event) {

		spin_lock_irqsave(&crtc->dev->event_lock, irqflags);

		drm_send_vblank_event(crtc->dev, -1, event);

		spin_unlock_irqrestore(&crtc->dev->event_lock, irqflags);

	}



	return 0;

}



static const struct drm_crtc_funcs virtio_gpu_crtc_funcs = {

	.cursor_set2            = virtio_gpu_crtc_cursor_set,

	.cursor_move            = virtio_gpu_crtc_cursor_move,
@@ -124,9 +177,7 @@ static const struct drm_crtc_funcs virtio_gpu_crtc_funcs = { 
	.set_config             = drm_atomic_helper_set_config,

	.destroy                = drm_crtc_cleanup,



#if 0 /* not (yet) working without vblank support according to docs */

	.page_flip              = drm_atomic_helper_page_flip,

#endif

	.page_flip              = virtio_gpu_page_flip,

	.reset                  = drm_atomic_helper_crtc_reset,

	.atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state,

	.atomic_destroy_state   = drm_atomic_helper_crtc_destroy_state,

drivers/gpu/drm/virtio/virtgpu_drv.c

+27 −1
Original line number Diff line number Diff line
@@ -73,6 +73,14 @@ static struct virtio_device_id id_table[] = { 
};



static unsigned int features[] = {

#ifdef __LITTLE_ENDIAN

	/*

	 * Gallium command stream send by virgl is native endian.

	 * Because of that we only support little endian guests on

	 * little endian hosts.

	 */

	VIRTIO_GPU_F_VIRGL,

#endif

};

static struct virtio_driver virtio_gpu_driver = {

	.feature_table = features,
@@ -110,10 +118,12 @@ static const struct file_operations virtio_gpu_driver_fops = { 




static struct drm_driver driver = {

	.driver_features = DRIVER_MODESET | DRIVER_GEM,

	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME | DRIVER_RENDER,

	.set_busid = drm_virtio_set_busid,

	.load = virtio_gpu_driver_load,

	.unload = virtio_gpu_driver_unload,

	.open = virtio_gpu_driver_open,

	.postclose = virtio_gpu_driver_postclose,



	.dumb_create = virtio_gpu_mode_dumb_create,

	.dumb_map_offset = virtio_gpu_mode_dumb_mmap,
@@ -123,10 +133,26 @@ static struct drm_driver driver = { 
	.debugfs_init = virtio_gpu_debugfs_init,

	.debugfs_cleanup = virtio_gpu_debugfs_takedown,

#endif

	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,

	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,

	.gem_prime_export = drm_gem_prime_export,

	.gem_prime_import = drm_gem_prime_import,

	.gem_prime_pin = virtgpu_gem_prime_pin,

	.gem_prime_unpin = virtgpu_gem_prime_unpin,

	.gem_prime_get_sg_table = virtgpu_gem_prime_get_sg_table,

	.gem_prime_import_sg_table = virtgpu_gem_prime_import_sg_table,

	.gem_prime_vmap = virtgpu_gem_prime_vmap,

	.gem_prime_vunmap = virtgpu_gem_prime_vunmap,

	.gem_prime_mmap = virtgpu_gem_prime_mmap,



	.gem_free_object = virtio_gpu_gem_free_object,

	.gem_open_object = virtio_gpu_gem_object_open,

	.gem_close_object = virtio_gpu_gem_object_close,

	.fops = &virtio_gpu_driver_fops,



	.ioctls = virtio_gpu_ioctls,

	.num_ioctls = DRM_VIRTIO_NUM_IOCTLS,



	.name = DRIVER_NAME,

	.desc = DRIVER_DESC,

	.date = DRIVER_DATE,

drivers/gpu/drm/virtio/virtgpu_drv.h

+72 −0
Original line number Diff line number Diff line
@@ -146,6 +146,21 @@ struct virtio_gpu_queue { 
	struct work_struct dequeue_work;

};



struct virtio_gpu_drv_capset {

	uint32_t id;

	uint32_t max_version;

	uint32_t max_size;

};



struct virtio_gpu_drv_cap_cache {

	struct list_head head;

	void *caps_cache;

	uint32_t id;

	uint32_t version;

	uint32_t size;

	atomic_t is_valid;

};



struct virtio_gpu_device {

	struct device *dev;

	struct drm_device *ddev;
@@ -179,7 +194,13 @@ struct virtio_gpu_device { 
	struct idr	ctx_id_idr;

	spinlock_t ctx_id_idr_lock;



	bool has_virgl_3d;



	struct work_struct config_changed_work;



	struct virtio_gpu_drv_capset *capsets;

	uint32_t num_capsets;

	struct list_head cap_cache;

};



struct virtio_gpu_fpriv {
@@ -193,6 +214,8 @@ extern struct drm_ioctl_desc virtio_gpu_ioctls[DRM_VIRTIO_NUM_IOCTLS]; 
/* virtio_kms.c */

int virtio_gpu_driver_load(struct drm_device *dev, unsigned long flags);

int virtio_gpu_driver_unload(struct drm_device *dev);

int virtio_gpu_driver_open(struct drm_device *dev, struct drm_file *file);

void virtio_gpu_driver_postclose(struct drm_device *dev, struct drm_file *file);



/* virtio_gem.c */

void virtio_gpu_gem_free_object(struct drm_gem_object *gem_obj);
@@ -203,6 +226,10 @@ int virtio_gpu_gem_create(struct drm_file *file, 
			  uint64_t size,

			  struct drm_gem_object **obj_p,

			  uint32_t *handle_p);

int virtio_gpu_gem_object_open(struct drm_gem_object *obj,

			       struct drm_file *file);

void virtio_gpu_gem_object_close(struct drm_gem_object *obj,

				 struct drm_file *file);

struct virtio_gpu_object *virtio_gpu_alloc_object(struct drm_device *dev,

						  size_t size, bool kernel,

						  bool pinned);
@@ -260,10 +287,43 @@ void virtio_gpu_cursor_ping(struct virtio_gpu_device *vgdev, 
int virtio_gpu_cmd_get_display_info(struct virtio_gpu_device *vgdev);

void virtio_gpu_cmd_resource_inval_backing(struct virtio_gpu_device *vgdev,

					   uint32_t resource_id);

int virtio_gpu_cmd_get_capset_info(struct virtio_gpu_device *vgdev, int idx);

int virtio_gpu_cmd_get_capset(struct virtio_gpu_device *vgdev,

			      int idx, int version,

			      struct virtio_gpu_drv_cap_cache **cache_p);

void virtio_gpu_cmd_context_create(struct virtio_gpu_device *vgdev, uint32_t id,

				   uint32_t nlen, const char *name);

void virtio_gpu_cmd_context_destroy(struct virtio_gpu_device *vgdev,

				    uint32_t id);

void virtio_gpu_cmd_context_attach_resource(struct virtio_gpu_device *vgdev,

					    uint32_t ctx_id,

					    uint32_t resource_id);

void virtio_gpu_cmd_context_detach_resource(struct virtio_gpu_device *vgdev,

					    uint32_t ctx_id,

					    uint32_t resource_id);

void virtio_gpu_cmd_submit(struct virtio_gpu_device *vgdev,

			   void *data, uint32_t data_size,

			   uint32_t ctx_id, struct virtio_gpu_fence **fence);

void virtio_gpu_cmd_transfer_from_host_3d(struct virtio_gpu_device *vgdev,

					  uint32_t resource_id, uint32_t ctx_id,

					  uint64_t offset, uint32_t level,

					  struct virtio_gpu_box *box,

					  struct virtio_gpu_fence **fence);

void virtio_gpu_cmd_transfer_to_host_3d(struct virtio_gpu_device *vgdev,

					uint32_t resource_id, uint32_t ctx_id,

					uint64_t offset, uint32_t level,

					struct virtio_gpu_box *box,

					struct virtio_gpu_fence **fence);

void

virtio_gpu_cmd_resource_create_3d(struct virtio_gpu_device *vgdev,

				  struct virtio_gpu_resource_create_3d *rc_3d,

				  struct virtio_gpu_fence **fence);

void virtio_gpu_ctrl_ack(struct virtqueue *vq);

void virtio_gpu_cursor_ack(struct virtqueue *vq);

void virtio_gpu_fence_ack(struct virtqueue *vq);

void virtio_gpu_dequeue_ctrl_func(struct work_struct *work);

void virtio_gpu_dequeue_cursor_func(struct work_struct *work);

void virtio_gpu_dequeue_fence_func(struct work_struct *work);



/* virtio_gpu_display.c */

int virtio_gpu_framebuffer_init(struct drm_device *dev,
@@ -299,6 +359,18 @@ int virtio_gpu_object_get_sg_table(struct virtio_gpu_device *qdev, 
void virtio_gpu_object_free_sg_table(struct virtio_gpu_object *bo);

int virtio_gpu_object_wait(struct virtio_gpu_object *bo, bool no_wait);



/* virtgpu_prime.c */

int virtgpu_gem_prime_pin(struct drm_gem_object *obj);

void virtgpu_gem_prime_unpin(struct drm_gem_object *obj);

struct sg_table *virtgpu_gem_prime_get_sg_table(struct drm_gem_object *obj);

struct drm_gem_object *virtgpu_gem_prime_import_sg_table(

        struct drm_device *dev, struct dma_buf_attachment *attach,

        struct sg_table *sgt);

void *virtgpu_gem_prime_vmap(struct drm_gem_object *obj);

void virtgpu_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr);

int virtgpu_gem_prime_mmap(struct drm_gem_object *obj,

                                struct vm_area_struct *vma);



static inline struct virtio_gpu_object*

virtio_gpu_object_ref(struct virtio_gpu_object *bo)

{

drivers/gpu/drm/virtio/virtgpu_fence.c

+1 −1
Original line number Diff line number Diff line
@@ -81,7 +81,7 @@ int virtio_gpu_fence_emit(struct virtio_gpu_device *vgdev, 
	struct virtio_gpu_fence_driver *drv = &vgdev->fence_drv;

	unsigned long irq_flags;



	*fence = kmalloc(sizeof(struct virtio_gpu_fence), GFP_KERNEL);

	*fence = kmalloc(sizeof(struct virtio_gpu_fence), GFP_ATOMIC);

	if ((*fence) == NULL)

		return -ENOMEM;