2013-09-09 08:02:56 +08:00
|
|
|
/*
|
|
|
|
|
* Copyright (C) 2015 Red Hat, Inc.
|
|
|
|
|
* All Rights Reserved.
|
|
|
|
|
*
|
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining
|
|
|
|
|
* a copy of this software and associated documentation files (the
|
|
|
|
|
* "Software"), to deal in the Software without restriction, including
|
|
|
|
|
* without limitation the rights to use, copy, modify, merge, publish,
|
|
|
|
|
* distribute, sublicense, and/or sell copies of the Software, and to
|
|
|
|
|
* permit persons to whom the Software is furnished to do so, subject to
|
|
|
|
|
* the following conditions:
|
|
|
|
|
*
|
|
|
|
|
* The above copyright notice and this permission notice (including the
|
|
|
|
|
* next paragraph) shall be included in all copies or substantial
|
|
|
|
|
* portions of the Software.
|
|
|
|
|
*
|
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
|
|
|
|
|
* IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
|
|
|
|
|
* LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
|
|
|
|
|
* OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
|
|
|
|
|
* WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
#ifndef VIRTIO_DRV_H
|
|
|
|
|
#define VIRTIO_DRV_H
|
|
|
|
|
|
|
|
|
|
#include <linux/virtio.h>
|
|
|
|
|
#include <linux/virtio_ids.h>
|
|
|
|
|
#include <linux/virtio_config.h>
|
|
|
|
|
#include <linux/virtio_gpu.h>
|
|
|
|
|
|
2016-05-31 14:50:47 +08:00
|
|
|
#include <drm/drm_atomic.h>
|
2020-02-11 21:58:04 +08:00
|
|
|
#include <drm/drm_drv.h>
|
2016-11-29 02:51:09 +08:00
|
|
|
#include <drm/drm_encoder.h>
|
2018-09-19 15:09:53 +08:00
|
|
|
#include <drm/drm_fb_helper.h>
|
2020-09-24 08:32:08 +08:00
|
|
|
#include <drm/drm_fourcc.h>
|
2019-06-30 14:19:16 +08:00
|
|
|
#include <drm/drm_gem.h>
|
2019-08-29 18:32:57 +08:00
|
|
|
#include <drm/drm_gem_shmem_helper.h>
|
2019-06-30 14:19:16 +08:00
|
|
|
#include <drm/drm_ioctl.h>
|
2019-01-18 05:03:34 +08:00
|
|
|
#include <drm/drm_probe_helper.h>
|
2019-10-23 14:25:37 +08:00
|
|
|
#include <drm/virtgpu_drm.h>
|
2013-09-09 08:02:56 +08:00
|
|
|
|
|
|
|
|
#define DRIVER_NAME "virtio_gpu"
|
|
|
|
|
#define DRIVER_DESC "virtio GPU"
|
|
|
|
|
#define DRIVER_DATE "0"
|
|
|
|
|
|
|
|
|
|
#define DRIVER_MAJOR 0
|
2018-11-13 00:51:57 +08:00
|
|
|
#define DRIVER_MINOR 1
|
|
|
|
|
#define DRIVER_PATCHLEVEL 0
|
2013-09-09 08:02:56 +08:00
|
|
|
|
2020-09-24 08:31:57 +08:00
|
|
|
#define STATE_INITIALIZING 0
|
|
|
|
|
#define STATE_OK 1
|
|
|
|
|
#define STATE_ERR 2
|
2020-08-18 15:13:43 +08:00
|
|
|
|
2019-03-18 19:33:29 +08:00
|
|
|
struct virtio_gpu_object_params {
|
|
|
|
|
unsigned long size;
|
2019-03-18 19:33:32 +08:00
|
|
|
bool dumb;
|
2019-03-18 19:33:31 +08:00
|
|
|
/* 3d */
|
2019-03-18 19:33:32 +08:00
|
|
|
bool virgl;
|
2020-09-24 08:32:06 +08:00
|
|
|
bool blob;
|
|
|
|
|
|
|
|
|
|
/* classic resources only */
|
|
|
|
|
uint32_t format;
|
|
|
|
|
uint32_t width;
|
|
|
|
|
uint32_t height;
|
2019-03-18 19:33:31 +08:00
|
|
|
uint32_t target;
|
|
|
|
|
uint32_t bind;
|
|
|
|
|
uint32_t depth;
|
|
|
|
|
uint32_t array_size;
|
|
|
|
|
uint32_t last_level;
|
|
|
|
|
uint32_t nr_samples;
|
|
|
|
|
uint32_t flags;
|
2020-09-24 08:32:06 +08:00
|
|
|
|
|
|
|
|
/* blob resources only */
|
|
|
|
|
uint32_t ctx_id;
|
|
|
|
|
uint32_t blob_mem;
|
|
|
|
|
uint32_t blob_flags;
|
|
|
|
|
uint64_t blob_id;
|
2019-03-18 19:33:29 +08:00
|
|
|
};
|
|
|
|
|
|
2013-09-09 08:02:56 +08:00
|
|
|
struct virtio_gpu_object {
|
2019-08-29 18:32:57 +08:00
|
|
|
struct drm_gem_shmem_object base;
|
2013-09-09 08:02:56 +08:00
|
|
|
uint32_t hw_res_handle;
|
|
|
|
|
bool dumb;
|
2018-10-19 14:18:42 +08:00
|
|
|
bool created;
|
2020-09-24 08:32:06 +08:00
|
|
|
bool host3d_blob, guest_blob;
|
|
|
|
|
uint32_t blob_mem, blob_flags;
|
2020-08-18 15:13:43 +08:00
|
|
|
|
|
|
|
|
int uuid_state;
|
|
|
|
|
uuid_t uuid;
|
2013-09-09 08:02:56 +08:00
|
|
|
};
|
|
|
|
|
#define gem_to_virtio_gpu_obj(gobj) \
|
2019-08-29 18:32:57 +08:00
|
|
|
container_of((gobj), struct virtio_gpu_object, base.base)
|
2013-09-09 08:02:56 +08:00
|
|
|
|
2020-03-05 09:32:11 +08:00
|
|
|
struct virtio_gpu_object_shmem {
|
|
|
|
|
struct virtio_gpu_object base;
|
|
|
|
|
struct sg_table *pages;
|
|
|
|
|
uint32_t mapped;
|
|
|
|
|
};
|
|
|
|
|
|
2020-09-24 08:32:07 +08:00
|
|
|
struct virtio_gpu_object_vram {
|
|
|
|
|
struct virtio_gpu_object base;
|
|
|
|
|
uint32_t map_state;
|
|
|
|
|
uint32_t map_info;
|
|
|
|
|
struct drm_mm_node vram_node;
|
|
|
|
|
};
|
|
|
|
|
|
2020-03-05 09:32:11 +08:00
|
|
|
#define to_virtio_gpu_shmem(virtio_gpu_object) \
|
|
|
|
|
container_of((virtio_gpu_object), struct virtio_gpu_object_shmem, base)
|
|
|
|
|
|
2020-09-24 08:32:07 +08:00
|
|
|
#define to_virtio_gpu_vram(virtio_gpu_object) \
|
|
|
|
|
container_of((virtio_gpu_object), struct virtio_gpu_object_vram, base)
|
|
|
|
|
|
2019-08-29 18:32:50 +08:00
|
|
|
struct virtio_gpu_object_array {
|
|
|
|
|
struct ww_acquire_ctx ticket;
|
2019-08-30 14:01:16 +08:00
|
|
|
struct list_head next;
|
2019-08-29 18:32:50 +08:00
|
|
|
u32 nents, total;
|
|
|
|
|
struct drm_gem_object *objs[];
|
|
|
|
|
};
|
|
|
|
|
|
2013-09-09 08:02:56 +08:00
|
|
|
struct virtio_gpu_vbuffer;
|
|
|
|
|
struct virtio_gpu_device;
|
|
|
|
|
|
|
|
|
|
typedef void (*virtio_gpu_resp_cb)(struct virtio_gpu_device *vgdev,
|
|
|
|
|
struct virtio_gpu_vbuffer *vbuf);
|
|
|
|
|
|
|
|
|
|
struct virtio_gpu_fence_driver {
|
2020-11-19 09:08:09 +08:00
|
|
|
atomic64_t last_fence_id;
|
|
|
|
|
uint64_t current_fence_id;
|
2016-09-01 00:26:53 +08:00
|
|
|
uint64_t context;
|
2013-09-09 08:02:56 +08:00
|
|
|
struct list_head fences;
|
|
|
|
|
spinlock_t lock;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct virtio_gpu_fence {
|
2016-10-25 20:00:45 +08:00
|
|
|
struct dma_fence f;
|
drm/virtio: consider dma-fence context when signaling
This an incremental refactor towards multiple dma-fence contexts
in virtio-gpu. Since all fences are still allocated using
&virtio_gpu_fence_driver.context, nothing should break and every
processed fence will be signaled.
The overall idea is every 3D context can allocate a number of
dma-fence contexts. Each dma-fence context refers to it's own
timeline.
For example, consider the following case where virgl submits
commands to the GPU (fence ids 1, 3) and does a metadata query with
the CPU (fence id 5). In a different process, gfxstream submits
commands to the GPU (fence ids 2, 4).
fence_id (&dma_fence.seqno) | 1 2 3 4 5
----------------------------------|-----------
fence_ctx 0 (virgl gpu) | 1 3
fence_ctx 1 (virgl metadata query)| 5
fence_ctx 2 (gfxstream gpu) | 2 4
With multiple fence contexts, we can wait for the metadata query
to finish without waiting for the virgl gpu to finish. virgl gpu
does not have to wait for gfxstream gpu. The fence id still is the
monotonically increasing sequence number, but it's only revelant to
the specific dma-fence context.
To fully enable this feature, we'll need to:
- have each 3d context allocate a number of fence contexts. Not
too hard with explicit context initialization on the horizon.
- have guest userspace specify fence context when performing
ioctls.
- tag each fence emitted to the host with the fence context
information. virtio_gpu_ctrl_hdr has padding + flags available,
so that should be easy.
This change goes in the direction specified above, by:
- looking up the virtgpu_fence given a fence_id
- signalling all prior fences in a given context
- signalling current fence
v2: fix grammar in comment
v3: add r-b tags
Reviewed-by: Anthoine Bourgeois <anthoine.bourgeois@gmail.com>
Signed-off-by: Gurchetan Singh <gurchetansingh@chromium.org>
Link: http://patchwork.freedesktop.org/patch/msgid/20201201021623.619-3-gurchetansingh@chromium.org
Signed-off-by: Gerd Hoffmann <kraxel@redhat.com>
2020-12-01 10:16:23 +08:00
|
|
|
uint64_t fence_id;
|
2013-09-09 08:02:56 +08:00
|
|
|
struct virtio_gpu_fence_driver *drv;
|
|
|
|
|
struct list_head node;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct virtio_gpu_vbuffer {
|
|
|
|
|
char *buf;
|
|
|
|
|
int size;
|
|
|
|
|
|
|
|
|
|
void *data_buf;
|
|
|
|
|
uint32_t data_size;
|
|
|
|
|
|
|
|
|
|
char *resp_buf;
|
|
|
|
|
int resp_size;
|
|
|
|
|
virtio_gpu_resp_cb resp_cb;
|
2020-02-07 15:46:36 +08:00
|
|
|
void *resp_cb_data;
|
2013-09-09 08:02:56 +08:00
|
|
|
|
2019-08-29 18:32:51 +08:00
|
|
|
struct virtio_gpu_object_array *objs;
|
2013-09-09 08:02:56 +08:00
|
|
|
struct list_head list;
|
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct virtio_gpu_output {
|
|
|
|
|
int index;
|
|
|
|
|
struct drm_crtc crtc;
|
|
|
|
|
struct drm_connector conn;
|
|
|
|
|
struct drm_encoder enc;
|
|
|
|
|
struct virtio_gpu_display_one info;
|
|
|
|
|
struct virtio_gpu_update_cursor cursor;
|
2018-10-30 14:32:06 +08:00
|
|
|
struct edid *edid;
|
2013-09-09 08:02:56 +08:00
|
|
|
int cur_x;
|
|
|
|
|
int cur_y;
|
2020-08-18 15:25:10 +08:00
|
|
|
bool needs_modeset;
|
2013-09-09 08:02:56 +08:00
|
|
|
};
|
|
|
|
|
#define drm_crtc_to_virtio_gpu_output(x) \
|
|
|
|
|
container_of(x, struct virtio_gpu_output, crtc)
|
|
|
|
|
|
|
|
|
|
struct virtio_gpu_framebuffer {
|
|
|
|
|
struct drm_framebuffer base;
|
2018-11-13 00:51:54 +08:00
|
|
|
struct virtio_gpu_fence *fence;
|
2013-09-09 08:02:56 +08:00
|
|
|
};
|
|
|
|
|
#define to_virtio_gpu_framebuffer(x) \
|
|
|
|
|
container_of(x, struct virtio_gpu_framebuffer, base)
|
|
|
|
|
|
|
|
|
|
struct virtio_gpu_queue {
|
|
|
|
|
struct virtqueue *vq;
|
|
|
|
|
spinlock_t qlock;
|
|
|
|
|
wait_queue_head_t ack_queue;
|
|
|
|
|
struct work_struct dequeue_work;
|
|
|
|
|
};
|
|
|
|
|
|
2014-10-28 19:48:00 +08:00
|
|
|
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;
|
|
|
|
|
};
|
|
|
|
|
|
2013-09-09 08:02:56 +08:00
|
|
|
struct virtio_gpu_device {
|
|
|
|
|
struct device *dev;
|
|
|
|
|
struct drm_device *ddev;
|
|
|
|
|
|
|
|
|
|
struct virtio_device *vdev;
|
|
|
|
|
|
|
|
|
|
struct virtio_gpu_output outputs[VIRTIO_GPU_MAX_SCANOUTS];
|
|
|
|
|
uint32_t num_scanouts;
|
|
|
|
|
|
|
|
|
|
struct virtio_gpu_queue ctrlq;
|
|
|
|
|
struct virtio_gpu_queue cursorq;
|
2017-03-01 22:09:08 +08:00
|
|
|
struct kmem_cache *vbufs;
|
2013-09-09 08:02:56 +08:00
|
|
|
|
2020-02-14 20:55:30 +08:00
|
|
|
atomic_t pending_commands;
|
2019-12-12 20:53:45 +08:00
|
|
|
|
2018-09-27 00:00:28 +08:00
|
|
|
struct ida resource_ida;
|
2013-09-09 08:02:56 +08:00
|
|
|
|
|
|
|
|
wait_queue_head_t resp_wq;
|
|
|
|
|
/* current display info */
|
|
|
|
|
spinlock_t display_info_lock;
|
2015-06-16 12:25:34 +08:00
|
|
|
bool display_info_pending;
|
2013-09-09 08:02:56 +08:00
|
|
|
|
|
|
|
|
struct virtio_gpu_fence_driver fence_drv;
|
|
|
|
|
|
2018-09-27 00:00:28 +08:00
|
|
|
struct ida ctx_id_ida;
|
2013-09-09 08:02:56 +08:00
|
|
|
|
2014-10-28 19:48:00 +08:00
|
|
|
bool has_virgl_3d;
|
2018-10-30 14:32:06 +08:00
|
|
|
bool has_edid;
|
2020-02-07 14:46:53 +08:00
|
|
|
bool has_indirect;
|
2020-08-18 15:13:43 +08:00
|
|
|
bool has_resource_assign_uuid;
|
2020-09-24 08:32:03 +08:00
|
|
|
bool has_resource_blob;
|
2020-09-24 08:32:04 +08:00
|
|
|
bool has_host_visible;
|
|
|
|
|
struct virtio_shm_region host_visible_region;
|
2020-09-24 08:32:07 +08:00
|
|
|
struct drm_mm host_visible_mm;
|
2014-10-28 19:48:00 +08:00
|
|
|
|
2013-09-09 08:02:56 +08:00
|
|
|
struct work_struct config_changed_work;
|
2014-10-28 19:48:00 +08:00
|
|
|
|
2019-08-30 14:01:16 +08:00
|
|
|
struct work_struct obj_free_work;
|
|
|
|
|
spinlock_t obj_free_lock;
|
|
|
|
|
struct list_head obj_free_list;
|
|
|
|
|
|
2014-10-28 19:48:00 +08:00
|
|
|
struct virtio_gpu_drv_capset *capsets;
|
|
|
|
|
uint32_t num_capsets;
|
|
|
|
|
struct list_head cap_cache;
|
2020-08-18 15:13:43 +08:00
|
|
|
|
2020-09-24 08:32:07 +08:00
|
|
|
/* protects uuid state when exporting */
|
2020-08-18 15:13:43 +08:00
|
|
|
spinlock_t resource_export_lock;
|
2020-09-24 08:32:07 +08:00
|
|
|
/* protects map state and host_visible_mm */
|
|
|
|
|
spinlock_t host_visible_lock;
|
2013-09-09 08:02:56 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
struct virtio_gpu_fpriv {
|
|
|
|
|
uint32_t ctx_id;
|
2020-02-25 08:07:59 +08:00
|
|
|
bool context_created;
|
|
|
|
|
struct mutex context_lock;
|
2013-09-09 08:02:56 +08:00
|
|
|
};
|
|
|
|
|
|
2020-11-19 09:08:06 +08:00
|
|
|
/* virtgpu_ioctl.c */
|
2020-09-24 08:32:13 +08:00
|
|
|
#define DRM_VIRTIO_NUM_IOCTLS 11
|
2013-09-09 08:02:56 +08:00
|
|
|
extern struct drm_ioctl_desc virtio_gpu_ioctls[DRM_VIRTIO_NUM_IOCTLS];
|
2020-05-02 02:55:57 +08:00
|
|
|
void virtio_gpu_create_context(struct drm_device *dev, struct drm_file *file);
|
2013-09-09 08:02:56 +08:00
|
|
|
|
2020-04-02 06:30:35 +08:00
|
|
|
/* virtgpu_kms.c */
|
2019-01-08 22:59:30 +08:00
|
|
|
int virtio_gpu_init(struct drm_device *dev);
|
|
|
|
|
void virtio_gpu_deinit(struct drm_device *dev);
|
2020-02-11 21:58:04 +08:00
|
|
|
void virtio_gpu_release(struct drm_device *dev);
|
2014-10-28 19:48:00 +08:00
|
|
|
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);
|
2013-09-09 08:02:56 +08:00
|
|
|
|
2020-04-02 06:30:35 +08:00
|
|
|
/* virtgpu_gem.c */
|
2014-10-28 19:48:00 +08:00
|
|
|
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);
|
2013-09-09 08:02:56 +08:00
|
|
|
int virtio_gpu_mode_dumb_create(struct drm_file *file_priv,
|
|
|
|
|
struct drm_device *dev,
|
|
|
|
|
struct drm_mode_create_dumb *args);
|
|
|
|
|
int virtio_gpu_mode_dumb_mmap(struct drm_file *file_priv,
|
|
|
|
|
struct drm_device *dev,
|
|
|
|
|
uint32_t handle, uint64_t *offset_p);
|
|
|
|
|
|
2019-08-29 18:32:50 +08:00
|
|
|
struct virtio_gpu_object_array *virtio_gpu_array_alloc(u32 nents);
|
|
|
|
|
struct virtio_gpu_object_array*
|
|
|
|
|
virtio_gpu_array_from_handles(struct drm_file *drm_file, u32 *handles, u32 nents);
|
|
|
|
|
void virtio_gpu_array_add_obj(struct virtio_gpu_object_array *objs,
|
|
|
|
|
struct drm_gem_object *obj);
|
|
|
|
|
int virtio_gpu_array_lock_resv(struct virtio_gpu_object_array *objs);
|
|
|
|
|
void virtio_gpu_array_unlock_resv(struct virtio_gpu_object_array *objs);
|
|
|
|
|
void virtio_gpu_array_add_fence(struct virtio_gpu_object_array *objs,
|
|
|
|
|
struct dma_fence *fence);
|
|
|
|
|
void virtio_gpu_array_put_free(struct virtio_gpu_object_array *objs);
|
2019-08-30 14:01:16 +08:00
|
|
|
void virtio_gpu_array_put_free_delayed(struct virtio_gpu_device *vgdev,
|
|
|
|
|
struct virtio_gpu_object_array *objs);
|
|
|
|
|
void virtio_gpu_array_put_free_work(struct work_struct *work);
|
2019-08-29 18:32:50 +08:00
|
|
|
|
2020-04-02 06:30:35 +08:00
|
|
|
/* virtgpu_vq.c */
|
2013-09-09 08:02:56 +08:00
|
|
|
int virtio_gpu_alloc_vbufs(struct virtio_gpu_device *vgdev);
|
|
|
|
|
void virtio_gpu_free_vbufs(struct virtio_gpu_device *vgdev);
|
|
|
|
|
void virtio_gpu_cmd_create_resource(struct virtio_gpu_device *vgdev,
|
2018-10-19 14:18:42 +08:00
|
|
|
struct virtio_gpu_object *bo,
|
2019-03-18 19:33:32 +08:00
|
|
|
struct virtio_gpu_object_params *params,
|
2019-08-29 18:32:52 +08:00
|
|
|
struct virtio_gpu_object_array *objs,
|
2019-03-18 19:33:32 +08:00
|
|
|
struct virtio_gpu_fence *fence);
|
2013-09-09 08:02:56 +08:00
|
|
|
void virtio_gpu_cmd_unref_resource(struct virtio_gpu_device *vgdev,
|
2020-02-07 15:46:36 +08:00
|
|
|
struct virtio_gpu_object *bo);
|
2013-09-09 08:02:56 +08:00
|
|
|
void virtio_gpu_cmd_transfer_to_host_2d(struct virtio_gpu_device *vgdev,
|
2018-09-20 14:29:23 +08:00
|
|
|
uint64_t offset,
|
2019-10-18 20:23:52 +08:00
|
|
|
uint32_t width, uint32_t height,
|
|
|
|
|
uint32_t x, uint32_t y,
|
2019-08-29 18:32:54 +08:00
|
|
|
struct virtio_gpu_object_array *objs,
|
2018-11-28 23:10:20 +08:00
|
|
|
struct virtio_gpu_fence *fence);
|
2013-09-09 08:02:56 +08:00
|
|
|
void virtio_gpu_cmd_resource_flush(struct virtio_gpu_device *vgdev,
|
|
|
|
|
uint32_t resource_id,
|
|
|
|
|
uint32_t x, uint32_t y,
|
|
|
|
|
uint32_t width, uint32_t height);
|
|
|
|
|
void virtio_gpu_cmd_set_scanout(struct virtio_gpu_device *vgdev,
|
|
|
|
|
uint32_t scanout_id, uint32_t resource_id,
|
|
|
|
|
uint32_t width, uint32_t height,
|
|
|
|
|
uint32_t x, uint32_t y);
|
2020-04-02 06:30:38 +08:00
|
|
|
void virtio_gpu_object_attach(struct virtio_gpu_device *vgdev,
|
|
|
|
|
struct virtio_gpu_object *obj,
|
|
|
|
|
struct virtio_gpu_mem_entry *ents,
|
|
|
|
|
unsigned int nents);
|
2013-09-09 08:02:56 +08:00
|
|
|
int virtio_gpu_attach_status_page(struct virtio_gpu_device *vgdev);
|
|
|
|
|
int virtio_gpu_detach_status_page(struct virtio_gpu_device *vgdev);
|
|
|
|
|
void virtio_gpu_cursor_ping(struct virtio_gpu_device *vgdev,
|
|
|
|
|
struct virtio_gpu_output *output);
|
|
|
|
|
int virtio_gpu_cmd_get_display_info(struct virtio_gpu_device *vgdev);
|
2014-10-28 19:48:00 +08:00
|
|
|
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);
|
2018-10-30 14:32:06 +08:00
|
|
|
int virtio_gpu_cmd_get_edids(struct virtio_gpu_device *vgdev);
|
2014-10-28 19:48:00 +08:00
|
|
|
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,
|
2019-08-29 18:32:55 +08:00
|
|
|
struct virtio_gpu_object_array *objs);
|
2014-10-28 19:48:00 +08:00
|
|
|
void virtio_gpu_cmd_context_detach_resource(struct virtio_gpu_device *vgdev,
|
|
|
|
|
uint32_t ctx_id,
|
2019-08-29 18:32:55 +08:00
|
|
|
struct virtio_gpu_object_array *objs);
|
2014-10-28 19:48:00 +08:00
|
|
|
void virtio_gpu_cmd_submit(struct virtio_gpu_device *vgdev,
|
|
|
|
|
void *data, uint32_t data_size,
|
2019-08-29 18:32:51 +08:00
|
|
|
uint32_t ctx_id,
|
|
|
|
|
struct virtio_gpu_object_array *objs,
|
|
|
|
|
struct virtio_gpu_fence *fence);
|
2014-10-28 19:48:00 +08:00
|
|
|
void virtio_gpu_cmd_transfer_from_host_3d(struct virtio_gpu_device *vgdev,
|
2019-08-29 18:32:53 +08:00
|
|
|
uint32_t ctx_id,
|
2014-10-28 19:48:00 +08:00
|
|
|
uint64_t offset, uint32_t level,
|
2020-09-24 08:32:11 +08:00
|
|
|
uint32_t stride,
|
|
|
|
|
uint32_t layer_stride,
|
2019-10-23 14:25:37 +08:00
|
|
|
struct drm_virtgpu_3d_box *box,
|
2019-08-29 18:32:53 +08:00
|
|
|
struct virtio_gpu_object_array *objs,
|
2018-11-28 23:10:20 +08:00
|
|
|
struct virtio_gpu_fence *fence);
|
2014-10-28 19:48:00 +08:00
|
|
|
void virtio_gpu_cmd_transfer_to_host_3d(struct virtio_gpu_device *vgdev,
|
2018-09-20 14:29:23 +08:00
|
|
|
uint32_t ctx_id,
|
2014-10-28 19:48:00 +08:00
|
|
|
uint64_t offset, uint32_t level,
|
2020-09-24 08:32:11 +08:00
|
|
|
uint32_t stride,
|
|
|
|
|
uint32_t layer_stride,
|
2019-10-23 14:25:37 +08:00
|
|
|
struct drm_virtgpu_3d_box *box,
|
2019-08-29 18:32:54 +08:00
|
|
|
struct virtio_gpu_object_array *objs,
|
2018-11-28 23:10:20 +08:00
|
|
|
struct virtio_gpu_fence *fence);
|
2014-10-28 19:48:00 +08:00
|
|
|
void
|
|
|
|
|
virtio_gpu_cmd_resource_create_3d(struct virtio_gpu_device *vgdev,
|
2018-10-19 14:18:42 +08:00
|
|
|
struct virtio_gpu_object *bo,
|
2019-03-18 19:33:32 +08:00
|
|
|
struct virtio_gpu_object_params *params,
|
2019-08-29 18:32:52 +08:00
|
|
|
struct virtio_gpu_object_array *objs,
|
2019-03-18 19:33:32 +08:00
|
|
|
struct virtio_gpu_fence *fence);
|
2013-09-09 08:02:56 +08:00
|
|
|
void virtio_gpu_ctrl_ack(struct virtqueue *vq);
|
|
|
|
|
void virtio_gpu_cursor_ack(struct virtqueue *vq);
|
2014-10-28 19:48:00 +08:00
|
|
|
void virtio_gpu_fence_ack(struct virtqueue *vq);
|
2013-09-09 08:02:56 +08:00
|
|
|
void virtio_gpu_dequeue_ctrl_func(struct work_struct *work);
|
|
|
|
|
void virtio_gpu_dequeue_cursor_func(struct work_struct *work);
|
2014-10-28 19:48:00 +08:00
|
|
|
void virtio_gpu_dequeue_fence_func(struct work_struct *work);
|
2013-09-09 08:02:56 +08:00
|
|
|
|
2020-02-14 20:55:30 +08:00
|
|
|
void virtio_gpu_notify(struct virtio_gpu_device *vgdev);
|
2019-12-12 20:53:45 +08:00
|
|
|
|
2020-08-18 15:13:43 +08:00
|
|
|
int
|
|
|
|
|
virtio_gpu_cmd_resource_assign_uuid(struct virtio_gpu_device *vgdev,
|
|
|
|
|
struct virtio_gpu_object_array *objs);
|
|
|
|
|
|
2020-09-24 08:32:07 +08:00
|
|
|
int virtio_gpu_cmd_map(struct virtio_gpu_device *vgdev,
|
|
|
|
|
struct virtio_gpu_object_array *objs, uint64_t offset);
|
|
|
|
|
|
|
|
|
|
void virtio_gpu_cmd_unmap(struct virtio_gpu_device *vgdev,
|
|
|
|
|
struct virtio_gpu_object *bo);
|
|
|
|
|
|
2020-09-24 08:32:08 +08:00
|
|
|
void
|
|
|
|
|
virtio_gpu_cmd_resource_create_blob(struct virtio_gpu_device *vgdev,
|
|
|
|
|
struct virtio_gpu_object *bo,
|
|
|
|
|
struct virtio_gpu_object_params *params,
|
|
|
|
|
struct virtio_gpu_mem_entry *ents,
|
|
|
|
|
uint32_t nents);
|
|
|
|
|
void
|
|
|
|
|
virtio_gpu_cmd_set_scanout_blob(struct virtio_gpu_device *vgdev,
|
|
|
|
|
uint32_t scanout_id,
|
|
|
|
|
struct virtio_gpu_object *bo,
|
|
|
|
|
struct drm_framebuffer *fb,
|
|
|
|
|
uint32_t width, uint32_t height,
|
|
|
|
|
uint32_t x, uint32_t y);
|
|
|
|
|
|
2020-04-02 06:30:35 +08:00
|
|
|
/* virtgpu_display.c */
|
2020-09-08 15:07:21 +08:00
|
|
|
int virtio_gpu_modeset_init(struct virtio_gpu_device *vgdev);
|
2013-09-09 08:02:56 +08:00
|
|
|
void virtio_gpu_modeset_fini(struct virtio_gpu_device *vgdev);
|
|
|
|
|
|
2020-04-02 06:30:35 +08:00
|
|
|
/* virtgpu_plane.c */
|
2017-04-03 15:08:44 +08:00
|
|
|
uint32_t virtio_gpu_translate_format(uint32_t drm_fourcc);
|
2013-09-09 08:02:56 +08:00
|
|
|
struct drm_plane *virtio_gpu_plane_init(struct virtio_gpu_device *vgdev,
|
2016-05-26 17:42:52 +08:00
|
|
|
enum drm_plane_type type,
|
2013-09-09 08:02:56 +08:00
|
|
|
int index);
|
|
|
|
|
|
2020-04-02 06:30:35 +08:00
|
|
|
/* virtgpu_fence.c */
|
2018-11-13 00:51:54 +08:00
|
|
|
struct virtio_gpu_fence *virtio_gpu_fence_alloc(
|
|
|
|
|
struct virtio_gpu_device *vgdev);
|
2019-05-06 17:10:34 +08:00
|
|
|
void virtio_gpu_fence_emit(struct virtio_gpu_device *vgdev,
|
2013-09-09 08:02:56 +08:00
|
|
|
struct virtio_gpu_ctrl_hdr *cmd_hdr,
|
2018-11-28 23:10:20 +08:00
|
|
|
struct virtio_gpu_fence *fence);
|
2013-09-09 08:02:56 +08:00
|
|
|
void virtio_gpu_fence_event_process(struct virtio_gpu_device *vdev,
|
2020-11-19 09:08:08 +08:00
|
|
|
u64 fence_id);
|
2013-09-09 08:02:56 +08:00
|
|
|
|
2020-04-02 06:30:35 +08:00
|
|
|
/* virtgpu_object.c */
|
2020-02-07 15:46:36 +08:00
|
|
|
void virtio_gpu_cleanup_object(struct virtio_gpu_object *bo);
|
2019-08-29 18:32:57 +08:00
|
|
|
struct drm_gem_object *virtio_gpu_create_object(struct drm_device *dev,
|
|
|
|
|
size_t size);
|
2013-09-09 08:02:56 +08:00
|
|
|
int virtio_gpu_object_create(struct virtio_gpu_device *vgdev,
|
2019-03-18 19:33:29 +08:00
|
|
|
struct virtio_gpu_object_params *params,
|
2019-03-18 19:33:32 +08:00
|
|
|
struct virtio_gpu_object **bo_ptr,
|
|
|
|
|
struct virtio_gpu_fence *fence);
|
2020-02-27 08:25:55 +08:00
|
|
|
|
2020-03-05 09:32:12 +08:00
|
|
|
bool virtio_gpu_is_shmem(struct virtio_gpu_object *bo);
|
2020-02-27 08:25:55 +08:00
|
|
|
|
2020-09-24 08:32:05 +08:00
|
|
|
int virtio_gpu_resource_id_get(struct virtio_gpu_device *vgdev,
|
|
|
|
|
uint32_t *resid);
|
2015-01-23 11:04:11 +08:00
|
|
|
/* virtgpu_prime.c */
|
2020-09-24 08:32:10 +08:00
|
|
|
int virtio_gpu_resource_assign_uuid(struct virtio_gpu_device *vgdev,
|
|
|
|
|
struct virtio_gpu_object *bo);
|
2020-08-18 15:13:43 +08:00
|
|
|
struct dma_buf *virtgpu_gem_prime_export(struct drm_gem_object *obj,
|
|
|
|
|
int flags);
|
|
|
|
|
struct drm_gem_object *virtgpu_gem_prime_import(struct drm_device *dev,
|
|
|
|
|
struct dma_buf *buf);
|
|
|
|
|
int virtgpu_gem_prime_get_uuid(struct drm_gem_object *obj,
|
|
|
|
|
uuid_t *uuid);
|
2019-04-24 08:52:20 +08:00
|
|
|
struct drm_gem_object *virtgpu_gem_prime_import_sg_table(
|
|
|
|
|
struct drm_device *dev, struct dma_buf_attachment *attach,
|
|
|
|
|
struct sg_table *sgt);
|
2015-01-23 11:04:11 +08:00
|
|
|
|
2020-04-02 06:30:35 +08:00
|
|
|
/* virtgpu_debugfs.c */
|
2020-03-10 21:31:21 +08:00
|
|
|
void virtio_gpu_debugfs_init(struct drm_minor *minor);
|
2013-09-09 08:02:56 +08:00
|
|
|
|
2020-09-24 08:32:07 +08:00
|
|
|
/* virtgpu_vram.c */
|
|
|
|
|
bool virtio_gpu_is_vram(struct virtio_gpu_object *bo);
|
|
|
|
|
int virtio_gpu_vram_create(struct virtio_gpu_device *vgdev,
|
|
|
|
|
struct virtio_gpu_object_params *params,
|
|
|
|
|
struct virtio_gpu_object **bo_ptr);
|
2013-09-09 08:02:56 +08:00
|
|
|
#endif
|