| Message ID | 1432300312-24792-5-git-send-email-kraxel@redhat.com (mailing list archive) |
|---|---|
| State | New, archived |
| Headers | show |
On Fri, May 22, 2015 at 03:11:52PM +0200, Gerd Hoffmann wrote: > From: Dave Airlie <airlied@gmail.com> > > This patch adds a kms driver for the virtio gpu. The xorg modesetting > driver can handle the device just fine, the framebuffer for fbcon is > there too. > > Qemu patches for the host side are under review currently. > > The pci version of the device comes in two variants: with and without > vga compatibility. The former has a extra memory bar for the vga > framebuffer, the later is a pure virtio device. The only concern for > this driver is that in the virtio-vga case we have to kick out the > firmware framebuffer. > > Initial revision has only 2d support, 3d (virgl) support requires > some more work on the qemu side and will be added later. > > Signed-off-by: Dave Airlie <airlied@redhat.com> > Signed-off-by: Gerd Hoffmann <kraxel@redhat.com> I think it's ok to merge this through the dri tree. Acked-by: Michael S. Tsirkin <mst@redhat.com> > --- > drivers/gpu/drm/Kconfig | 2 + > drivers/gpu/drm/Makefile | 1 + > drivers/gpu/drm/virtio/Kconfig | 14 + > drivers/gpu/drm/virtio/Makefile | 11 + > drivers/gpu/drm/virtio/virtgpu_debugfs.c | 64 ++++ > drivers/gpu/drm/virtio/virtgpu_display.c | 485 ++++++++++++++++++++++++ > drivers/gpu/drm/virtio/virtgpu_drm_bus.c | 91 +++++ > drivers/gpu/drm/virtio/virtgpu_drv.c | 136 +++++++ > drivers/gpu/drm/virtio/virtgpu_drv.h | 350 ++++++++++++++++++ > drivers/gpu/drm/virtio/virtgpu_fb.c | 431 ++++++++++++++++++++++ > drivers/gpu/drm/virtio/virtgpu_fence.c | 119 ++++++ > drivers/gpu/drm/virtio/virtgpu_gem.c | 140 +++++++ > drivers/gpu/drm/virtio/virtgpu_kms.c | 164 +++++++++ > drivers/gpu/drm/virtio/virtgpu_object.c | 170 +++++++++ > drivers/gpu/drm/virtio/virtgpu_plane.c | 120 ++++++ > drivers/gpu/drm/virtio/virtgpu_ttm.c | 469 +++++++++++++++++++++++ > drivers/gpu/drm/virtio/virtgpu_vq.c | 614 +++++++++++++++++++++++++++++++ > include/drm/drmP.h | 1 + > include/uapi/linux/Kbuild | 1 + > include/uapi/linux/virtio_gpu.h | 204 ++++++++++ > include/uapi/linux/virtio_ids.h | 1 + > 21 files changed, 3588 insertions(+) > create mode 100644 drivers/gpu/drm/virtio/Kconfig > create mode 100644 drivers/gpu/drm/virtio/Makefile > create mode 100644 drivers/gpu/drm/virtio/virtgpu_debugfs.c > create mode 100644 drivers/gpu/drm/virtio/virtgpu_display.c > create mode 100644 drivers/gpu/drm/virtio/virtgpu_drm_bus.c > create mode 100644 drivers/gpu/drm/virtio/virtgpu_drv.c > create mode 100644 drivers/gpu/drm/virtio/virtgpu_drv.h > create mode 100644 drivers/gpu/drm/virtio/virtgpu_fb.c > create mode 100644 drivers/gpu/drm/virtio/virtgpu_fence.c > create mode 100644 drivers/gpu/drm/virtio/virtgpu_gem.c > create mode 100644 drivers/gpu/drm/virtio/virtgpu_kms.c > create mode 100644 drivers/gpu/drm/virtio/virtgpu_object.c > create mode 100644 drivers/gpu/drm/virtio/virtgpu_plane.c > create mode 100644 drivers/gpu/drm/virtio/virtgpu_ttm.c > create mode 100644 drivers/gpu/drm/virtio/virtgpu_vq.c > create mode 100644 include/uapi/linux/virtio_gpu.h > > diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig > index 47f2ce8..d4b6545 100644 > --- a/drivers/gpu/drm/Kconfig > +++ b/drivers/gpu/drm/Kconfig > @@ -206,6 +206,8 @@ source "drivers/gpu/drm/qxl/Kconfig" > > source "drivers/gpu/drm/bochs/Kconfig" > > +source "drivers/gpu/drm/virtio/Kconfig" > + > source "drivers/gpu/drm/msm/Kconfig" > > source "drivers/gpu/drm/tegra/Kconfig" > diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile > index 7d4944e..dbbc101 100644 > --- a/drivers/gpu/drm/Makefile > +++ b/drivers/gpu/drm/Makefile > @@ -63,6 +63,7 @@ obj-$(CONFIG_DRM_OMAP) += omapdrm/ > obj-$(CONFIG_DRM_TILCDC) += tilcdc/ > obj-$(CONFIG_DRM_QXL) += qxl/ > obj-$(CONFIG_DRM_BOCHS) += bochs/ > +obj-$(CONFIG_DRM_VIRTIO_GPU) += virtio/ > obj-$(CONFIG_DRM_MSM) += msm/ > obj-$(CONFIG_DRM_TEGRA) += tegra/ > obj-$(CONFIG_DRM_STI) += sti/ > diff --git a/drivers/gpu/drm/virtio/Kconfig b/drivers/gpu/drm/virtio/Kconfig > new file mode 100644 > index 0000000..9983ead > --- /dev/null > +++ b/drivers/gpu/drm/virtio/Kconfig > @@ -0,0 +1,14 @@ > +config DRM_VIRTIO_GPU > + tristate "Virtio GPU driver" > + depends on DRM && VIRTIO > + select FB_SYS_FILLRECT > + select FB_SYS_COPYAREA > + select FB_SYS_IMAGEBLIT > + select DRM_KMS_HELPER > + select DRM_KMS_FB_HELPER > + select DRM_TTM > + help > + This is the virtual GPU driver for virtio. It can be used with > + QEMU based VMMs (like KVM or Xen). > + > + If unsure say M. > diff --git a/drivers/gpu/drm/virtio/Makefile b/drivers/gpu/drm/virtio/Makefile > new file mode 100644 > index 0000000..2ee1602 > --- /dev/null > +++ b/drivers/gpu/drm/virtio/Makefile > @@ -0,0 +1,11 @@ > +# > +# Makefile for the drm device driver. This driver provides support for the > +# Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher. > + > +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 > + > +obj-$(CONFIG_DRM_VIRTIO_GPU) += virtio-gpu.o > diff --git a/drivers/gpu/drm/virtio/virtgpu_debugfs.c b/drivers/gpu/drm/virtio/virtgpu_debugfs.c > new file mode 100644 > index 0000000..db8b491 > --- /dev/null > +++ b/drivers/gpu/drm/virtio/virtgpu_debugfs.c > @@ -0,0 +1,64 @@ > +/* > + * 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. > + */ > + > +#include <linux/debugfs.h> > + > +#include "drmP.h" > +#include "virtgpu_drv.h" > + > +static int > +virtio_gpu_debugfs_irq_info(struct seq_file *m, void *data) > +{ > + struct drm_info_node *node = (struct drm_info_node *) m->private; > + struct virtio_gpu_device *vgdev = node->minor->dev->dev_private; > + > + seq_printf(m, "fence %ld %lld\n", > + atomic64_read(&vgdev->fence_drv.last_seq), > + vgdev->fence_drv.sync_seq); > + return 0; > +} > + > +static struct drm_info_list virtio_gpu_debugfs_list[] = { > + { "irq_fence", virtio_gpu_debugfs_irq_info, 0, NULL }, > +}; > + > +#define VIRTIO_GPU_DEBUGFS_ENTRIES ARRAY_SIZE(virtio_gpu_debugfs_list) > + > +int > +virtio_gpu_debugfs_init(struct drm_minor *minor) > +{ > + drm_debugfs_create_files(virtio_gpu_debugfs_list, > + VIRTIO_GPU_DEBUGFS_ENTRIES, > + minor->debugfs_root, minor); > + return 0; > +} > + > +void > +virtio_gpu_debugfs_takedown(struct drm_minor *minor) > +{ > + drm_debugfs_remove_files(virtio_gpu_debugfs_list, > + VIRTIO_GPU_DEBUGFS_ENTRIES, > + minor); > +} > diff --git a/drivers/gpu/drm/virtio/virtgpu_display.c b/drivers/gpu/drm/virtio/virtgpu_display.c > new file mode 100644 > index 0000000..a2eca5f > --- /dev/null > +++ b/drivers/gpu/drm/virtio/virtgpu_display.c > @@ -0,0 +1,485 @@ > +/* > + * Copyright (C) 2015 Red Hat, Inc. > + * All Rights Reserved. > + * > + * Authors: > + * Dave Airlie > + * Alon Levy > + * > + * 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 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 HOLDER(S) OR AUTHOR(S) 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. > + */ > + > +#include "virtgpu_drv.h" > +#include <drm/drm_crtc_helper.h> > +#include <drm/drm_atomic_helper.h> > + > +#define XRES_MIN 320 > +#define YRES_MIN 200 > + > +#define XRES_DEF 1024 > +#define YRES_DEF 768 > + > +#define XRES_MAX 8192 > +#define YRES_MAX 8192 > + > +static int virtio_gpu_fbdev = 1; > + > +MODULE_PARM_DESC(fbdev, "Disable/Enable framebuffer device & console"); > +module_param_named(fbdev, virtio_gpu_fbdev, int, 0400); > + > +static void virtio_gpu_crtc_gamma_set(struct drm_crtc *crtc, > + u16 *red, u16 *green, u16 *blue, > + uint32_t start, uint32_t size) > +{ > + /* TODO */ > +} > + > +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(crtc->dev, 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); > + > + 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 const struct drm_crtc_funcs virtio_gpu_crtc_funcs = { > + .cursor_set2 = virtio_gpu_crtc_cursor_set, > + .cursor_move = virtio_gpu_crtc_cursor_move, > + .gamma_set = virtio_gpu_crtc_gamma_set, > + .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 > + .reset = drm_atomic_helper_crtc_reset, > + .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state, > + .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state, > +}; > + > +static void virtio_gpu_user_framebuffer_destroy(struct drm_framebuffer *fb) > +{ > + struct virtio_gpu_framebuffer *virtio_gpu_fb > + = to_virtio_gpu_framebuffer(fb); > + > + if (virtio_gpu_fb->obj) > + drm_gem_object_unreference_unlocked(virtio_gpu_fb->obj); > + drm_framebuffer_cleanup(fb); > + kfree(virtio_gpu_fb); > +} > + > +static int > +virtio_gpu_framebuffer_surface_dirty(struct drm_framebuffer *fb, > + struct drm_file *file_priv, > + unsigned flags, unsigned color, > + struct drm_clip_rect *clips, > + unsigned num_clips) > +{ > + struct virtio_gpu_framebuffer *virtio_gpu_fb > + = to_virtio_gpu_framebuffer(fb); > + > + return virtio_gpu_surface_dirty(virtio_gpu_fb, clips, num_clips); > +} > + > +static const struct drm_framebuffer_funcs virtio_gpu_fb_funcs = { > + .destroy = virtio_gpu_user_framebuffer_destroy, > + .dirty = virtio_gpu_framebuffer_surface_dirty, > +}; > + > +int > +virtio_gpu_framebuffer_init(struct drm_device *dev, > + struct virtio_gpu_framebuffer *vgfb, > + struct drm_mode_fb_cmd2 *mode_cmd, > + struct drm_gem_object *obj) > +{ > + int ret; > + struct virtio_gpu_object *bo; > + vgfb->obj = obj; > + > + bo = gem_to_virtio_gpu_obj(obj); > + > + ret = drm_framebuffer_init(dev, &vgfb->base, &virtio_gpu_fb_funcs); > + if (ret) { > + vgfb->obj = NULL; > + return ret; > + } > + drm_helper_mode_fill_fb_struct(&vgfb->base, mode_cmd); > + > + spin_lock_init(&vgfb->dirty_lock); > + vgfb->x1 = vgfb->y1 = INT_MAX; > + vgfb->x2 = vgfb->y2 = 0; > + return 0; > +} > + > +static bool virtio_gpu_crtc_mode_fixup(struct drm_crtc *crtc, > + const struct drm_display_mode *mode, > + struct drm_display_mode *adjusted_mode) > +{ > + return true; > +} > + > +static void virtio_gpu_crtc_mode_set_nofb(struct drm_crtc *crtc) > +{ > + struct drm_device *dev = crtc->dev; > + struct virtio_gpu_device *vgdev = dev->dev_private; > + struct virtio_gpu_output *output = drm_crtc_to_virtio_gpu_output(crtc); > + > + virtio_gpu_cmd_set_scanout(vgdev, output->index, 0, > + crtc->mode.hdisplay, > + crtc->mode.vdisplay, 0, 0); > +} > + > +static void virtio_gpu_crtc_enable(struct drm_crtc *crtc) > +{ > +} > + > +static void virtio_gpu_crtc_disable(struct drm_crtc *crtc) > +{ > + struct drm_device *dev = crtc->dev; > + struct virtio_gpu_device *vgdev = dev->dev_private; > + struct virtio_gpu_output *output = drm_crtc_to_virtio_gpu_output(crtc); > + > + virtio_gpu_cmd_set_scanout(vgdev, output->index, 0, 0, 0, 0, 0); > +} > + > +static int virtio_gpu_crtc_atomic_check(struct drm_crtc *crtc, > + struct drm_crtc_state *state) > +{ > + return 0; > +} > + > +static const struct drm_crtc_helper_funcs virtio_gpu_crtc_helper_funcs = { > + .enable = virtio_gpu_crtc_enable, > + .disable = virtio_gpu_crtc_disable, > + .mode_fixup = virtio_gpu_crtc_mode_fixup, > + .mode_set_nofb = virtio_gpu_crtc_mode_set_nofb, > + .atomic_check = virtio_gpu_crtc_atomic_check, > +}; > + > +static bool virtio_gpu_enc_mode_fixup(struct drm_encoder *encoder, > + const struct drm_display_mode *mode, > + struct drm_display_mode *adjusted_mode) > +{ > + return true; > +} > + > +static void virtio_gpu_enc_mode_set(struct drm_encoder *encoder, > + struct drm_display_mode *mode, > + struct drm_display_mode *adjusted_mode) > +{ > +} > + > +static void virtio_gpu_enc_enable(struct drm_encoder *encoder) > +{ > +} > + > +static void virtio_gpu_enc_disable(struct drm_encoder *encoder) > +{ > +} > + > +static int virtio_gpu_conn_get_modes(struct drm_connector *connector) > +{ > + struct virtio_gpu_output *output = > + drm_connector_to_virtio_gpu_output(connector); > + struct drm_display_mode *mode = NULL; > + int count, width, height; > + > + width = le32_to_cpu(output->info.r.width); > + height = le32_to_cpu(output->info.r.height); > + count = drm_add_modes_noedid(connector, XRES_MAX, YRES_MAX); > + > + if (width == 0 || height == 0) { > + width = XRES_DEF; > + height = YRES_DEF; > + drm_set_preferred_mode(connector, XRES_DEF, YRES_DEF); > + } else { > + DRM_DEBUG("add mode: %dx%d\n", width, height); > + mode = drm_cvt_mode(connector->dev, width, height, 60, > + false, false, false); > + mode->type |= DRM_MODE_TYPE_PREFERRED; > + drm_mode_probed_add(connector, mode); > + count++; > + } > + > + return count; > +} > + > +static int virtio_gpu_conn_mode_valid(struct drm_connector *connector, > + struct drm_display_mode *mode) > +{ > + struct virtio_gpu_output *output = > + drm_connector_to_virtio_gpu_output(connector); > + int width, height; > + > + width = le32_to_cpu(output->info.r.width); > + height = le32_to_cpu(output->info.r.height); > + > + if (!(mode->type & DRM_MODE_TYPE_PREFERRED)) > + return MODE_OK; > + if (mode->hdisplay == XRES_DEF && mode->vdisplay == YRES_DEF) > + return MODE_OK; > + if (mode->hdisplay <= width && mode->hdisplay >= width - 16 && > + mode->vdisplay <= height && mode->vdisplay >= height - 16) > + return MODE_OK; > + > + DRM_DEBUG("del mode: %dx%d\n", mode->hdisplay, mode->vdisplay); > + return MODE_BAD; > +} > + > +static struct drm_encoder* > +virtio_gpu_best_encoder(struct drm_connector *connector) > +{ > + struct virtio_gpu_output *virtio_gpu_output = > + drm_connector_to_virtio_gpu_output(connector); > + > + return &virtio_gpu_output->enc; > +} > + > +static const struct drm_encoder_helper_funcs virtio_gpu_enc_helper_funcs = { > + .mode_fixup = virtio_gpu_enc_mode_fixup, > + .mode_set = virtio_gpu_enc_mode_set, > + .enable = virtio_gpu_enc_enable, > + .disable = virtio_gpu_enc_disable, > +}; > + > +static const struct drm_connector_helper_funcs virtio_gpu_conn_helper_funcs = { > + .get_modes = virtio_gpu_conn_get_modes, > + .mode_valid = virtio_gpu_conn_mode_valid, > + .best_encoder = virtio_gpu_best_encoder, > +}; > + > +static void virtio_gpu_conn_save(struct drm_connector *connector) > +{ > + DRM_DEBUG("\n"); > +} > + > +static void virtio_gpu_conn_restore(struct drm_connector *connector) > +{ > + DRM_DEBUG("\n"); > +} > + > +static enum drm_connector_status virtio_gpu_conn_detect( > + struct drm_connector *connector, > + bool force) > +{ > + struct virtio_gpu_output *output = > + drm_connector_to_virtio_gpu_output(connector); > + > + if (output->info.enabled) > + return connector_status_connected; > + else > + return connector_status_disconnected; > +} > + > +static void virtio_gpu_conn_destroy(struct drm_connector *connector) > +{ > + struct virtio_gpu_output *virtio_gpu_output = > + drm_connector_to_virtio_gpu_output(connector); > + > + drm_connector_unregister(connector); > + drm_connector_cleanup(connector); > + kfree(virtio_gpu_output); > +} > + > +static const struct drm_connector_funcs virtio_gpu_connector_funcs = { > + .dpms = drm_atomic_helper_connector_dpms, > + .save = virtio_gpu_conn_save, > + .restore = virtio_gpu_conn_restore, > + .detect = virtio_gpu_conn_detect, > + .fill_modes = drm_helper_probe_single_connector_modes, > + .destroy = virtio_gpu_conn_destroy, > + .reset = drm_atomic_helper_connector_reset, > + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, > + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, > +}; > + > +static const struct drm_encoder_funcs virtio_gpu_enc_funcs = { > + .destroy = drm_encoder_cleanup, > +}; > + > +static int vgdev_output_init(struct virtio_gpu_device *vgdev, int index) > +{ > + struct drm_device *dev = vgdev->ddev; > + struct virtio_gpu_output *output = vgdev->outputs + index; > + struct drm_connector *connector = &output->conn; > + struct drm_encoder *encoder = &output->enc; > + struct drm_crtc *crtc = &output->crtc; > + struct drm_plane *plane; > + > + output->index = index; > + if (index == 0) { > + output->info.enabled = cpu_to_le32(true); > + output->info.r.width = cpu_to_le32(XRES_DEF); > + 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, > + &virtio_gpu_crtc_funcs); > + drm_mode_crtc_set_gamma_size(crtc, 256); > + drm_crtc_helper_add(crtc, &virtio_gpu_crtc_helper_funcs); > + plane->crtc = crtc; > + > + drm_connector_init(dev, connector, &virtio_gpu_connector_funcs, > + DRM_MODE_CONNECTOR_VIRTUAL); > + drm_connector_helper_add(connector, &virtio_gpu_conn_helper_funcs); > + > + drm_encoder_init(dev, encoder, &virtio_gpu_enc_funcs, > + DRM_MODE_ENCODER_VIRTUAL); > + drm_encoder_helper_add(encoder, &virtio_gpu_enc_helper_funcs); > + encoder->possible_crtcs = 1 << index; > + > + drm_mode_connector_attach_encoder(connector, encoder); > + drm_connector_register(connector); > + return 0; > +} > + > +static struct drm_framebuffer * > +virtio_gpu_user_framebuffer_create(struct drm_device *dev, > + struct drm_file *file_priv, > + struct drm_mode_fb_cmd2 *mode_cmd) > +{ > + struct drm_gem_object *obj = NULL; > + struct virtio_gpu_framebuffer *virtio_gpu_fb; > + int ret; > + > + /* lookup object associated with res handle */ > + obj = drm_gem_object_lookup(dev, file_priv, mode_cmd->handles[0]); > + if (!obj) > + return ERR_PTR(-EINVAL); > + > + virtio_gpu_fb = kzalloc(sizeof(*virtio_gpu_fb), GFP_KERNEL); > + if (virtio_gpu_fb == NULL) > + return ERR_PTR(-ENOMEM); > + > + ret = virtio_gpu_framebuffer_init(dev, virtio_gpu_fb, mode_cmd, obj); > + if (ret) { > + kfree(virtio_gpu_fb); > + if (obj) > + drm_gem_object_unreference_unlocked(obj); > + return NULL; > + } > + > + return &virtio_gpu_fb->base; > +} > + > +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, > +}; > + > +int virtio_gpu_modeset_init(struct virtio_gpu_device *vgdev) > +{ > + int i, ret; > + > + drm_mode_config_init(vgdev->ddev); > + vgdev->ddev->mode_config.funcs = (void *)&virtio_gpu_mode_funcs; > + > + /* modes will be validated against the framebuffer size */ > + vgdev->ddev->mode_config.min_width = XRES_MIN; > + vgdev->ddev->mode_config.min_height = YRES_MIN; > + vgdev->ddev->mode_config.max_width = XRES_MAX; > + vgdev->ddev->mode_config.max_height = YRES_MAX; > + > + for (i = 0 ; i < vgdev->num_scanouts; ++i) > + vgdev_output_init(vgdev, i); > + > + drm_mode_config_reset(vgdev->ddev); > + > + if (virtio_gpu_fbdev) { > + ret = virtio_gpu_fbdev_init(vgdev); > + if (ret) > + return ret; > + } > + > + return 0; > +} > + > +void virtio_gpu_modeset_fini(struct virtio_gpu_device *vgdev) > +{ > + virtio_gpu_fbdev_fini(vgdev); > + drm_mode_config_cleanup(vgdev->ddev); > +} > diff --git a/drivers/gpu/drm/virtio/virtgpu_drm_bus.c b/drivers/gpu/drm/virtio/virtgpu_drm_bus.c > new file mode 100644 > index 0000000..f4ec816 > --- /dev/null > +++ b/drivers/gpu/drm/virtio/virtgpu_drm_bus.c > @@ -0,0 +1,91 @@ > +/* > + * 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. > + */ > + > +#include <linux/pci.h> > + > +#include "virtgpu_drv.h" > + > +int drm_virtio_set_busid(struct drm_device *dev, struct drm_master *master) > +{ > + struct pci_dev *pdev = dev->pdev; > + > + if (pdev) { > + return drm_pci_set_busid(dev, master); > + } > + return 0; > +} > + > +int drm_virtio_init(struct drm_driver *driver, struct virtio_device *vdev) > +{ > + struct drm_device *dev; > + int ret; > + > + dev = drm_dev_alloc(driver, &vdev->dev); > + if (!dev) > + return -ENOMEM; > + dev->virtdev = vdev; > + vdev->priv = dev; > + > + if (strcmp(vdev->dev.parent->bus->name, "pci") == 0) { > + struct pci_dev *pdev = to_pci_dev(vdev->dev.parent); > + bool vga = (pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA; > + > + if (vga) { > + /* > + * Need to make sure we don't have two drivers > + * for the same hardware here. Some day we > + * will simply kick out the firmware > + * (vesa/efi) framebuffer. > + * > + * Virtual hardware specs for virtio-vga are > + * not finalized yet, therefore we can't add > + * code for that yet. > + * > + * So ignore the device for the time being, > + * and suggest to the user use the device > + * variant without vga compatibility mode. > + */ > + DRM_ERROR("virtio-vga not (yet) supported\n"); > + DRM_ERROR("please use virtio-gpu-pci instead\n"); > + ret = -ENODEV; > + goto err_free; > + } > + dev->pdev = pdev; > + } > + > + ret = drm_dev_register(dev, 0); > + if (ret) > + goto err_free; > + > + DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n", driver->name, > + driver->major, driver->minor, driver->patchlevel, > + driver->date, dev->primary->index); > + > + return 0; > + > +err_free: > + drm_dev_unref(dev); > + return ret; > +} > diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.c b/drivers/gpu/drm/virtio/virtgpu_drv.c > new file mode 100644 > index 0000000..7d9610a > --- /dev/null > +++ b/drivers/gpu/drm/virtio/virtgpu_drv.c > @@ -0,0 +1,136 @@ > +/* > + * Copyright (C) 2015 Red Hat, Inc. > + * All Rights Reserved. > + * > + * Authors: > + * Dave Airlie <airlied@redhat.com> > + * Gerd Hoffmann <kraxel@redhat.com> > + * > + * 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 > + * VA LINUX SYSTEMS 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. > + */ > + > +#include <linux/module.h> > +#include <linux/console.h> > +#include <linux/pci.h> > +#include "drmP.h" > +#include "drm/drm.h" > + > +#include "virtgpu_drv.h" > +static struct drm_driver driver; > + > +static int virtio_gpu_modeset = -1; > + > +MODULE_PARM_DESC(modeset, "Disable/Enable modesetting"); > +module_param_named(modeset, virtio_gpu_modeset, int, 0400); > + > +static int virtio_gpu_probe(struct virtio_device *vdev) > +{ > +#ifdef CONFIG_VGA_CONSOLE > + if (vgacon_text_force() && virtio_gpu_modeset == -1) > + return -EINVAL; > +#endif > + > + if (virtio_gpu_modeset == 0) > + return -EINVAL; > + > + return drm_virtio_init(&driver, vdev); > +} > + > +static void virtio_gpu_remove(struct virtio_device *vdev) > +{ > + struct drm_device *dev = vdev->priv; > + drm_put_dev(dev); > +} > + > +static void virtio_gpu_config_changed(struct virtio_device *vdev) > +{ > + struct drm_device *dev = vdev->priv; > + struct virtio_gpu_device *vgdev = dev->dev_private; > + > + schedule_work(&vgdev->config_changed_work); > +} > + > +static struct virtio_device_id id_table[] = { > + { VIRTIO_ID_GPU, VIRTIO_DEV_ANY_ID }, > + { 0 }, > +}; > + > +static unsigned int features[] = { > +}; > +static struct virtio_driver virtio_gpu_driver = { > + .feature_table = features, > + .feature_table_size = ARRAY_SIZE(features), > + .driver.name = KBUILD_MODNAME, > + .driver.owner = THIS_MODULE, > + .id_table = id_table, > + .probe = virtio_gpu_probe, > + .remove = virtio_gpu_remove, > + .config_changed = virtio_gpu_config_changed > +}; > + > +module_virtio_driver(virtio_gpu_driver); > + > +MODULE_DEVICE_TABLE(virtio, id_table); > +MODULE_DESCRIPTION("Virtio GPU driver"); > +MODULE_LICENSE("GPL and additional rights"); > +MODULE_AUTHOR("Dave Airlie <airlied@redhat.com>"); > +MODULE_AUTHOR("Gerd Hoffmann <kraxel@redhat.com>"); > +MODULE_AUTHOR("Alon Levy"); > + > +static const struct file_operations virtio_gpu_driver_fops = { > + .owner = THIS_MODULE, > + .open = drm_open, > + .mmap = virtio_gpu_mmap, > + .poll = drm_poll, > + .read = drm_read, > + .unlocked_ioctl = drm_ioctl, > + .release = drm_release, > +#ifdef CONFIG_COMPAT > + .compat_ioctl = drm_compat_ioctl, > +#endif > + .llseek = noop_llseek, > +}; > + > + > +static struct drm_driver driver = { > + .driver_features = DRIVER_MODESET | DRIVER_GEM, > + .set_busid = drm_virtio_set_busid, > + .load = virtio_gpu_driver_load, > + .unload = virtio_gpu_driver_unload, > + > + .dumb_create = virtio_gpu_mode_dumb_create, > + .dumb_map_offset = virtio_gpu_mode_dumb_mmap, > + .dumb_destroy = virtio_gpu_mode_dumb_destroy, > + > +#if defined(CONFIG_DEBUG_FS) > + .debugfs_init = virtio_gpu_debugfs_init, > + .debugfs_cleanup = virtio_gpu_debugfs_takedown, > +#endif > + > + .gem_free_object = virtio_gpu_gem_free_object, > + .fops = &virtio_gpu_driver_fops, > + > + .name = DRIVER_NAME, > + .desc = DRIVER_DESC, > + .date = DRIVER_DATE, > + .major = DRIVER_MAJOR, > + .minor = DRIVER_MINOR, > + .patchlevel = DRIVER_PATCHLEVEL, > +}; > diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.h b/drivers/gpu/drm/virtio/virtgpu_drv.h > new file mode 100644 > index 0000000..e5a2c09 > --- /dev/null > +++ b/drivers/gpu/drm/virtio/virtgpu_drv.h > @@ -0,0 +1,350 @@ > +/* > + * 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> > + > +#include <drm/drmP.h> > +#include <drm/drm_gem.h> > +#include <drm/drm_crtc_helper.h> > +#include <ttm/ttm_bo_api.h> > +#include <ttm/ttm_bo_driver.h> > +#include <ttm/ttm_placement.h> > +#include <ttm/ttm_module.h> > + > +#define DRIVER_NAME "virtio_gpu" > +#define DRIVER_DESC "virtio GPU" > +#define DRIVER_DATE "0" > + > +#define DRIVER_MAJOR 0 > +#define DRIVER_MINOR 0 > +#define DRIVER_PATCHLEVEL 1 > + > +/* virtgpu_drm_bus.c */ > +int drm_virtio_set_busid(struct drm_device *dev, struct drm_master *master); > +int drm_virtio_init(struct drm_driver *driver, struct virtio_device *vdev); > + > +struct virtio_gpu_object { > + struct drm_gem_object gem_base; > + uint32_t hw_res_handle; > + > + struct sg_table *pages; > + void *vmap; > + bool dumb; > + struct ttm_place placement_code; > + struct ttm_placement placement; > + struct ttm_buffer_object tbo; > + struct ttm_bo_kmap_obj kmap; > +}; > +#define gem_to_virtio_gpu_obj(gobj) \ > + container_of((gobj), struct virtio_gpu_object, gem_base) > + > +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 { > + atomic64_t last_seq; > + uint64_t sync_seq; > + struct list_head fences; > + spinlock_t lock; > +}; > + > +struct virtio_gpu_fence { > + struct fence f; > + struct virtio_gpu_fence_driver *drv; > + struct list_head node; > + uint64_t seq; > +}; > +#define to_virtio_fence(x) \ > + container_of(x, struct virtio_gpu_fence, f) > + > +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; > + > + 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; > + int cur_x; > + int cur_y; > +}; > +#define drm_crtc_to_virtio_gpu_output(x) \ > + container_of(x, struct virtio_gpu_output, crtc) > +#define drm_connector_to_virtio_gpu_output(x) \ > + container_of(x, struct virtio_gpu_output, conn) > +#define drm_encoder_to_virtio_gpu_output(x) \ > + container_of(x, struct virtio_gpu_output, enc) > + > +struct virtio_gpu_framebuffer { > + struct drm_framebuffer base; > + struct drm_gem_object *obj; > + int x1, y1, x2, y2; /* dirty rect */ > + spinlock_t dirty_lock; > + uint32_t hw_res_handle; > +}; > +#define to_virtio_gpu_framebuffer(x) \ > + container_of(x, struct virtio_gpu_framebuffer, base) > + > +struct virtio_gpu_mman { > + struct ttm_bo_global_ref bo_global_ref; > + struct drm_global_reference mem_global_ref; > + bool mem_global_referenced; > + struct ttm_bo_device bdev; > +}; > + > +struct virtio_gpu_fbdev; > + > +struct virtio_gpu_queue { > + struct virtqueue *vq; > + spinlock_t qlock; > + wait_queue_head_t ack_queue; > + struct work_struct dequeue_work; > +}; > + > +struct virtio_gpu_device { > + struct device *dev; > + struct drm_device *ddev; > + > + struct virtio_device *vdev; > + > + struct virtio_gpu_mman mman; > + > + /* pointer to fbdev info structure */ > + struct virtio_gpu_fbdev *vgfbdev; > + struct virtio_gpu_output outputs[VIRTIO_GPU_MAX_SCANOUTS]; > + uint32_t num_scanouts; > + > + struct virtio_gpu_queue ctrlq; > + struct virtio_gpu_queue cursorq; > + struct list_head free_vbufs; > + void *vbufs; > + bool vqs_ready; > + > + struct idr resource_idr; > + spinlock_t resource_idr_lock; > + > + wait_queue_head_t resp_wq; > + /* current display info */ > + spinlock_t display_info_lock; > + > + struct virtio_gpu_fence_driver fence_drv; > + > + struct idr ctx_id_idr; > + spinlock_t ctx_id_idr_lock; > + > + struct work_struct config_changed_work; > +}; > + > +struct virtio_gpu_fpriv { > + uint32_t ctx_id; > +}; > + > +/* virtio_ioctl.c */ > +#define DRM_VIRTIO_NUM_IOCTLS 10 > +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); > + > +/* virtio_gem.c */ > +void virtio_gpu_gem_free_object(struct drm_gem_object *gem_obj); > +int virtio_gpu_gem_init(struct virtio_gpu_device *vgdev); > +void virtio_gpu_gem_fini(struct virtio_gpu_device *vgdev); > +int virtio_gpu_gem_create(struct drm_file *file, > + struct drm_device *dev, > + uint64_t size, > + struct drm_gem_object **obj_p, > + uint32_t *handle_p); > +struct virtio_gpu_object *virtio_gpu_alloc_object(struct drm_device *dev, > + size_t size, bool kernel, > + bool pinned); > +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_destroy(struct drm_file *file_priv, > + struct drm_device *dev, > + uint32_t handle); > +int virtio_gpu_mode_dumb_mmap(struct drm_file *file_priv, > + struct drm_device *dev, > + uint32_t handle, uint64_t *offset_p); > + > +/* virtio_fb */ > +#define VIRTIO_GPUFB_CONN_LIMIT 1 > +int virtio_gpu_fbdev_init(struct virtio_gpu_device *vgdev); > +void virtio_gpu_fbdev_fini(struct virtio_gpu_device *vgdev); > +int virtio_gpu_surface_dirty(struct virtio_gpu_framebuffer *qfb, > + struct drm_clip_rect *clips, > + unsigned num_clips); > +/* virtio vg */ > +int virtio_gpu_alloc_vbufs(struct virtio_gpu_device *vgdev); > +void virtio_gpu_free_vbufs(struct virtio_gpu_device *vgdev); > +void virtio_gpu_resource_id_get(struct virtio_gpu_device *vgdev, > + uint32_t *resid); > +void virtio_gpu_resource_id_put(struct virtio_gpu_device *vgdev, uint32_t id); > +void virtio_gpu_cmd_create_resource(struct virtio_gpu_device *vgdev, > + uint32_t resource_id, > + uint32_t format, > + uint32_t width, > + uint32_t height); > +void virtio_gpu_cmd_unref_resource(struct virtio_gpu_device *vgdev, > + uint32_t resource_id); > +void virtio_gpu_cmd_transfer_to_host_2d(struct virtio_gpu_device *vgdev, > + uint32_t resource_id, uint64_t offset, > + __le32 width, __le32 height, > + __le32 x, __le32 y, > + struct virtio_gpu_fence **fence); > +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); > +int virtio_gpu_object_attach(struct virtio_gpu_device *vgdev, > + struct virtio_gpu_object *obj, > + uint32_t resource_id, > + struct virtio_gpu_fence **fence); > +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); > +void virtio_gpu_cmd_resource_inval_backing(struct virtio_gpu_device *vgdev, > + uint32_t resource_id); > +void virtio_gpu_ctrl_ack(struct virtqueue *vq); > +void virtio_gpu_cursor_ack(struct virtqueue *vq); > +void virtio_gpu_dequeue_ctrl_func(struct work_struct *work); > +void virtio_gpu_dequeue_cursor_func(struct work_struct *work); > + > +/* virtio_gpu_display.c */ > +int virtio_gpu_framebuffer_init(struct drm_device *dev, > + struct virtio_gpu_framebuffer *vgfb, > + struct drm_mode_fb_cmd2 *mode_cmd, > + struct drm_gem_object *obj); > +int virtio_gpu_modeset_init(struct virtio_gpu_device *vgdev); > +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, > + int index); > + > +/* virtio_gpu_ttm.c */ > +int virtio_gpu_ttm_init(struct virtio_gpu_device *vgdev); > +void virtio_gpu_ttm_fini(struct virtio_gpu_device *vgdev); > +int virtio_gpu_mmap(struct file *filp, struct vm_area_struct *vma); > + > +/* virtio_gpu_fence.c */ > +int virtio_gpu_fence_emit(struct virtio_gpu_device *vgdev, > + struct virtio_gpu_ctrl_hdr *cmd_hdr, > + struct virtio_gpu_fence **fence); > +void virtio_gpu_fence_event_process(struct virtio_gpu_device *vdev, > + u64 last_seq); > + > +/* virtio_gpu_object */ > +int virtio_gpu_object_create(struct virtio_gpu_device *vgdev, > + unsigned long size, bool kernel, bool pinned, > + struct virtio_gpu_object **bo_ptr); > +int virtio_gpu_object_kmap(struct virtio_gpu_object *bo, void **ptr); > +int virtio_gpu_object_get_sg_table(struct virtio_gpu_device *qdev, > + struct virtio_gpu_object *bo); > +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); > + > +static inline struct virtio_gpu_object* > +virtio_gpu_object_ref(struct virtio_gpu_object *bo) > +{ > + ttm_bo_reference(&bo->tbo); > + return bo; > +} > + > +static inline void virtio_gpu_object_unref(struct virtio_gpu_object **bo) > +{ > + struct ttm_buffer_object *tbo; > + > + if ((*bo) == NULL) > + return; > + tbo = &((*bo)->tbo); > + ttm_bo_unref(&tbo); > + if (tbo == NULL) > + *bo = NULL; > +} > + > +static inline u64 virtio_gpu_object_mmap_offset(struct virtio_gpu_object *bo) > +{ > + return drm_vma_node_offset_addr(&bo->tbo.vma_node); > +} > + > +static inline int virtio_gpu_object_reserve(struct virtio_gpu_object *bo, > + bool no_wait) > +{ > + int r; > + > + r = ttm_bo_reserve(&bo->tbo, true, no_wait, false, NULL); > + if (unlikely(r != 0)) { > + if (r != -ERESTARTSYS) { > + struct virtio_gpu_device *qdev = > + bo->gem_base.dev->dev_private; > + dev_err(qdev->dev, "%p reserve failed\n", bo); > + } > + return r; > + } > + return 0; > +} > + > +static inline void virtio_gpu_object_unreserve(struct virtio_gpu_object *bo) > +{ > + ttm_bo_unreserve(&bo->tbo); > +} > + > +/* virgl debufs */ > +int virtio_gpu_debugfs_init(struct drm_minor *minor); > +void virtio_gpu_debugfs_takedown(struct drm_minor *minor); > + > +#endif > diff --git a/drivers/gpu/drm/virtio/virtgpu_fb.c b/drivers/gpu/drm/virtio/virtgpu_fb.c > new file mode 100644 > index 0000000..25bf333 > --- /dev/null > +++ b/drivers/gpu/drm/virtio/virtgpu_fb.c > @@ -0,0 +1,431 @@ > +/* > + * 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. > + */ > + > +#include <drm/drmP.h> > +#include <drm/drm_fb_helper.h> > +#include "virtgpu_drv.h" > + > +#define VIRTIO_GPU_FBCON_POLL_PERIOD (HZ / 60) > + > +struct virtio_gpu_fbdev { > + struct drm_fb_helper helper; > + struct virtio_gpu_framebuffer vgfb; > + struct list_head fbdev_list; > + struct virtio_gpu_device *vgdev; > + struct delayed_work work; > +}; > + > +static int virtio_gpu_dirty_update(struct virtio_gpu_framebuffer *fb, > + bool store, int x, int y, > + int width, int height) > +{ > + struct drm_device *dev = fb->base.dev; > + struct virtio_gpu_device *vgdev = dev->dev_private; > + bool store_for_later = false; > + int bpp = fb->base.bits_per_pixel / 8; > + int x2, y2; > + unsigned long flags; > + struct virtio_gpu_object *obj = gem_to_virtio_gpu_obj(fb->obj); > + > + if ((width <= 0) || > + (x + width > fb->base.width) || > + (y + height > fb->base.height)) { > + DRM_DEBUG("values out of range %dx%d+%d+%d, fb %dx%d\n", > + width, height, x, y, > + fb->base.width, fb->base.height); > + return -EINVAL; > + } > + > + /* > + * Can be called with pretty much any context (console output > + * path). If we are in atomic just store the dirty rect info > + * to send out the update later. > + * > + * Can't test inside spin lock. > + */ > + if (in_atomic() || store) > + store_for_later = true; > + > + x2 = x + width - 1; > + y2 = y + height - 1; > + > + spin_lock_irqsave(&fb->dirty_lock, flags); > + > + if (fb->y1 < y) > + y = fb->y1; > + if (fb->y2 > y2) > + y2 = fb->y2; > + if (fb->x1 < x) > + x = fb->x1; > + if (fb->x2 > x2) > + x2 = fb->x2; > + > + if (store_for_later) { > + fb->x1 = x; > + fb->x2 = x2; > + fb->y1 = y; > + fb->y2 = y2; > + spin_unlock_irqrestore(&fb->dirty_lock, flags); > + return 0; > + } > + > + fb->x1 = fb->y1 = INT_MAX; > + fb->x2 = fb->y2 = 0; > + > + spin_unlock_irqrestore(&fb->dirty_lock, flags); > + > + { > + uint32_t offset; > + uint32_t w = x2 - x + 1; > + uint32_t h = y2 - y + 1; > + > + offset = (y * fb->base.pitches[0]) + x * bpp; > + > + virtio_gpu_cmd_transfer_to_host_2d(vgdev, obj->hw_res_handle, > + offset, > + cpu_to_le32(w), > + cpu_to_le32(h), > + cpu_to_le32(x), > + cpu_to_le32(y), > + NULL); > + > + } > + virtio_gpu_cmd_resource_flush(vgdev, obj->hw_res_handle, > + x, y, x2 - x + 1, y2 - y + 1); > + return 0; > +} > + > +int virtio_gpu_surface_dirty(struct virtio_gpu_framebuffer *vgfb, > + struct drm_clip_rect *clips, > + unsigned num_clips) > +{ > + struct virtio_gpu_device *vgdev = vgfb->base.dev->dev_private; > + struct virtio_gpu_object *obj = gem_to_virtio_gpu_obj(vgfb->obj); > + struct drm_clip_rect norect; > + struct drm_clip_rect *clips_ptr; > + int left, right, top, bottom; > + int i; > + int inc = 1; > + if (!num_clips) { > + num_clips = 1; > + clips = &norect; > + norect.x1 = norect.y1 = 0; > + norect.x2 = vgfb->base.width; > + norect.y2 = vgfb->base.height; > + } > + left = clips->x1; > + right = clips->x2; > + top = clips->y1; > + bottom = clips->y2; > + > + /* skip the first clip rect */ > + for (i = 1, clips_ptr = clips + inc; > + i < num_clips; i++, clips_ptr += inc) { > + left = min_t(int, left, (int)clips_ptr->x1); > + right = max_t(int, right, (int)clips_ptr->x2); > + top = min_t(int, top, (int)clips_ptr->y1); > + bottom = max_t(int, bottom, (int)clips_ptr->y2); > + } > + > + if (obj->dumb) > + return virtio_gpu_dirty_update(vgfb, false, left, top, > + right - left, bottom - top); > + > + virtio_gpu_cmd_resource_flush(vgdev, obj->hw_res_handle, > + left, top, right - left, bottom - top); > + return 0; > +} > + > +static void virtio_gpu_fb_dirty_work(struct work_struct *work) > +{ > + struct delayed_work *delayed_work = to_delayed_work(work); > + struct virtio_gpu_fbdev *vfbdev = > + container_of(delayed_work, struct virtio_gpu_fbdev, work); > + struct virtio_gpu_framebuffer *vgfb = &vfbdev->vgfb; > + > + virtio_gpu_dirty_update(&vfbdev->vgfb, false, vgfb->x1, vgfb->y1, > + vgfb->x2 - vgfb->x1, vgfb->y2 - vgfb->y1); > +} > + > +static void virtio_gpu_3d_fillrect(struct fb_info *info, > + const struct fb_fillrect *rect) > +{ > + struct virtio_gpu_fbdev *vfbdev = info->par; > + sys_fillrect(info, rect); > + virtio_gpu_dirty_update(&vfbdev->vgfb, true, rect->dx, rect->dy, > + rect->width, rect->height); > + schedule_delayed_work(&vfbdev->work, VIRTIO_GPU_FBCON_POLL_PERIOD); > +} > + > +static void virtio_gpu_3d_copyarea(struct fb_info *info, > + const struct fb_copyarea *area) > +{ > + struct virtio_gpu_fbdev *vfbdev = info->par; > + sys_copyarea(info, area); > + virtio_gpu_dirty_update(&vfbdev->vgfb, true, area->dx, area->dy, > + area->width, area->height); > + schedule_delayed_work(&vfbdev->work, VIRTIO_GPU_FBCON_POLL_PERIOD); > +} > + > +static void virtio_gpu_3d_imageblit(struct fb_info *info, > + const struct fb_image *image) > +{ > + struct virtio_gpu_fbdev *vfbdev = info->par; > + sys_imageblit(info, image); > + virtio_gpu_dirty_update(&vfbdev->vgfb, true, image->dx, image->dy, > + image->width, image->height); > + schedule_delayed_work(&vfbdev->work, VIRTIO_GPU_FBCON_POLL_PERIOD); > +} > + > +static struct fb_ops virtio_gpufb_ops = { > + .owner = THIS_MODULE, > + .fb_check_var = drm_fb_helper_check_var, > + .fb_set_par = drm_fb_helper_set_par, /* TODO: copy vmwgfx */ > + .fb_fillrect = virtio_gpu_3d_fillrect, > + .fb_copyarea = virtio_gpu_3d_copyarea, > + .fb_imageblit = virtio_gpu_3d_imageblit, > + .fb_pan_display = drm_fb_helper_pan_display, > + .fb_blank = drm_fb_helper_blank, > + .fb_setcmap = drm_fb_helper_setcmap, > + .fb_debug_enter = drm_fb_helper_debug_enter, > + .fb_debug_leave = drm_fb_helper_debug_leave, > +}; > + > +static int virtio_gpu_vmap_fb(struct virtio_gpu_device *vgdev, > + struct virtio_gpu_object *obj) > +{ > + return virtio_gpu_object_kmap(obj, NULL); > +} > + > +static int virtio_gpufb_create(struct drm_fb_helper *helper, > + struct drm_fb_helper_surface_size *sizes) > +{ > + struct virtio_gpu_fbdev *vfbdev = > + container_of(helper, struct virtio_gpu_fbdev, helper); > + struct drm_device *dev = helper->dev; > + struct virtio_gpu_device *vgdev = dev->dev_private; > + struct fb_info *info; > + struct drm_framebuffer *fb; > + struct drm_mode_fb_cmd2 mode_cmd = {}; > + struct virtio_gpu_object *obj; > + struct device *device = vgdev->dev; > + uint32_t resid, format, size; > + int ret; > + > + mode_cmd.width = sizes->surface_width; > + mode_cmd.height = sizes->surface_height; > + mode_cmd.pitches[0] = mode_cmd.width * 4; > + mode_cmd.pixel_format = drm_mode_legacy_fb_format(32, 24); > + > + switch (mode_cmd.pixel_format) { > +#ifdef __BIG_ENDIAN > + case DRM_FORMAT_XRGB8888: > + format = VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM; > + break; > + case DRM_FORMAT_ARGB8888: > + format = VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM; > + break; > + case DRM_FORMAT_BGRX8888: > + format = VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM; > + break; > + case DRM_FORMAT_BGRA8888: > + format = VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM; > + break; > + case DRM_FORMAT_RGBX8888: > + format = VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM; > + break; > + case DRM_FORMAT_RGBA8888: > + format = VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM; > + break; > + case DRM_FORMAT_XBGR8888: > + format = VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM; > + break; > + case DRM_FORMAT_ABGR8888: > + format = VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM; > + break; > +#else > + case DRM_FORMAT_XRGB8888: > + format = VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM; > + break; > + case DRM_FORMAT_ARGB8888: > + format = VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM; > + break; > + case DRM_FORMAT_BGRX8888: > + format = VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM; > + break; > + case DRM_FORMAT_BGRA8888: > + format = VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM; > + break; > + case DRM_FORMAT_RGBX8888: > + format = VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM; > + break; > + case DRM_FORMAT_RGBA8888: > + format = VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM; > + break; > + case DRM_FORMAT_XBGR8888: > + format = VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM; > + break; > + case DRM_FORMAT_ABGR8888: > + format = VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM; > + break; > +#endif > + default: > + DRM_ERROR("failed to find virtio gpu format for %d\n", > + mode_cmd.pixel_format); > + return -EINVAL; > + } > + > + size = mode_cmd.pitches[0] * mode_cmd.height; > + obj = virtio_gpu_alloc_object(dev, size, false, true); > + if (!obj) > + return -ENOMEM; > + > + virtio_gpu_resource_id_get(vgdev, &resid); > + virtio_gpu_cmd_create_resource(vgdev, resid, format, > + mode_cmd.width, mode_cmd.height); > + > + ret = virtio_gpu_vmap_fb(vgdev, obj); > + if (ret) { > + DRM_ERROR("failed to vmap fb %d\n", ret); > + goto err_obj_vmap; > + } > + > + /* attach the object to the resource */ > + ret = virtio_gpu_object_attach(vgdev, obj, resid, NULL); > + if (ret) > + goto err_obj_attach; > + > + info = framebuffer_alloc(0, device); > + if (!info) { > + ret = -ENOMEM; > + goto err_fb_alloc; > + } > + > + ret = fb_alloc_cmap(&info->cmap, 256, 0); > + if (ret) { > + ret = -ENOMEM; > + goto err_fb_alloc_cmap; > + } > + > + info->par = helper; > + > + ret = virtio_gpu_framebuffer_init(dev, &vfbdev->vgfb, > + &mode_cmd, &obj->gem_base); > + if (ret) > + goto err_fb_init; > + > + fb = &vfbdev->vgfb.base; > + > + vfbdev->helper.fb = fb; > + vfbdev->helper.fbdev = info; > + > + strcpy(info->fix.id, "virtiodrmfb"); > + info->flags = FBINFO_DEFAULT; > + info->fbops = &virtio_gpufb_ops; > + info->pixmap.flags = FB_PIXMAP_SYSTEM; > + > + info->screen_base = obj->vmap; > + info->screen_size = obj->gem_base.size; > + drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth); > + drm_fb_helper_fill_var(info, &vfbdev->helper, > + sizes->fb_width, sizes->fb_height); > + > + info->fix.mmio_start = 0; > + info->fix.mmio_len = 0; > + return 0; > + > +err_fb_init: > + fb_dealloc_cmap(&info->cmap); > +err_fb_alloc_cmap: > + framebuffer_release(info); > +err_fb_alloc: > + virtio_gpu_cmd_resource_inval_backing(vgdev, resid); > +err_obj_attach: > +err_obj_vmap: > + virtio_gpu_gem_free_object(&obj->gem_base); > + return ret; > +} > + > +static int virtio_gpu_fbdev_destroy(struct drm_device *dev, > + struct virtio_gpu_fbdev *vgfbdev) > +{ > + struct fb_info *info; > + struct virtio_gpu_framebuffer *vgfb = &vgfbdev->vgfb; > + > + if (vgfbdev->helper.fbdev) { > + info = vgfbdev->helper.fbdev; > + > + unregister_framebuffer(info); > + framebuffer_release(info); > + } > + if (vgfb->obj) > + vgfb->obj = NULL; > + drm_fb_helper_fini(&vgfbdev->helper); > + drm_framebuffer_cleanup(&vgfb->base); > + > + return 0; > +} > +static struct drm_fb_helper_funcs virtio_gpu_fb_helper_funcs = { > + .fb_probe = virtio_gpufb_create, > +}; > + > +int virtio_gpu_fbdev_init(struct virtio_gpu_device *vgdev) > +{ > + struct virtio_gpu_fbdev *vgfbdev; > + int bpp_sel = 32; /* TODO: parameter from somewhere? */ > + int ret; > + > + vgfbdev = kzalloc(sizeof(struct virtio_gpu_fbdev), GFP_KERNEL); > + if (!vgfbdev) > + return -ENOMEM; > + > + vgfbdev->vgdev = vgdev; > + vgdev->vgfbdev = vgfbdev; > + INIT_DELAYED_WORK(&vgfbdev->work, virtio_gpu_fb_dirty_work); > + > + drm_fb_helper_prepare(vgdev->ddev, &vgfbdev->helper, > + &virtio_gpu_fb_helper_funcs); > + ret = drm_fb_helper_init(vgdev->ddev, &vgfbdev->helper, > + vgdev->num_scanouts, > + VIRTIO_GPUFB_CONN_LIMIT); > + if (ret) { > + kfree(vgfbdev); > + return ret; > + } > + > + drm_fb_helper_single_add_all_connectors(&vgfbdev->helper); > + drm_fb_helper_initial_config(&vgfbdev->helper, bpp_sel); > + return 0; > +} > + > +void virtio_gpu_fbdev_fini(struct virtio_gpu_device *vgdev) > +{ > + if (!vgdev->vgfbdev) > + return; > + > + virtio_gpu_fbdev_destroy(vgdev->ddev, vgdev->vgfbdev); > + kfree(vgdev->vgfbdev); > + vgdev->vgfbdev = NULL; > +} > diff --git a/drivers/gpu/drm/virtio/virtgpu_fence.c b/drivers/gpu/drm/virtio/virtgpu_fence.c > new file mode 100644 > index 0000000..1da6326 > --- /dev/null > +++ b/drivers/gpu/drm/virtio/virtgpu_fence.c > @@ -0,0 +1,119 @@ > +/* > + * 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. > + */ > + > +#include <drm/drmP.h> > +#include "virtgpu_drv.h" > + > +static const char *virtio_get_driver_name(struct fence *f) > +{ > + return "virtio_gpu"; > +} > + > +static const char *virtio_get_timeline_name(struct fence *f) > +{ > + return "controlq"; > +} > + > +static bool virtio_enable_signaling(struct fence *f) > +{ > + return true; > +} > + > +static bool virtio_signaled(struct fence *f) > +{ > + struct virtio_gpu_fence *fence = to_virtio_fence(f); > + > + if (atomic64_read(&fence->drv->last_seq) >= fence->seq) > + return true; > + return false; > +} > + > +static void virtio_fence_value_str(struct fence *f, char *str, int size) > +{ > + struct virtio_gpu_fence *fence = to_virtio_fence(f); > + > + snprintf(str, size, "%llu", fence->seq); > +} > + > +static void virtio_timeline_value_str(struct fence *f, char *str, int size) > +{ > + struct virtio_gpu_fence *fence = to_virtio_fence(f); > + > + snprintf(str, size, "%lu", atomic64_read(&fence->drv->last_seq)); > +} > + > +static const struct fence_ops virtio_fence_ops = { > + .get_driver_name = virtio_get_driver_name, > + .get_timeline_name = virtio_get_timeline_name, > + .enable_signaling = virtio_enable_signaling, > + .signaled = virtio_signaled, > + .wait = fence_default_wait, > + .fence_value_str = virtio_fence_value_str, > + .timeline_value_str = virtio_timeline_value_str, > +}; > + > +int virtio_gpu_fence_emit(struct virtio_gpu_device *vgdev, > + struct virtio_gpu_ctrl_hdr *cmd_hdr, > + struct virtio_gpu_fence **fence) > +{ > + struct virtio_gpu_fence_driver *drv = &vgdev->fence_drv; > + unsigned long irq_flags; > + > + *fence = kmalloc(sizeof(struct virtio_gpu_fence), GFP_KERNEL); > + if ((*fence) == NULL) > + return -ENOMEM; > + > + spin_lock_irqsave(&drv->lock, irq_flags); > + (*fence)->drv = drv; > + (*fence)->seq = ++drv->sync_seq; > + fence_init(&(*fence)->f, &virtio_fence_ops, &drv->lock, > + 0, (*fence)->seq); > + fence_get(&(*fence)->f); > + list_add_tail(&(*fence)->node, &drv->fences); > + spin_unlock_irqrestore(&drv->lock, irq_flags); > + > + cmd_hdr->flags |= cpu_to_le32(VIRTIO_GPU_FLAG_FENCE); > + cmd_hdr->fence_id = cpu_to_le64((*fence)->seq); > + return 0; > +} > + > +void virtio_gpu_fence_event_process(struct virtio_gpu_device *vgdev, > + u64 last_seq) > +{ > + struct virtio_gpu_fence_driver *drv = &vgdev->fence_drv; > + struct virtio_gpu_fence *fence, *tmp; > + unsigned long irq_flags; > + > + spin_lock_irqsave(&drv->lock, irq_flags); > + atomic64_set(&vgdev->fence_drv.last_seq, last_seq); > + list_for_each_entry_safe(fence, tmp, &drv->fences, node) { > + if (last_seq < fence->seq) > + continue; > + fence_signal_locked(&fence->f); > + list_del(&fence->node); > + fence_put(&fence->f); > + } > + spin_unlock_irqrestore(&drv->lock, irq_flags); > +} > diff --git a/drivers/gpu/drm/virtio/virtgpu_gem.c b/drivers/gpu/drm/virtio/virtgpu_gem.c > new file mode 100644 > index 0000000..cfa0d27 > --- /dev/null > +++ b/drivers/gpu/drm/virtio/virtgpu_gem.c > @@ -0,0 +1,140 @@ > +/* > + * 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. > + */ > + > +#include <drm/drmP.h> > +#include "virtgpu_drv.h" > + > +void virtio_gpu_gem_free_object(struct drm_gem_object *gem_obj) > +{ > + struct virtio_gpu_object *obj = gem_to_virtio_gpu_obj(gem_obj); > + > + if (obj) > + virtio_gpu_object_unref(&obj); > +} > + > +struct virtio_gpu_object *virtio_gpu_alloc_object(struct drm_device *dev, > + size_t size, bool kernel, > + bool pinned) > +{ > + struct virtio_gpu_device *vgdev = dev->dev_private; > + struct virtio_gpu_object *obj; > + int ret; > + > + ret = virtio_gpu_object_create(vgdev, size, kernel, pinned, &obj); > + if (ret) > + return ERR_PTR(ret); > + > + return obj; > +} > + > +int virtio_gpu_gem_create(struct drm_file *file, > + struct drm_device *dev, > + uint64_t size, > + struct drm_gem_object **obj_p, > + uint32_t *handle_p) > +{ > + struct virtio_gpu_object *obj; > + int ret; > + u32 handle; > + > + obj = virtio_gpu_alloc_object(dev, size, false, false); > + if (IS_ERR(obj)) > + return PTR_ERR(obj); > + > + ret = drm_gem_handle_create(file, &obj->gem_base, &handle); > + if (ret) { > + drm_gem_object_release(&obj->gem_base); > + return ret; > + } > + > + *obj_p = &obj->gem_base; > + > + /* drop reference from allocate - handle holds it now */ > + drm_gem_object_unreference_unlocked(&obj->gem_base); > + > + *handle_p = handle; > + return 0; > +} > + > +int virtio_gpu_mode_dumb_create(struct drm_file *file_priv, > + struct drm_device *dev, > + struct drm_mode_create_dumb *args) > +{ > + struct virtio_gpu_device *vgdev = dev->dev_private; > + struct drm_gem_object *gobj; > + struct virtio_gpu_object *obj; > + int ret; > + uint32_t pitch; > + uint32_t resid; > + > + pitch = args->width * ((args->bpp + 1) / 8); > + args->size = pitch * args->height; > + args->size = ALIGN(args->size, PAGE_SIZE); > + > + ret = virtio_gpu_gem_create(file_priv, dev, args->size, &gobj, > + &args->handle); > + if (ret) > + goto fail; > + > + virtio_gpu_resource_id_get(vgdev, &resid); > + virtio_gpu_cmd_create_resource(vgdev, resid, > + 2, args->width, args->height); > + > + /* attach the object to the resource */ > + obj = gem_to_virtio_gpu_obj(gobj); > + ret = virtio_gpu_object_attach(vgdev, obj, resid, NULL); > + if (ret) > + goto fail; > + > + obj->dumb = true; > + args->pitch = pitch; > + return ret; > + > +fail: > + return ret; > +} > + > +int virtio_gpu_mode_dumb_destroy(struct drm_file *file_priv, > + struct drm_device *dev, > + uint32_t handle) > +{ > + return drm_gem_handle_delete(file_priv, handle); > +} > + > +int virtio_gpu_mode_dumb_mmap(struct drm_file *file_priv, > + struct drm_device *dev, > + uint32_t handle, uint64_t *offset_p) > +{ > + struct drm_gem_object *gobj; > + struct virtio_gpu_object *obj; > + BUG_ON(!offset_p); > + gobj = drm_gem_object_lookup(dev, file_priv, handle); > + if (gobj == NULL) > + return -ENOENT; > + obj = gem_to_virtio_gpu_obj(gobj); > + *offset_p = virtio_gpu_object_mmap_offset(obj); > + drm_gem_object_unreference_unlocked(gobj); > + return 0; > +} > diff --git a/drivers/gpu/drm/virtio/virtgpu_kms.c b/drivers/gpu/drm/virtio/virtgpu_kms.c > new file mode 100644 > index 0000000..e503ffb > --- /dev/null > +++ b/drivers/gpu/drm/virtio/virtgpu_kms.c > @@ -0,0 +1,164 @@ > +/* > + * 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. > + */ > + > +#include <linux/virtio.h> > +#include <linux/virtio_config.h> > +#include <drm/drmP.h> > +#include "virtgpu_drv.h" > + > +static void virtio_gpu_config_changed_work_func(struct work_struct *work) > +{ > + struct virtio_gpu_device *vgdev = > + container_of(work, struct virtio_gpu_device, > + config_changed_work); > + u32 events_read, events_clear = 0; > + > + /* read the config space */ > + virtio_cread(vgdev->vdev, struct virtio_gpu_config, > + events_read, &events_read); > + if (events_read & VIRTIO_GPU_EVENT_DISPLAY) { > + virtio_gpu_cmd_get_display_info(vgdev); > + drm_helper_hpd_irq_event(vgdev->ddev); > + events_clear |= VIRTIO_GPU_EVENT_DISPLAY; > + } > + virtio_cwrite(vgdev->vdev, struct virtio_gpu_config, > + events_clear, &events_clear); > +} > + > +static void virtio_gpu_init_vq(struct virtio_gpu_queue *vgvq, > + void (*work_func)(struct work_struct *work)) > +{ > + spin_lock_init(&vgvq->qlock); > + init_waitqueue_head(&vgvq->ack_queue); > + INIT_WORK(&vgvq->dequeue_work, work_func); > +} > + > +int virtio_gpu_driver_load(struct drm_device *dev, unsigned long flags) > +{ > + static vq_callback_t *callbacks[] = { > + virtio_gpu_ctrl_ack, virtio_gpu_cursor_ack > + }; > + static const char *names[] = { "control", "cursor" }; > + > + struct virtio_gpu_device *vgdev; > + /* this will expand later */ > + struct virtqueue *vqs[2]; > + u32 num_scanouts; > + int ret; > + > + if (!virtio_has_feature(dev->virtdev, VIRTIO_F_VERSION_1)) > + return -ENODEV; > + > + vgdev = kzalloc(sizeof(struct virtio_gpu_device), GFP_KERNEL); > + if (!vgdev) > + return -ENOMEM; > + > + vgdev->ddev = dev; > + dev->dev_private = vgdev; > + vgdev->vdev = dev->virtdev; > + vgdev->dev = dev->dev; > + > + spin_lock_init(&vgdev->display_info_lock); > + spin_lock_init(&vgdev->ctx_id_idr_lock); > + idr_init(&vgdev->ctx_id_idr); > + spin_lock_init(&vgdev->resource_idr_lock); > + idr_init(&vgdev->resource_idr); > + init_waitqueue_head(&vgdev->resp_wq); > + virtio_gpu_init_vq(&vgdev->ctrlq, virtio_gpu_dequeue_ctrl_func); > + virtio_gpu_init_vq(&vgdev->cursorq, virtio_gpu_dequeue_cursor_func); > + > + spin_lock_init(&vgdev->fence_drv.lock); > + INIT_LIST_HEAD(&vgdev->fence_drv.fences); > + INIT_WORK(&vgdev->config_changed_work, > + virtio_gpu_config_changed_work_func); > + > + ret = vgdev->vdev->config->find_vqs(vgdev->vdev, 2, vqs, > + callbacks, names); > + if (ret) { > + DRM_ERROR("failed to find virt queues\n"); > + goto err_vqs; > + } > + vgdev->ctrlq.vq = vqs[0]; > + vgdev->cursorq.vq = vqs[1]; > + ret = virtio_gpu_alloc_vbufs(vgdev); > + if (ret) { > + DRM_ERROR("failed to alloc vbufs\n"); > + goto err_vbufs; > + } > + > + ret = virtio_gpu_ttm_init(vgdev); > + if (ret) { > + DRM_ERROR("failed to init ttm %d\n", ret); > + goto err_ttm; > + } > + > + /* get display info */ > + virtio_cread(vgdev->vdev, struct virtio_gpu_config, > + num_scanouts, &num_scanouts); > + vgdev->num_scanouts = min_t(uint32_t, num_scanouts, > + VIRTIO_GPU_MAX_SCANOUTS); > + if (!vgdev->num_scanouts) { > + DRM_ERROR("num_scanouts is zero\n"); > + ret = -EINVAL; > + goto err_scanouts; > + } > + > + ret = virtio_gpu_modeset_init(vgdev); > + if (ret) > + goto err_modeset; > + > + virtio_device_ready(vgdev->vdev); > + vgdev->vqs_ready = true; > + virtio_gpu_cmd_get_display_info(vgdev); > + return 0; > + > +err_modeset: > +err_scanouts: > + virtio_gpu_ttm_fini(vgdev); > +err_ttm: > + virtio_gpu_free_vbufs(vgdev); > +err_vbufs: > + vgdev->vdev->config->del_vqs(vgdev->vdev); > +err_vqs: > + kfree(vgdev); > + return ret; > +} > + > +int virtio_gpu_driver_unload(struct drm_device *dev) > +{ > + struct virtio_gpu_device *vgdev = dev->dev_private; > + > + vgdev->vqs_ready = false; > + flush_work(&vgdev->ctrlq.dequeue_work); > + flush_work(&vgdev->cursorq.dequeue_work); > + flush_work(&vgdev->config_changed_work); > + vgdev->vdev->config->del_vqs(vgdev->vdev); > + > + virtio_gpu_modeset_fini(vgdev); > + virtio_gpu_ttm_fini(vgdev); > + virtio_gpu_free_vbufs(vgdev); > + kfree(vgdev); > + return 0; > +} > diff --git a/drivers/gpu/drm/virtio/virtgpu_object.c b/drivers/gpu/drm/virtio/virtgpu_object.c > new file mode 100644 > index 0000000..2c624c7 > --- /dev/null > +++ b/drivers/gpu/drm/virtio/virtgpu_object.c > @@ -0,0 +1,170 @@ > +/* > + * 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. > + */ > + > +#include "virtgpu_drv.h" > + > +static void virtio_gpu_ttm_bo_destroy(struct ttm_buffer_object *tbo) > +{ > + struct virtio_gpu_object *bo; > + struct virtio_gpu_device *vgdev; > + > + bo = container_of(tbo, struct virtio_gpu_object, tbo); > + vgdev = (struct virtio_gpu_device *)bo->gem_base.dev->dev_private; > + > + if (bo->hw_res_handle) > + virtio_gpu_cmd_unref_resource(vgdev, bo->hw_res_handle); > + if (bo->pages) > + virtio_gpu_object_free_sg_table(bo); > + drm_gem_object_release(&bo->gem_base); > + kfree(bo); > +} > + > +static void virtio_gpu_init_ttm_placement(struct virtio_gpu_object *vgbo, > + bool pinned) > +{ > + u32 c = 1; > + u32 pflag = pinned ? TTM_PL_FLAG_NO_EVICT : 0; > + > + vgbo->placement.placement = &vgbo->placement_code; > + vgbo->placement.busy_placement = &vgbo->placement_code; > + vgbo->placement_code.fpfn = 0; > + vgbo->placement_code.lpfn = 0; > + vgbo->placement_code.flags = > + TTM_PL_MASK_CACHING | TTM_PL_FLAG_TT | pflag; > + vgbo->placement.num_placement = c; > + vgbo->placement.num_busy_placement = c; > + > +} > + > +int virtio_gpu_object_create(struct virtio_gpu_device *vgdev, > + unsigned long size, bool kernel, bool pinned, > + struct virtio_gpu_object **bo_ptr) > +{ > + struct virtio_gpu_object *bo; > + enum ttm_bo_type type; > + size_t acc_size; > + int ret; > + > + if (kernel) > + type = ttm_bo_type_kernel; > + else > + type = ttm_bo_type_device; > + *bo_ptr = NULL; > + > + acc_size = ttm_bo_dma_acc_size(&vgdev->mman.bdev, size, > + sizeof(struct virtio_gpu_object)); > + > + bo = kzalloc(sizeof(struct virtio_gpu_object), GFP_KERNEL); > + if (bo == NULL) > + return -ENOMEM; > + size = roundup(size, PAGE_SIZE); > + ret = drm_gem_object_init(vgdev->ddev, &bo->gem_base, size); > + if (ret != 0) > + goto err_gem_init; > + bo->dumb = false; > + virtio_gpu_init_ttm_placement(bo, pinned); > + > + ret = ttm_bo_init(&vgdev->mman.bdev, &bo->tbo, size, type, > + &bo->placement, 0, !kernel, NULL, acc_size, > + NULL, NULL, &virtio_gpu_ttm_bo_destroy); > + if (ret != 0) > + goto err_ttm_init; > + > + *bo_ptr = bo; > + return 0; > + > +err_ttm_init: > + drm_gem_object_release(&bo->gem_base); > +err_gem_init: > + kfree(bo); > + return ret; > +} > + > +int virtio_gpu_object_kmap(struct virtio_gpu_object *bo, void **ptr) > +{ > + bool is_iomem; > + int r; > + > + if (bo->vmap) { > + if (ptr) > + *ptr = bo->vmap; > + return 0; > + } > + r = ttm_bo_kmap(&bo->tbo, 0, bo->tbo.num_pages, &bo->kmap); > + if (r) > + return r; > + bo->vmap = ttm_kmap_obj_virtual(&bo->kmap, &is_iomem); > + if (ptr) > + *ptr = bo->vmap; > + return 0; > +} > + > +int virtio_gpu_object_get_sg_table(struct virtio_gpu_device *qdev, > + struct virtio_gpu_object *bo) > +{ > + int ret; > + struct page **pages = bo->tbo.ttm->pages; > + int nr_pages = bo->tbo.num_pages; > + > + /* wtf swapping */ > + if (bo->pages) > + return 0; > + > + if (bo->tbo.ttm->state == tt_unpopulated) > + bo->tbo.ttm->bdev->driver->ttm_tt_populate(bo->tbo.ttm); > + bo->pages = kmalloc(sizeof(struct sg_table), GFP_KERNEL); > + if (!bo->pages) > + goto out; > + > + ret = sg_alloc_table_from_pages(bo->pages, pages, nr_pages, 0, > + nr_pages << PAGE_SHIFT, GFP_KERNEL); > + if (ret) > + goto out; > + return 0; > +out: > + kfree(bo->pages); > + bo->pages = NULL; > + return -ENOMEM; > +} > + > +void virtio_gpu_object_free_sg_table(struct virtio_gpu_object *bo) > +{ > + sg_free_table(bo->pages); > + kfree(bo->pages); > + bo->pages = NULL; > +} > + > +int virtio_gpu_object_wait(struct virtio_gpu_object *bo, bool no_wait) > +{ > + int r; > + > + r = ttm_bo_reserve(&bo->tbo, true, no_wait, false, NULL); > + if (unlikely(r != 0)) > + return r; > + r = ttm_bo_wait(&bo->tbo, true, true, no_wait); > + ttm_bo_unreserve(&bo->tbo); > + return r; > +} > + > diff --git a/drivers/gpu/drm/virtio/virtgpu_plane.c b/drivers/gpu/drm/virtio/virtgpu_plane.c > new file mode 100644 > index 0000000..4a74129 > --- /dev/null > +++ b/drivers/gpu/drm/virtio/virtgpu_plane.c > @@ -0,0 +1,120 @@ > +/* > + * 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. > + */ > + > +#include "virtgpu_drv.h" > +#include <drm/drm_plane_helper.h> > +#include <drm/drm_atomic_helper.h> > + > +static const uint32_t virtio_gpu_formats[] = { > + DRM_FORMAT_XRGB8888, > + DRM_FORMAT_ARGB8888, > + DRM_FORMAT_BGRX8888, > + DRM_FORMAT_BGRA8888, > + DRM_FORMAT_RGBX8888, > + DRM_FORMAT_RGBA8888, > + DRM_FORMAT_XBGR8888, > + DRM_FORMAT_ABGR8888, > +}; > + > +static void virtio_gpu_plane_destroy(struct drm_plane *plane) > +{ > + kfree(plane); > +} > + > +static const struct drm_plane_funcs virtio_gpu_plane_funcs = { > + .update_plane = drm_atomic_helper_update_plane, > + .disable_plane = drm_atomic_helper_disable_plane, > + .destroy = virtio_gpu_plane_destroy, > + .reset = drm_atomic_helper_plane_reset, > + .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state, > + .atomic_destroy_state = drm_atomic_helper_plane_destroy_state, > +}; > + > +static int virtio_gpu_plane_atomic_check(struct drm_plane *plane, > + struct drm_plane_state *state) > +{ > + return 0; > +} > + > +static void virtio_gpu_plane_atomic_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 = drm_crtc_to_virtio_gpu_output(plane->crtc); > + struct virtio_gpu_framebuffer *vgfb; > + struct virtio_gpu_object *bo; > + uint32_t handle; > + > + if (plane->fb) { > + vgfb = to_virtio_gpu_framebuffer(plane->fb); > + bo = gem_to_virtio_gpu_obj(vgfb->obj); > + handle = bo->hw_res_handle; > + } else { > + handle = 0; > + } > + > + DRM_DEBUG("handle 0x%x, crtc %dx%d+%d+%d\n", handle, > + plane->state->crtc_w, plane->state->crtc_h, > + plane->state->crtc_x, plane->state->crtc_y); > + 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); > +} > + > + > +static const struct drm_plane_helper_funcs virtio_gpu_plane_helper_funcs = { > + .atomic_check = virtio_gpu_plane_atomic_check, > + .atomic_update = virtio_gpu_plane_atomic_update, > +}; > + > +struct drm_plane *virtio_gpu_plane_init(struct virtio_gpu_device *vgdev, > + int index) > +{ > + struct drm_device *dev = vgdev->ddev; > + struct drm_plane *plane; > + int ret; > + > + plane = kzalloc(sizeof(*plane), GFP_KERNEL); > + if (!plane) > + return ERR_PTR(-ENOMEM); > + > + 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); > + if (ret) > + goto err_plane_init; > + > + drm_plane_helper_add(plane, &virtio_gpu_plane_helper_funcs); > + return plane; > + > +err_plane_init: > + kfree(plane); > + return ERR_PTR(ret); > +} > diff --git a/drivers/gpu/drm/virtio/virtgpu_ttm.c b/drivers/gpu/drm/virtio/virtgpu_ttm.c > new file mode 100644 > index 0000000..e0e74c6 > --- /dev/null > +++ b/drivers/gpu/drm/virtio/virtgpu_ttm.c > @@ -0,0 +1,469 @@ > +/* > + * Copyright (C) 2015 Red Hat, Inc. > + * All Rights Reserved. > + * > + * Authors: > + * Dave Airlie > + * Alon Levy > + * > + * 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 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 HOLDER(S) OR AUTHOR(S) 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. > + */ > + > +#include <ttm/ttm_bo_api.h> > +#include <ttm/ttm_bo_driver.h> > +#include <ttm/ttm_placement.h> > +#include <ttm/ttm_page_alloc.h> > +#include <ttm/ttm_module.h> > +#include <drm/drmP.h> > +#include <drm/drm.h> > +#include "virtgpu_drv.h" > + > +#include <linux/delay.h> > + > +#define DRM_FILE_PAGE_OFFSET (0x100000000ULL >> PAGE_SHIFT) > + > +static struct > +virtio_gpu_device *virtio_gpu_get_vgdev(struct ttm_bo_device *bdev) > +{ > + struct virtio_gpu_mman *mman; > + struct virtio_gpu_device *vgdev; > + > + mman = container_of(bdev, struct virtio_gpu_mman, bdev); > + vgdev = container_of(mman, struct virtio_gpu_device, mman); > + return vgdev; > +} > + > +static int virtio_gpu_ttm_mem_global_init(struct drm_global_reference *ref) > +{ > + return ttm_mem_global_init(ref->object); > +} > + > +static void virtio_gpu_ttm_mem_global_release(struct drm_global_reference *ref) > +{ > + ttm_mem_global_release(ref->object); > +} > + > +static int virtio_gpu_ttm_global_init(struct virtio_gpu_device *vgdev) > +{ > + struct drm_global_reference *global_ref; > + int r; > + > + vgdev->mman.mem_global_referenced = false; > + global_ref = &vgdev->mman.mem_global_ref; > + global_ref->global_type = DRM_GLOBAL_TTM_MEM; > + global_ref->size = sizeof(struct ttm_mem_global); > + global_ref->init = &virtio_gpu_ttm_mem_global_init; > + global_ref->release = &virtio_gpu_ttm_mem_global_release; > + > + r = drm_global_item_ref(global_ref); > + if (r != 0) { > + DRM_ERROR("Failed setting up TTM memory accounting " > + "subsystem.\n"); > + return r; > + } > + > + vgdev->mman.bo_global_ref.mem_glob = > + vgdev->mman.mem_global_ref.object; > + global_ref = &vgdev->mman.bo_global_ref.ref; > + global_ref->global_type = DRM_GLOBAL_TTM_BO; > + global_ref->size = sizeof(struct ttm_bo_global); > + global_ref->init = &ttm_bo_global_init; > + global_ref->release = &ttm_bo_global_release; > + r = drm_global_item_ref(global_ref); > + if (r != 0) { > + DRM_ERROR("Failed setting up TTM BO subsystem.\n"); > + drm_global_item_unref(&vgdev->mman.mem_global_ref); > + return r; > + } > + > + vgdev->mman.mem_global_referenced = true; > + return 0; > +} > + > +static void virtio_gpu_ttm_global_fini(struct virtio_gpu_device *vgdev) > +{ > + if (vgdev->mman.mem_global_referenced) { > + drm_global_item_unref(&vgdev->mman.bo_global_ref.ref); > + drm_global_item_unref(&vgdev->mman.mem_global_ref); > + vgdev->mman.mem_global_referenced = false; > + } > +} > + > +#if 0 > +/* > + * Hmm, seems to not do anything useful. Leftover debug hack? > + * Something like printing pagefaults to kernel log? > + */ > +static struct vm_operations_struct virtio_gpu_ttm_vm_ops; > +static const struct vm_operations_struct *ttm_vm_ops; > + > +static int virtio_gpu_ttm_fault(struct vm_area_struct *vma, > + struct vm_fault *vmf) > +{ > + struct ttm_buffer_object *bo; > + struct virtio_gpu_device *vgdev; > + int r; > + > + bo = (struct ttm_buffer_object *)vma->vm_private_data; > + if (bo == NULL) > + return VM_FAULT_NOPAGE; > + vgdev = virtio_gpu_get_vgdev(bo->bdev); > + r = ttm_vm_ops->fault(vma, vmf); > + return r; > +} > +#endif > + > +int virtio_gpu_mmap(struct file *filp, struct vm_area_struct *vma) > +{ > + struct drm_file *file_priv; > + struct virtio_gpu_device *vgdev; > + int r; > + > + file_priv = filp->private_data; > + vgdev = file_priv->minor->dev->dev_private; > + if (vgdev == NULL) { > + DRM_ERROR( > + "filp->private_data->minor->dev->dev_private == NULL\n"); > + return -EINVAL; > + } > + r = ttm_bo_mmap(filp, vma, &vgdev->mman.bdev); > +#if 0 > + if (unlikely(r != 0)) > + return r; > + if (unlikely(ttm_vm_ops == NULL)) { > + ttm_vm_ops = vma->vm_ops; > + virtio_gpu_ttm_vm_ops = *ttm_vm_ops; > + virtio_gpu_ttm_vm_ops.fault = &virtio_gpu_ttm_fault; > + } > + vma->vm_ops = &virtio_gpu_ttm_vm_ops; > + return 0; > +#else > + return r; > +#endif > +} > + > +static int virtio_gpu_invalidate_caches(struct ttm_bo_device *bdev, > + uint32_t flags) > +{ > + return 0; > +} > + > +static int ttm_bo_man_get_node(struct ttm_mem_type_manager *man, > + struct ttm_buffer_object *bo, > + const struct ttm_place *place, > + struct ttm_mem_reg *mem) > +{ > + mem->mm_node = (void *)1; > + return 0; > +} > + > +static void ttm_bo_man_put_node(struct ttm_mem_type_manager *man, > + struct ttm_mem_reg *mem) > +{ > + mem->mm_node = (void *)NULL; > + return; > +} > + > +static int ttm_bo_man_init(struct ttm_mem_type_manager *man, > + unsigned long p_size) > +{ > + return 0; > +} > + > +static int ttm_bo_man_takedown(struct ttm_mem_type_manager *man) > +{ > + return 0; > +} > + > +static void ttm_bo_man_debug(struct ttm_mem_type_manager *man, > + const char *prefix) > +{ > +} > + > +static const struct ttm_mem_type_manager_func virtio_gpu_bo_manager_func = { > + ttm_bo_man_init, > + ttm_bo_man_takedown, > + ttm_bo_man_get_node, > + ttm_bo_man_put_node, > + ttm_bo_man_debug > +}; > + > +static int virtio_gpu_init_mem_type(struct ttm_bo_device *bdev, uint32_t type, > + struct ttm_mem_type_manager *man) > +{ > + struct virtio_gpu_device *vgdev; > + > + vgdev = virtio_gpu_get_vgdev(bdev); > + > + switch (type) { > + case TTM_PL_SYSTEM: > + /* System memory */ > + man->flags = TTM_MEMTYPE_FLAG_MAPPABLE; > + man->available_caching = TTM_PL_MASK_CACHING; > + man->default_caching = TTM_PL_FLAG_CACHED; > + break; > + case TTM_PL_TT: > + man->func = &virtio_gpu_bo_manager_func; > + man->flags = TTM_MEMTYPE_FLAG_MAPPABLE; > + man->available_caching = TTM_PL_MASK_CACHING; > + man->default_caching = TTM_PL_FLAG_CACHED; > + break; > + default: > + DRM_ERROR("Unsupported memory type %u\n", (unsigned)type); > + return -EINVAL; > + } > + return 0; > +} > + > +static void virtio_gpu_evict_flags(struct ttm_buffer_object *bo, > + struct ttm_placement *placement) > +{ > + static struct ttm_place placements = { > + .fpfn = 0, > + .lpfn = 0, > + .flags = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM, > + }; > + > + placement->placement = &placements; > + placement->busy_placement = &placements; > + placement->num_placement = 1; > + placement->num_busy_placement = 1; > + return; > +} > + > +static int virtio_gpu_verify_access(struct ttm_buffer_object *bo, > + struct file *filp) > +{ > + return 0; > +} > + > +static int virtio_gpu_ttm_io_mem_reserve(struct ttm_bo_device *bdev, > + struct ttm_mem_reg *mem) > +{ > + struct ttm_mem_type_manager *man = &bdev->man[mem->mem_type]; > + > + mem->bus.addr = NULL; > + mem->bus.offset = 0; > + mem->bus.size = mem->num_pages << PAGE_SHIFT; > + mem->bus.base = 0; > + mem->bus.is_iomem = false; > + if (!(man->flags & TTM_MEMTYPE_FLAG_MAPPABLE)) > + return -EINVAL; > + switch (mem->mem_type) { > + case TTM_PL_SYSTEM: > + case TTM_PL_TT: > + /* system memory */ > + return 0; > + default: > + return -EINVAL; > + } > + return 0; > +} > + > +static void virtio_gpu_ttm_io_mem_free(struct ttm_bo_device *bdev, > + struct ttm_mem_reg *mem) > +{ > +} > + > +/* > + * TTM backend functions. > + */ > +struct virtio_gpu_ttm_tt { > + struct ttm_dma_tt ttm; > + struct virtio_gpu_device *vgdev; > + u64 offset; > +}; > + > +static int virtio_gpu_ttm_backend_bind(struct ttm_tt *ttm, > + struct ttm_mem_reg *bo_mem) > +{ > + struct virtio_gpu_ttm_tt *gtt = (void *)ttm; > + > + gtt->offset = (unsigned long)(bo_mem->start << PAGE_SHIFT); > + if (!ttm->num_pages) > + WARN(1, "nothing to bind %lu pages for mreg %p back %p!\n", > + ttm->num_pages, bo_mem, ttm); > + > + /* Not implemented */ > + return 0; > +} > + > +static int virtio_gpu_ttm_backend_unbind(struct ttm_tt *ttm) > +{ > + /* Not implemented */ > + return 0; > +} > + > +static void virtio_gpu_ttm_backend_destroy(struct ttm_tt *ttm) > +{ > + struct virtio_gpu_ttm_tt *gtt = (void *)ttm; > + > + ttm_dma_tt_fini(>t->ttm); > + kfree(gtt); > +} > + > +static struct ttm_backend_func virtio_gpu_backend_func = { > + .bind = &virtio_gpu_ttm_backend_bind, > + .unbind = &virtio_gpu_ttm_backend_unbind, > + .destroy = &virtio_gpu_ttm_backend_destroy, > +}; > + > +static int virtio_gpu_ttm_tt_populate(struct ttm_tt *ttm) > +{ > + if (ttm->state != tt_unpopulated) > + return 0; > + > + return ttm_pool_populate(ttm); > +} > + > +static void virtio_gpu_ttm_tt_unpopulate(struct ttm_tt *ttm) > +{ > + ttm_pool_unpopulate(ttm); > +} > + > +static struct ttm_tt *virtio_gpu_ttm_tt_create(struct ttm_bo_device *bdev, > + unsigned long size, > + uint32_t page_flags, > + struct page *dummy_read_page) > +{ > + struct virtio_gpu_device *vgdev; > + struct virtio_gpu_ttm_tt *gtt; > + > + vgdev = virtio_gpu_get_vgdev(bdev); > + gtt = kzalloc(sizeof(struct virtio_gpu_ttm_tt), GFP_KERNEL); > + if (gtt == NULL) > + return NULL; > + gtt->ttm.ttm.func = &virtio_gpu_backend_func; > + gtt->vgdev = vgdev; > + if (ttm_dma_tt_init(>t->ttm, bdev, size, page_flags, > + dummy_read_page)) { > + kfree(gtt); > + return NULL; > + } > + return >t->ttm.ttm; > +} > + > +static void virtio_gpu_move_null(struct ttm_buffer_object *bo, > + struct ttm_mem_reg *new_mem) > +{ > + struct ttm_mem_reg *old_mem = &bo->mem; > + > + BUG_ON(old_mem->mm_node != NULL); > + *old_mem = *new_mem; > + new_mem->mm_node = NULL; > +} > + > +static int virtio_gpu_bo_move(struct ttm_buffer_object *bo, > + bool evict, bool interruptible, > + bool no_wait_gpu, > + struct ttm_mem_reg *new_mem) > +{ > + virtio_gpu_move_null(bo, new_mem); > + return 0; > +} > + > +static void virtio_gpu_bo_move_notify(struct ttm_buffer_object *tbo, > + struct ttm_mem_reg *new_mem) > +{ > + struct virtio_gpu_object *bo; > + struct virtio_gpu_device *vgdev; > + > + bo = container_of(tbo, struct virtio_gpu_object, tbo); > + vgdev = (struct virtio_gpu_device *)bo->gem_base.dev->dev_private; > + > + if (!new_mem || (new_mem->placement & TTM_PL_FLAG_SYSTEM)) { > + if (bo->hw_res_handle) > + virtio_gpu_cmd_resource_inval_backing(vgdev, > + bo->hw_res_handle); > + > + } else if (new_mem->placement & TTM_PL_FLAG_TT) { > + if (bo->hw_res_handle) { > + virtio_gpu_object_attach(vgdev, bo, bo->hw_res_handle, > + NULL); > + } > + } > +} > + > +static void virtio_gpu_bo_swap_notify(struct ttm_buffer_object *tbo) > +{ > + struct virtio_gpu_object *bo; > + struct virtio_gpu_device *vgdev; > + > + bo = container_of(tbo, struct virtio_gpu_object, tbo); > + vgdev = (struct virtio_gpu_device *)bo->gem_base.dev->dev_private; > + > + if (bo->pages) > + virtio_gpu_object_free_sg_table(bo); > +} > + > +static struct ttm_bo_driver virtio_gpu_bo_driver = { > + .ttm_tt_create = &virtio_gpu_ttm_tt_create, > + .ttm_tt_populate = &virtio_gpu_ttm_tt_populate, > + .ttm_tt_unpopulate = &virtio_gpu_ttm_tt_unpopulate, > + .invalidate_caches = &virtio_gpu_invalidate_caches, > + .init_mem_type = &virtio_gpu_init_mem_type, > + .evict_flags = &virtio_gpu_evict_flags, > + .move = &virtio_gpu_bo_move, > + .verify_access = &virtio_gpu_verify_access, > + .io_mem_reserve = &virtio_gpu_ttm_io_mem_reserve, > + .io_mem_free = &virtio_gpu_ttm_io_mem_free, > + .move_notify = &virtio_gpu_bo_move_notify, > + .swap_notify = &virtio_gpu_bo_swap_notify, > +}; > + > +int virtio_gpu_ttm_init(struct virtio_gpu_device *vgdev) > +{ > + int r; > + > + r = virtio_gpu_ttm_global_init(vgdev); > + if (r) > + return r; > + /* No others user of address space so set it to 0 */ > + r = ttm_bo_device_init(&vgdev->mman.bdev, > + vgdev->mman.bo_global_ref.ref.object, > + &virtio_gpu_bo_driver, > + vgdev->ddev->anon_inode->i_mapping, > + DRM_FILE_PAGE_OFFSET, 0); > + if (r) { > + DRM_ERROR("failed initializing buffer object driver(%d).\n", r); > + goto err_dev_init; > + return r; > + } > + > + r = ttm_bo_init_mm(&vgdev->mman.bdev, TTM_PL_TT, 0); > + if (r) { > + DRM_ERROR("Failed initializing GTT heap.\n"); > + goto err_mm_init; > + return r; > + } > + return 0; > + > +err_mm_init: > + ttm_bo_device_release(&vgdev->mman.bdev); > +err_dev_init: > + virtio_gpu_ttm_global_fini(vgdev); > + return r; > +} > + > +void virtio_gpu_ttm_fini(struct virtio_gpu_device *vgdev) > +{ > + ttm_bo_device_release(&vgdev->mman.bdev); > + virtio_gpu_ttm_global_fini(vgdev); > + DRM_INFO("virtio_gpu: ttm finalized\n"); > +} > diff --git a/drivers/gpu/drm/virtio/virtgpu_vq.c b/drivers/gpu/drm/virtio/virtgpu_vq.c > new file mode 100644 > index 0000000..8fa6513e > --- /dev/null > +++ b/drivers/gpu/drm/virtio/virtgpu_vq.c > @@ -0,0 +1,614 @@ > +/* > + * Copyright (C) 2015 Red Hat, Inc. > + * All Rights Reserved. > + * > + * Authors: > + * Dave Airlie <airlied@redhat.com> > + * Gerd Hoffmann <kraxel@redhat.com> > + * > + * 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 > + * VA LINUX SYSTEMS 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. > + */ > + > +#include <drm/drmP.h> > +#include "virtgpu_drv.h" > +#include <linux/virtio.h> > +#include <linux/virtio_config.h> > +#include <linux/virtio_ring.h> > + > +#define MAX_INLINE_CMD_SIZE 96 > +#define MAX_INLINE_RESP_SIZE 24 > +#define VBUFFER_SIZE (sizeof(struct virtio_gpu_vbuffer) \ > + + MAX_INLINE_CMD_SIZE \ > + + MAX_INLINE_RESP_SIZE) > + > +void virtio_gpu_resource_id_get(struct virtio_gpu_device *vgdev, > + uint32_t *resid) > +{ > + int handle; > + > + idr_preload(GFP_KERNEL); > + spin_lock(&vgdev->resource_idr_lock); > + handle = idr_alloc(&vgdev->resource_idr, NULL, 1, 0, GFP_NOWAIT); > + spin_unlock(&vgdev->resource_idr_lock); > + idr_preload_end(); > + *resid = handle; > +} > + > +void virtio_gpu_resource_id_put(struct virtio_gpu_device *vgdev, uint32_t id) > +{ > + spin_lock(&vgdev->resource_idr_lock); > + idr_remove(&vgdev->resource_idr, id); > + spin_unlock(&vgdev->resource_idr_lock); > +} > + > +void virtio_gpu_ctrl_ack(struct virtqueue *vq) > +{ > + struct drm_device *dev = vq->vdev->priv; > + struct virtio_gpu_device *vgdev = dev->dev_private; > + schedule_work(&vgdev->ctrlq.dequeue_work); > +} > + > +void virtio_gpu_cursor_ack(struct virtqueue *vq) > +{ > + struct drm_device *dev = vq->vdev->priv; > + struct virtio_gpu_device *vgdev = dev->dev_private; > + schedule_work(&vgdev->cursorq.dequeue_work); > +} > + > +int virtio_gpu_alloc_vbufs(struct virtio_gpu_device *vgdev) > +{ > + struct virtio_gpu_vbuffer *vbuf; > + int i, size, count = 0; > + void *ptr; > + > + INIT_LIST_HEAD(&vgdev->free_vbufs); > + count += virtqueue_get_vring_size(vgdev->ctrlq.vq); > + count += virtqueue_get_vring_size(vgdev->cursorq.vq); > + size = count * VBUFFER_SIZE; > + DRM_INFO("virtio vbuffers: %d bufs, %zdB each, %dkB total.\n", > + count, VBUFFER_SIZE, size / 1024); > + > + vgdev->vbufs = kzalloc(size, GFP_KERNEL); > + if (!vgdev->vbufs) > + return -ENOMEM; > + > + for (i = 0, ptr = vgdev->vbufs; > + i < count; > + i++, ptr += VBUFFER_SIZE) { > + vbuf = ptr; > + list_add(&vbuf->list, &vgdev->free_vbufs); > + } > + return 0; > +} > + > +void virtio_gpu_free_vbufs(struct virtio_gpu_device *vgdev) > +{ > + struct virtio_gpu_vbuffer *vbuf; > + int i, count = 0; > + > + count += virtqueue_get_vring_size(vgdev->ctrlq.vq); > + count += virtqueue_get_vring_size(vgdev->cursorq.vq); > + > + for (i = 0; i < count; i++) { > + if (WARN_ON(list_empty(&vgdev->free_vbufs))) > + return; > + vbuf = list_first_entry(&vgdev->free_vbufs, > + struct virtio_gpu_vbuffer, list); > + list_del(&vbuf->list); > + } > + kfree(vgdev->vbufs); > +} > + > +static struct virtio_gpu_vbuffer* > +virtio_gpu_get_vbuf(struct virtio_gpu_device *vgdev, > + int size, int resp_size, void *resp_buf, > + virtio_gpu_resp_cb resp_cb) > +{ > + struct virtio_gpu_vbuffer *vbuf; > + > + BUG_ON(list_empty(&vgdev->free_vbufs)); > + vbuf = list_first_entry(&vgdev->free_vbufs, > + struct virtio_gpu_vbuffer, list); > + list_del(&vbuf->list); > + memset(vbuf, 0, VBUFFER_SIZE); > + > + BUG_ON(size > MAX_INLINE_CMD_SIZE); > + vbuf->buf = (void *)vbuf + sizeof(*vbuf); > + vbuf->size = size; > + > + vbuf->resp_cb = resp_cb; > + vbuf->resp_size = resp_size; > + if (resp_size <= MAX_INLINE_RESP_SIZE) > + vbuf->resp_buf = (void *)vbuf->buf + size; > + else > + vbuf->resp_buf = resp_buf; > + BUG_ON(!vbuf->resp_buf); > + return vbuf; > +} > + > +static void *virtio_gpu_alloc_cmd(struct virtio_gpu_device *vgdev, > + struct virtio_gpu_vbuffer **vbuffer_p, > + int size) > +{ > + struct virtio_gpu_vbuffer *vbuf; > + > + vbuf = virtio_gpu_get_vbuf(vgdev, size, > + sizeof(struct virtio_gpu_ctrl_hdr), > + NULL, NULL); > + if (IS_ERR(vbuf)) { > + *vbuffer_p = NULL; > + return ERR_CAST(vbuf); > + } > + *vbuffer_p = vbuf; > + return vbuf->buf; > +} > + > +static struct virtio_gpu_update_cursor* > +virtio_gpu_alloc_cursor(struct virtio_gpu_device *vgdev, > + struct virtio_gpu_vbuffer **vbuffer_p) > +{ > + struct virtio_gpu_vbuffer *vbuf; > + > + vbuf = virtio_gpu_get_vbuf > + (vgdev, sizeof(struct virtio_gpu_update_cursor), > + 0, NULL, NULL); > + if (IS_ERR(vbuf)) { > + *vbuffer_p = NULL; > + return ERR_CAST(vbuf); > + } > + *vbuffer_p = vbuf; > + return (struct virtio_gpu_update_cursor *)vbuf->buf; > +} > + > +static void *virtio_gpu_alloc_cmd_resp(struct virtio_gpu_device *vgdev, > + virtio_gpu_resp_cb cb, > + struct virtio_gpu_vbuffer **vbuffer_p, > + int cmd_size, int resp_size, > + void *resp_buf) > +{ > + struct virtio_gpu_vbuffer *vbuf; > + > + vbuf = virtio_gpu_get_vbuf(vgdev, cmd_size, > + resp_size, resp_buf, cb); > + if (IS_ERR(vbuf)) { > + *vbuffer_p = NULL; > + return ERR_CAST(vbuf); > + } > + *vbuffer_p = vbuf; > + return (struct virtio_gpu_command *)vbuf->buf; > +} > + > +static void free_vbuf(struct virtio_gpu_device *vgdev, > + struct virtio_gpu_vbuffer *vbuf) > +{ > + if (vbuf->resp_size > MAX_INLINE_RESP_SIZE) > + kfree(vbuf->resp_buf); > + kfree(vbuf->data_buf); > + list_add(&vbuf->list, &vgdev->free_vbufs); > +} > + > +static void reclaim_vbufs(struct virtqueue *vq, struct list_head *reclaim_list) > +{ > + struct virtio_gpu_vbuffer *vbuf; > + unsigned int len; > + int freed = 0; > + > + while ((vbuf = virtqueue_get_buf(vq, &len))) { > + list_add_tail(&vbuf->list, reclaim_list); > + freed++; > + } > + if (freed == 0) > + DRM_DEBUG("Huh? zero vbufs reclaimed"); > +} > + > +void virtio_gpu_dequeue_ctrl_func(struct work_struct *work) > +{ > + struct virtio_gpu_device *vgdev = > + container_of(work, struct virtio_gpu_device, > + ctrlq.dequeue_work); > + struct list_head reclaim_list; > + struct virtio_gpu_vbuffer *entry, *tmp; > + struct virtio_gpu_ctrl_hdr *resp; > + u64 fence_id = 0; > + > + INIT_LIST_HEAD(&reclaim_list); > + spin_lock(&vgdev->ctrlq.qlock); > + do { > + virtqueue_disable_cb(vgdev->ctrlq.vq); > + reclaim_vbufs(vgdev->ctrlq.vq, &reclaim_list); > + > + } while (!virtqueue_enable_cb(vgdev->ctrlq.vq)); > + spin_unlock(&vgdev->ctrlq.qlock); > + > + list_for_each_entry_safe(entry, tmp, &reclaim_list, list) { > + resp = (struct virtio_gpu_ctrl_hdr *)entry->resp_buf; > + if (resp->type != cpu_to_le32(VIRTIO_GPU_RESP_OK_NODATA)) > + DRM_DEBUG("response 0x%x\n", le32_to_cpu(resp->type)); > + if (resp->flags & cpu_to_le32(VIRTIO_GPU_FLAG_FENCE)) { > + u64 f = le64_to_cpu(resp->fence_id); > + > + if (fence_id > f) { > + DRM_ERROR("%s: Oops: fence %llx -> %llx\n", > + __func__, fence_id, f); > + } else { > + fence_id = f; > + } > + } > + if (entry->resp_cb) > + entry->resp_cb(vgdev, entry); > + > + list_del(&entry->list); > + free_vbuf(vgdev, entry); > + } > + wake_up(&vgdev->ctrlq.ack_queue); > + > + if (fence_id) > + virtio_gpu_fence_event_process(vgdev, fence_id); > +} > + > +void virtio_gpu_dequeue_cursor_func(struct work_struct *work) > +{ > + struct virtio_gpu_device *vgdev = > + container_of(work, struct virtio_gpu_device, > + cursorq.dequeue_work); > + struct list_head reclaim_list; > + struct virtio_gpu_vbuffer *entry, *tmp; > + > + INIT_LIST_HEAD(&reclaim_list); > + spin_lock(&vgdev->cursorq.qlock); > + do { > + virtqueue_disable_cb(vgdev->cursorq.vq); > + reclaim_vbufs(vgdev->cursorq.vq, &reclaim_list); > + } while (!virtqueue_enable_cb(vgdev->cursorq.vq)); > + spin_unlock(&vgdev->cursorq.qlock); > + > + list_for_each_entry_safe(entry, tmp, &reclaim_list, list) { > + list_del(&entry->list); > + free_vbuf(vgdev, entry); > + } > + wake_up(&vgdev->cursorq.ack_queue); > +} > + > +static int virtio_gpu_queue_ctrl_buffer(struct virtio_gpu_device *vgdev, > + struct virtio_gpu_vbuffer *vbuf) > +{ > + struct virtqueue *vq = vgdev->ctrlq.vq; > + struct scatterlist *sgs[3], vcmd, vout, vresp; > + int outcnt = 0, incnt = 0; > + int ret; > + > + if (!vgdev->vqs_ready) > + return -ENODEV; > + > + sg_init_one(&vcmd, vbuf->buf, vbuf->size); > + sgs[outcnt+incnt] = &vcmd; > + outcnt++; > + > + if (vbuf->data_size) { > + sg_init_one(&vout, vbuf->data_buf, vbuf->data_size); > + sgs[outcnt + incnt] = &vout; > + outcnt++; > + } > + > + if (vbuf->resp_size) { > + sg_init_one(&vresp, vbuf->resp_buf, vbuf->resp_size); > + sgs[outcnt + incnt] = &vresp; > + incnt++; > + } > + > + spin_lock(&vgdev->ctrlq.qlock); > +retry: > + ret = virtqueue_add_sgs(vq, sgs, outcnt, incnt, vbuf, GFP_ATOMIC); > + if (ret == -ENOSPC) { > + spin_unlock(&vgdev->ctrlq.qlock); > + wait_event(vgdev->ctrlq.ack_queue, vq->num_free); > + spin_lock(&vgdev->ctrlq.qlock); > + goto retry; > + } else { > + virtqueue_kick(vq); > + } > + spin_unlock(&vgdev->ctrlq.qlock); > + > + if (!ret) > + ret = vq->num_free; > + return ret; > +} > + > +static int virtio_gpu_queue_cursor(struct virtio_gpu_device *vgdev, > + struct virtio_gpu_vbuffer *vbuf) > +{ > + struct virtqueue *vq = vgdev->cursorq.vq; > + struct scatterlist *sgs[1], ccmd; > + int ret; > + int outcnt; > + > + if (!vgdev->vqs_ready) > + return -ENODEV; > + > + sg_init_one(&ccmd, vbuf->buf, vbuf->size); > + sgs[0] = &ccmd; > + outcnt = 1; > + > + spin_lock(&vgdev->cursorq.qlock); > +retry: > + ret = virtqueue_add_sgs(vq, sgs, outcnt, 0, vbuf, GFP_ATOMIC); > + if (ret == -ENOSPC) { > + spin_unlock(&vgdev->cursorq.qlock); > + wait_event(vgdev->cursorq.ack_queue, vq->num_free); > + spin_lock(&vgdev->cursorq.qlock); > + goto retry; > + } else { > + virtqueue_kick(vq); > + } > + > + spin_unlock(&vgdev->cursorq.qlock); > + > + if (!ret) > + ret = vq->num_free; > + return ret; > +} > + > +/* just create gem objects for userspace and long lived objects, > + just use dma_alloced pages for the queue objects? */ > + > +/* create a basic resource */ > +void virtio_gpu_cmd_create_resource(struct virtio_gpu_device *vgdev, > + uint32_t resource_id, > + uint32_t format, > + uint32_t width, > + uint32_t height) > +{ > + struct virtio_gpu_resource_create_2d *cmd_p; > + struct virtio_gpu_vbuffer *vbuf; > + > + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); > + memset(cmd_p, 0, sizeof(*cmd_p)); > + > + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_CREATE_2D); > + cmd_p->resource_id = cpu_to_le32(resource_id); > + cmd_p->format = cpu_to_le32(format); > + cmd_p->width = cpu_to_le32(width); > + cmd_p->height = cpu_to_le32(height); > + > + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); > +} > + > +void virtio_gpu_cmd_unref_resource(struct virtio_gpu_device *vgdev, > + uint32_t resource_id) > +{ > + struct virtio_gpu_resource_unref *cmd_p; > + struct virtio_gpu_vbuffer *vbuf; > + > + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); > + memset(cmd_p, 0, sizeof(*cmd_p)); > + > + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_UNREF); > + cmd_p->resource_id = cpu_to_le32(resource_id); > + > + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); > +} > + > +void virtio_gpu_cmd_resource_inval_backing(struct virtio_gpu_device *vgdev, > + uint32_t resource_id) > +{ > + struct virtio_gpu_resource_detach_backing *cmd_p; > + struct virtio_gpu_vbuffer *vbuf; > + > + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); > + memset(cmd_p, 0, sizeof(*cmd_p)); > + > + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING); > + cmd_p->resource_id = cpu_to_le32(resource_id); > + > + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); > +} > + > +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) > +{ > + struct virtio_gpu_set_scanout *cmd_p; > + struct virtio_gpu_vbuffer *vbuf; > + > + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); > + memset(cmd_p, 0, sizeof(*cmd_p)); > + > + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_SET_SCANOUT); > + cmd_p->resource_id = cpu_to_le32(resource_id); > + cmd_p->scanout_id = cpu_to_le32(scanout_id); > + cmd_p->r.width = cpu_to_le32(width); > + cmd_p->r.height = cpu_to_le32(height); > + cmd_p->r.x = cpu_to_le32(x); > + cmd_p->r.y = cpu_to_le32(y); > + > + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); > +} > + > +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) > +{ > + struct virtio_gpu_resource_flush *cmd_p; > + struct virtio_gpu_vbuffer *vbuf; > + > + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); > + memset(cmd_p, 0, sizeof(*cmd_p)); > + > + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_FLUSH); > + cmd_p->resource_id = cpu_to_le32(resource_id); > + cmd_p->r.width = cpu_to_le32(width); > + cmd_p->r.height = cpu_to_le32(height); > + cmd_p->r.x = cpu_to_le32(x); > + cmd_p->r.y = cpu_to_le32(y); > + > + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); > +} > + > +void virtio_gpu_cmd_transfer_to_host_2d(struct virtio_gpu_device *vgdev, > + uint32_t resource_id, uint64_t offset, > + __le32 width, __le32 height, > + __le32 x, __le32 y, > + struct virtio_gpu_fence **fence) > +{ > + struct virtio_gpu_transfer_to_host_2d *cmd_p; > + struct virtio_gpu_vbuffer *vbuf; > + > + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); > + memset(cmd_p, 0, sizeof(*cmd_p)); > + > + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D); > + cmd_p->resource_id = cpu_to_le32(resource_id); > + cmd_p->offset = cpu_to_le64(offset); > + cmd_p->r.width = width; > + cmd_p->r.height = height; > + cmd_p->r.x = x; > + cmd_p->r.y = y; > + > + if (fence) > + virtio_gpu_fence_emit(vgdev, &cmd_p->hdr, fence); > + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); > +} > + > +static void > +virtio_gpu_cmd_resource_attach_backing(struct virtio_gpu_device *vgdev, > + uint32_t resource_id, > + struct virtio_gpu_mem_entry *ents, > + uint32_t nents, > + struct virtio_gpu_fence **fence) > +{ > + struct virtio_gpu_resource_attach_backing *cmd_p; > + struct virtio_gpu_vbuffer *vbuf; > + > + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); > + memset(cmd_p, 0, sizeof(*cmd_p)); > + > + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING); > + cmd_p->resource_id = cpu_to_le32(resource_id); > + cmd_p->nr_entries = cpu_to_le32(nents); > + > + vbuf->data_buf = ents; > + vbuf->data_size = sizeof(*ents) * nents; > + > + if (fence) > + virtio_gpu_fence_emit(vgdev, &cmd_p->hdr, fence); > + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); > +} > + > +static void virtio_gpu_cmd_get_display_info_cb(struct virtio_gpu_device *vgdev, > + struct virtio_gpu_vbuffer *vbuf) > +{ > + struct virtio_gpu_resp_display_info *resp = > + (struct virtio_gpu_resp_display_info *)vbuf->resp_buf; > + int i; > + > + spin_lock(&vgdev->display_info_lock); > + for (i = 0; i < vgdev->num_scanouts; i++) { > + vgdev->outputs[i].info = resp->pmodes[i]; > + if (resp->pmodes[i].enabled) { > + DRM_DEBUG("output %d: %dx%d+%d+%d", i, > + le32_to_cpu(resp->pmodes[i].r.width), > + le32_to_cpu(resp->pmodes[i].r.height), > + le32_to_cpu(resp->pmodes[i].r.x), > + le32_to_cpu(resp->pmodes[i].r.y)); > + } else { > + DRM_DEBUG("output %d: disabled", i); > + } > + } > + > + spin_unlock(&vgdev->display_info_lock); > + wake_up(&vgdev->resp_wq); > + > + if (!drm_helper_hpd_irq_event(vgdev->ddev)) > + drm_kms_helper_hotplug_event(vgdev->ddev); > +} > + > +int virtio_gpu_cmd_get_display_info(struct virtio_gpu_device *vgdev) > +{ > + struct virtio_gpu_ctrl_hdr *cmd_p; > + struct virtio_gpu_vbuffer *vbuf; > + void *resp_buf; > + > + resp_buf = kzalloc(sizeof(struct virtio_gpu_resp_display_info), > + GFP_KERNEL); > + if (!resp_buf) > + return -ENOMEM; > + > + cmd_p = virtio_gpu_alloc_cmd_resp > + (vgdev, &virtio_gpu_cmd_get_display_info_cb, &vbuf, > + sizeof(*cmd_p), sizeof(struct virtio_gpu_resp_display_info), > + resp_buf); > + memset(cmd_p, 0, sizeof(*cmd_p)); > + > + cmd_p->type = cpu_to_le32(VIRTIO_GPU_CMD_GET_DISPLAY_INFO); > + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); > + return 0; > +} > + > +int virtio_gpu_object_attach(struct virtio_gpu_device *vgdev, > + struct virtio_gpu_object *obj, > + uint32_t resource_id, > + struct virtio_gpu_fence **fence) > +{ > + struct virtio_gpu_mem_entry *ents; > + struct scatterlist *sg; > + int si; > + > + if (!obj->pages) { > + int ret; > + ret = virtio_gpu_object_get_sg_table(vgdev, obj); > + if (ret) > + return ret; > + } > + > + /* gets freed when the ring has consumed it */ > + ents = kmalloc_array(obj->pages->nents, > + sizeof(struct virtio_gpu_mem_entry), > + GFP_KERNEL); > + if (!ents) { > + DRM_ERROR("failed to allocate ent list\n"); > + return -ENOMEM; > + } > + > + for_each_sg(obj->pages->sgl, sg, obj->pages->nents, si) { > + ents[si].addr = cpu_to_le64(sg_phys(sg)); > + ents[si].length = cpu_to_le32(sg->length); > + ents[si].padding = 0; > + } > + > + virtio_gpu_cmd_resource_attach_backing(vgdev, resource_id, > + ents, obj->pages->nents, > + fence); > + obj->hw_res_handle = resource_id; > + return 0; > +} > + > +void virtio_gpu_cursor_ping(struct virtio_gpu_device *vgdev, > + struct virtio_gpu_output *output) > +{ > + struct virtio_gpu_vbuffer *vbuf; > + struct virtio_gpu_update_cursor *cur_p; > + > + output->cursor.pos.scanout_id = cpu_to_le32(output->index); > + cur_p = virtio_gpu_alloc_cursor(vgdev, &vbuf); > + memcpy(cur_p, &output->cursor, sizeof(output->cursor)); > + virtio_gpu_queue_cursor(vgdev, vbuf); > +} > diff --git a/include/drm/drmP.h b/include/drm/drmP.h > index 62c40777..1544bb1 100644 > --- a/include/drm/drmP.h > +++ b/include/drm/drmP.h > @@ -812,6 +812,7 @@ struct drm_device { > #endif > > struct platform_device *platformdev; /**< Platform device struture */ > + struct virtio_device *virtdev; > > struct drm_sg_mem *sg; /**< Scatter gather memory */ > unsigned int num_crtcs; /**< Number of CRTCs on this device */ > diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild > index 1a0006a..4460e58 100644 > --- a/include/uapi/linux/Kbuild > +++ b/include/uapi/linux/Kbuild > @@ -430,6 +430,7 @@ header-y += virtio_balloon.h > header-y += virtio_blk.h > header-y += virtio_config.h > header-y += virtio_console.h > +header-y += virtio_gpu.h > header-y += virtio_ids.h > header-y += virtio_input.h > header-y += virtio_net.h > diff --git a/include/uapi/linux/virtio_gpu.h b/include/uapi/linux/virtio_gpu.h > new file mode 100644 > index 0000000..571c4cb > --- /dev/null > +++ b/include/uapi/linux/virtio_gpu.h > @@ -0,0 +1,204 @@ > +/* > + * Virtio GPU Device > + * > + * Copyright Red Hat, Inc. 2013-2014 > + * > + * Authors: > + * Dave Airlie <airlied@redhat.com> > + * Gerd Hoffmann <kraxel@redhat.com> > + * > + * This header is BSD licensed so anyone can use the definitions > + * to implement compatible drivers/servers: > + * > + * Redistribution and use in source and binary forms, with or without > + * modification, are permitted provided that the following conditions > + * are met: > + * 1. Redistributions of source code must retain the above copyright > + * notice, this list of conditions and the following disclaimer. > + * 2. Redistributions in binary form must reproduce the above copyright > + * notice, this list of conditions and the following disclaimer in the > + * documentation and/or other materials provided with the distribution. > + * 3. Neither the name of IBM nor the names of its contributors > + * may be used to endorse or promote products derived from this software > + * without specific prior written permission. > + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS > + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT > + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS > + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL IBM OR > + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, > + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT > + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF > + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND > + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, > + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT > + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF > + * SUCH DAMAGE. > + */ > + > +#ifndef VIRTIO_GPU_HW_H > +#define VIRTIO_GPU_HW_H > + > +enum virtio_gpu_ctrl_type { > + VIRTIO_GPU_UNDEFINED = 0, > + > + /* 2d commands */ > + VIRTIO_GPU_CMD_GET_DISPLAY_INFO = 0x0100, > + VIRTIO_GPU_CMD_RESOURCE_CREATE_2D, > + VIRTIO_GPU_CMD_RESOURCE_UNREF, > + VIRTIO_GPU_CMD_SET_SCANOUT, > + VIRTIO_GPU_CMD_RESOURCE_FLUSH, > + VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D, > + VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING, > + VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING, > + > + /* cursor commands */ > + VIRTIO_GPU_CMD_UPDATE_CURSOR = 0x0300, > + VIRTIO_GPU_CMD_MOVE_CURSOR, > + > + /* success responses */ > + VIRTIO_GPU_RESP_OK_NODATA = 0x1100, > + VIRTIO_GPU_RESP_OK_DISPLAY_INFO, > + > + /* error responses */ > + VIRTIO_GPU_RESP_ERR_UNSPEC = 0x1200, > + VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY, > + VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID, > + VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID, > + VIRTIO_GPU_RESP_ERR_INVALID_CONTEXT_ID, > + VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER, > +}; > + > +#define VIRTIO_GPU_FLAG_FENCE (1 << 0) > + > +struct virtio_gpu_ctrl_hdr { > + __le32 type; > + __le32 flags; > + __le64 fence_id; > + __le32 ctx_id; > + __le32 padding; > +}; > + > +/* data passed in the cursor vq */ > + > +struct virtio_gpu_cursor_pos { > + __le32 scanout_id; > + __le32 x; > + __le32 y; > + __le32 padding; > +}; > + > +/* VIRTIO_GPU_CMD_UPDATE_CURSOR, VIRTIO_GPU_CMD_MOVE_CURSOR */ > +struct virtio_gpu_update_cursor { > + struct virtio_gpu_ctrl_hdr hdr; > + struct virtio_gpu_cursor_pos pos; /* update & move */ > + __le32 resource_id; /* update only */ > + __le32 hot_x; /* update only */ > + __le32 hot_y; /* update only */ > + __le32 padding; > +}; > + > +/* data passed in the control vq, 2d related */ > + > +struct virtio_gpu_rect { > + __le32 x; > + __le32 y; > + __le32 width; > + __le32 height; > +}; > + > +/* VIRTIO_GPU_CMD_RESOURCE_UNREF */ > +struct virtio_gpu_resource_unref { > + struct virtio_gpu_ctrl_hdr hdr; > + __le32 resource_id; > + __le32 padding; > +}; > + > +/* VIRTIO_GPU_CMD_RESOURCE_CREATE_2D: create a 2d resource with a format */ > +struct virtio_gpu_resource_create_2d { > + struct virtio_gpu_ctrl_hdr hdr; > + __le32 resource_id; > + __le32 format; > + __le32 width; > + __le32 height; > +}; > + > +/* VIRTIO_GPU_CMD_SET_SCANOUT */ > +struct virtio_gpu_set_scanout { > + struct virtio_gpu_ctrl_hdr hdr; > + struct virtio_gpu_rect r; > + __le32 scanout_id; > + __le32 resource_id; > +}; > + > +/* VIRTIO_GPU_CMD_RESOURCE_FLUSH */ > +struct virtio_gpu_resource_flush { > + struct virtio_gpu_ctrl_hdr hdr; > + struct virtio_gpu_rect r; > + __le32 resource_id; > + __le32 padding; > +}; > + > +/* VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D: simple transfer to_host */ > +struct virtio_gpu_transfer_to_host_2d { > + struct virtio_gpu_ctrl_hdr hdr; > + struct virtio_gpu_rect r; > + __le64 offset; > + __le32 resource_id; > + __le32 padding; > +}; > + > +struct virtio_gpu_mem_entry { > + __le64 addr; > + __le32 length; > + __le32 padding; > +}; > + > +/* VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING */ > +struct virtio_gpu_resource_attach_backing { > + struct virtio_gpu_ctrl_hdr hdr; > + __le32 resource_id; > + __le32 nr_entries; > +}; > + > +/* VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING */ > +struct virtio_gpu_resource_detach_backing { > + struct virtio_gpu_ctrl_hdr hdr; > + __le32 resource_id; > + __le32 padding; > +}; > + > +/* VIRTIO_GPU_RESP_OK_DISPLAY_INFO */ > +#define VIRTIO_GPU_MAX_SCANOUTS 16 > +struct virtio_gpu_resp_display_info { > + struct virtio_gpu_ctrl_hdr hdr; > + struct virtio_gpu_display_one { > + struct virtio_gpu_rect r; > + __le32 enabled; > + __le32 flags; > + } pmodes[VIRTIO_GPU_MAX_SCANOUTS]; > +}; > + > +#define VIRTIO_GPU_EVENT_DISPLAY (1 << 0) > + > +struct virtio_gpu_config { > + __u32 events_read; > + __u32 events_clear; > + __u32 num_scanouts; > + __u32 reserved; > +}; > + > +/* simple formats for fbcon/X use */ > +enum virtio_gpu_formats { > + VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM = 1, > + VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM = 2, > + VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM = 3, > + VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM = 4, > + > + VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM = 67, > + VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM = 68, > + > + VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM = 121, > + VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM = 134, > +}; > + > +#endif > diff --git a/include/uapi/linux/virtio_ids.h b/include/uapi/linux/virtio_ids.h > index 5f60aa4..77925f5 100644 > --- a/include/uapi/linux/virtio_ids.h > +++ b/include/uapi/linux/virtio_ids.h > @@ -39,6 +39,7 @@ > #define VIRTIO_ID_9P 9 /* 9p virtio console */ > #define VIRTIO_ID_RPROC_SERIAL 11 /* virtio remoteproc serial link */ > #define VIRTIO_ID_CAIF 12 /* Virtio caif */ > +#define VIRTIO_ID_GPU 16 /* virtio GPU */ > #define VIRTIO_ID_INPUT 18 /* virtio input */ > > #endif /* _LINUX_VIRTIO_IDS_H */ > -- > 1.8.3.1
diff --git a/drivers/gpu/drm/Kconfig b/drivers/gpu/drm/Kconfig index 47f2ce8..d4b6545 100644 --- a/drivers/gpu/drm/Kconfig +++ b/drivers/gpu/drm/Kconfig @@ -206,6 +206,8 @@ source "drivers/gpu/drm/qxl/Kconfig" source "drivers/gpu/drm/bochs/Kconfig" +source "drivers/gpu/drm/virtio/Kconfig" + source "drivers/gpu/drm/msm/Kconfig" source "drivers/gpu/drm/tegra/Kconfig" diff --git a/drivers/gpu/drm/Makefile b/drivers/gpu/drm/Makefile index 7d4944e..dbbc101 100644 --- a/drivers/gpu/drm/Makefile +++ b/drivers/gpu/drm/Makefile @@ -63,6 +63,7 @@ obj-$(CONFIG_DRM_OMAP) += omapdrm/ obj-$(CONFIG_DRM_TILCDC) += tilcdc/ obj-$(CONFIG_DRM_QXL) += qxl/ obj-$(CONFIG_DRM_BOCHS) += bochs/ +obj-$(CONFIG_DRM_VIRTIO_GPU) += virtio/ obj-$(CONFIG_DRM_MSM) += msm/ obj-$(CONFIG_DRM_TEGRA) += tegra/ obj-$(CONFIG_DRM_STI) += sti/ diff --git a/drivers/gpu/drm/virtio/Kconfig b/drivers/gpu/drm/virtio/Kconfig new file mode 100644 index 0000000..9983ead --- /dev/null +++ b/drivers/gpu/drm/virtio/Kconfig @@ -0,0 +1,14 @@ +config DRM_VIRTIO_GPU + tristate "Virtio GPU driver" + depends on DRM && VIRTIO + select FB_SYS_FILLRECT + select FB_SYS_COPYAREA + select FB_SYS_IMAGEBLIT + select DRM_KMS_HELPER + select DRM_KMS_FB_HELPER + select DRM_TTM + help + This is the virtual GPU driver for virtio. It can be used with + QEMU based VMMs (like KVM or Xen). + + If unsure say M. diff --git a/drivers/gpu/drm/virtio/Makefile b/drivers/gpu/drm/virtio/Makefile new file mode 100644 index 0000000..2ee1602 --- /dev/null +++ b/drivers/gpu/drm/virtio/Makefile @@ -0,0 +1,11 @@ +# +# Makefile for the drm device driver. This driver provides support for the +# Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher. + +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 + +obj-$(CONFIG_DRM_VIRTIO_GPU) += virtio-gpu.o diff --git a/drivers/gpu/drm/virtio/virtgpu_debugfs.c b/drivers/gpu/drm/virtio/virtgpu_debugfs.c new file mode 100644 index 0000000..db8b491 --- /dev/null +++ b/drivers/gpu/drm/virtio/virtgpu_debugfs.c @@ -0,0 +1,64 @@ +/* + * 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. + */ + +#include <linux/debugfs.h> + +#include "drmP.h" +#include "virtgpu_drv.h" + +static int +virtio_gpu_debugfs_irq_info(struct seq_file *m, void *data) +{ + struct drm_info_node *node = (struct drm_info_node *) m->private; + struct virtio_gpu_device *vgdev = node->minor->dev->dev_private; + + seq_printf(m, "fence %ld %lld\n", + atomic64_read(&vgdev->fence_drv.last_seq), + vgdev->fence_drv.sync_seq); + return 0; +} + +static struct drm_info_list virtio_gpu_debugfs_list[] = { + { "irq_fence", virtio_gpu_debugfs_irq_info, 0, NULL }, +}; + +#define VIRTIO_GPU_DEBUGFS_ENTRIES ARRAY_SIZE(virtio_gpu_debugfs_list) + +int +virtio_gpu_debugfs_init(struct drm_minor *minor) +{ + drm_debugfs_create_files(virtio_gpu_debugfs_list, + VIRTIO_GPU_DEBUGFS_ENTRIES, + minor->debugfs_root, minor); + return 0; +} + +void +virtio_gpu_debugfs_takedown(struct drm_minor *minor) +{ + drm_debugfs_remove_files(virtio_gpu_debugfs_list, + VIRTIO_GPU_DEBUGFS_ENTRIES, + minor); +} diff --git a/drivers/gpu/drm/virtio/virtgpu_display.c b/drivers/gpu/drm/virtio/virtgpu_display.c new file mode 100644 index 0000000..a2eca5f --- /dev/null +++ b/drivers/gpu/drm/virtio/virtgpu_display.c @@ -0,0 +1,485 @@ +/* + * Copyright (C) 2015 Red Hat, Inc. + * All Rights Reserved. + * + * Authors: + * Dave Airlie + * Alon Levy + * + * 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 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 HOLDER(S) OR AUTHOR(S) 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. + */ + +#include "virtgpu_drv.h" +#include <drm/drm_crtc_helper.h> +#include <drm/drm_atomic_helper.h> + +#define XRES_MIN 320 +#define YRES_MIN 200 + +#define XRES_DEF 1024 +#define YRES_DEF 768 + +#define XRES_MAX 8192 +#define YRES_MAX 8192 + +static int virtio_gpu_fbdev = 1; + +MODULE_PARM_DESC(fbdev, "Disable/Enable framebuffer device & console"); +module_param_named(fbdev, virtio_gpu_fbdev, int, 0400); + +static void virtio_gpu_crtc_gamma_set(struct drm_crtc *crtc, + u16 *red, u16 *green, u16 *blue, + uint32_t start, uint32_t size) +{ + /* TODO */ +} + +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(crtc->dev, 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); + + 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 const struct drm_crtc_funcs virtio_gpu_crtc_funcs = { + .cursor_set2 = virtio_gpu_crtc_cursor_set, + .cursor_move = virtio_gpu_crtc_cursor_move, + .gamma_set = virtio_gpu_crtc_gamma_set, + .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 + .reset = drm_atomic_helper_crtc_reset, + .atomic_duplicate_state = drm_atomic_helper_crtc_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_crtc_destroy_state, +}; + +static void virtio_gpu_user_framebuffer_destroy(struct drm_framebuffer *fb) +{ + struct virtio_gpu_framebuffer *virtio_gpu_fb + = to_virtio_gpu_framebuffer(fb); + + if (virtio_gpu_fb->obj) + drm_gem_object_unreference_unlocked(virtio_gpu_fb->obj); + drm_framebuffer_cleanup(fb); + kfree(virtio_gpu_fb); +} + +static int +virtio_gpu_framebuffer_surface_dirty(struct drm_framebuffer *fb, + struct drm_file *file_priv, + unsigned flags, unsigned color, + struct drm_clip_rect *clips, + unsigned num_clips) +{ + struct virtio_gpu_framebuffer *virtio_gpu_fb + = to_virtio_gpu_framebuffer(fb); + + return virtio_gpu_surface_dirty(virtio_gpu_fb, clips, num_clips); +} + +static const struct drm_framebuffer_funcs virtio_gpu_fb_funcs = { + .destroy = virtio_gpu_user_framebuffer_destroy, + .dirty = virtio_gpu_framebuffer_surface_dirty, +}; + +int +virtio_gpu_framebuffer_init(struct drm_device *dev, + struct virtio_gpu_framebuffer *vgfb, + struct drm_mode_fb_cmd2 *mode_cmd, + struct drm_gem_object *obj) +{ + int ret; + struct virtio_gpu_object *bo; + vgfb->obj = obj; + + bo = gem_to_virtio_gpu_obj(obj); + + ret = drm_framebuffer_init(dev, &vgfb->base, &virtio_gpu_fb_funcs); + if (ret) { + vgfb->obj = NULL; + return ret; + } + drm_helper_mode_fill_fb_struct(&vgfb->base, mode_cmd); + + spin_lock_init(&vgfb->dirty_lock); + vgfb->x1 = vgfb->y1 = INT_MAX; + vgfb->x2 = vgfb->y2 = 0; + return 0; +} + +static bool virtio_gpu_crtc_mode_fixup(struct drm_crtc *crtc, + const struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ + return true; +} + +static void virtio_gpu_crtc_mode_set_nofb(struct drm_crtc *crtc) +{ + struct drm_device *dev = crtc->dev; + struct virtio_gpu_device *vgdev = dev->dev_private; + struct virtio_gpu_output *output = drm_crtc_to_virtio_gpu_output(crtc); + + virtio_gpu_cmd_set_scanout(vgdev, output->index, 0, + crtc->mode.hdisplay, + crtc->mode.vdisplay, 0, 0); +} + +static void virtio_gpu_crtc_enable(struct drm_crtc *crtc) +{ +} + +static void virtio_gpu_crtc_disable(struct drm_crtc *crtc) +{ + struct drm_device *dev = crtc->dev; + struct virtio_gpu_device *vgdev = dev->dev_private; + struct virtio_gpu_output *output = drm_crtc_to_virtio_gpu_output(crtc); + + virtio_gpu_cmd_set_scanout(vgdev, output->index, 0, 0, 0, 0, 0); +} + +static int virtio_gpu_crtc_atomic_check(struct drm_crtc *crtc, + struct drm_crtc_state *state) +{ + return 0; +} + +static const struct drm_crtc_helper_funcs virtio_gpu_crtc_helper_funcs = { + .enable = virtio_gpu_crtc_enable, + .disable = virtio_gpu_crtc_disable, + .mode_fixup = virtio_gpu_crtc_mode_fixup, + .mode_set_nofb = virtio_gpu_crtc_mode_set_nofb, + .atomic_check = virtio_gpu_crtc_atomic_check, +}; + +static bool virtio_gpu_enc_mode_fixup(struct drm_encoder *encoder, + const struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ + return true; +} + +static void virtio_gpu_enc_mode_set(struct drm_encoder *encoder, + struct drm_display_mode *mode, + struct drm_display_mode *adjusted_mode) +{ +} + +static void virtio_gpu_enc_enable(struct drm_encoder *encoder) +{ +} + +static void virtio_gpu_enc_disable(struct drm_encoder *encoder) +{ +} + +static int virtio_gpu_conn_get_modes(struct drm_connector *connector) +{ + struct virtio_gpu_output *output = + drm_connector_to_virtio_gpu_output(connector); + struct drm_display_mode *mode = NULL; + int count, width, height; + + width = le32_to_cpu(output->info.r.width); + height = le32_to_cpu(output->info.r.height); + count = drm_add_modes_noedid(connector, XRES_MAX, YRES_MAX); + + if (width == 0 || height == 0) { + width = XRES_DEF; + height = YRES_DEF; + drm_set_preferred_mode(connector, XRES_DEF, YRES_DEF); + } else { + DRM_DEBUG("add mode: %dx%d\n", width, height); + mode = drm_cvt_mode(connector->dev, width, height, 60, + false, false, false); + mode->type |= DRM_MODE_TYPE_PREFERRED; + drm_mode_probed_add(connector, mode); + count++; + } + + return count; +} + +static int virtio_gpu_conn_mode_valid(struct drm_connector *connector, + struct drm_display_mode *mode) +{ + struct virtio_gpu_output *output = + drm_connector_to_virtio_gpu_output(connector); + int width, height; + + width = le32_to_cpu(output->info.r.width); + height = le32_to_cpu(output->info.r.height); + + if (!(mode->type & DRM_MODE_TYPE_PREFERRED)) + return MODE_OK; + if (mode->hdisplay == XRES_DEF && mode->vdisplay == YRES_DEF) + return MODE_OK; + if (mode->hdisplay <= width && mode->hdisplay >= width - 16 && + mode->vdisplay <= height && mode->vdisplay >= height - 16) + return MODE_OK; + + DRM_DEBUG("del mode: %dx%d\n", mode->hdisplay, mode->vdisplay); + return MODE_BAD; +} + +static struct drm_encoder* +virtio_gpu_best_encoder(struct drm_connector *connector) +{ + struct virtio_gpu_output *virtio_gpu_output = + drm_connector_to_virtio_gpu_output(connector); + + return &virtio_gpu_output->enc; +} + +static const struct drm_encoder_helper_funcs virtio_gpu_enc_helper_funcs = { + .mode_fixup = virtio_gpu_enc_mode_fixup, + .mode_set = virtio_gpu_enc_mode_set, + .enable = virtio_gpu_enc_enable, + .disable = virtio_gpu_enc_disable, +}; + +static const struct drm_connector_helper_funcs virtio_gpu_conn_helper_funcs = { + .get_modes = virtio_gpu_conn_get_modes, + .mode_valid = virtio_gpu_conn_mode_valid, + .best_encoder = virtio_gpu_best_encoder, +}; + +static void virtio_gpu_conn_save(struct drm_connector *connector) +{ + DRM_DEBUG("\n"); +} + +static void virtio_gpu_conn_restore(struct drm_connector *connector) +{ + DRM_DEBUG("\n"); +} + +static enum drm_connector_status virtio_gpu_conn_detect( + struct drm_connector *connector, + bool force) +{ + struct virtio_gpu_output *output = + drm_connector_to_virtio_gpu_output(connector); + + if (output->info.enabled) + return connector_status_connected; + else + return connector_status_disconnected; +} + +static void virtio_gpu_conn_destroy(struct drm_connector *connector) +{ + struct virtio_gpu_output *virtio_gpu_output = + drm_connector_to_virtio_gpu_output(connector); + + drm_connector_unregister(connector); + drm_connector_cleanup(connector); + kfree(virtio_gpu_output); +} + +static const struct drm_connector_funcs virtio_gpu_connector_funcs = { + .dpms = drm_atomic_helper_connector_dpms, + .save = virtio_gpu_conn_save, + .restore = virtio_gpu_conn_restore, + .detect = virtio_gpu_conn_detect, + .fill_modes = drm_helper_probe_single_connector_modes, + .destroy = virtio_gpu_conn_destroy, + .reset = drm_atomic_helper_connector_reset, + .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, +}; + +static const struct drm_encoder_funcs virtio_gpu_enc_funcs = { + .destroy = drm_encoder_cleanup, +}; + +static int vgdev_output_init(struct virtio_gpu_device *vgdev, int index) +{ + struct drm_device *dev = vgdev->ddev; + struct virtio_gpu_output *output = vgdev->outputs + index; + struct drm_connector *connector = &output->conn; + struct drm_encoder *encoder = &output->enc; + struct drm_crtc *crtc = &output->crtc; + struct drm_plane *plane; + + output->index = index; + if (index == 0) { + output->info.enabled = cpu_to_le32(true); + output->info.r.width = cpu_to_le32(XRES_DEF); + 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, + &virtio_gpu_crtc_funcs); + drm_mode_crtc_set_gamma_size(crtc, 256); + drm_crtc_helper_add(crtc, &virtio_gpu_crtc_helper_funcs); + plane->crtc = crtc; + + drm_connector_init(dev, connector, &virtio_gpu_connector_funcs, + DRM_MODE_CONNECTOR_VIRTUAL); + drm_connector_helper_add(connector, &virtio_gpu_conn_helper_funcs); + + drm_encoder_init(dev, encoder, &virtio_gpu_enc_funcs, + DRM_MODE_ENCODER_VIRTUAL); + drm_encoder_helper_add(encoder, &virtio_gpu_enc_helper_funcs); + encoder->possible_crtcs = 1 << index; + + drm_mode_connector_attach_encoder(connector, encoder); + drm_connector_register(connector); + return 0; +} + +static struct drm_framebuffer * +virtio_gpu_user_framebuffer_create(struct drm_device *dev, + struct drm_file *file_priv, + struct drm_mode_fb_cmd2 *mode_cmd) +{ + struct drm_gem_object *obj = NULL; + struct virtio_gpu_framebuffer *virtio_gpu_fb; + int ret; + + /* lookup object associated with res handle */ + obj = drm_gem_object_lookup(dev, file_priv, mode_cmd->handles[0]); + if (!obj) + return ERR_PTR(-EINVAL); + + virtio_gpu_fb = kzalloc(sizeof(*virtio_gpu_fb), GFP_KERNEL); + if (virtio_gpu_fb == NULL) + return ERR_PTR(-ENOMEM); + + ret = virtio_gpu_framebuffer_init(dev, virtio_gpu_fb, mode_cmd, obj); + if (ret) { + kfree(virtio_gpu_fb); + if (obj) + drm_gem_object_unreference_unlocked(obj); + return NULL; + } + + return &virtio_gpu_fb->base; +} + +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, +}; + +int virtio_gpu_modeset_init(struct virtio_gpu_device *vgdev) +{ + int i, ret; + + drm_mode_config_init(vgdev->ddev); + vgdev->ddev->mode_config.funcs = (void *)&virtio_gpu_mode_funcs; + + /* modes will be validated against the framebuffer size */ + vgdev->ddev->mode_config.min_width = XRES_MIN; + vgdev->ddev->mode_config.min_height = YRES_MIN; + vgdev->ddev->mode_config.max_width = XRES_MAX; + vgdev->ddev->mode_config.max_height = YRES_MAX; + + for (i = 0 ; i < vgdev->num_scanouts; ++i) + vgdev_output_init(vgdev, i); + + drm_mode_config_reset(vgdev->ddev); + + if (virtio_gpu_fbdev) { + ret = virtio_gpu_fbdev_init(vgdev); + if (ret) + return ret; + } + + return 0; +} + +void virtio_gpu_modeset_fini(struct virtio_gpu_device *vgdev) +{ + virtio_gpu_fbdev_fini(vgdev); + drm_mode_config_cleanup(vgdev->ddev); +} diff --git a/drivers/gpu/drm/virtio/virtgpu_drm_bus.c b/drivers/gpu/drm/virtio/virtgpu_drm_bus.c new file mode 100644 index 0000000..f4ec816 --- /dev/null +++ b/drivers/gpu/drm/virtio/virtgpu_drm_bus.c @@ -0,0 +1,91 @@ +/* + * 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. + */ + +#include <linux/pci.h> + +#include "virtgpu_drv.h" + +int drm_virtio_set_busid(struct drm_device *dev, struct drm_master *master) +{ + struct pci_dev *pdev = dev->pdev; + + if (pdev) { + return drm_pci_set_busid(dev, master); + } + return 0; +} + +int drm_virtio_init(struct drm_driver *driver, struct virtio_device *vdev) +{ + struct drm_device *dev; + int ret; + + dev = drm_dev_alloc(driver, &vdev->dev); + if (!dev) + return -ENOMEM; + dev->virtdev = vdev; + vdev->priv = dev; + + if (strcmp(vdev->dev.parent->bus->name, "pci") == 0) { + struct pci_dev *pdev = to_pci_dev(vdev->dev.parent); + bool vga = (pdev->class >> 8) == PCI_CLASS_DISPLAY_VGA; + + if (vga) { + /* + * Need to make sure we don't have two drivers + * for the same hardware here. Some day we + * will simply kick out the firmware + * (vesa/efi) framebuffer. + * + * Virtual hardware specs for virtio-vga are + * not finalized yet, therefore we can't add + * code for that yet. + * + * So ignore the device for the time being, + * and suggest to the user use the device + * variant without vga compatibility mode. + */ + DRM_ERROR("virtio-vga not (yet) supported\n"); + DRM_ERROR("please use virtio-gpu-pci instead\n"); + ret = -ENODEV; + goto err_free; + } + dev->pdev = pdev; + } + + ret = drm_dev_register(dev, 0); + if (ret) + goto err_free; + + DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n", driver->name, + driver->major, driver->minor, driver->patchlevel, + driver->date, dev->primary->index); + + return 0; + +err_free: + drm_dev_unref(dev); + return ret; +} diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.c b/drivers/gpu/drm/virtio/virtgpu_drv.c new file mode 100644 index 0000000..7d9610a --- /dev/null +++ b/drivers/gpu/drm/virtio/virtgpu_drv.c @@ -0,0 +1,136 @@ +/* + * Copyright (C) 2015 Red Hat, Inc. + * All Rights Reserved. + * + * Authors: + * Dave Airlie <airlied@redhat.com> + * Gerd Hoffmann <kraxel@redhat.com> + * + * 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 + * VA LINUX SYSTEMS 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. + */ + +#include <linux/module.h> +#include <linux/console.h> +#include <linux/pci.h> +#include "drmP.h" +#include "drm/drm.h" + +#include "virtgpu_drv.h" +static struct drm_driver driver; + +static int virtio_gpu_modeset = -1; + +MODULE_PARM_DESC(modeset, "Disable/Enable modesetting"); +module_param_named(modeset, virtio_gpu_modeset, int, 0400); + +static int virtio_gpu_probe(struct virtio_device *vdev) +{ +#ifdef CONFIG_VGA_CONSOLE + if (vgacon_text_force() && virtio_gpu_modeset == -1) + return -EINVAL; +#endif + + if (virtio_gpu_modeset == 0) + return -EINVAL; + + return drm_virtio_init(&driver, vdev); +} + +static void virtio_gpu_remove(struct virtio_device *vdev) +{ + struct drm_device *dev = vdev->priv; + drm_put_dev(dev); +} + +static void virtio_gpu_config_changed(struct virtio_device *vdev) +{ + struct drm_device *dev = vdev->priv; + struct virtio_gpu_device *vgdev = dev->dev_private; + + schedule_work(&vgdev->config_changed_work); +} + +static struct virtio_device_id id_table[] = { + { VIRTIO_ID_GPU, VIRTIO_DEV_ANY_ID }, + { 0 }, +}; + +static unsigned int features[] = { +}; +static struct virtio_driver virtio_gpu_driver = { + .feature_table = features, + .feature_table_size = ARRAY_SIZE(features), + .driver.name = KBUILD_MODNAME, + .driver.owner = THIS_MODULE, + .id_table = id_table, + .probe = virtio_gpu_probe, + .remove = virtio_gpu_remove, + .config_changed = virtio_gpu_config_changed +}; + +module_virtio_driver(virtio_gpu_driver); + +MODULE_DEVICE_TABLE(virtio, id_table); +MODULE_DESCRIPTION("Virtio GPU driver"); +MODULE_LICENSE("GPL and additional rights"); +MODULE_AUTHOR("Dave Airlie <airlied@redhat.com>"); +MODULE_AUTHOR("Gerd Hoffmann <kraxel@redhat.com>"); +MODULE_AUTHOR("Alon Levy"); + +static const struct file_operations virtio_gpu_driver_fops = { + .owner = THIS_MODULE, + .open = drm_open, + .mmap = virtio_gpu_mmap, + .poll = drm_poll, + .read = drm_read, + .unlocked_ioctl = drm_ioctl, + .release = drm_release, +#ifdef CONFIG_COMPAT + .compat_ioctl = drm_compat_ioctl, +#endif + .llseek = noop_llseek, +}; + + +static struct drm_driver driver = { + .driver_features = DRIVER_MODESET | DRIVER_GEM, + .set_busid = drm_virtio_set_busid, + .load = virtio_gpu_driver_load, + .unload = virtio_gpu_driver_unload, + + .dumb_create = virtio_gpu_mode_dumb_create, + .dumb_map_offset = virtio_gpu_mode_dumb_mmap, + .dumb_destroy = virtio_gpu_mode_dumb_destroy, + +#if defined(CONFIG_DEBUG_FS) + .debugfs_init = virtio_gpu_debugfs_init, + .debugfs_cleanup = virtio_gpu_debugfs_takedown, +#endif + + .gem_free_object = virtio_gpu_gem_free_object, + .fops = &virtio_gpu_driver_fops, + + .name = DRIVER_NAME, + .desc = DRIVER_DESC, + .date = DRIVER_DATE, + .major = DRIVER_MAJOR, + .minor = DRIVER_MINOR, + .patchlevel = DRIVER_PATCHLEVEL, +}; diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.h b/drivers/gpu/drm/virtio/virtgpu_drv.h new file mode 100644 index 0000000..e5a2c09 --- /dev/null +++ b/drivers/gpu/drm/virtio/virtgpu_drv.h @@ -0,0 +1,350 @@ +/* + * 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> + +#include <drm/drmP.h> +#include <drm/drm_gem.h> +#include <drm/drm_crtc_helper.h> +#include <ttm/ttm_bo_api.h> +#include <ttm/ttm_bo_driver.h> +#include <ttm/ttm_placement.h> +#include <ttm/ttm_module.h> + +#define DRIVER_NAME "virtio_gpu" +#define DRIVER_DESC "virtio GPU" +#define DRIVER_DATE "0" + +#define DRIVER_MAJOR 0 +#define DRIVER_MINOR 0 +#define DRIVER_PATCHLEVEL 1 + +/* virtgpu_drm_bus.c */ +int drm_virtio_set_busid(struct drm_device *dev, struct drm_master *master); +int drm_virtio_init(struct drm_driver *driver, struct virtio_device *vdev); + +struct virtio_gpu_object { + struct drm_gem_object gem_base; + uint32_t hw_res_handle; + + struct sg_table *pages; + void *vmap; + bool dumb; + struct ttm_place placement_code; + struct ttm_placement placement; + struct ttm_buffer_object tbo; + struct ttm_bo_kmap_obj kmap; +}; +#define gem_to_virtio_gpu_obj(gobj) \ + container_of((gobj), struct virtio_gpu_object, gem_base) + +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 { + atomic64_t last_seq; + uint64_t sync_seq; + struct list_head fences; + spinlock_t lock; +}; + +struct virtio_gpu_fence { + struct fence f; + struct virtio_gpu_fence_driver *drv; + struct list_head node; + uint64_t seq; +}; +#define to_virtio_fence(x) \ + container_of(x, struct virtio_gpu_fence, f) + +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; + + 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; + int cur_x; + int cur_y; +}; +#define drm_crtc_to_virtio_gpu_output(x) \ + container_of(x, struct virtio_gpu_output, crtc) +#define drm_connector_to_virtio_gpu_output(x) \ + container_of(x, struct virtio_gpu_output, conn) +#define drm_encoder_to_virtio_gpu_output(x) \ + container_of(x, struct virtio_gpu_output, enc) + +struct virtio_gpu_framebuffer { + struct drm_framebuffer base; + struct drm_gem_object *obj; + int x1, y1, x2, y2; /* dirty rect */ + spinlock_t dirty_lock; + uint32_t hw_res_handle; +}; +#define to_virtio_gpu_framebuffer(x) \ + container_of(x, struct virtio_gpu_framebuffer, base) + +struct virtio_gpu_mman { + struct ttm_bo_global_ref bo_global_ref; + struct drm_global_reference mem_global_ref; + bool mem_global_referenced; + struct ttm_bo_device bdev; +}; + +struct virtio_gpu_fbdev; + +struct virtio_gpu_queue { + struct virtqueue *vq; + spinlock_t qlock; + wait_queue_head_t ack_queue; + struct work_struct dequeue_work; +}; + +struct virtio_gpu_device { + struct device *dev; + struct drm_device *ddev; + + struct virtio_device *vdev; + + struct virtio_gpu_mman mman; + + /* pointer to fbdev info structure */ + struct virtio_gpu_fbdev *vgfbdev; + struct virtio_gpu_output outputs[VIRTIO_GPU_MAX_SCANOUTS]; + uint32_t num_scanouts; + + struct virtio_gpu_queue ctrlq; + struct virtio_gpu_queue cursorq; + struct list_head free_vbufs; + void *vbufs; + bool vqs_ready; + + struct idr resource_idr; + spinlock_t resource_idr_lock; + + wait_queue_head_t resp_wq; + /* current display info */ + spinlock_t display_info_lock; + + struct virtio_gpu_fence_driver fence_drv; + + struct idr ctx_id_idr; + spinlock_t ctx_id_idr_lock; + + struct work_struct config_changed_work; +}; + +struct virtio_gpu_fpriv { + uint32_t ctx_id; +}; + +/* virtio_ioctl.c */ +#define DRM_VIRTIO_NUM_IOCTLS 10 +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); + +/* virtio_gem.c */ +void virtio_gpu_gem_free_object(struct drm_gem_object *gem_obj); +int virtio_gpu_gem_init(struct virtio_gpu_device *vgdev); +void virtio_gpu_gem_fini(struct virtio_gpu_device *vgdev); +int virtio_gpu_gem_create(struct drm_file *file, + struct drm_device *dev, + uint64_t size, + struct drm_gem_object **obj_p, + uint32_t *handle_p); +struct virtio_gpu_object *virtio_gpu_alloc_object(struct drm_device *dev, + size_t size, bool kernel, + bool pinned); +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_destroy(struct drm_file *file_priv, + struct drm_device *dev, + uint32_t handle); +int virtio_gpu_mode_dumb_mmap(struct drm_file *file_priv, + struct drm_device *dev, + uint32_t handle, uint64_t *offset_p); + +/* virtio_fb */ +#define VIRTIO_GPUFB_CONN_LIMIT 1 +int virtio_gpu_fbdev_init(struct virtio_gpu_device *vgdev); +void virtio_gpu_fbdev_fini(struct virtio_gpu_device *vgdev); +int virtio_gpu_surface_dirty(struct virtio_gpu_framebuffer *qfb, + struct drm_clip_rect *clips, + unsigned num_clips); +/* virtio vg */ +int virtio_gpu_alloc_vbufs(struct virtio_gpu_device *vgdev); +void virtio_gpu_free_vbufs(struct virtio_gpu_device *vgdev); +void virtio_gpu_resource_id_get(struct virtio_gpu_device *vgdev, + uint32_t *resid); +void virtio_gpu_resource_id_put(struct virtio_gpu_device *vgdev, uint32_t id); +void virtio_gpu_cmd_create_resource(struct virtio_gpu_device *vgdev, + uint32_t resource_id, + uint32_t format, + uint32_t width, + uint32_t height); +void virtio_gpu_cmd_unref_resource(struct virtio_gpu_device *vgdev, + uint32_t resource_id); +void virtio_gpu_cmd_transfer_to_host_2d(struct virtio_gpu_device *vgdev, + uint32_t resource_id, uint64_t offset, + __le32 width, __le32 height, + __le32 x, __le32 y, + struct virtio_gpu_fence **fence); +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); +int virtio_gpu_object_attach(struct virtio_gpu_device *vgdev, + struct virtio_gpu_object *obj, + uint32_t resource_id, + struct virtio_gpu_fence **fence); +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); +void virtio_gpu_cmd_resource_inval_backing(struct virtio_gpu_device *vgdev, + uint32_t resource_id); +void virtio_gpu_ctrl_ack(struct virtqueue *vq); +void virtio_gpu_cursor_ack(struct virtqueue *vq); +void virtio_gpu_dequeue_ctrl_func(struct work_struct *work); +void virtio_gpu_dequeue_cursor_func(struct work_struct *work); + +/* virtio_gpu_display.c */ +int virtio_gpu_framebuffer_init(struct drm_device *dev, + struct virtio_gpu_framebuffer *vgfb, + struct drm_mode_fb_cmd2 *mode_cmd, + struct drm_gem_object *obj); +int virtio_gpu_modeset_init(struct virtio_gpu_device *vgdev); +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, + int index); + +/* virtio_gpu_ttm.c */ +int virtio_gpu_ttm_init(struct virtio_gpu_device *vgdev); +void virtio_gpu_ttm_fini(struct virtio_gpu_device *vgdev); +int virtio_gpu_mmap(struct file *filp, struct vm_area_struct *vma); + +/* virtio_gpu_fence.c */ +int virtio_gpu_fence_emit(struct virtio_gpu_device *vgdev, + struct virtio_gpu_ctrl_hdr *cmd_hdr, + struct virtio_gpu_fence **fence); +void virtio_gpu_fence_event_process(struct virtio_gpu_device *vdev, + u64 last_seq); + +/* virtio_gpu_object */ +int virtio_gpu_object_create(struct virtio_gpu_device *vgdev, + unsigned long size, bool kernel, bool pinned, + struct virtio_gpu_object **bo_ptr); +int virtio_gpu_object_kmap(struct virtio_gpu_object *bo, void **ptr); +int virtio_gpu_object_get_sg_table(struct virtio_gpu_device *qdev, + struct virtio_gpu_object *bo); +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); + +static inline struct virtio_gpu_object* +virtio_gpu_object_ref(struct virtio_gpu_object *bo) +{ + ttm_bo_reference(&bo->tbo); + return bo; +} + +static inline void virtio_gpu_object_unref(struct virtio_gpu_object **bo) +{ + struct ttm_buffer_object *tbo; + + if ((*bo) == NULL) + return; + tbo = &((*bo)->tbo); + ttm_bo_unref(&tbo); + if (tbo == NULL) + *bo = NULL; +} + +static inline u64 virtio_gpu_object_mmap_offset(struct virtio_gpu_object *bo) +{ + return drm_vma_node_offset_addr(&bo->tbo.vma_node); +} + +static inline int virtio_gpu_object_reserve(struct virtio_gpu_object *bo, + bool no_wait) +{ + int r; + + r = ttm_bo_reserve(&bo->tbo, true, no_wait, false, NULL); + if (unlikely(r != 0)) { + if (r != -ERESTARTSYS) { + struct virtio_gpu_device *qdev = + bo->gem_base.dev->dev_private; + dev_err(qdev->dev, "%p reserve failed\n", bo); + } + return r; + } + return 0; +} + +static inline void virtio_gpu_object_unreserve(struct virtio_gpu_object *bo) +{ + ttm_bo_unreserve(&bo->tbo); +} + +/* virgl debufs */ +int virtio_gpu_debugfs_init(struct drm_minor *minor); +void virtio_gpu_debugfs_takedown(struct drm_minor *minor); + +#endif diff --git a/drivers/gpu/drm/virtio/virtgpu_fb.c b/drivers/gpu/drm/virtio/virtgpu_fb.c new file mode 100644 index 0000000..25bf333 --- /dev/null +++ b/drivers/gpu/drm/virtio/virtgpu_fb.c @@ -0,0 +1,431 @@ +/* + * 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. + */ + +#include <drm/drmP.h> +#include <drm/drm_fb_helper.h> +#include "virtgpu_drv.h" + +#define VIRTIO_GPU_FBCON_POLL_PERIOD (HZ / 60) + +struct virtio_gpu_fbdev { + struct drm_fb_helper helper; + struct virtio_gpu_framebuffer vgfb; + struct list_head fbdev_list; + struct virtio_gpu_device *vgdev; + struct delayed_work work; +}; + +static int virtio_gpu_dirty_update(struct virtio_gpu_framebuffer *fb, + bool store, int x, int y, + int width, int height) +{ + struct drm_device *dev = fb->base.dev; + struct virtio_gpu_device *vgdev = dev->dev_private; + bool store_for_later = false; + int bpp = fb->base.bits_per_pixel / 8; + int x2, y2; + unsigned long flags; + struct virtio_gpu_object *obj = gem_to_virtio_gpu_obj(fb->obj); + + if ((width <= 0) || + (x + width > fb->base.width) || + (y + height > fb->base.height)) { + DRM_DEBUG("values out of range %dx%d+%d+%d, fb %dx%d\n", + width, height, x, y, + fb->base.width, fb->base.height); + return -EINVAL; + } + + /* + * Can be called with pretty much any context (console output + * path). If we are in atomic just store the dirty rect info + * to send out the update later. + * + * Can't test inside spin lock. + */ + if (in_atomic() || store) + store_for_later = true; + + x2 = x + width - 1; + y2 = y + height - 1; + + spin_lock_irqsave(&fb->dirty_lock, flags); + + if (fb->y1 < y) + y = fb->y1; + if (fb->y2 > y2) + y2 = fb->y2; + if (fb->x1 < x) + x = fb->x1; + if (fb->x2 > x2) + x2 = fb->x2; + + if (store_for_later) { + fb->x1 = x; + fb->x2 = x2; + fb->y1 = y; + fb->y2 = y2; + spin_unlock_irqrestore(&fb->dirty_lock, flags); + return 0; + } + + fb->x1 = fb->y1 = INT_MAX; + fb->x2 = fb->y2 = 0; + + spin_unlock_irqrestore(&fb->dirty_lock, flags); + + { + uint32_t offset; + uint32_t w = x2 - x + 1; + uint32_t h = y2 - y + 1; + + offset = (y * fb->base.pitches[0]) + x * bpp; + + virtio_gpu_cmd_transfer_to_host_2d(vgdev, obj->hw_res_handle, + offset, + cpu_to_le32(w), + cpu_to_le32(h), + cpu_to_le32(x), + cpu_to_le32(y), + NULL); + + } + virtio_gpu_cmd_resource_flush(vgdev, obj->hw_res_handle, + x, y, x2 - x + 1, y2 - y + 1); + return 0; +} + +int virtio_gpu_surface_dirty(struct virtio_gpu_framebuffer *vgfb, + struct drm_clip_rect *clips, + unsigned num_clips) +{ + struct virtio_gpu_device *vgdev = vgfb->base.dev->dev_private; + struct virtio_gpu_object *obj = gem_to_virtio_gpu_obj(vgfb->obj); + struct drm_clip_rect norect; + struct drm_clip_rect *clips_ptr; + int left, right, top, bottom; + int i; + int inc = 1; + if (!num_clips) { + num_clips = 1; + clips = &norect; + norect.x1 = norect.y1 = 0; + norect.x2 = vgfb->base.width; + norect.y2 = vgfb->base.height; + } + left = clips->x1; + right = clips->x2; + top = clips->y1; + bottom = clips->y2; + + /* skip the first clip rect */ + for (i = 1, clips_ptr = clips + inc; + i < num_clips; i++, clips_ptr += inc) { + left = min_t(int, left, (int)clips_ptr->x1); + right = max_t(int, right, (int)clips_ptr->x2); + top = min_t(int, top, (int)clips_ptr->y1); + bottom = max_t(int, bottom, (int)clips_ptr->y2); + } + + if (obj->dumb) + return virtio_gpu_dirty_update(vgfb, false, left, top, + right - left, bottom - top); + + virtio_gpu_cmd_resource_flush(vgdev, obj->hw_res_handle, + left, top, right - left, bottom - top); + return 0; +} + +static void virtio_gpu_fb_dirty_work(struct work_struct *work) +{ + struct delayed_work *delayed_work = to_delayed_work(work); + struct virtio_gpu_fbdev *vfbdev = + container_of(delayed_work, struct virtio_gpu_fbdev, work); + struct virtio_gpu_framebuffer *vgfb = &vfbdev->vgfb; + + virtio_gpu_dirty_update(&vfbdev->vgfb, false, vgfb->x1, vgfb->y1, + vgfb->x2 - vgfb->x1, vgfb->y2 - vgfb->y1); +} + +static void virtio_gpu_3d_fillrect(struct fb_info *info, + const struct fb_fillrect *rect) +{ + struct virtio_gpu_fbdev *vfbdev = info->par; + sys_fillrect(info, rect); + virtio_gpu_dirty_update(&vfbdev->vgfb, true, rect->dx, rect->dy, + rect->width, rect->height); + schedule_delayed_work(&vfbdev->work, VIRTIO_GPU_FBCON_POLL_PERIOD); +} + +static void virtio_gpu_3d_copyarea(struct fb_info *info, + const struct fb_copyarea *area) +{ + struct virtio_gpu_fbdev *vfbdev = info->par; + sys_copyarea(info, area); + virtio_gpu_dirty_update(&vfbdev->vgfb, true, area->dx, area->dy, + area->width, area->height); + schedule_delayed_work(&vfbdev->work, VIRTIO_GPU_FBCON_POLL_PERIOD); +} + +static void virtio_gpu_3d_imageblit(struct fb_info *info, + const struct fb_image *image) +{ + struct virtio_gpu_fbdev *vfbdev = info->par; + sys_imageblit(info, image); + virtio_gpu_dirty_update(&vfbdev->vgfb, true, image->dx, image->dy, + image->width, image->height); + schedule_delayed_work(&vfbdev->work, VIRTIO_GPU_FBCON_POLL_PERIOD); +} + +static struct fb_ops virtio_gpufb_ops = { + .owner = THIS_MODULE, + .fb_check_var = drm_fb_helper_check_var, + .fb_set_par = drm_fb_helper_set_par, /* TODO: copy vmwgfx */ + .fb_fillrect = virtio_gpu_3d_fillrect, + .fb_copyarea = virtio_gpu_3d_copyarea, + .fb_imageblit = virtio_gpu_3d_imageblit, + .fb_pan_display = drm_fb_helper_pan_display, + .fb_blank = drm_fb_helper_blank, + .fb_setcmap = drm_fb_helper_setcmap, + .fb_debug_enter = drm_fb_helper_debug_enter, + .fb_debug_leave = drm_fb_helper_debug_leave, +}; + +static int virtio_gpu_vmap_fb(struct virtio_gpu_device *vgdev, + struct virtio_gpu_object *obj) +{ + return virtio_gpu_object_kmap(obj, NULL); +} + +static int virtio_gpufb_create(struct drm_fb_helper *helper, + struct drm_fb_helper_surface_size *sizes) +{ + struct virtio_gpu_fbdev *vfbdev = + container_of(helper, struct virtio_gpu_fbdev, helper); + struct drm_device *dev = helper->dev; + struct virtio_gpu_device *vgdev = dev->dev_private; + struct fb_info *info; + struct drm_framebuffer *fb; + struct drm_mode_fb_cmd2 mode_cmd = {}; + struct virtio_gpu_object *obj; + struct device *device = vgdev->dev; + uint32_t resid, format, size; + int ret; + + mode_cmd.width = sizes->surface_width; + mode_cmd.height = sizes->surface_height; + mode_cmd.pitches[0] = mode_cmd.width * 4; + mode_cmd.pixel_format = drm_mode_legacy_fb_format(32, 24); + + switch (mode_cmd.pixel_format) { +#ifdef __BIG_ENDIAN + case DRM_FORMAT_XRGB8888: + format = VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM; + break; + case DRM_FORMAT_ARGB8888: + format = VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM; + break; + case DRM_FORMAT_BGRX8888: + format = VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM; + break; + case DRM_FORMAT_BGRA8888: + format = VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM; + break; + case DRM_FORMAT_RGBX8888: + format = VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM; + break; + case DRM_FORMAT_RGBA8888: + format = VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM; + break; + case DRM_FORMAT_XBGR8888: + format = VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM; + break; + case DRM_FORMAT_ABGR8888: + format = VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM; + break; +#else + case DRM_FORMAT_XRGB8888: + format = VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM; + break; + case DRM_FORMAT_ARGB8888: + format = VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM; + break; + case DRM_FORMAT_BGRX8888: + format = VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM; + break; + case DRM_FORMAT_BGRA8888: + format = VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM; + break; + case DRM_FORMAT_RGBX8888: + format = VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM; + break; + case DRM_FORMAT_RGBA8888: + format = VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM; + break; + case DRM_FORMAT_XBGR8888: + format = VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM; + break; + case DRM_FORMAT_ABGR8888: + format = VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM; + break; +#endif + default: + DRM_ERROR("failed to find virtio gpu format for %d\n", + mode_cmd.pixel_format); + return -EINVAL; + } + + size = mode_cmd.pitches[0] * mode_cmd.height; + obj = virtio_gpu_alloc_object(dev, size, false, true); + if (!obj) + return -ENOMEM; + + virtio_gpu_resource_id_get(vgdev, &resid); + virtio_gpu_cmd_create_resource(vgdev, resid, format, + mode_cmd.width, mode_cmd.height); + + ret = virtio_gpu_vmap_fb(vgdev, obj); + if (ret) { + DRM_ERROR("failed to vmap fb %d\n", ret); + goto err_obj_vmap; + } + + /* attach the object to the resource */ + ret = virtio_gpu_object_attach(vgdev, obj, resid, NULL); + if (ret) + goto err_obj_attach; + + info = framebuffer_alloc(0, device); + if (!info) { + ret = -ENOMEM; + goto err_fb_alloc; + } + + ret = fb_alloc_cmap(&info->cmap, 256, 0); + if (ret) { + ret = -ENOMEM; + goto err_fb_alloc_cmap; + } + + info->par = helper; + + ret = virtio_gpu_framebuffer_init(dev, &vfbdev->vgfb, + &mode_cmd, &obj->gem_base); + if (ret) + goto err_fb_init; + + fb = &vfbdev->vgfb.base; + + vfbdev->helper.fb = fb; + vfbdev->helper.fbdev = info; + + strcpy(info->fix.id, "virtiodrmfb"); + info->flags = FBINFO_DEFAULT; + info->fbops = &virtio_gpufb_ops; + info->pixmap.flags = FB_PIXMAP_SYSTEM; + + info->screen_base = obj->vmap; + info->screen_size = obj->gem_base.size; + drm_fb_helper_fill_fix(info, fb->pitches[0], fb->depth); + drm_fb_helper_fill_var(info, &vfbdev->helper, + sizes->fb_width, sizes->fb_height); + + info->fix.mmio_start = 0; + info->fix.mmio_len = 0; + return 0; + +err_fb_init: + fb_dealloc_cmap(&info->cmap); +err_fb_alloc_cmap: + framebuffer_release(info); +err_fb_alloc: + virtio_gpu_cmd_resource_inval_backing(vgdev, resid); +err_obj_attach: +err_obj_vmap: + virtio_gpu_gem_free_object(&obj->gem_base); + return ret; +} + +static int virtio_gpu_fbdev_destroy(struct drm_device *dev, + struct virtio_gpu_fbdev *vgfbdev) +{ + struct fb_info *info; + struct virtio_gpu_framebuffer *vgfb = &vgfbdev->vgfb; + + if (vgfbdev->helper.fbdev) { + info = vgfbdev->helper.fbdev; + + unregister_framebuffer(info); + framebuffer_release(info); + } + if (vgfb->obj) + vgfb->obj = NULL; + drm_fb_helper_fini(&vgfbdev->helper); + drm_framebuffer_cleanup(&vgfb->base); + + return 0; +} +static struct drm_fb_helper_funcs virtio_gpu_fb_helper_funcs = { + .fb_probe = virtio_gpufb_create, +}; + +int virtio_gpu_fbdev_init(struct virtio_gpu_device *vgdev) +{ + struct virtio_gpu_fbdev *vgfbdev; + int bpp_sel = 32; /* TODO: parameter from somewhere? */ + int ret; + + vgfbdev = kzalloc(sizeof(struct virtio_gpu_fbdev), GFP_KERNEL); + if (!vgfbdev) + return -ENOMEM; + + vgfbdev->vgdev = vgdev; + vgdev->vgfbdev = vgfbdev; + INIT_DELAYED_WORK(&vgfbdev->work, virtio_gpu_fb_dirty_work); + + drm_fb_helper_prepare(vgdev->ddev, &vgfbdev->helper, + &virtio_gpu_fb_helper_funcs); + ret = drm_fb_helper_init(vgdev->ddev, &vgfbdev->helper, + vgdev->num_scanouts, + VIRTIO_GPUFB_CONN_LIMIT); + if (ret) { + kfree(vgfbdev); + return ret; + } + + drm_fb_helper_single_add_all_connectors(&vgfbdev->helper); + drm_fb_helper_initial_config(&vgfbdev->helper, bpp_sel); + return 0; +} + +void virtio_gpu_fbdev_fini(struct virtio_gpu_device *vgdev) +{ + if (!vgdev->vgfbdev) + return; + + virtio_gpu_fbdev_destroy(vgdev->ddev, vgdev->vgfbdev); + kfree(vgdev->vgfbdev); + vgdev->vgfbdev = NULL; +} diff --git a/drivers/gpu/drm/virtio/virtgpu_fence.c b/drivers/gpu/drm/virtio/virtgpu_fence.c new file mode 100644 index 0000000..1da6326 --- /dev/null +++ b/drivers/gpu/drm/virtio/virtgpu_fence.c @@ -0,0 +1,119 @@ +/* + * 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. + */ + +#include <drm/drmP.h> +#include "virtgpu_drv.h" + +static const char *virtio_get_driver_name(struct fence *f) +{ + return "virtio_gpu"; +} + +static const char *virtio_get_timeline_name(struct fence *f) +{ + return "controlq"; +} + +static bool virtio_enable_signaling(struct fence *f) +{ + return true; +} + +static bool virtio_signaled(struct fence *f) +{ + struct virtio_gpu_fence *fence = to_virtio_fence(f); + + if (atomic64_read(&fence->drv->last_seq) >= fence->seq) + return true; + return false; +} + +static void virtio_fence_value_str(struct fence *f, char *str, int size) +{ + struct virtio_gpu_fence *fence = to_virtio_fence(f); + + snprintf(str, size, "%llu", fence->seq); +} + +static void virtio_timeline_value_str(struct fence *f, char *str, int size) +{ + struct virtio_gpu_fence *fence = to_virtio_fence(f); + + snprintf(str, size, "%lu", atomic64_read(&fence->drv->last_seq)); +} + +static const struct fence_ops virtio_fence_ops = { + .get_driver_name = virtio_get_driver_name, + .get_timeline_name = virtio_get_timeline_name, + .enable_signaling = virtio_enable_signaling, + .signaled = virtio_signaled, + .wait = fence_default_wait, + .fence_value_str = virtio_fence_value_str, + .timeline_value_str = virtio_timeline_value_str, +}; + +int virtio_gpu_fence_emit(struct virtio_gpu_device *vgdev, + struct virtio_gpu_ctrl_hdr *cmd_hdr, + struct virtio_gpu_fence **fence) +{ + struct virtio_gpu_fence_driver *drv = &vgdev->fence_drv; + unsigned long irq_flags; + + *fence = kmalloc(sizeof(struct virtio_gpu_fence), GFP_KERNEL); + if ((*fence) == NULL) + return -ENOMEM; + + spin_lock_irqsave(&drv->lock, irq_flags); + (*fence)->drv = drv; + (*fence)->seq = ++drv->sync_seq; + fence_init(&(*fence)->f, &virtio_fence_ops, &drv->lock, + 0, (*fence)->seq); + fence_get(&(*fence)->f); + list_add_tail(&(*fence)->node, &drv->fences); + spin_unlock_irqrestore(&drv->lock, irq_flags); + + cmd_hdr->flags |= cpu_to_le32(VIRTIO_GPU_FLAG_FENCE); + cmd_hdr->fence_id = cpu_to_le64((*fence)->seq); + return 0; +} + +void virtio_gpu_fence_event_process(struct virtio_gpu_device *vgdev, + u64 last_seq) +{ + struct virtio_gpu_fence_driver *drv = &vgdev->fence_drv; + struct virtio_gpu_fence *fence, *tmp; + unsigned long irq_flags; + + spin_lock_irqsave(&drv->lock, irq_flags); + atomic64_set(&vgdev->fence_drv.last_seq, last_seq); + list_for_each_entry_safe(fence, tmp, &drv->fences, node) { + if (last_seq < fence->seq) + continue; + fence_signal_locked(&fence->f); + list_del(&fence->node); + fence_put(&fence->f); + } + spin_unlock_irqrestore(&drv->lock, irq_flags); +} diff --git a/drivers/gpu/drm/virtio/virtgpu_gem.c b/drivers/gpu/drm/virtio/virtgpu_gem.c new file mode 100644 index 0000000..cfa0d27 --- /dev/null +++ b/drivers/gpu/drm/virtio/virtgpu_gem.c @@ -0,0 +1,140 @@ +/* + * 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. + */ + +#include <drm/drmP.h> +#include "virtgpu_drv.h" + +void virtio_gpu_gem_free_object(struct drm_gem_object *gem_obj) +{ + struct virtio_gpu_object *obj = gem_to_virtio_gpu_obj(gem_obj); + + if (obj) + virtio_gpu_object_unref(&obj); +} + +struct virtio_gpu_object *virtio_gpu_alloc_object(struct drm_device *dev, + size_t size, bool kernel, + bool pinned) +{ + struct virtio_gpu_device *vgdev = dev->dev_private; + struct virtio_gpu_object *obj; + int ret; + + ret = virtio_gpu_object_create(vgdev, size, kernel, pinned, &obj); + if (ret) + return ERR_PTR(ret); + + return obj; +} + +int virtio_gpu_gem_create(struct drm_file *file, + struct drm_device *dev, + uint64_t size, + struct drm_gem_object **obj_p, + uint32_t *handle_p) +{ + struct virtio_gpu_object *obj; + int ret; + u32 handle; + + obj = virtio_gpu_alloc_object(dev, size, false, false); + if (IS_ERR(obj)) + return PTR_ERR(obj); + + ret = drm_gem_handle_create(file, &obj->gem_base, &handle); + if (ret) { + drm_gem_object_release(&obj->gem_base); + return ret; + } + + *obj_p = &obj->gem_base; + + /* drop reference from allocate - handle holds it now */ + drm_gem_object_unreference_unlocked(&obj->gem_base); + + *handle_p = handle; + return 0; +} + +int virtio_gpu_mode_dumb_create(struct drm_file *file_priv, + struct drm_device *dev, + struct drm_mode_create_dumb *args) +{ + struct virtio_gpu_device *vgdev = dev->dev_private; + struct drm_gem_object *gobj; + struct virtio_gpu_object *obj; + int ret; + uint32_t pitch; + uint32_t resid; + + pitch = args->width * ((args->bpp + 1) / 8); + args->size = pitch * args->height; + args->size = ALIGN(args->size, PAGE_SIZE); + + ret = virtio_gpu_gem_create(file_priv, dev, args->size, &gobj, + &args->handle); + if (ret) + goto fail; + + virtio_gpu_resource_id_get(vgdev, &resid); + virtio_gpu_cmd_create_resource(vgdev, resid, + 2, args->width, args->height); + + /* attach the object to the resource */ + obj = gem_to_virtio_gpu_obj(gobj); + ret = virtio_gpu_object_attach(vgdev, obj, resid, NULL); + if (ret) + goto fail; + + obj->dumb = true; + args->pitch = pitch; + return ret; + +fail: + return ret; +} + +int virtio_gpu_mode_dumb_destroy(struct drm_file *file_priv, + struct drm_device *dev, + uint32_t handle) +{ + return drm_gem_handle_delete(file_priv, handle); +} + +int virtio_gpu_mode_dumb_mmap(struct drm_file *file_priv, + struct drm_device *dev, + uint32_t handle, uint64_t *offset_p) +{ + struct drm_gem_object *gobj; + struct virtio_gpu_object *obj; + BUG_ON(!offset_p); + gobj = drm_gem_object_lookup(dev, file_priv, handle); + if (gobj == NULL) + return -ENOENT; + obj = gem_to_virtio_gpu_obj(gobj); + *offset_p = virtio_gpu_object_mmap_offset(obj); + drm_gem_object_unreference_unlocked(gobj); + return 0; +} diff --git a/drivers/gpu/drm/virtio/virtgpu_kms.c b/drivers/gpu/drm/virtio/virtgpu_kms.c new file mode 100644 index 0000000..e503ffb --- /dev/null +++ b/drivers/gpu/drm/virtio/virtgpu_kms.c @@ -0,0 +1,164 @@ +/* + * 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. + */ + +#include <linux/virtio.h> +#include <linux/virtio_config.h> +#include <drm/drmP.h> +#include "virtgpu_drv.h" + +static void virtio_gpu_config_changed_work_func(struct work_struct *work) +{ + struct virtio_gpu_device *vgdev = + container_of(work, struct virtio_gpu_device, + config_changed_work); + u32 events_read, events_clear = 0; + + /* read the config space */ + virtio_cread(vgdev->vdev, struct virtio_gpu_config, + events_read, &events_read); + if (events_read & VIRTIO_GPU_EVENT_DISPLAY) { + virtio_gpu_cmd_get_display_info(vgdev); + drm_helper_hpd_irq_event(vgdev->ddev); + events_clear |= VIRTIO_GPU_EVENT_DISPLAY; + } + virtio_cwrite(vgdev->vdev, struct virtio_gpu_config, + events_clear, &events_clear); +} + +static void virtio_gpu_init_vq(struct virtio_gpu_queue *vgvq, + void (*work_func)(struct work_struct *work)) +{ + spin_lock_init(&vgvq->qlock); + init_waitqueue_head(&vgvq->ack_queue); + INIT_WORK(&vgvq->dequeue_work, work_func); +} + +int virtio_gpu_driver_load(struct drm_device *dev, unsigned long flags) +{ + static vq_callback_t *callbacks[] = { + virtio_gpu_ctrl_ack, virtio_gpu_cursor_ack + }; + static const char *names[] = { "control", "cursor" }; + + struct virtio_gpu_device *vgdev; + /* this will expand later */ + struct virtqueue *vqs[2]; + u32 num_scanouts; + int ret; + + if (!virtio_has_feature(dev->virtdev, VIRTIO_F_VERSION_1)) + return -ENODEV; + + vgdev = kzalloc(sizeof(struct virtio_gpu_device), GFP_KERNEL); + if (!vgdev) + return -ENOMEM; + + vgdev->ddev = dev; + dev->dev_private = vgdev; + vgdev->vdev = dev->virtdev; + vgdev->dev = dev->dev; + + spin_lock_init(&vgdev->display_info_lock); + spin_lock_init(&vgdev->ctx_id_idr_lock); + idr_init(&vgdev->ctx_id_idr); + spin_lock_init(&vgdev->resource_idr_lock); + idr_init(&vgdev->resource_idr); + init_waitqueue_head(&vgdev->resp_wq); + virtio_gpu_init_vq(&vgdev->ctrlq, virtio_gpu_dequeue_ctrl_func); + virtio_gpu_init_vq(&vgdev->cursorq, virtio_gpu_dequeue_cursor_func); + + spin_lock_init(&vgdev->fence_drv.lock); + INIT_LIST_HEAD(&vgdev->fence_drv.fences); + INIT_WORK(&vgdev->config_changed_work, + virtio_gpu_config_changed_work_func); + + ret = vgdev->vdev->config->find_vqs(vgdev->vdev, 2, vqs, + callbacks, names); + if (ret) { + DRM_ERROR("failed to find virt queues\n"); + goto err_vqs; + } + vgdev->ctrlq.vq = vqs[0]; + vgdev->cursorq.vq = vqs[1]; + ret = virtio_gpu_alloc_vbufs(vgdev); + if (ret) { + DRM_ERROR("failed to alloc vbufs\n"); + goto err_vbufs; + } + + ret = virtio_gpu_ttm_init(vgdev); + if (ret) { + DRM_ERROR("failed to init ttm %d\n", ret); + goto err_ttm; + } + + /* get display info */ + virtio_cread(vgdev->vdev, struct virtio_gpu_config, + num_scanouts, &num_scanouts); + vgdev->num_scanouts = min_t(uint32_t, num_scanouts, + VIRTIO_GPU_MAX_SCANOUTS); + if (!vgdev->num_scanouts) { + DRM_ERROR("num_scanouts is zero\n"); + ret = -EINVAL; + goto err_scanouts; + } + + ret = virtio_gpu_modeset_init(vgdev); + if (ret) + goto err_modeset; + + virtio_device_ready(vgdev->vdev); + vgdev->vqs_ready = true; + virtio_gpu_cmd_get_display_info(vgdev); + return 0; + +err_modeset: +err_scanouts: + virtio_gpu_ttm_fini(vgdev); +err_ttm: + virtio_gpu_free_vbufs(vgdev); +err_vbufs: + vgdev->vdev->config->del_vqs(vgdev->vdev); +err_vqs: + kfree(vgdev); + return ret; +} + +int virtio_gpu_driver_unload(struct drm_device *dev) +{ + struct virtio_gpu_device *vgdev = dev->dev_private; + + vgdev->vqs_ready = false; + flush_work(&vgdev->ctrlq.dequeue_work); + flush_work(&vgdev->cursorq.dequeue_work); + flush_work(&vgdev->config_changed_work); + vgdev->vdev->config->del_vqs(vgdev->vdev); + + virtio_gpu_modeset_fini(vgdev); + virtio_gpu_ttm_fini(vgdev); + virtio_gpu_free_vbufs(vgdev); + kfree(vgdev); + return 0; +} diff --git a/drivers/gpu/drm/virtio/virtgpu_object.c b/drivers/gpu/drm/virtio/virtgpu_object.c new file mode 100644 index 0000000..2c624c7 --- /dev/null +++ b/drivers/gpu/drm/virtio/virtgpu_object.c @@ -0,0 +1,170 @@ +/* + * 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. + */ + +#include "virtgpu_drv.h" + +static void virtio_gpu_ttm_bo_destroy(struct ttm_buffer_object *tbo) +{ + struct virtio_gpu_object *bo; + struct virtio_gpu_device *vgdev; + + bo = container_of(tbo, struct virtio_gpu_object, tbo); + vgdev = (struct virtio_gpu_device *)bo->gem_base.dev->dev_private; + + if (bo->hw_res_handle) + virtio_gpu_cmd_unref_resource(vgdev, bo->hw_res_handle); + if (bo->pages) + virtio_gpu_object_free_sg_table(bo); + drm_gem_object_release(&bo->gem_base); + kfree(bo); +} + +static void virtio_gpu_init_ttm_placement(struct virtio_gpu_object *vgbo, + bool pinned) +{ + u32 c = 1; + u32 pflag = pinned ? TTM_PL_FLAG_NO_EVICT : 0; + + vgbo->placement.placement = &vgbo->placement_code; + vgbo->placement.busy_placement = &vgbo->placement_code; + vgbo->placement_code.fpfn = 0; + vgbo->placement_code.lpfn = 0; + vgbo->placement_code.flags = + TTM_PL_MASK_CACHING | TTM_PL_FLAG_TT | pflag; + vgbo->placement.num_placement = c; + vgbo->placement.num_busy_placement = c; + +} + +int virtio_gpu_object_create(struct virtio_gpu_device *vgdev, + unsigned long size, bool kernel, bool pinned, + struct virtio_gpu_object **bo_ptr) +{ + struct virtio_gpu_object *bo; + enum ttm_bo_type type; + size_t acc_size; + int ret; + + if (kernel) + type = ttm_bo_type_kernel; + else + type = ttm_bo_type_device; + *bo_ptr = NULL; + + acc_size = ttm_bo_dma_acc_size(&vgdev->mman.bdev, size, + sizeof(struct virtio_gpu_object)); + + bo = kzalloc(sizeof(struct virtio_gpu_object), GFP_KERNEL); + if (bo == NULL) + return -ENOMEM; + size = roundup(size, PAGE_SIZE); + ret = drm_gem_object_init(vgdev->ddev, &bo->gem_base, size); + if (ret != 0) + goto err_gem_init; + bo->dumb = false; + virtio_gpu_init_ttm_placement(bo, pinned); + + ret = ttm_bo_init(&vgdev->mman.bdev, &bo->tbo, size, type, + &bo->placement, 0, !kernel, NULL, acc_size, + NULL, NULL, &virtio_gpu_ttm_bo_destroy); + if (ret != 0) + goto err_ttm_init; + + *bo_ptr = bo; + return 0; + +err_ttm_init: + drm_gem_object_release(&bo->gem_base); +err_gem_init: + kfree(bo); + return ret; +} + +int virtio_gpu_object_kmap(struct virtio_gpu_object *bo, void **ptr) +{ + bool is_iomem; + int r; + + if (bo->vmap) { + if (ptr) + *ptr = bo->vmap; + return 0; + } + r = ttm_bo_kmap(&bo->tbo, 0, bo->tbo.num_pages, &bo->kmap); + if (r) + return r; + bo->vmap = ttm_kmap_obj_virtual(&bo->kmap, &is_iomem); + if (ptr) + *ptr = bo->vmap; + return 0; +} + +int virtio_gpu_object_get_sg_table(struct virtio_gpu_device *qdev, + struct virtio_gpu_object *bo) +{ + int ret; + struct page **pages = bo->tbo.ttm->pages; + int nr_pages = bo->tbo.num_pages; + + /* wtf swapping */ + if (bo->pages) + return 0; + + if (bo->tbo.ttm->state == tt_unpopulated) + bo->tbo.ttm->bdev->driver->ttm_tt_populate(bo->tbo.ttm); + bo->pages = kmalloc(sizeof(struct sg_table), GFP_KERNEL); + if (!bo->pages) + goto out; + + ret = sg_alloc_table_from_pages(bo->pages, pages, nr_pages, 0, + nr_pages << PAGE_SHIFT, GFP_KERNEL); + if (ret) + goto out; + return 0; +out: + kfree(bo->pages); + bo->pages = NULL; + return -ENOMEM; +} + +void virtio_gpu_object_free_sg_table(struct virtio_gpu_object *bo) +{ + sg_free_table(bo->pages); + kfree(bo->pages); + bo->pages = NULL; +} + +int virtio_gpu_object_wait(struct virtio_gpu_object *bo, bool no_wait) +{ + int r; + + r = ttm_bo_reserve(&bo->tbo, true, no_wait, false, NULL); + if (unlikely(r != 0)) + return r; + r = ttm_bo_wait(&bo->tbo, true, true, no_wait); + ttm_bo_unreserve(&bo->tbo); + return r; +} + diff --git a/drivers/gpu/drm/virtio/virtgpu_plane.c b/drivers/gpu/drm/virtio/virtgpu_plane.c new file mode 100644 index 0000000..4a74129 --- /dev/null +++ b/drivers/gpu/drm/virtio/virtgpu_plane.c @@ -0,0 +1,120 @@ +/* + * 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. + */ + +#include "virtgpu_drv.h" +#include <drm/drm_plane_helper.h> +#include <drm/drm_atomic_helper.h> + +static const uint32_t virtio_gpu_formats[] = { + DRM_FORMAT_XRGB8888, + DRM_FORMAT_ARGB8888, + DRM_FORMAT_BGRX8888, + DRM_FORMAT_BGRA8888, + DRM_FORMAT_RGBX8888, + DRM_FORMAT_RGBA8888, + DRM_FORMAT_XBGR8888, + DRM_FORMAT_ABGR8888, +}; + +static void virtio_gpu_plane_destroy(struct drm_plane *plane) +{ + kfree(plane); +} + +static const struct drm_plane_funcs virtio_gpu_plane_funcs = { + .update_plane = drm_atomic_helper_update_plane, + .disable_plane = drm_atomic_helper_disable_plane, + .destroy = virtio_gpu_plane_destroy, + .reset = drm_atomic_helper_plane_reset, + .atomic_duplicate_state = drm_atomic_helper_plane_duplicate_state, + .atomic_destroy_state = drm_atomic_helper_plane_destroy_state, +}; + +static int virtio_gpu_plane_atomic_check(struct drm_plane *plane, + struct drm_plane_state *state) +{ + return 0; +} + +static void virtio_gpu_plane_atomic_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 = drm_crtc_to_virtio_gpu_output(plane->crtc); + struct virtio_gpu_framebuffer *vgfb; + struct virtio_gpu_object *bo; + uint32_t handle; + + if (plane->fb) { + vgfb = to_virtio_gpu_framebuffer(plane->fb); + bo = gem_to_virtio_gpu_obj(vgfb->obj); + handle = bo->hw_res_handle; + } else { + handle = 0; + } + + DRM_DEBUG("handle 0x%x, crtc %dx%d+%d+%d\n", handle, + plane->state->crtc_w, plane->state->crtc_h, + plane->state->crtc_x, plane->state->crtc_y); + 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); +} + + +static const struct drm_plane_helper_funcs virtio_gpu_plane_helper_funcs = { + .atomic_check = virtio_gpu_plane_atomic_check, + .atomic_update = virtio_gpu_plane_atomic_update, +}; + +struct drm_plane *virtio_gpu_plane_init(struct virtio_gpu_device *vgdev, + int index) +{ + struct drm_device *dev = vgdev->ddev; + struct drm_plane *plane; + int ret; + + plane = kzalloc(sizeof(*plane), GFP_KERNEL); + if (!plane) + return ERR_PTR(-ENOMEM); + + 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); + if (ret) + goto err_plane_init; + + drm_plane_helper_add(plane, &virtio_gpu_plane_helper_funcs); + return plane; + +err_plane_init: + kfree(plane); + return ERR_PTR(ret); +} diff --git a/drivers/gpu/drm/virtio/virtgpu_ttm.c b/drivers/gpu/drm/virtio/virtgpu_ttm.c new file mode 100644 index 0000000..e0e74c6 --- /dev/null +++ b/drivers/gpu/drm/virtio/virtgpu_ttm.c @@ -0,0 +1,469 @@ +/* + * Copyright (C) 2015 Red Hat, Inc. + * All Rights Reserved. + * + * Authors: + * Dave Airlie + * Alon Levy + * + * 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 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 HOLDER(S) OR AUTHOR(S) 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. + */ + +#include <ttm/ttm_bo_api.h> +#include <ttm/ttm_bo_driver.h> +#include <ttm/ttm_placement.h> +#include <ttm/ttm_page_alloc.h> +#include <ttm/ttm_module.h> +#include <drm/drmP.h> +#include <drm/drm.h> +#include "virtgpu_drv.h" + +#include <linux/delay.h> + +#define DRM_FILE_PAGE_OFFSET (0x100000000ULL >> PAGE_SHIFT) + +static struct +virtio_gpu_device *virtio_gpu_get_vgdev(struct ttm_bo_device *bdev) +{ + struct virtio_gpu_mman *mman; + struct virtio_gpu_device *vgdev; + + mman = container_of(bdev, struct virtio_gpu_mman, bdev); + vgdev = container_of(mman, struct virtio_gpu_device, mman); + return vgdev; +} + +static int virtio_gpu_ttm_mem_global_init(struct drm_global_reference *ref) +{ + return ttm_mem_global_init(ref->object); +} + +static void virtio_gpu_ttm_mem_global_release(struct drm_global_reference *ref) +{ + ttm_mem_global_release(ref->object); +} + +static int virtio_gpu_ttm_global_init(struct virtio_gpu_device *vgdev) +{ + struct drm_global_reference *global_ref; + int r; + + vgdev->mman.mem_global_referenced = false; + global_ref = &vgdev->mman.mem_global_ref; + global_ref->global_type = DRM_GLOBAL_TTM_MEM; + global_ref->size = sizeof(struct ttm_mem_global); + global_ref->init = &virtio_gpu_ttm_mem_global_init; + global_ref->release = &virtio_gpu_ttm_mem_global_release; + + r = drm_global_item_ref(global_ref); + if (r != 0) { + DRM_ERROR("Failed setting up TTM memory accounting " + "subsystem.\n"); + return r; + } + + vgdev->mman.bo_global_ref.mem_glob = + vgdev->mman.mem_global_ref.object; + global_ref = &vgdev->mman.bo_global_ref.ref; + global_ref->global_type = DRM_GLOBAL_TTM_BO; + global_ref->size = sizeof(struct ttm_bo_global); + global_ref->init = &ttm_bo_global_init; + global_ref->release = &ttm_bo_global_release; + r = drm_global_item_ref(global_ref); + if (r != 0) { + DRM_ERROR("Failed setting up TTM BO subsystem.\n"); + drm_global_item_unref(&vgdev->mman.mem_global_ref); + return r; + } + + vgdev->mman.mem_global_referenced = true; + return 0; +} + +static void virtio_gpu_ttm_global_fini(struct virtio_gpu_device *vgdev) +{ + if (vgdev->mman.mem_global_referenced) { + drm_global_item_unref(&vgdev->mman.bo_global_ref.ref); + drm_global_item_unref(&vgdev->mman.mem_global_ref); + vgdev->mman.mem_global_referenced = false; + } +} + +#if 0 +/* + * Hmm, seems to not do anything useful. Leftover debug hack? + * Something like printing pagefaults to kernel log? + */ +static struct vm_operations_struct virtio_gpu_ttm_vm_ops; +static const struct vm_operations_struct *ttm_vm_ops; + +static int virtio_gpu_ttm_fault(struct vm_area_struct *vma, + struct vm_fault *vmf) +{ + struct ttm_buffer_object *bo; + struct virtio_gpu_device *vgdev; + int r; + + bo = (struct ttm_buffer_object *)vma->vm_private_data; + if (bo == NULL) + return VM_FAULT_NOPAGE; + vgdev = virtio_gpu_get_vgdev(bo->bdev); + r = ttm_vm_ops->fault(vma, vmf); + return r; +} +#endif + +int virtio_gpu_mmap(struct file *filp, struct vm_area_struct *vma) +{ + struct drm_file *file_priv; + struct virtio_gpu_device *vgdev; + int r; + + file_priv = filp->private_data; + vgdev = file_priv->minor->dev->dev_private; + if (vgdev == NULL) { + DRM_ERROR( + "filp->private_data->minor->dev->dev_private == NULL\n"); + return -EINVAL; + } + r = ttm_bo_mmap(filp, vma, &vgdev->mman.bdev); +#if 0 + if (unlikely(r != 0)) + return r; + if (unlikely(ttm_vm_ops == NULL)) { + ttm_vm_ops = vma->vm_ops; + virtio_gpu_ttm_vm_ops = *ttm_vm_ops; + virtio_gpu_ttm_vm_ops.fault = &virtio_gpu_ttm_fault; + } + vma->vm_ops = &virtio_gpu_ttm_vm_ops; + return 0; +#else + return r; +#endif +} + +static int virtio_gpu_invalidate_caches(struct ttm_bo_device *bdev, + uint32_t flags) +{ + return 0; +} + +static int ttm_bo_man_get_node(struct ttm_mem_type_manager *man, + struct ttm_buffer_object *bo, + const struct ttm_place *place, + struct ttm_mem_reg *mem) +{ + mem->mm_node = (void *)1; + return 0; +} + +static void ttm_bo_man_put_node(struct ttm_mem_type_manager *man, + struct ttm_mem_reg *mem) +{ + mem->mm_node = (void *)NULL; + return; +} + +static int ttm_bo_man_init(struct ttm_mem_type_manager *man, + unsigned long p_size) +{ + return 0; +} + +static int ttm_bo_man_takedown(struct ttm_mem_type_manager *man) +{ + return 0; +} + +static void ttm_bo_man_debug(struct ttm_mem_type_manager *man, + const char *prefix) +{ +} + +static const struct ttm_mem_type_manager_func virtio_gpu_bo_manager_func = { + ttm_bo_man_init, + ttm_bo_man_takedown, + ttm_bo_man_get_node, + ttm_bo_man_put_node, + ttm_bo_man_debug +}; + +static int virtio_gpu_init_mem_type(struct ttm_bo_device *bdev, uint32_t type, + struct ttm_mem_type_manager *man) +{ + struct virtio_gpu_device *vgdev; + + vgdev = virtio_gpu_get_vgdev(bdev); + + switch (type) { + case TTM_PL_SYSTEM: + /* System memory */ + man->flags = TTM_MEMTYPE_FLAG_MAPPABLE; + man->available_caching = TTM_PL_MASK_CACHING; + man->default_caching = TTM_PL_FLAG_CACHED; + break; + case TTM_PL_TT: + man->func = &virtio_gpu_bo_manager_func; + man->flags = TTM_MEMTYPE_FLAG_MAPPABLE; + man->available_caching = TTM_PL_MASK_CACHING; + man->default_caching = TTM_PL_FLAG_CACHED; + break; + default: + DRM_ERROR("Unsupported memory type %u\n", (unsigned)type); + return -EINVAL; + } + return 0; +} + +static void virtio_gpu_evict_flags(struct ttm_buffer_object *bo, + struct ttm_placement *placement) +{ + static struct ttm_place placements = { + .fpfn = 0, + .lpfn = 0, + .flags = TTM_PL_MASK_CACHING | TTM_PL_FLAG_SYSTEM, + }; + + placement->placement = &placements; + placement->busy_placement = &placements; + placement->num_placement = 1; + placement->num_busy_placement = 1; + return; +} + +static int virtio_gpu_verify_access(struct ttm_buffer_object *bo, + struct file *filp) +{ + return 0; +} + +static int virtio_gpu_ttm_io_mem_reserve(struct ttm_bo_device *bdev, + struct ttm_mem_reg *mem) +{ + struct ttm_mem_type_manager *man = &bdev->man[mem->mem_type]; + + mem->bus.addr = NULL; + mem->bus.offset = 0; + mem->bus.size = mem->num_pages << PAGE_SHIFT; + mem->bus.base = 0; + mem->bus.is_iomem = false; + if (!(man->flags & TTM_MEMTYPE_FLAG_MAPPABLE)) + return -EINVAL; + switch (mem->mem_type) { + case TTM_PL_SYSTEM: + case TTM_PL_TT: + /* system memory */ + return 0; + default: + return -EINVAL; + } + return 0; +} + +static void virtio_gpu_ttm_io_mem_free(struct ttm_bo_device *bdev, + struct ttm_mem_reg *mem) +{ +} + +/* + * TTM backend functions. + */ +struct virtio_gpu_ttm_tt { + struct ttm_dma_tt ttm; + struct virtio_gpu_device *vgdev; + u64 offset; +}; + +static int virtio_gpu_ttm_backend_bind(struct ttm_tt *ttm, + struct ttm_mem_reg *bo_mem) +{ + struct virtio_gpu_ttm_tt *gtt = (void *)ttm; + + gtt->offset = (unsigned long)(bo_mem->start << PAGE_SHIFT); + if (!ttm->num_pages) + WARN(1, "nothing to bind %lu pages for mreg %p back %p!\n", + ttm->num_pages, bo_mem, ttm); + + /* Not implemented */ + return 0; +} + +static int virtio_gpu_ttm_backend_unbind(struct ttm_tt *ttm) +{ + /* Not implemented */ + return 0; +} + +static void virtio_gpu_ttm_backend_destroy(struct ttm_tt *ttm) +{ + struct virtio_gpu_ttm_tt *gtt = (void *)ttm; + + ttm_dma_tt_fini(>t->ttm); + kfree(gtt); +} + +static struct ttm_backend_func virtio_gpu_backend_func = { + .bind = &virtio_gpu_ttm_backend_bind, + .unbind = &virtio_gpu_ttm_backend_unbind, + .destroy = &virtio_gpu_ttm_backend_destroy, +}; + +static int virtio_gpu_ttm_tt_populate(struct ttm_tt *ttm) +{ + if (ttm->state != tt_unpopulated) + return 0; + + return ttm_pool_populate(ttm); +} + +static void virtio_gpu_ttm_tt_unpopulate(struct ttm_tt *ttm) +{ + ttm_pool_unpopulate(ttm); +} + +static struct ttm_tt *virtio_gpu_ttm_tt_create(struct ttm_bo_device *bdev, + unsigned long size, + uint32_t page_flags, + struct page *dummy_read_page) +{ + struct virtio_gpu_device *vgdev; + struct virtio_gpu_ttm_tt *gtt; + + vgdev = virtio_gpu_get_vgdev(bdev); + gtt = kzalloc(sizeof(struct virtio_gpu_ttm_tt), GFP_KERNEL); + if (gtt == NULL) + return NULL; + gtt->ttm.ttm.func = &virtio_gpu_backend_func; + gtt->vgdev = vgdev; + if (ttm_dma_tt_init(>t->ttm, bdev, size, page_flags, + dummy_read_page)) { + kfree(gtt); + return NULL; + } + return >t->ttm.ttm; +} + +static void virtio_gpu_move_null(struct ttm_buffer_object *bo, + struct ttm_mem_reg *new_mem) +{ + struct ttm_mem_reg *old_mem = &bo->mem; + + BUG_ON(old_mem->mm_node != NULL); + *old_mem = *new_mem; + new_mem->mm_node = NULL; +} + +static int virtio_gpu_bo_move(struct ttm_buffer_object *bo, + bool evict, bool interruptible, + bool no_wait_gpu, + struct ttm_mem_reg *new_mem) +{ + virtio_gpu_move_null(bo, new_mem); + return 0; +} + +static void virtio_gpu_bo_move_notify(struct ttm_buffer_object *tbo, + struct ttm_mem_reg *new_mem) +{ + struct virtio_gpu_object *bo; + struct virtio_gpu_device *vgdev; + + bo = container_of(tbo, struct virtio_gpu_object, tbo); + vgdev = (struct virtio_gpu_device *)bo->gem_base.dev->dev_private; + + if (!new_mem || (new_mem->placement & TTM_PL_FLAG_SYSTEM)) { + if (bo->hw_res_handle) + virtio_gpu_cmd_resource_inval_backing(vgdev, + bo->hw_res_handle); + + } else if (new_mem->placement & TTM_PL_FLAG_TT) { + if (bo->hw_res_handle) { + virtio_gpu_object_attach(vgdev, bo, bo->hw_res_handle, + NULL); + } + } +} + +static void virtio_gpu_bo_swap_notify(struct ttm_buffer_object *tbo) +{ + struct virtio_gpu_object *bo; + struct virtio_gpu_device *vgdev; + + bo = container_of(tbo, struct virtio_gpu_object, tbo); + vgdev = (struct virtio_gpu_device *)bo->gem_base.dev->dev_private; + + if (bo->pages) + virtio_gpu_object_free_sg_table(bo); +} + +static struct ttm_bo_driver virtio_gpu_bo_driver = { + .ttm_tt_create = &virtio_gpu_ttm_tt_create, + .ttm_tt_populate = &virtio_gpu_ttm_tt_populate, + .ttm_tt_unpopulate = &virtio_gpu_ttm_tt_unpopulate, + .invalidate_caches = &virtio_gpu_invalidate_caches, + .init_mem_type = &virtio_gpu_init_mem_type, + .evict_flags = &virtio_gpu_evict_flags, + .move = &virtio_gpu_bo_move, + .verify_access = &virtio_gpu_verify_access, + .io_mem_reserve = &virtio_gpu_ttm_io_mem_reserve, + .io_mem_free = &virtio_gpu_ttm_io_mem_free, + .move_notify = &virtio_gpu_bo_move_notify, + .swap_notify = &virtio_gpu_bo_swap_notify, +}; + +int virtio_gpu_ttm_init(struct virtio_gpu_device *vgdev) +{ + int r; + + r = virtio_gpu_ttm_global_init(vgdev); + if (r) + return r; + /* No others user of address space so set it to 0 */ + r = ttm_bo_device_init(&vgdev->mman.bdev, + vgdev->mman.bo_global_ref.ref.object, + &virtio_gpu_bo_driver, + vgdev->ddev->anon_inode->i_mapping, + DRM_FILE_PAGE_OFFSET, 0); + if (r) { + DRM_ERROR("failed initializing buffer object driver(%d).\n", r); + goto err_dev_init; + return r; + } + + r = ttm_bo_init_mm(&vgdev->mman.bdev, TTM_PL_TT, 0); + if (r) { + DRM_ERROR("Failed initializing GTT heap.\n"); + goto err_mm_init; + return r; + } + return 0; + +err_mm_init: + ttm_bo_device_release(&vgdev->mman.bdev); +err_dev_init: + virtio_gpu_ttm_global_fini(vgdev); + return r; +} + +void virtio_gpu_ttm_fini(struct virtio_gpu_device *vgdev) +{ + ttm_bo_device_release(&vgdev->mman.bdev); + virtio_gpu_ttm_global_fini(vgdev); + DRM_INFO("virtio_gpu: ttm finalized\n"); +} diff --git a/drivers/gpu/drm/virtio/virtgpu_vq.c b/drivers/gpu/drm/virtio/virtgpu_vq.c new file mode 100644 index 0000000..8fa6513e --- /dev/null +++ b/drivers/gpu/drm/virtio/virtgpu_vq.c @@ -0,0 +1,614 @@ +/* + * Copyright (C) 2015 Red Hat, Inc. + * All Rights Reserved. + * + * Authors: + * Dave Airlie <airlied@redhat.com> + * Gerd Hoffmann <kraxel@redhat.com> + * + * 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 + * VA LINUX SYSTEMS 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. + */ + +#include <drm/drmP.h> +#include "virtgpu_drv.h" +#include <linux/virtio.h> +#include <linux/virtio_config.h> +#include <linux/virtio_ring.h> + +#define MAX_INLINE_CMD_SIZE 96 +#define MAX_INLINE_RESP_SIZE 24 +#define VBUFFER_SIZE (sizeof(struct virtio_gpu_vbuffer) \ + + MAX_INLINE_CMD_SIZE \ + + MAX_INLINE_RESP_SIZE) + +void virtio_gpu_resource_id_get(struct virtio_gpu_device *vgdev, + uint32_t *resid) +{ + int handle; + + idr_preload(GFP_KERNEL); + spin_lock(&vgdev->resource_idr_lock); + handle = idr_alloc(&vgdev->resource_idr, NULL, 1, 0, GFP_NOWAIT); + spin_unlock(&vgdev->resource_idr_lock); + idr_preload_end(); + *resid = handle; +} + +void virtio_gpu_resource_id_put(struct virtio_gpu_device *vgdev, uint32_t id) +{ + spin_lock(&vgdev->resource_idr_lock); + idr_remove(&vgdev->resource_idr, id); + spin_unlock(&vgdev->resource_idr_lock); +} + +void virtio_gpu_ctrl_ack(struct virtqueue *vq) +{ + struct drm_device *dev = vq->vdev->priv; + struct virtio_gpu_device *vgdev = dev->dev_private; + schedule_work(&vgdev->ctrlq.dequeue_work); +} + +void virtio_gpu_cursor_ack(struct virtqueue *vq) +{ + struct drm_device *dev = vq->vdev->priv; + struct virtio_gpu_device *vgdev = dev->dev_private; + schedule_work(&vgdev->cursorq.dequeue_work); +} + +int virtio_gpu_alloc_vbufs(struct virtio_gpu_device *vgdev) +{ + struct virtio_gpu_vbuffer *vbuf; + int i, size, count = 0; + void *ptr; + + INIT_LIST_HEAD(&vgdev->free_vbufs); + count += virtqueue_get_vring_size(vgdev->ctrlq.vq); + count += virtqueue_get_vring_size(vgdev->cursorq.vq); + size = count * VBUFFER_SIZE; + DRM_INFO("virtio vbuffers: %d bufs, %zdB each, %dkB total.\n", + count, VBUFFER_SIZE, size / 1024); + + vgdev->vbufs = kzalloc(size, GFP_KERNEL); + if (!vgdev->vbufs) + return -ENOMEM; + + for (i = 0, ptr = vgdev->vbufs; + i < count; + i++, ptr += VBUFFER_SIZE) { + vbuf = ptr; + list_add(&vbuf->list, &vgdev->free_vbufs); + } + return 0; +} + +void virtio_gpu_free_vbufs(struct virtio_gpu_device *vgdev) +{ + struct virtio_gpu_vbuffer *vbuf; + int i, count = 0; + + count += virtqueue_get_vring_size(vgdev->ctrlq.vq); + count += virtqueue_get_vring_size(vgdev->cursorq.vq); + + for (i = 0; i < count; i++) { + if (WARN_ON(list_empty(&vgdev->free_vbufs))) + return; + vbuf = list_first_entry(&vgdev->free_vbufs, + struct virtio_gpu_vbuffer, list); + list_del(&vbuf->list); + } + kfree(vgdev->vbufs); +} + +static struct virtio_gpu_vbuffer* +virtio_gpu_get_vbuf(struct virtio_gpu_device *vgdev, + int size, int resp_size, void *resp_buf, + virtio_gpu_resp_cb resp_cb) +{ + struct virtio_gpu_vbuffer *vbuf; + + BUG_ON(list_empty(&vgdev->free_vbufs)); + vbuf = list_first_entry(&vgdev->free_vbufs, + struct virtio_gpu_vbuffer, list); + list_del(&vbuf->list); + memset(vbuf, 0, VBUFFER_SIZE); + + BUG_ON(size > MAX_INLINE_CMD_SIZE); + vbuf->buf = (void *)vbuf + sizeof(*vbuf); + vbuf->size = size; + + vbuf->resp_cb = resp_cb; + vbuf->resp_size = resp_size; + if (resp_size <= MAX_INLINE_RESP_SIZE) + vbuf->resp_buf = (void *)vbuf->buf + size; + else + vbuf->resp_buf = resp_buf; + BUG_ON(!vbuf->resp_buf); + return vbuf; +} + +static void *virtio_gpu_alloc_cmd(struct virtio_gpu_device *vgdev, + struct virtio_gpu_vbuffer **vbuffer_p, + int size) +{ + struct virtio_gpu_vbuffer *vbuf; + + vbuf = virtio_gpu_get_vbuf(vgdev, size, + sizeof(struct virtio_gpu_ctrl_hdr), + NULL, NULL); + if (IS_ERR(vbuf)) { + *vbuffer_p = NULL; + return ERR_CAST(vbuf); + } + *vbuffer_p = vbuf; + return vbuf->buf; +} + +static struct virtio_gpu_update_cursor* +virtio_gpu_alloc_cursor(struct virtio_gpu_device *vgdev, + struct virtio_gpu_vbuffer **vbuffer_p) +{ + struct virtio_gpu_vbuffer *vbuf; + + vbuf = virtio_gpu_get_vbuf + (vgdev, sizeof(struct virtio_gpu_update_cursor), + 0, NULL, NULL); + if (IS_ERR(vbuf)) { + *vbuffer_p = NULL; + return ERR_CAST(vbuf); + } + *vbuffer_p = vbuf; + return (struct virtio_gpu_update_cursor *)vbuf->buf; +} + +static void *virtio_gpu_alloc_cmd_resp(struct virtio_gpu_device *vgdev, + virtio_gpu_resp_cb cb, + struct virtio_gpu_vbuffer **vbuffer_p, + int cmd_size, int resp_size, + void *resp_buf) +{ + struct virtio_gpu_vbuffer *vbuf; + + vbuf = virtio_gpu_get_vbuf(vgdev, cmd_size, + resp_size, resp_buf, cb); + if (IS_ERR(vbuf)) { + *vbuffer_p = NULL; + return ERR_CAST(vbuf); + } + *vbuffer_p = vbuf; + return (struct virtio_gpu_command *)vbuf->buf; +} + +static void free_vbuf(struct virtio_gpu_device *vgdev, + struct virtio_gpu_vbuffer *vbuf) +{ + if (vbuf->resp_size > MAX_INLINE_RESP_SIZE) + kfree(vbuf->resp_buf); + kfree(vbuf->data_buf); + list_add(&vbuf->list, &vgdev->free_vbufs); +} + +static void reclaim_vbufs(struct virtqueue *vq, struct list_head *reclaim_list) +{ + struct virtio_gpu_vbuffer *vbuf; + unsigned int len; + int freed = 0; + + while ((vbuf = virtqueue_get_buf(vq, &len))) { + list_add_tail(&vbuf->list, reclaim_list); + freed++; + } + if (freed == 0) + DRM_DEBUG("Huh? zero vbufs reclaimed"); +} + +void virtio_gpu_dequeue_ctrl_func(struct work_struct *work) +{ + struct virtio_gpu_device *vgdev = + container_of(work, struct virtio_gpu_device, + ctrlq.dequeue_work); + struct list_head reclaim_list; + struct virtio_gpu_vbuffer *entry, *tmp; + struct virtio_gpu_ctrl_hdr *resp; + u64 fence_id = 0; + + INIT_LIST_HEAD(&reclaim_list); + spin_lock(&vgdev->ctrlq.qlock); + do { + virtqueue_disable_cb(vgdev->ctrlq.vq); + reclaim_vbufs(vgdev->ctrlq.vq, &reclaim_list); + + } while (!virtqueue_enable_cb(vgdev->ctrlq.vq)); + spin_unlock(&vgdev->ctrlq.qlock); + + list_for_each_entry_safe(entry, tmp, &reclaim_list, list) { + resp = (struct virtio_gpu_ctrl_hdr *)entry->resp_buf; + if (resp->type != cpu_to_le32(VIRTIO_GPU_RESP_OK_NODATA)) + DRM_DEBUG("response 0x%x\n", le32_to_cpu(resp->type)); + if (resp->flags & cpu_to_le32(VIRTIO_GPU_FLAG_FENCE)) { + u64 f = le64_to_cpu(resp->fence_id); + + if (fence_id > f) { + DRM_ERROR("%s: Oops: fence %llx -> %llx\n", + __func__, fence_id, f); + } else { + fence_id = f; + } + } + if (entry->resp_cb) + entry->resp_cb(vgdev, entry); + + list_del(&entry->list); + free_vbuf(vgdev, entry); + } + wake_up(&vgdev->ctrlq.ack_queue); + + if (fence_id) + virtio_gpu_fence_event_process(vgdev, fence_id); +} + +void virtio_gpu_dequeue_cursor_func(struct work_struct *work) +{ + struct virtio_gpu_device *vgdev = + container_of(work, struct virtio_gpu_device, + cursorq.dequeue_work); + struct list_head reclaim_list; + struct virtio_gpu_vbuffer *entry, *tmp; + + INIT_LIST_HEAD(&reclaim_list); + spin_lock(&vgdev->cursorq.qlock); + do { + virtqueue_disable_cb(vgdev->cursorq.vq); + reclaim_vbufs(vgdev->cursorq.vq, &reclaim_list); + } while (!virtqueue_enable_cb(vgdev->cursorq.vq)); + spin_unlock(&vgdev->cursorq.qlock); + + list_for_each_entry_safe(entry, tmp, &reclaim_list, list) { + list_del(&entry->list); + free_vbuf(vgdev, entry); + } + wake_up(&vgdev->cursorq.ack_queue); +} + +static int virtio_gpu_queue_ctrl_buffer(struct virtio_gpu_device *vgdev, + struct virtio_gpu_vbuffer *vbuf) +{ + struct virtqueue *vq = vgdev->ctrlq.vq; + struct scatterlist *sgs[3], vcmd, vout, vresp; + int outcnt = 0, incnt = 0; + int ret; + + if (!vgdev->vqs_ready) + return -ENODEV; + + sg_init_one(&vcmd, vbuf->buf, vbuf->size); + sgs[outcnt+incnt] = &vcmd; + outcnt++; + + if (vbuf->data_size) { + sg_init_one(&vout, vbuf->data_buf, vbuf->data_size); + sgs[outcnt + incnt] = &vout; + outcnt++; + } + + if (vbuf->resp_size) { + sg_init_one(&vresp, vbuf->resp_buf, vbuf->resp_size); + sgs[outcnt + incnt] = &vresp; + incnt++; + } + + spin_lock(&vgdev->ctrlq.qlock); +retry: + ret = virtqueue_add_sgs(vq, sgs, outcnt, incnt, vbuf, GFP_ATOMIC); + if (ret == -ENOSPC) { + spin_unlock(&vgdev->ctrlq.qlock); + wait_event(vgdev->ctrlq.ack_queue, vq->num_free); + spin_lock(&vgdev->ctrlq.qlock); + goto retry; + } else { + virtqueue_kick(vq); + } + spin_unlock(&vgdev->ctrlq.qlock); + + if (!ret) + ret = vq->num_free; + return ret; +} + +static int virtio_gpu_queue_cursor(struct virtio_gpu_device *vgdev, + struct virtio_gpu_vbuffer *vbuf) +{ + struct virtqueue *vq = vgdev->cursorq.vq; + struct scatterlist *sgs[1], ccmd; + int ret; + int outcnt; + + if (!vgdev->vqs_ready) + return -ENODEV; + + sg_init_one(&ccmd, vbuf->buf, vbuf->size); + sgs[0] = &ccmd; + outcnt = 1; + + spin_lock(&vgdev->cursorq.qlock); +retry: + ret = virtqueue_add_sgs(vq, sgs, outcnt, 0, vbuf, GFP_ATOMIC); + if (ret == -ENOSPC) { + spin_unlock(&vgdev->cursorq.qlock); + wait_event(vgdev->cursorq.ack_queue, vq->num_free); + spin_lock(&vgdev->cursorq.qlock); + goto retry; + } else { + virtqueue_kick(vq); + } + + spin_unlock(&vgdev->cursorq.qlock); + + if (!ret) + ret = vq->num_free; + return ret; +} + +/* just create gem objects for userspace and long lived objects, + just use dma_alloced pages for the queue objects? */ + +/* create a basic resource */ +void virtio_gpu_cmd_create_resource(struct virtio_gpu_device *vgdev, + uint32_t resource_id, + uint32_t format, + uint32_t width, + uint32_t height) +{ + struct virtio_gpu_resource_create_2d *cmd_p; + struct virtio_gpu_vbuffer *vbuf; + + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); + memset(cmd_p, 0, sizeof(*cmd_p)); + + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_CREATE_2D); + cmd_p->resource_id = cpu_to_le32(resource_id); + cmd_p->format = cpu_to_le32(format); + cmd_p->width = cpu_to_le32(width); + cmd_p->height = cpu_to_le32(height); + + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); +} + +void virtio_gpu_cmd_unref_resource(struct virtio_gpu_device *vgdev, + uint32_t resource_id) +{ + struct virtio_gpu_resource_unref *cmd_p; + struct virtio_gpu_vbuffer *vbuf; + + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); + memset(cmd_p, 0, sizeof(*cmd_p)); + + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_UNREF); + cmd_p->resource_id = cpu_to_le32(resource_id); + + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); +} + +void virtio_gpu_cmd_resource_inval_backing(struct virtio_gpu_device *vgdev, + uint32_t resource_id) +{ + struct virtio_gpu_resource_detach_backing *cmd_p; + struct virtio_gpu_vbuffer *vbuf; + + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); + memset(cmd_p, 0, sizeof(*cmd_p)); + + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING); + cmd_p->resource_id = cpu_to_le32(resource_id); + + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); +} + +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) +{ + struct virtio_gpu_set_scanout *cmd_p; + struct virtio_gpu_vbuffer *vbuf; + + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); + memset(cmd_p, 0, sizeof(*cmd_p)); + + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_SET_SCANOUT); + cmd_p->resource_id = cpu_to_le32(resource_id); + cmd_p->scanout_id = cpu_to_le32(scanout_id); + cmd_p->r.width = cpu_to_le32(width); + cmd_p->r.height = cpu_to_le32(height); + cmd_p->r.x = cpu_to_le32(x); + cmd_p->r.y = cpu_to_le32(y); + + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); +} + +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) +{ + struct virtio_gpu_resource_flush *cmd_p; + struct virtio_gpu_vbuffer *vbuf; + + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); + memset(cmd_p, 0, sizeof(*cmd_p)); + + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_FLUSH); + cmd_p->resource_id = cpu_to_le32(resource_id); + cmd_p->r.width = cpu_to_le32(width); + cmd_p->r.height = cpu_to_le32(height); + cmd_p->r.x = cpu_to_le32(x); + cmd_p->r.y = cpu_to_le32(y); + + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); +} + +void virtio_gpu_cmd_transfer_to_host_2d(struct virtio_gpu_device *vgdev, + uint32_t resource_id, uint64_t offset, + __le32 width, __le32 height, + __le32 x, __le32 y, + struct virtio_gpu_fence **fence) +{ + struct virtio_gpu_transfer_to_host_2d *cmd_p; + struct virtio_gpu_vbuffer *vbuf; + + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); + memset(cmd_p, 0, sizeof(*cmd_p)); + + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D); + cmd_p->resource_id = cpu_to_le32(resource_id); + cmd_p->offset = cpu_to_le64(offset); + cmd_p->r.width = width; + cmd_p->r.height = height; + cmd_p->r.x = x; + cmd_p->r.y = y; + + if (fence) + virtio_gpu_fence_emit(vgdev, &cmd_p->hdr, fence); + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); +} + +static void +virtio_gpu_cmd_resource_attach_backing(struct virtio_gpu_device *vgdev, + uint32_t resource_id, + struct virtio_gpu_mem_entry *ents, + uint32_t nents, + struct virtio_gpu_fence **fence) +{ + struct virtio_gpu_resource_attach_backing *cmd_p; + struct virtio_gpu_vbuffer *vbuf; + + cmd_p = virtio_gpu_alloc_cmd(vgdev, &vbuf, sizeof(*cmd_p)); + memset(cmd_p, 0, sizeof(*cmd_p)); + + cmd_p->hdr.type = cpu_to_le32(VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING); + cmd_p->resource_id = cpu_to_le32(resource_id); + cmd_p->nr_entries = cpu_to_le32(nents); + + vbuf->data_buf = ents; + vbuf->data_size = sizeof(*ents) * nents; + + if (fence) + virtio_gpu_fence_emit(vgdev, &cmd_p->hdr, fence); + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); +} + +static void virtio_gpu_cmd_get_display_info_cb(struct virtio_gpu_device *vgdev, + struct virtio_gpu_vbuffer *vbuf) +{ + struct virtio_gpu_resp_display_info *resp = + (struct virtio_gpu_resp_display_info *)vbuf->resp_buf; + int i; + + spin_lock(&vgdev->display_info_lock); + for (i = 0; i < vgdev->num_scanouts; i++) { + vgdev->outputs[i].info = resp->pmodes[i]; + if (resp->pmodes[i].enabled) { + DRM_DEBUG("output %d: %dx%d+%d+%d", i, + le32_to_cpu(resp->pmodes[i].r.width), + le32_to_cpu(resp->pmodes[i].r.height), + le32_to_cpu(resp->pmodes[i].r.x), + le32_to_cpu(resp->pmodes[i].r.y)); + } else { + DRM_DEBUG("output %d: disabled", i); + } + } + + spin_unlock(&vgdev->display_info_lock); + wake_up(&vgdev->resp_wq); + + if (!drm_helper_hpd_irq_event(vgdev->ddev)) + drm_kms_helper_hotplug_event(vgdev->ddev); +} + +int virtio_gpu_cmd_get_display_info(struct virtio_gpu_device *vgdev) +{ + struct virtio_gpu_ctrl_hdr *cmd_p; + struct virtio_gpu_vbuffer *vbuf; + void *resp_buf; + + resp_buf = kzalloc(sizeof(struct virtio_gpu_resp_display_info), + GFP_KERNEL); + if (!resp_buf) + return -ENOMEM; + + cmd_p = virtio_gpu_alloc_cmd_resp + (vgdev, &virtio_gpu_cmd_get_display_info_cb, &vbuf, + sizeof(*cmd_p), sizeof(struct virtio_gpu_resp_display_info), + resp_buf); + memset(cmd_p, 0, sizeof(*cmd_p)); + + cmd_p->type = cpu_to_le32(VIRTIO_GPU_CMD_GET_DISPLAY_INFO); + virtio_gpu_queue_ctrl_buffer(vgdev, vbuf); + return 0; +} + +int virtio_gpu_object_attach(struct virtio_gpu_device *vgdev, + struct virtio_gpu_object *obj, + uint32_t resource_id, + struct virtio_gpu_fence **fence) +{ + struct virtio_gpu_mem_entry *ents; + struct scatterlist *sg; + int si; + + if (!obj->pages) { + int ret; + ret = virtio_gpu_object_get_sg_table(vgdev, obj); + if (ret) + return ret; + } + + /* gets freed when the ring has consumed it */ + ents = kmalloc_array(obj->pages->nents, + sizeof(struct virtio_gpu_mem_entry), + GFP_KERNEL); + if (!ents) { + DRM_ERROR("failed to allocate ent list\n"); + return -ENOMEM; + } + + for_each_sg(obj->pages->sgl, sg, obj->pages->nents, si) { + ents[si].addr = cpu_to_le64(sg_phys(sg)); + ents[si].length = cpu_to_le32(sg->length); + ents[si].padding = 0; + } + + virtio_gpu_cmd_resource_attach_backing(vgdev, resource_id, + ents, obj->pages->nents, + fence); + obj->hw_res_handle = resource_id; + return 0; +} + +void virtio_gpu_cursor_ping(struct virtio_gpu_device *vgdev, + struct virtio_gpu_output *output) +{ + struct virtio_gpu_vbuffer *vbuf; + struct virtio_gpu_update_cursor *cur_p; + + output->cursor.pos.scanout_id = cpu_to_le32(output->index); + cur_p = virtio_gpu_alloc_cursor(vgdev, &vbuf); + memcpy(cur_p, &output->cursor, sizeof(output->cursor)); + virtio_gpu_queue_cursor(vgdev, vbuf); +} diff --git a/include/drm/drmP.h b/include/drm/drmP.h index 62c40777..1544bb1 100644 --- a/include/drm/drmP.h +++ b/include/drm/drmP.h @@ -812,6 +812,7 @@ struct drm_device { #endif struct platform_device *platformdev; /**< Platform device struture */ + struct virtio_device *virtdev; struct drm_sg_mem *sg; /**< Scatter gather memory */ unsigned int num_crtcs; /**< Number of CRTCs on this device */ diff --git a/include/uapi/linux/Kbuild b/include/uapi/linux/Kbuild index 1a0006a..4460e58 100644 --- a/include/uapi/linux/Kbuild +++ b/include/uapi/linux/Kbuild @@ -430,6 +430,7 @@ header-y += virtio_balloon.h header-y += virtio_blk.h header-y += virtio_config.h header-y += virtio_console.h +header-y += virtio_gpu.h header-y += virtio_ids.h header-y += virtio_input.h header-y += virtio_net.h diff --git a/include/uapi/linux/virtio_gpu.h b/include/uapi/linux/virtio_gpu.h new file mode 100644 index 0000000..571c4cb --- /dev/null +++ b/include/uapi/linux/virtio_gpu.h @@ -0,0 +1,204 @@ +/* + * Virtio GPU Device + * + * Copyright Red Hat, Inc. 2013-2014 + * + * Authors: + * Dave Airlie <airlied@redhat.com> + * Gerd Hoffmann <kraxel@redhat.com> + * + * This header is BSD licensed so anyone can use the definitions + * to implement compatible drivers/servers: + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions + * are met: + * 1. Redistributions of source code must retain the above copyright + * notice, this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright + * notice, this list of conditions and the following disclaimer in the + * documentation and/or other materials provided with the distribution. + * 3. Neither the name of IBM nor the names of its contributors + * may be used to endorse or promote products derived from this software + * without specific prior written permission. + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS + * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT + * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS + * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL IBM OR + * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, + * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT + * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF + * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND + * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, + * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT + * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF + * SUCH DAMAGE. + */ + +#ifndef VIRTIO_GPU_HW_H +#define VIRTIO_GPU_HW_H + +enum virtio_gpu_ctrl_type { + VIRTIO_GPU_UNDEFINED = 0, + + /* 2d commands */ + VIRTIO_GPU_CMD_GET_DISPLAY_INFO = 0x0100, + VIRTIO_GPU_CMD_RESOURCE_CREATE_2D, + VIRTIO_GPU_CMD_RESOURCE_UNREF, + VIRTIO_GPU_CMD_SET_SCANOUT, + VIRTIO_GPU_CMD_RESOURCE_FLUSH, + VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D, + VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING, + VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING, + + /* cursor commands */ + VIRTIO_GPU_CMD_UPDATE_CURSOR = 0x0300, + VIRTIO_GPU_CMD_MOVE_CURSOR, + + /* success responses */ + VIRTIO_GPU_RESP_OK_NODATA = 0x1100, + VIRTIO_GPU_RESP_OK_DISPLAY_INFO, + + /* error responses */ + VIRTIO_GPU_RESP_ERR_UNSPEC = 0x1200, + VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY, + VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID, + VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID, + VIRTIO_GPU_RESP_ERR_INVALID_CONTEXT_ID, + VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER, +}; + +#define VIRTIO_GPU_FLAG_FENCE (1 << 0) + +struct virtio_gpu_ctrl_hdr { + __le32 type; + __le32 flags; + __le64 fence_id; + __le32 ctx_id; + __le32 padding; +}; + +/* data passed in the cursor vq */ + +struct virtio_gpu_cursor_pos { + __le32 scanout_id; + __le32 x; + __le32 y; + __le32 padding; +}; + +/* VIRTIO_GPU_CMD_UPDATE_CURSOR, VIRTIO_GPU_CMD_MOVE_CURSOR */ +struct virtio_gpu_update_cursor { + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_cursor_pos pos; /* update & move */ + __le32 resource_id; /* update only */ + __le32 hot_x; /* update only */ + __le32 hot_y; /* update only */ + __le32 padding; +}; + +/* data passed in the control vq, 2d related */ + +struct virtio_gpu_rect { + __le32 x; + __le32 y; + __le32 width; + __le32 height; +}; + +/* VIRTIO_GPU_CMD_RESOURCE_UNREF */ +struct virtio_gpu_resource_unref { + struct virtio_gpu_ctrl_hdr hdr; + __le32 resource_id; + __le32 padding; +}; + +/* VIRTIO_GPU_CMD_RESOURCE_CREATE_2D: create a 2d resource with a format */ +struct virtio_gpu_resource_create_2d { + struct virtio_gpu_ctrl_hdr hdr; + __le32 resource_id; + __le32 format; + __le32 width; + __le32 height; +}; + +/* VIRTIO_GPU_CMD_SET_SCANOUT */ +struct virtio_gpu_set_scanout { + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_rect r; + __le32 scanout_id; + __le32 resource_id; +}; + +/* VIRTIO_GPU_CMD_RESOURCE_FLUSH */ +struct virtio_gpu_resource_flush { + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_rect r; + __le32 resource_id; + __le32 padding; +}; + +/* VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D: simple transfer to_host */ +struct virtio_gpu_transfer_to_host_2d { + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_rect r; + __le64 offset; + __le32 resource_id; + __le32 padding; +}; + +struct virtio_gpu_mem_entry { + __le64 addr; + __le32 length; + __le32 padding; +}; + +/* VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING */ +struct virtio_gpu_resource_attach_backing { + struct virtio_gpu_ctrl_hdr hdr; + __le32 resource_id; + __le32 nr_entries; +}; + +/* VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING */ +struct virtio_gpu_resource_detach_backing { + struct virtio_gpu_ctrl_hdr hdr; + __le32 resource_id; + __le32 padding; +}; + +/* VIRTIO_GPU_RESP_OK_DISPLAY_INFO */ +#define VIRTIO_GPU_MAX_SCANOUTS 16 +struct virtio_gpu_resp_display_info { + struct virtio_gpu_ctrl_hdr hdr; + struct virtio_gpu_display_one { + struct virtio_gpu_rect r; + __le32 enabled; + __le32 flags; + } pmodes[VIRTIO_GPU_MAX_SCANOUTS]; +}; + +#define VIRTIO_GPU_EVENT_DISPLAY (1 << 0) + +struct virtio_gpu_config { + __u32 events_read; + __u32 events_clear; + __u32 num_scanouts; + __u32 reserved; +}; + +/* simple formats for fbcon/X use */ +enum virtio_gpu_formats { + VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM = 1, + VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM = 2, + VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM = 3, + VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM = 4, + + VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM = 67, + VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM = 68, + + VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM = 121, + VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM = 134, +}; + +#endif diff --git a/include/uapi/linux/virtio_ids.h b/include/uapi/linux/virtio_ids.h index 5f60aa4..77925f5 100644 --- a/include/uapi/linux/virtio_ids.h +++ b/include/uapi/linux/virtio_ids.h @@ -39,6 +39,7 @@ #define VIRTIO_ID_9P 9 /* 9p virtio console */ #define VIRTIO_ID_RPROC_SERIAL 11 /* virtio remoteproc serial link */ #define VIRTIO_ID_CAIF 12 /* Virtio caif */ +#define VIRTIO_ID_GPU 16 /* virtio GPU */ #define VIRTIO_ID_INPUT 18 /* virtio input */ #endif /* _LINUX_VIRTIO_IDS_H */