WebSVN – Kolibri OS – Diff – /drivers/video/drm/vmwgfx/vmwgfx_context.c

 struct vmw_user_context {
 	struct ttm_base_object base;
 	struct vmw_resource res;
+	struct vmw_ctx_binding_state cbs;
-	struct vmw_ctx_binding_state cbs;
+	struct vmw_cmdbuf_res_manager *man;
 };
 			       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_shader(struct vmw_ctx_bindinfo *bi, bool rebind);
-static int vmw_context_scrub_render_target(struct vmw_ctx_bindinfo *bi);
+static int vmw_context_scrub_render_target(struct vmw_ctx_bindinfo *bi,
+					   bool rebind);
-static int vmw_context_scrub_texture(struct vmw_ctx_bindinfo *bi);
+static int vmw_context_scrub_texture(struct vmw_ctx_bindinfo *bi, bool rebind);
+static void vmw_context_binding_state_scrub(struct vmw_ctx_binding_state *cbs);
 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 = {
  * Context management:
  */
 static void vmw_hw_context_destroy(struct vmw_resource *res)
-{
+{
+	struct vmw_user_context *uctx =
 		container_of(res, struct vmw_user_context, res);
 	struct vmw_private *dev_priv = res->dev_priv;
 	struct {
 		SVGA3dCmdHeader header;
 		SVGA3dCmdDestroyContext body;
 	} *cmd;
+	if (res->func->destroy == vmw_gb_context_destroy) {
+		mutex_lock(&dev_priv->cmdbuf_mutex);
 		vmw_cmdbuf_res_man_destroy(uctx->man);
+		mutex_lock(&dev_priv->binding_mutex);
-	if (res->func->destroy == vmw_gb_context_destroy) {
+		(void) vmw_context_binding_state_kill(&uctx->cbs);
-		mutex_lock(&dev_priv->cmdbuf_mutex);
+		(void) vmw_gb_context_destroy(res);
-		(void) vmw_gb_context_destroy(res);
+		mutex_unlock(&dev_priv->binding_mutex);
 		if (dev_priv->pinned_bo != NULL &&
 		    !dev_priv->query_cid_valid)
 		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))
-	res->backup_size = SVGA3D_CONTEXT_DATA_SIZE;
+		goto out_err;
+	if (dev_priv->has_mob) {
-	if (unlikely(ret != 0)) {
+		uctx->man = vmw_cmdbuf_res_man_create(dev_priv);
-		if (res_free)
+		if (unlikely(IS_ERR(uctx->man))) {
-			res_free(res);
+			ret = PTR_ERR(uctx->man);
-		else
+			uctx->man = NULL;
-			kfree(res);
+			goto out_err;
 		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;
+out_err:
+	if (res_free)
-	INIT_LIST_HEAD(&uctx->cbs.list);
+		res_free(res);
 	else
-	vmw_resource_activate(res, vmw_hw_context_destroy);
+		kfree(res);
-	return 0;
+	return ret;
 	BUG_ON(bo->mem.mem_type != VMW_PL_MOB);
 	mutex_lock(&dev_priv->binding_mutex);
-	vmw_context_binding_state_kill(&uctx->cbs);
+	vmw_context_binding_state_scrub(&uctx->cbs);
 	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;
 	struct vmw_user_context *ctx;
 	struct vmw_resource *res;
 	struct vmw_resource *tmp;
 	struct drm_vmw_context_arg *arg = (struct drm_vmw_context_arg *)data;
 	struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
-	struct vmw_master *vmaster = vmw_master(file_priv->master);
 	int ret;
 	/*
 	 * Approximate idr memory usage with 128 bytes. It will be limited
 	 * by maximum number_of contexts anyway.
 	 */
+	if (unlikely(vmw_user_context_size == 0))
-	if (unlikely(vmw_user_context_size == 0))
+		vmw_user_context_size = ttm_round_pot(sizeof(*ctx)) + 128 +
-		vmw_user_context_size = ttm_round_pot(sizeof(*ctx)) + 128;
+		  ((dev_priv->has_mob) ? vmw_cmdbuf_res_man_size() : 0);
-	ret = ttm_read_lock(&vmaster->lock, true);
+	ret = ttm_read_lock(&dev_priv->reservation_sem, true);
 	arg->cid = ctx->base.hash.key;
 out_err:
 	vmw_resource_unreference(&res);
 out_unlock:
-	ttm_read_unlock(&vmaster->lock);
+	ttm_read_unlock(&dev_priv->reservation_sem);
 	return ret;
+}
 #endif
 /**
+ * vmw_context_scrub_shader - scrub a shader binding from a context.
  * vmw_context_scrub_shader - scrub a shader binding from a context.
- *
+ * @bi: single binding information.
- * @bi: single binding information.
+ * @rebind: Whether to issue a bind instead of scrub command.
  */
-static int vmw_context_scrub_shader(struct vmw_ctx_bindinfo *bi)
+static int vmw_context_scrub_shader(struct vmw_ctx_bindinfo *bi, bool rebind)
+{
 	struct vmw_private *dev_priv = bi->ctx->dev_priv;
 	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;
+	cmd->body.shid = ((rebind) ? bi->res->id : 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.
  * from a context.
- *
+ * @bi: single binding information.
+ * @rebind: Whether to issue a bind instead of scrub command.
- * @bi: single binding information.
+ */
- */
+static int vmw_context_scrub_render_target(struct vmw_ctx_bindinfo *bi,
-static int vmw_context_scrub_render_target(struct vmw_ctx_bindinfo *bi)
+					   bool rebind)
+{
 	struct vmw_private *dev_priv = bi->ctx->dev_priv;
 	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.sid = ((rebind) ? bi->res->id : SVGA3D_INVALID_ID);
 	cmd->body.target.face = 0;
 	cmd->body.target.mipmap = 0;
 	vmw_fifo_commit(dev_priv, sizeof(*cmd));
 /**
  * vmw_context_scrub_texture - scrub a texture binding from a context.
+ *
+ * @bi: single binding information.
- * @bi: single binding information.
+ * @rebind: Whether to issue a bind instead of scrub command.
+ *
  * 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,
-static int vmw_context_scrub_texture(struct vmw_ctx_bindinfo *bi)
+				     bool rebind)
+{
 	struct vmw_private *dev_priv = bi->ctx->dev_priv;
 	struct {
 		SVGA3dCmdHeader header;
 	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;
+	cmd->body.s1.value = ((rebind) ? bi->res->id : SVGA3D_INVALID_ID);
 	vmw_fifo_commit(dev_priv, sizeof(*cmd));
 	return 0;
 	if (loc->bi.ctx != NULL)
 		vmw_context_binding_drop(loc);
 	loc->bi = *bi;
-	loc->bi = *bi;
+	loc->bi.scrubbed = false;
 	list_add_tail(&loc->ctx_list, &cbs->list);
 	INIT_LIST_HEAD(&loc->res_list);
+	}
 	if (loc->bi.ctx != NULL)
+		vmw_context_binding_drop(loc);
 		vmw_context_binding_drop(loc);
 	if (bi->res != NULL) {
-	loc->bi = *bi;
-	list_add_tail(&loc->ctx_list, &cbs->list);
+	loc->bi = *bi;
-	if (bi->res != NULL)
+	list_add_tail(&loc->ctx_list, &cbs->list);
-		list_add_tail(&loc->res_list, &bi->res->binding_head);
-	else
+		list_add_tail(&loc->res_list, &bi->res->binding_head);
 		INIT_LIST_HEAD(&loc->res_list);
+}
  * Emits FIFO commands to scrub a binding represented by @cb.
  * Then stops tracking the binding and re-initializes its storage.
  */
 static void vmw_context_binding_kill(struct vmw_ctx_binding *cb)
+{
+	if (!cb->bi.scrubbed) {
-	(void) vmw_scrub_funcs[cb->bi.bt](&cb->bi);
+		(void) vmw_scrub_funcs[cb->bi.bt](&cb->bi, false);
+		cb->bi.scrubbed = true;
+	}
 	vmw_context_binding_drop(cb);
+}
 /**
 	list_for_each_entry_safe(entry, next, &cbs->list, ctx_list)
 		vmw_context_binding_kill(entry);
+}
+/**
+ * vmw_context_binding_state_scrub - Scrub all bindings associated with a
+ * struct vmw_ctx_binding state structure.
+ *
+ * @cbs: Pointer to the context binding state tracker.
+ *
+ * Emits commands to scrub all bindings associated with the
+ * context binding state tracker.
+ */
+static void vmw_context_binding_state_scrub(struct vmw_ctx_binding_state *cbs)
+{
+	struct vmw_ctx_binding *entry;
+	list_for_each_entry(entry, &cbs->list, ctx_list) {
+		if (!entry->bi.scrubbed) {
+			(void) vmw_scrub_funcs[entry->bi.bt](&entry->bi, false);
+			entry->bi.scrubbed = true;
+		}
+	}
+}
 /**
  * vmw_context_binding_res_list_kill - Kill all bindings on a
  * resource binding list
+ *
  * @head: list head of resource binding list
 	list_for_each_entry_safe(entry, next, head, res_list)
 		vmw_context_binding_kill(entry);
+}
+/**
+ * vmw_context_binding_res_list_scrub - Scrub all bindings on a
+ * resource binding list
+ *
+ * @head: list head of resource binding list
+ *
+ * Scrub all bindings associated with a specific resource. Typically
+ * called before the resource is evicted.
+ */
+void vmw_context_binding_res_list_scrub(struct list_head *head)
+{
+	struct vmw_ctx_binding *entry;
+	list_for_each_entry(entry, head, res_list) {
+		if (!entry->bi.scrubbed) {
+			(void) vmw_scrub_funcs[entry->bi.bt](&entry->bi, false);
+			entry->bi.scrubbed = true;
+		}
+	}
+}
 /**
  * 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.
 	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);
+}
+/**
+ * vmw_context_rebind_all - Rebind all scrubbed bindings of a context
+ *
+ * @ctx: The context resource
+ *
+ * Walks through the context binding list and rebinds all scrubbed
+ * resources.
+ */
+int vmw_context_rebind_all(struct vmw_resource *ctx)
+{
+	struct vmw_ctx_binding *entry;
+	struct vmw_user_context *uctx =
+		container_of(ctx, struct vmw_user_context, res);
+	struct vmw_ctx_binding_state *cbs = &uctx->cbs;
+	int ret;
+	list_for_each_entry(entry, &cbs->list, ctx_list) {
+		if (likely(!entry->bi.scrubbed))
+			continue;
+		if (WARN_ON(entry->bi.res == NULL || entry->bi.res->id ==
+			    SVGA3D_INVALID_ID))
+			continue;
+		ret = vmw_scrub_funcs[entry->bi.bt](&entry->bi, true);
+		if (unlikely(ret != 0))
+			return ret;
+		entry->bi.scrubbed = false;
+	}
+	return 0;
+}
+/**
+ * vmw_context_binding_list - Return a list of context bindings
+ *
+ * @ctx: The context resource
+ *
+ * Returns the current list of bindings of the given context. Note that
+ * this list becomes stale as soon as the dev_priv::binding_mutex is unlocked.
+ */
+struct list_head *vmw_context_binding_list(struct vmw_resource *ctx)
+{
+	return &(container_of(ctx, struct vmw_user_context, res)->cbs.list);
+}
+struct vmw_cmdbuf_res_manager *vmw_context_res_man(struct vmw_resource *ctx)
+{
+	return container_of(ctx, struct vmw_user_context, res)->man;

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/vmwgfx/vmwgfx_context.c – Rev 4569 → 5078