Merge tag 'vmwgfx-next-2014-01-17' of git://people.freedesktop.org/~thomash/linux into drm-next

Pull request of 2014-01-17

Pull request for 3.14. One not so urgent fix, One huge device update.

The pull request corresponds to the patches sent out on dri-devel, except:
[PATCH 02/33], review tag typo pointed out by Matt Turner.
[PATCH 04/33], dropped. The new surface formats are never used.

The upcoming vmware svga2 hardware version 11 will introduce the concept
of "guest backed objects" or -resources. The device will in principle
get all
of its memory from the guest, which has big advantages from the device
point of view.

This means that vmwgfx contexts, shaders and surfaces need to be backed
by guest memory in the form of buffer objects called MOBs, presumably
short for MemoryOBjects, which are bound to the device in a special way.

This patch series introduces guest backed object support. Some new IOCTLs
are added to allocate these new guest backed object, and to optionally
provide
them with a backing MOB.

There is an update to the gallium driver that comes with this update, and
it will be pushed in the near timeframe presumably to a separate mesa branch
before merged to master.

* tag 'vmwgfx-next-2014-01-17' of git://people.freedesktop.org/~thomash/linux: (33 commits)
  drm/vmwgfx: Invalidate surface on non-readback unbind
  drm/vmwgfx: Silence the device command verifier
  drm/vmwgfx: Implement 64-bit Otable- and MOB binding v2
  drm/vmwgfx: Fix surface framebuffer check for guest-backed surfaces
  drm/vmwgfx: Update otable definitions
  drm/vmwgfx: Use the linux DMA api also for MOBs
  drm/vmwgfx: Ditch the vmw_dummy_query_bo_prepare function
  drm/vmwgfx: Persistent tracking of context bindings
  drm/vmwgfx: Track context bindings and scrub them upon exiting execbuf
  drm/vmwgfx: Block the BIND_SHADERCONSTS command
  drm/vmwgfx: Add a parameter to get max MOB memory size
  drm/vmwgfx: Implement a buffer object synccpu ioctl.
  drm/vmwgfx: Make sure that the multisampling is off
  drm/vmwgfx: Extend the command verifier to handle guest-backed on / off
  drm/vmwgfx: Fix up the vmwgfx_drv.h header for new files
  drm/vmwgfx: Enable 3D for new hardware version
  drm/vmwgfx: Add new unused (by user-space) commands to the verifier
  drm/vmwgfx: Validate guest-backed shader const commands
  drm/vmwgfx: Add guest-backed shaders
  drm/vmwgfx: Hook up guest-backed surfaces
  ...

1 files changed, 531 insertions, 0 deletions

diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_context.c b/drivers/gpu/drm/vmwgfx/vmwgfx_context.c
index 00ae0925aca8..97aa55159107 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_context.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_context.c
@@ -32,12 +32,28 @@
 struct vmw_user_context {
         struct ttm_base_object base;
         struct vmw_resource res;
+        struct vmw_ctx_binding_state cbs;
 };
 
+
+
+typedef int (*vmw_scrub_func)(struct vmw_ctx_bindinfo *);
+
 static void vmw_user_context_free(struct vmw_resource *res);
 static struct vmw_resource *
 vmw_user_context_base_to_res(struct ttm_base_object *base);
 
+static int vmw_gb_context_create(struct vmw_resource *res);
+static int vmw_gb_context_bind(struct vmw_resource *res,
+                               struct ttm_validate_buffer *val_buf);
+static int vmw_gb_context_unbind(struct vmw_resource *res,
+                                 bool readback,
+                                 struct ttm_validate_buffer *val_buf);
+static int vmw_gb_context_destroy(struct vmw_resource *res);
+static int vmw_context_scrub_shader(struct vmw_ctx_bindinfo *bi);
+static int vmw_context_scrub_render_target(struct vmw_ctx_bindinfo *bi);
+static int vmw_context_scrub_texture(struct vmw_ctx_bindinfo *bi);
+static void vmw_context_binding_state_kill(struct vmw_ctx_binding_state *cbs);
 static uint64_t vmw_user_context_size;
 
 static const struct vmw_user_resource_conv user_context_conv = {
@@ -62,6 +78,23 @@ static const struct vmw_res_func vmw_legacy_context_func = {
         .unbind = NULL
 };
 
+static const struct vmw_res_func vmw_gb_context_func = {
+        .res_type = vmw_res_context,
+        .needs_backup = true,
+        .may_evict = true,
+        .type_name = "guest backed contexts",
+        .backup_placement = &vmw_mob_placement,
+        .create = vmw_gb_context_create,
+        .destroy = vmw_gb_context_destroy,
+        .bind = vmw_gb_context_bind,
+        .unbind = vmw_gb_context_unbind
+};
+
+static const vmw_scrub_func vmw_scrub_funcs[vmw_ctx_binding_max] = {
+        [vmw_ctx_binding_shader] = vmw_context_scrub_shader,
+        [vmw_ctx_binding_rt] = vmw_context_scrub_render_target,
+        [vmw_ctx_binding_tex] = vmw_context_scrub_texture };
+
 /**
  * Context management:
  */
@@ -76,6 +109,16 @@ static void vmw_hw_context_destroy(struct vmw_resource *res)
         } *cmd;
 
 
+        if (res->func->destroy == vmw_gb_context_destroy) {
+                mutex_lock(&dev_priv->cmdbuf_mutex);
+                (void) vmw_gb_context_destroy(res);
+                if (dev_priv->pinned_bo != NULL &&
+                    !dev_priv->query_cid_valid)
+                        __vmw_execbuf_release_pinned_bo(dev_priv, NULL);
+                mutex_unlock(&dev_priv->cmdbuf_mutex);
+                return;
+        }
+
         vmw_execbuf_release_pinned_bo(dev_priv);
         cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
         if (unlikely(cmd == NULL)) {
@@ -92,6 +135,33 @@ static void vmw_hw_context_destroy(struct vmw_resource *res)
         vmw_3d_resource_dec(dev_priv, false);
 }
 
+static int vmw_gb_context_init(struct vmw_private *dev_priv,
+                               struct vmw_resource *res,
+                               void (*res_free) (struct vmw_resource *res))
+{
+        int ret;
+        struct vmw_user_context *uctx =
+                container_of(res, struct vmw_user_context, res);
+
+        ret = vmw_resource_init(dev_priv, res, true,
+                                res_free, &vmw_gb_context_func);
+        res->backup_size = SVGA3D_CONTEXT_DATA_SIZE;
+
+        if (unlikely(ret != 0)) {
+                if (res_free)
+                        res_free(res);
+                else
+                        kfree(res);
+                return ret;
+        }
+
+        memset(&uctx->cbs, 0, sizeof(uctx->cbs));
+        INIT_LIST_HEAD(&uctx->cbs.list);
+
+        vmw_resource_activate(res, vmw_hw_context_destroy);
+        return 0;
+}
+
 static int vmw_context_init(struct vmw_private *dev_priv,
                             struct vmw_resource *res,
                             void (*res_free) (struct vmw_resource *res))
@@ -103,6 +173,9 @@ static int vmw_context_init(struct vmw_private *dev_priv,
                 SVGA3dCmdDefineContext body;
         } *cmd;
 
+        if (dev_priv->has_mob)
+                return vmw_gb_context_init(dev_priv, res, res_free);
+
         ret = vmw_resource_init(dev_priv, res, false,
                                 res_free, &vmw_legacy_context_func);
 
@@ -154,6 +227,184 @@ struct vmw_resource *vmw_context_alloc(struct vmw_private *dev_priv)
         return (ret == 0) ? res : NULL;
 }
 
+
+static int vmw_gb_context_create(struct vmw_resource *res)
+{
+        struct vmw_private *dev_priv = res->dev_priv;
+        int ret;
+        struct {
+                SVGA3dCmdHeader header;
+                SVGA3dCmdDefineGBContext body;
+        } *cmd;
+
+        if (likely(res->id != -1))
+                return 0;
+
+        ret = vmw_resource_alloc_id(res);
+        if (unlikely(ret != 0)) {
+                DRM_ERROR("Failed to allocate a context id.\n");
+                goto out_no_id;
+        }
+
+        if (unlikely(res->id >= VMWGFX_NUM_GB_CONTEXT)) {
+                ret = -EBUSY;
+                goto out_no_fifo;
+        }
+
+        cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
+        if (unlikely(cmd == NULL)) {
+                DRM_ERROR("Failed reserving FIFO space for context "
+                          "creation.\n");
+                ret = -ENOMEM;
+                goto out_no_fifo;
+        }
+
+        cmd->header.id = SVGA_3D_CMD_DEFINE_GB_CONTEXT;
+        cmd->header.size = sizeof(cmd->body);
+        cmd->body.cid = res->id;
+        vmw_fifo_commit(dev_priv, sizeof(*cmd));
+        (void) vmw_3d_resource_inc(dev_priv, false);
+
+        return 0;
+
+out_no_fifo:
+        vmw_resource_release_id(res);
+out_no_id:
+        return ret;
+}
+
+static int vmw_gb_context_bind(struct vmw_resource *res,
+                               struct ttm_validate_buffer *val_buf)
+{
+        struct vmw_private *dev_priv = res->dev_priv;
+        struct {
+                SVGA3dCmdHeader header;
+                SVGA3dCmdBindGBContext body;
+        } *cmd;
+        struct ttm_buffer_object *bo = val_buf->bo;
+
+        BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
+
+        cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
+        if (unlikely(cmd == NULL)) {
+                DRM_ERROR("Failed reserving FIFO space for context "
+                          "binding.\n");
+                return -ENOMEM;
+        }
+
+        cmd->header.id = SVGA_3D_CMD_BIND_GB_CONTEXT;
+        cmd->header.size = sizeof(cmd->body);
+        cmd->body.cid = res->id;
+        cmd->body.mobid = bo->mem.start;
+        cmd->body.validContents = res->backup_dirty;
+        res->backup_dirty = false;
+        vmw_fifo_commit(dev_priv, sizeof(*cmd));
+
+        return 0;
+}
+
+static int vmw_gb_context_unbind(struct vmw_resource *res,
+                                 bool readback,
+                                 struct ttm_validate_buffer *val_buf)
+{
+        struct vmw_private *dev_priv = res->dev_priv;
+        struct ttm_buffer_object *bo = val_buf->bo;
+        struct vmw_fence_obj *fence;
+        struct vmw_user_context *uctx =
+                container_of(res, struct vmw_user_context, res);
+
+        struct {
+                SVGA3dCmdHeader header;
+                SVGA3dCmdReadbackGBContext body;
+        } *cmd1;
+        struct {
+                SVGA3dCmdHeader header;
+                SVGA3dCmdBindGBContext body;
+        } *cmd2;
+        uint32_t submit_size;
+        uint8_t *cmd;
+
+
+        BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
+
+        mutex_lock(&dev_priv->binding_mutex);
+        vmw_context_binding_state_kill(&uctx->cbs);
+
+        submit_size = sizeof(*cmd2) + (readback ? sizeof(*cmd1) : 0);
+
+        cmd = vmw_fifo_reserve(dev_priv, submit_size);
+        if (unlikely(cmd == NULL)) {
+                DRM_ERROR("Failed reserving FIFO space for context "
+                          "unbinding.\n");
+                mutex_unlock(&dev_priv->binding_mutex);
+                return -ENOMEM;
+        }
+
+        cmd2 = (void *) cmd;
+        if (readback) {
+                cmd1 = (void *) cmd;
+                cmd1->header.id = SVGA_3D_CMD_READBACK_GB_CONTEXT;
+                cmd1->header.size = sizeof(cmd1->body);
+                cmd1->body.cid = res->id;
+                cmd2 = (void *) (&cmd1[1]);
+        }
+        cmd2->header.id = SVGA_3D_CMD_BIND_GB_CONTEXT;
+        cmd2->header.size = sizeof(cmd2->body);
+        cmd2->body.cid = res->id;
+        cmd2->body.mobid = SVGA3D_INVALID_ID;
+
+        vmw_fifo_commit(dev_priv, submit_size);
+        mutex_unlock(&dev_priv->binding_mutex);
+
+        /*
+         * Create a fence object and fence the backup buffer.
+         */
+
+        (void) vmw_execbuf_fence_commands(NULL, dev_priv,
+                                          &fence, NULL);
+
+        vmw_fence_single_bo(bo, fence);
+
+        if (likely(fence != NULL))
+                vmw_fence_obj_unreference(&fence);
+
+        return 0;
+}
+
+static int vmw_gb_context_destroy(struct vmw_resource *res)
+{
+        struct vmw_private *dev_priv = res->dev_priv;
+        struct {
+                SVGA3dCmdHeader header;
+                SVGA3dCmdDestroyGBContext body;
+        } *cmd;
+        struct vmw_user_context *uctx =
+                container_of(res, struct vmw_user_context, res);
+
+        BUG_ON(!list_empty(&uctx->cbs.list));
+
+        if (likely(res->id == -1))
+                return 0;
+
+        cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
+        if (unlikely(cmd == NULL)) {
+                DRM_ERROR("Failed reserving FIFO space for context "
+                          "destruction.\n");
+                return -ENOMEM;
+        }
+
+        cmd->header.id = SVGA_3D_CMD_DESTROY_GB_CONTEXT;
+        cmd->header.size = sizeof(cmd->body);
+        cmd->body.cid = res->id;
+        vmw_fifo_commit(dev_priv, sizeof(*cmd));
+        if (dev_priv->query_cid == res->id)
+                dev_priv->query_cid_valid = false;
+        vmw_resource_release_id(res);
+        vmw_3d_resource_dec(dev_priv, false);
+
+        return 0;
+}
+
 /**
  * User-space context management:
  */
@@ -272,3 +523,283 @@ out_unlock:
         return ret;
 
 }
+
+/**
+ * vmw_context_scrub_shader - scrub a shader binding from a context.
+ *
+ * @bi: single binding information.
+ */
+static int vmw_context_scrub_shader(struct vmw_ctx_bindinfo *bi)
+{
+        struct vmw_private *dev_priv = bi->ctx->dev_priv;
+        struct {
+                SVGA3dCmdHeader header;
+                SVGA3dCmdSetShader body;
+        } *cmd;
+
+        cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
+        if (unlikely(cmd == NULL)) {
+                DRM_ERROR("Failed reserving FIFO space for shader "
+                          "unbinding.\n");
+                return -ENOMEM;
+        }
+
+        cmd->header.id = SVGA_3D_CMD_SET_SHADER;
+        cmd->header.size = sizeof(cmd->body);
+        cmd->body.cid = bi->ctx->id;
+        cmd->body.type = bi->i1.shader_type;
+        cmd->body.shid = SVGA3D_INVALID_ID;
+        vmw_fifo_commit(dev_priv, sizeof(*cmd));
+
+        return 0;
+}
+
+/**
+ * vmw_context_scrub_render_target - scrub a render target binding
+ * from a context.
+ *
+ * @bi: single binding information.
+ */
+static int vmw_context_scrub_render_target(struct vmw_ctx_bindinfo *bi)
+{
+        struct vmw_private *dev_priv = bi->ctx->dev_priv;
+        struct {
+                SVGA3dCmdHeader header;
+                SVGA3dCmdSetRenderTarget body;
+        } *cmd;
+
+        cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
+        if (unlikely(cmd == NULL)) {
+                DRM_ERROR("Failed reserving FIFO space for render target "
+                          "unbinding.\n");
+                return -ENOMEM;
+        }
+
+        cmd->header.id = SVGA_3D_CMD_SETRENDERTARGET;
+        cmd->header.size = sizeof(cmd->body);
+        cmd->body.cid = bi->ctx->id;
+        cmd->body.type = bi->i1.rt_type;
+        cmd->body.target.sid = SVGA3D_INVALID_ID;
+        cmd->body.target.face = 0;
+        cmd->body.target.mipmap = 0;
+        vmw_fifo_commit(dev_priv, sizeof(*cmd));
+
+        return 0;
+}
+
+/**
+ * vmw_context_scrub_texture - scrub a texture binding from a context.
+ *
+ * @bi: single binding information.
+ *
+ * TODO: Possibly complement this function with a function that takes
+ * a list of texture bindings and combines them to a single command.
+ */
+static int vmw_context_scrub_texture(struct vmw_ctx_bindinfo *bi)
+{
+        struct vmw_private *dev_priv = bi->ctx->dev_priv;
+        struct {
+                SVGA3dCmdHeader header;
+                struct {
+                        SVGA3dCmdSetTextureState c;
+                        SVGA3dTextureState s1;
+                } body;
+        } *cmd;
+
+        cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));
+        if (unlikely(cmd == NULL)) {
+                DRM_ERROR("Failed reserving FIFO space for texture "
+                          "unbinding.\n");
+                return -ENOMEM;
+        }
+
+
+        cmd->header.id = SVGA_3D_CMD_SETTEXTURESTATE;
+        cmd->header.size = sizeof(cmd->body);
+        cmd->body.c.cid = bi->ctx->id;
+        cmd->body.s1.stage = bi->i1.texture_stage;
+        cmd->body.s1.name = SVGA3D_TS_BIND_TEXTURE;
+        cmd->body.s1.value = (uint32) SVGA3D_INVALID_ID;
+        vmw_fifo_commit(dev_priv, sizeof(*cmd));
+
+        return 0;
+}
+
+/**
+ * vmw_context_binding_drop: Stop tracking a context binding
+ *
+ * @cb: Pointer to binding tracker storage.
+ *
+ * Stops tracking a context binding, and re-initializes its storage.
+ * Typically used when the context binding is replaced with a binding to
+ * another (or the same, for that matter) resource.
+ */
+static void vmw_context_binding_drop(struct vmw_ctx_binding *cb)
+{
+        list_del(&cb->ctx_list);
+        if (!list_empty(&cb->res_list))
+                list_del(&cb->res_list);
+        cb->bi.ctx = NULL;
+}
+
+/**
+ * vmw_context_binding_add: Start tracking a context binding
+ *
+ * @cbs: Pointer to the context binding state tracker.
+ * @bi: Information about the binding to track.
+ *
+ * Performs basic checks on the binding to make sure arguments are within
+ * bounds and then starts tracking the binding in the context binding
+ * state structure @cbs.
+ */
+int vmw_context_binding_add(struct vmw_ctx_binding_state *cbs,
+                            const struct vmw_ctx_bindinfo *bi)
+{
+        struct vmw_ctx_binding *loc;
+
+        switch (bi->bt) {
+        case vmw_ctx_binding_rt:
+                if (unlikely((unsigned)bi->i1.rt_type >= SVGA3D_RT_MAX)) {
+                        DRM_ERROR("Illegal render target type %u.\n",
+                                  (unsigned) bi->i1.rt_type);
+                        return -EINVAL;
+                }
+                loc = &cbs->render_targets[bi->i1.rt_type];
+                break;
+        case vmw_ctx_binding_tex:
+                if (unlikely((unsigned)bi->i1.texture_stage >=
+                             SVGA3D_NUM_TEXTURE_UNITS)) {
+                        DRM_ERROR("Illegal texture/sampler unit %u.\n",
+                                  (unsigned) bi->i1.texture_stage);
+                        return -EINVAL;
+                }
+                loc = &cbs->texture_units[bi->i1.texture_stage];
+                break;
+        case vmw_ctx_binding_shader:
+                if (unlikely((unsigned)bi->i1.shader_type >=
+                             SVGA3D_SHADERTYPE_MAX)) {
+                        DRM_ERROR("Illegal shader type %u.\n",
+                                  (unsigned) bi->i1.shader_type);
+                        return -EINVAL;
+                }
+                loc = &cbs->shaders[bi->i1.shader_type];
+                break;
+        default:
+                BUG();
+        }
+
+        if (loc->bi.ctx != NULL)
+                vmw_context_binding_drop(loc);
+
+        loc->bi = *bi;
+        list_add_tail(&loc->ctx_list, &cbs->list);
+        INIT_LIST_HEAD(&loc->res_list);
+
+        return 0;
+}
+
+/**
+ * vmw_context_binding_transfer: Transfer a context binding tracking entry.
+ *
+ * @cbs: Pointer to the persistent context binding state tracker.
+ * @bi: Information about the binding to track.
+ *
+ */
+static void vmw_context_binding_transfer(struct vmw_ctx_binding_state *cbs,
+                                         const struct vmw_ctx_bindinfo *bi)
+{
+        struct vmw_ctx_binding *loc;
+
+        switch (bi->bt) {
+        case vmw_ctx_binding_rt:
+                loc = &cbs->render_targets[bi->i1.rt_type];
+                break;
+        case vmw_ctx_binding_tex:
+                loc = &cbs->texture_units[bi->i1.texture_stage];
+                break;
+        case vmw_ctx_binding_shader:
+                loc = &cbs->shaders[bi->i1.shader_type];
+                break;
+        default:
+                BUG();
+        }
+
+        if (loc->bi.ctx != NULL)
+                vmw_context_binding_drop(loc);
+
+        loc->bi = *bi;
+        list_add_tail(&loc->ctx_list, &cbs->list);
+        if (bi->res != NULL)
+                list_add_tail(&loc->res_list, &bi->res->binding_head);
+        else
+                INIT_LIST_HEAD(&loc->res_list);
+}
+
+/**
+ * vmw_context_binding_kill - Kill a binding on the device
+ * and stop tracking it.
+ *
+ * @cb: Pointer to binding tracker storage.
+ *
+ * Emits FIFO commands to scrub a binding represented by @cb.
+ * Then stops tracking the binding and re-initializes its storage.
+ */
+void vmw_context_binding_kill(struct vmw_ctx_binding *cb)
+{
+        (void) vmw_scrub_funcs[cb->bi.bt](&cb->bi);
+        vmw_context_binding_drop(cb);
+}
+
+/**
+ * vmw_context_binding_state_kill - Kill all bindings associated with a
+ * struct vmw_ctx_binding state structure, and re-initialize the structure.
+ *
+ * @cbs: Pointer to the context binding state tracker.
+ *
+ * Emits commands to scrub all bindings associated with the
+ * context binding state tracker. Then re-initializes the whole structure.
+ */
+static void vmw_context_binding_state_kill(struct vmw_ctx_binding_state *cbs)
+{
+        struct vmw_ctx_binding *entry, *next;
+
+        list_for_each_entry_safe(entry, next, &cbs->list, ctx_list)
+                vmw_context_binding_kill(entry);
+}
+
+/**
+ * vmw_context_binding_res_list_kill - Kill all bindings on a
+ * resource binding list
+ *
+ * @head: list head of resource binding list
+ *
+ * Kills all bindings associated with a specific resource. Typically
+ * called before the resource is destroyed.
+ */
+void vmw_context_binding_res_list_kill(struct list_head *head)
+{
+        struct vmw_ctx_binding *entry, *next;
+
+        list_for_each_entry_safe(entry, next, head, res_list)
+                vmw_context_binding_kill(entry);
+}
+
+/**
+ * vmw_context_binding_state_transfer - Commit staged binding info
+ *
+ * @ctx: Pointer to context to commit the staged binding info to.
+ * @from: Staged binding info built during execbuf.
+ *
+ * Transfers binding info from a temporary structure to the persistent
+ * structure in the context. This can be done once commands
+ */
+void vmw_context_binding_state_transfer(struct vmw_resource *ctx,
+                                        struct vmw_ctx_binding_state *from)
+{
+        struct vmw_user_context *uctx =
+                container_of(ctx, struct vmw_user_context, res);
+        struct vmw_ctx_binding *entry, *next;
+
+        list_for_each_entry_safe(entry, next, &from->list, ctx_list)
+                vmw_context_binding_transfer(&uctx->cbs, &entry->bi);
+}