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

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

Merge branch 'vmwgfx-next' of https://gitlab.freedesktop.org/drawat/linux into drm-next 



Resource dirtying improvement by Thomas,
user-space error logging improvement and
some other minor fixes.

Signed-off-by: default avatarDave Airlie <airlied@redhat.com>
From: Deepak Rawat <drawat@vmware.com>
Link: https://patchwork.freedesktop.org/patch/msgid/20190423211630.61874-1-drawat@vmware.com
parents dbb92471 c601b12f

drivers/gpu/drm/vmwgfx/vmwgfx_binding.c

+48 −50
Original line number Diff line number Diff line
@@ -499,12 +499,9 @@ static int vmw_binding_scrub_shader(struct vmw_ctx_bindinfo *bi, bool rebind) 
		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");

	cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_SET_SHADER;

	cmd->header.size = sizeof(cmd->body);
@@ -534,12 +531,9 @@ static int vmw_binding_scrub_render_target(struct vmw_ctx_bindinfo *bi, 
		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");

	cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_SETRENDERTARGET;

	cmd->header.size = sizeof(cmd->body);
@@ -576,12 +570,9 @@ static int vmw_binding_scrub_texture(struct vmw_ctx_bindinfo *bi, 
		} body;

	} *cmd;



	cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));

	if (unlikely(cmd == NULL)) {

		DRM_ERROR("Failed reserving FIFO space for texture "

			  "unbinding.\n");

	cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_SETTEXTURESTATE;

	cmd->header.size = sizeof(cmd->body);
@@ -610,12 +601,10 @@ static int vmw_binding_scrub_dx_shader(struct vmw_ctx_bindinfo *bi, bool rebind) 
		SVGA3dCmdDXSetShader body;

	} *cmd;



	cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), bi->ctx->id);

	if (unlikely(cmd == NULL)) {

		DRM_ERROR("Failed reserving FIFO space for DX shader "

			  "unbinding.\n");

	cmd = VMW_FIFO_RESERVE_DX(dev_priv, sizeof(*cmd), bi->ctx->id);

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_DX_SET_SHADER;

	cmd->header.size = sizeof(cmd->body);

	cmd->body.type = binding->shader_slot + SVGA3D_SHADERTYPE_MIN;
@@ -641,12 +630,9 @@ static int vmw_binding_scrub_cb(struct vmw_ctx_bindinfo *bi, bool rebind) 
		SVGA3dCmdDXSetSingleConstantBuffer body;

	} *cmd;



	cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), bi->ctx->id);

	if (unlikely(cmd == NULL)) {

		DRM_ERROR("Failed reserving FIFO space for DX shader "

			  "unbinding.\n");

	cmd = VMW_FIFO_RESERVE_DX(dev_priv, sizeof(*cmd), bi->ctx->id);

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_DX_SET_SINGLE_CONSTANT_BUFFER;

	cmd->header.size = sizeof(cmd->body);
@@ -768,12 +754,9 @@ static int vmw_emit_set_sr(struct vmw_ctx_binding_state *cbs, 


	view_id_size = cbs->bind_cmd_count*sizeof(uint32);

	cmd_size = sizeof(*cmd) + view_id_size;

	cmd = vmw_fifo_reserve_dx(ctx->dev_priv, cmd_size, ctx->id);

	if (unlikely(cmd == NULL)) {

		DRM_ERROR("Failed reserving FIFO space for DX shader"

			  " resource binding.\n");

	cmd = VMW_FIFO_RESERVE_DX(ctx->dev_priv, cmd_size, ctx->id);

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_DX_SET_SHADER_RESOURCES;

	cmd->header.size = sizeof(cmd->body) + view_id_size;
@@ -807,12 +790,9 @@ static int vmw_emit_set_rt(struct vmw_ctx_binding_state *cbs) 
	vmw_collect_view_ids(cbs, loc, SVGA3D_MAX_SIMULTANEOUS_RENDER_TARGETS);

	view_id_size = cbs->bind_cmd_count*sizeof(uint32);

	cmd_size = sizeof(*cmd) + view_id_size;

	cmd = vmw_fifo_reserve_dx(ctx->dev_priv, cmd_size, ctx->id);

	if (unlikely(cmd == NULL)) {

		DRM_ERROR("Failed reserving FIFO space for DX render-target"

			  " binding.\n");

	cmd = VMW_FIFO_RESERVE_DX(ctx->dev_priv, cmd_size, ctx->id);

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_DX_SET_RENDERTARGETS;

	cmd->header.size = sizeof(cmd->body) + view_id_size;
@@ -894,12 +874,9 @@ static int vmw_emit_set_so(struct vmw_ctx_binding_state *cbs) 


	so_target_size = cbs->bind_cmd_count*sizeof(SVGA3dSoTarget);

	cmd_size = sizeof(*cmd) + so_target_size;

	cmd = vmw_fifo_reserve_dx(ctx->dev_priv, cmd_size, ctx->id);

	if (unlikely(cmd == NULL)) {

		DRM_ERROR("Failed reserving FIFO space for DX SO target"

			  " binding.\n");

	cmd = VMW_FIFO_RESERVE_DX(ctx->dev_priv, cmd_size, ctx->id);

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_DX_SET_SOTARGETS;

	cmd->header.size = sizeof(cmd->body) + so_target_size;
@@ -1011,12 +988,9 @@ static int vmw_emit_set_vb(struct vmw_ctx_binding_state *cbs) 


	set_vb_size = cbs->bind_cmd_count*sizeof(SVGA3dVertexBuffer);

	cmd_size = sizeof(*cmd) + set_vb_size;

	cmd = vmw_fifo_reserve_dx(ctx->dev_priv, cmd_size, ctx->id);

	if (unlikely(cmd == NULL)) {

		DRM_ERROR("Failed reserving FIFO space for DX vertex buffer"

			  " binding.\n");

	cmd = VMW_FIFO_RESERVE_DX(ctx->dev_priv, cmd_size, ctx->id);

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_DX_SET_VERTEX_BUFFERS;

	cmd->header.size = sizeof(cmd->body) + set_vb_size;
@@ -1167,12 +1141,10 @@ static int vmw_binding_scrub_ib(struct vmw_ctx_bindinfo *bi, bool rebind) 
		SVGA3dCmdDXSetIndexBuffer body;

	} *cmd;



	cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), bi->ctx->id);

	if (unlikely(cmd == NULL)) {

		DRM_ERROR("Failed reserving FIFO space for DX index buffer "

			  "binding.\n");

	cmd = VMW_FIFO_RESERVE_DX(dev_priv, sizeof(*cmd), bi->ctx->id);

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_DX_SET_INDEX_BUFFER;

	cmd->header.size = sizeof(cmd->body);

	if (rebind) {
@@ -1269,6 +1241,32 @@ void vmw_binding_state_reset(struct vmw_ctx_binding_state *cbs) 
		vmw_binding_drop(entry);

}



/**

 * vmw_binding_dirtying - Return whether a binding type is dirtying its resource

 * @binding_type: The binding type

 *

 * Each time a resource is put on the validation list as the result of a

 * context binding referencing it, we need to determine whether that resource

 * will be dirtied (written to by the GPU) as a result of the corresponding

 * GPU operation. Currently rendertarget-, depth-stencil-, and

 * stream-output-target bindings are capable of dirtying its resource.

 *

 * Return: Whether the binding type dirties the resource its binding points to.

 */

u32 vmw_binding_dirtying(enum vmw_ctx_binding_type binding_type)

{

	static u32 is_binding_dirtying[vmw_ctx_binding_max] = {

		[vmw_ctx_binding_rt] = VMW_RES_DIRTY_SET,

		[vmw_ctx_binding_dx_rt] = VMW_RES_DIRTY_SET,

		[vmw_ctx_binding_ds] = VMW_RES_DIRTY_SET,

		[vmw_ctx_binding_so] = VMW_RES_DIRTY_SET,

	};



	/* Review this function as new bindings are added. */

	BUILD_BUG_ON(vmw_ctx_binding_max != 11);

	return is_binding_dirtying[binding_type];

}



/*

 * This function is unused at run-time, and only used to hold various build

 * asserts important for code optimization assumptions.

drivers/gpu/drm/vmwgfx/vmwgfx_binding.h

+2 −0
Original line number Diff line number Diff line
@@ -205,5 +205,7 @@ extern void vmw_binding_state_free(struct vmw_ctx_binding_state *cbs); 
extern struct list_head *

vmw_binding_state_list(struct vmw_ctx_binding_state *cbs);

extern void vmw_binding_state_reset(struct vmw_ctx_binding_state *cbs);

extern u32 vmw_binding_dirtying(enum vmw_ctx_binding_type binding_type);





#endif

drivers/gpu/drm/vmwgfx/vmwgfx_cmdbuf.c

+11 −13
Original line number Diff line number Diff line
@@ -393,6 +393,7 @@ static void vmw_cmdbuf_ctx_process(struct vmw_cmdbuf_man *man, 
			__vmw_cmdbuf_header_free(entry);

			break;

		case SVGA_CB_STATUS_COMMAND_ERROR:

			WARN_ONCE(true, "Command buffer error.\n");

			entry->cb_header->status = SVGA_CB_STATUS_NONE;

			list_add_tail(&entry->list, &man->error);

			schedule_work(&man->work);
@@ -511,17 +512,14 @@ static void vmw_cmdbuf_work_func(struct work_struct *work) 
		container_of(work, struct vmw_cmdbuf_man, work);

	struct vmw_cmdbuf_header *entry, *next;

	uint32_t dummy;

	bool restart[SVGA_CB_CONTEXT_MAX];

	bool send_fence = false;

	struct list_head restart_head[SVGA_CB_CONTEXT_MAX];

	int i;

	struct vmw_cmdbuf_context *ctx;

	bool global_block = false;



	for_each_cmdbuf_ctx(man, i, ctx) {

	for_each_cmdbuf_ctx(man, i, ctx)

		INIT_LIST_HEAD(&restart_head[i]);

		restart[i] = false;

	}



	mutex_lock(&man->error_mutex);

	spin_lock(&man->lock);
@@ -533,22 +531,22 @@ static void vmw_cmdbuf_work_func(struct work_struct *work) 
		const char *cmd_name;



		list_del_init(&entry->list);

		restart[entry->cb_context] = true;

		global_block = true;



		if (!vmw_cmd_describe(header, &error_cmd_size, &cmd_name)) {

			DRM_ERROR("Unknown command causing device error.\n");

			DRM_ERROR("Command buffer offset is %lu\n",

			VMW_DEBUG_USER("Unknown command causing device error.\n");

			VMW_DEBUG_USER("Command buffer offset is %lu\n",

				       (unsigned long) cb_hdr->errorOffset);

			__vmw_cmdbuf_header_free(entry);

			send_fence = true;

			continue;

		}



		DRM_ERROR("Command \"%s\" causing device error.\n", cmd_name);

		DRM_ERROR("Command buffer offset is %lu\n",

		VMW_DEBUG_USER("Command \"%s\" causing device error.\n",

			       cmd_name);

		VMW_DEBUG_USER("Command buffer offset is %lu\n",

			       (unsigned long) cb_hdr->errorOffset);

		DRM_ERROR("Command size is %lu\n",

		VMW_DEBUG_USER("Command size is %lu\n",

			       (unsigned long) error_cmd_size);



		new_start_offset = cb_hdr->errorOffset + error_cmd_size;

drivers/gpu/drm/vmwgfx/vmwgfx_context.c

+18 −41
Original line number Diff line number Diff line
@@ -156,12 +156,9 @@ static void vmw_hw_context_destroy(struct vmw_resource *res) 
	}



	vmw_execbuf_release_pinned_bo(dev_priv);

	cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));

	if (unlikely(cmd == NULL)) {

		DRM_ERROR("Failed reserving FIFO space for surface "

			  "destruction.\n");

	cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));

	if (unlikely(cmd == NULL))

		return;

	}



	cmd->header.id = SVGA_3D_CMD_CONTEXT_DESTROY;

	cmd->header.size = sizeof(cmd->body);
@@ -210,7 +207,7 @@ static int vmw_gb_context_init(struct vmw_private *dev_priv, 
		for (i = 0; i < SVGA_COTABLE_DX10_MAX; ++i) {

			uctx->cotables[i] = vmw_cotable_alloc(dev_priv,

							      &uctx->res, i);

			if (unlikely(IS_ERR(uctx->cotables[i]))) {

			if (IS_ERR(uctx->cotables[i])) {

				ret = PTR_ERR(uctx->cotables[i]);

				goto out_cotables;

			}
@@ -259,9 +256,8 @@ static int vmw_context_init(struct vmw_private *dev_priv, 
		return -ENOMEM;

	}



	cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));

	cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));

	if (unlikely(cmd == NULL)) {

		DRM_ERROR("Fifo reserve failed.\n");

		vmw_resource_unreference(&res);

		return -ENOMEM;

	}
@@ -311,10 +307,8 @@ static int vmw_gb_context_create(struct vmw_resource *res) 
		goto out_no_fifo;

	}



	cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));

	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;

	}
@@ -345,12 +339,10 @@ static int vmw_gb_context_bind(struct vmw_resource *res, 


	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");

	cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_BIND_GB_CONTEXT;

	cmd->header.size = sizeof(cmd->body);

	cmd->body.cid = res->id;
@@ -391,10 +383,8 @@ static int vmw_gb_context_unbind(struct vmw_resource *res, 


	submit_size = sizeof(*cmd2) + (readback ? sizeof(*cmd1) : 0);



	cmd = vmw_fifo_reserve(dev_priv, submit_size);

	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;

	}
@@ -441,12 +431,9 @@ static int vmw_gb_context_destroy(struct vmw_resource *res) 
	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");

	cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_DESTROY_GB_CONTEXT;

	cmd->header.size = sizeof(cmd->body);
@@ -487,10 +474,8 @@ static int vmw_dx_context_create(struct vmw_resource *res) 
		goto out_no_fifo;

	}



	cmd = vmw_fifo_reserve(dev_priv, sizeof(*cmd));

	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;

	}
@@ -521,12 +506,9 @@ static int vmw_dx_context_bind(struct vmw_resource *res, 


	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");

	cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_DX_BIND_CONTEXT;

	cmd->header.size = sizeof(cmd->body);
@@ -615,10 +597,8 @@ static int vmw_dx_context_unbind(struct vmw_resource *res, 


	submit_size = sizeof(*cmd2) + (readback ? sizeof(*cmd1) : 0);



	cmd = vmw_fifo_reserve(dev_priv, submit_size);

	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;

	}
@@ -665,12 +645,9 @@ static int vmw_dx_context_destroy(struct vmw_resource *res) 
	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");

	cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));

	if (unlikely(cmd == NULL))

		return -ENOMEM;

	}



	cmd->header.id = SVGA_3D_CMD_DX_DESTROY_CONTEXT;

	cmd->header.size = sizeof(cmd->body);
@@ -751,7 +728,7 @@ static int vmw_context_define(struct drm_device *dev, void *data, 
	int ret;



	if (!dev_priv->has_dx && dx) {

		DRM_ERROR("DX contexts not supported by device.\n");

		VMW_DEBUG_USER("DX contexts not supported by device.\n");

		return -EINVAL;

	}

drivers/gpu/drm/vmwgfx/vmwgfx_cotable.c

+7 −16
Original line number Diff line number Diff line
@@ -171,12 +171,9 @@ static int vmw_cotable_unscrub(struct vmw_resource *res) 
	WARN_ON_ONCE(bo->mem.mem_type != VMW_PL_MOB);

	lockdep_assert_held(&bo->resv->lock.base);



	cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd), SVGA3D_INVALID_ID);

	if (!cmd) {

		DRM_ERROR("Failed reserving FIFO space for cotable "

			  "binding.\n");

	cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));

	if (!cmd)

		return -ENOMEM;

	}



	WARN_ON(vcotbl->ctx->id == SVGA3D_INVALID_ID);

	WARN_ON(bo->mem.mem_type != VMW_PL_MOB);
@@ -262,12 +259,9 @@ int vmw_cotable_scrub(struct vmw_resource *res, bool readback) 
	if (readback)

		submit_size += sizeof(*cmd0);



	cmd1 = vmw_fifo_reserve_dx(dev_priv, submit_size, SVGA3D_INVALID_ID);

	if (!cmd1) {

		DRM_ERROR("Failed reserving FIFO space for cotable "

			  "unbinding.\n");

	cmd1 = VMW_FIFO_RESERVE(dev_priv, submit_size);

	if (!cmd1)

		return -ENOMEM;

	}



	vcotbl->size_read_back = 0;

	if (readback) {
@@ -351,13 +345,10 @@ static int vmw_cotable_readback(struct vmw_resource *res) 
	struct vmw_fence_obj *fence;



	if (!vcotbl->scrubbed) {

		cmd = vmw_fifo_reserve_dx(dev_priv, sizeof(*cmd),

					  SVGA3D_INVALID_ID);

		if (!cmd) {

			DRM_ERROR("Failed reserving FIFO space for cotable "

				  "readback.\n");

		cmd = VMW_FIFO_RESERVE(dev_priv, sizeof(*cmd));

		if (!cmd)

			return -ENOMEM;

		}



		cmd->header.id = SVGA_3D_CMD_DX_READBACK_COTABLE;

		cmd->header.size = sizeof(cmd->body);

		cmd->body.cid = vcotbl->ctx->id;