Merge tag 'vmwgfx-next-2014-07-04' of git://people.freedesktop.org/~thomash/linux into drm-next (4b7ba869) · Commits · 方亚芬 / linux

drivers/gpu/drm/vmwgfx/Makefile

+2 −1

Original line number	Diff line number	Diff line
		@@ -6,6 +6,7 @@ vmwgfx-y := vmwgfx_execbuf.o vmwgfx_gmr.o vmwgfx_kms.o vmwgfx_drv.o \
		vmwgfx_fifo.o vmwgfx_irq.o vmwgfx_ldu.o vmwgfx_ttm_glue.o \
		vmwgfx_overlay.o vmwgfx_marker.o vmwgfx_gmrid_manager.o \
		vmwgfx_fence.o vmwgfx_dmabuf.o vmwgfx_scrn.o vmwgfx_context.o \
		vmwgfx_surface.o vmwgfx_prime.o vmwgfx_mob.o vmwgfx_shader.o
		vmwgfx_surface.o vmwgfx_prime.o vmwgfx_mob.o vmwgfx_shader.o \
		vmwgfx_cmdbuf_res.o \

		obj-$(CONFIG_DRM_VMWGFX) := vmwgfx.o

drivers/gpu/drm/vmwgfx/vmwgfx_cmdbuf_res.c

0 → 100644

+341 −0

Original line number	Diff line number	Diff line
		/**************************************************************************
		*
		* Copyright © 2014 VMware, Inc., Palo Alto, CA., USA
		* 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, sub license, 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 NON-INFRINGEMENT. IN NO EVENT SHALL
		* THE COPYRIGHT HOLDERS, AUTHORS 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 "vmwgfx_drv.h"

		#define VMW_CMDBUF_RES_MAN_HT_ORDER 12

		enum vmw_cmdbuf_res_state {
		VMW_CMDBUF_RES_COMMITED,
		VMW_CMDBUF_RES_ADD,
		VMW_CMDBUF_RES_DEL
		};

		/**
		* struct vmw_cmdbuf_res - Command buffer managed resource entry.
		*
		* @res: Refcounted pointer to a struct vmw_resource.
		* @hash: Hash entry for the manager hash table.
		* @head: List head used either by the staging list or the manager list
		* of commited resources.
		* @state: Staging state of this resource entry.
		* @man: Pointer to a resource manager for this entry.
		*/
		struct vmw_cmdbuf_res {
		struct vmw_resource *res;
		struct drm_hash_item hash;
		struct list_head head;
		enum vmw_cmdbuf_res_state state;
		struct vmw_cmdbuf_res_manager *man;
		};

		/**
		* struct vmw_cmdbuf_res_manager - Command buffer resource manager.
		*
		* @resources: Hash table containing staged and commited command buffer
		* resources
		* @list: List of commited command buffer resources.
		* @dev_priv: Pointer to a device private structure.
		*
		* @resources and @list are protected by the cmdbuf mutex for now.
		*/
		struct vmw_cmdbuf_res_manager {
		struct drm_open_hash resources;
		struct list_head list;
		struct vmw_private *dev_priv;
		};


		/**
		* vmw_cmdbuf_res_lookup - Look up a command buffer resource
		*
		* @man: Pointer to the command buffer resource manager
		* @resource_type: The resource type, that combined with the user key
		* identifies the resource.
		* @user_key: The user key.
		*
		* Returns a valid refcounted struct vmw_resource pointer on success,
		* an error pointer on failure.
		*/
		struct vmw_resource *
		vmw_cmdbuf_res_lookup(struct vmw_cmdbuf_res_manager *man,
		enum vmw_cmdbuf_res_type res_type,
		u32 user_key)
		{
		struct drm_hash_item *hash;
		int ret;
		unsigned long key = user_key \| (res_type << 24);

		ret = drm_ht_find_item(&man->resources, key, &hash);
		if (unlikely(ret != 0))
		return ERR_PTR(ret);

		return vmw_resource_reference
		(drm_hash_entry(hash, struct vmw_cmdbuf_res, hash)->res);
		}

		/**
		* vmw_cmdbuf_res_free - Free a command buffer resource.
		*
		* @man: Pointer to the command buffer resource manager
		* @entry: Pointer to a struct vmw_cmdbuf_res.
		*
		* Frees a struct vmw_cmdbuf_res entry and drops its reference to the
		* struct vmw_resource.
		*/
		static void vmw_cmdbuf_res_free(struct vmw_cmdbuf_res_manager *man,
		struct vmw_cmdbuf_res *entry)
		{
		list_del(&entry->head);
		WARN_ON(drm_ht_remove_item(&man->resources, &entry->hash));
		vmw_resource_unreference(&entry->res);
		kfree(entry);
		}

		/**
		* vmw_cmdbuf_res_commit - Commit a list of command buffer resource actions
		*
		* @list: Caller's list of command buffer resource actions.
		*
		* This function commits a list of command buffer resource
		* additions or removals.
		* It is typically called when the execbuf ioctl call triggering these
		* actions has commited the fifo contents to the device.
		*/
		void vmw_cmdbuf_res_commit(struct list_head *list)
		{
		struct vmw_cmdbuf_res entry, next;

		list_for_each_entry_safe(entry, next, list, head) {
		list_del(&entry->head);
		switch (entry->state) {
		case VMW_CMDBUF_RES_ADD:
		entry->state = VMW_CMDBUF_RES_COMMITED;
		list_add_tail(&entry->head, &entry->man->list);
		break;
		case VMW_CMDBUF_RES_DEL:
		vmw_resource_unreference(&entry->res);
		kfree(entry);
		break;
		default:
		BUG();
		break;
		}
		}
		}

		/**
		* vmw_cmdbuf_res_revert - Revert a list of command buffer resource actions
		*
		* @man: Pointer to the command buffer resource manager
		* @list: Caller's list of command buffer resource action
		*
		* This function reverts a list of command buffer resource
		* additions or removals.
		* It is typically called when the execbuf ioctl call triggering these
		* actions failed for some reason, and the command stream was never
		* submitted.
		*/
		void vmw_cmdbuf_res_revert(struct list_head *list)
		{
		struct vmw_cmdbuf_res entry, next;
		int ret;

		list_for_each_entry_safe(entry, next, list, head) {
		switch (entry->state) {
		case VMW_CMDBUF_RES_ADD:
		vmw_cmdbuf_res_free(entry->man, entry);
		break;
		case VMW_CMDBUF_RES_DEL:
		ret = drm_ht_insert_item(&entry->man->resources,
		&entry->hash);
		list_del(&entry->head);
		list_add_tail(&entry->head, &entry->man->list);
		entry->state = VMW_CMDBUF_RES_COMMITED;
		break;
		default:
		BUG();
		break;
		}
		}
		}

		/**
		* vmw_cmdbuf_res_add - Stage a command buffer managed resource for addition.
		*
		* @man: Pointer to the command buffer resource manager.
		* @res_type: The resource type.
		* @user_key: The user-space id of the resource.
		* @res: Valid (refcount != 0) pointer to a struct vmw_resource.
		* @list: The staging list.
		*
		* This function allocates a struct vmw_cmdbuf_res entry and adds the
		* resource to the hash table of the manager identified by @man. The
		* entry is then put on the staging list identified by @list.
		*/
		int vmw_cmdbuf_res_add(struct vmw_cmdbuf_res_manager *man,
		enum vmw_cmdbuf_res_type res_type,
		u32 user_key,
		struct vmw_resource *res,
		struct list_head *list)
		{
		struct vmw_cmdbuf_res *cres;
		int ret;

		cres = kzalloc(sizeof(*cres), GFP_KERNEL);
		if (unlikely(cres == NULL))
		return -ENOMEM;

		cres->hash.key = user_key \| (res_type << 24);
		ret = drm_ht_insert_item(&man->resources, &cres->hash);
		if (unlikely(ret != 0))
		goto out_invalid_key;

		cres->state = VMW_CMDBUF_RES_ADD;
		cres->res = vmw_resource_reference(res);
		cres->man = man;
		list_add_tail(&cres->head, list);

		out_invalid_key:
		return ret;
		}

		/**
		* vmw_cmdbuf_res_remove - Stage a command buffer managed resource for removal.
		*
		* @man: Pointer to the command buffer resource manager.
		* @res_type: The resource type.
		* @user_key: The user-space id of the resource.
		* @list: The staging list.
		*
		* This function looks up the struct vmw_cmdbuf_res entry from the manager
		* hash table and, if it exists, removes it. Depending on its current staging
		* state it then either removes the entry from the staging list or adds it
		* to it with a staging state of removal.
		*/
		int vmw_cmdbuf_res_remove(struct vmw_cmdbuf_res_manager *man,
		enum vmw_cmdbuf_res_type res_type,
		u32 user_key,
		struct list_head *list)
		{
		struct vmw_cmdbuf_res *entry;
		struct drm_hash_item *hash;
		int ret;

		ret = drm_ht_find_item(&man->resources, user_key, &hash);
		if (likely(ret != 0))
		return -EINVAL;

		entry = drm_hash_entry(hash, struct vmw_cmdbuf_res, hash);

		switch (entry->state) {
		case VMW_CMDBUF_RES_ADD:
		vmw_cmdbuf_res_free(man, entry);
		break;
		case VMW_CMDBUF_RES_COMMITED:
		(void) drm_ht_remove_item(&man->resources, &entry->hash);
		list_del(&entry->head);
		entry->state = VMW_CMDBUF_RES_DEL;
		list_add_tail(&entry->head, list);
		break;
		default:
		BUG();
		break;
		}

		return 0;
		}

		/**
		* vmw_cmdbuf_res_man_create - Allocate a command buffer managed resource
		* manager.
		*
		* @dev_priv: Pointer to a struct vmw_private
		*
		* Allocates and initializes a command buffer managed resource manager. Returns
		* an error pointer on failure.
		*/
		struct vmw_cmdbuf_res_manager *
		vmw_cmdbuf_res_man_create(struct vmw_private *dev_priv)
		{
		struct vmw_cmdbuf_res_manager *man;
		int ret;

		man = kzalloc(sizeof(*man), GFP_KERNEL);
		if (man == NULL)
		return ERR_PTR(-ENOMEM);

		man->dev_priv = dev_priv;
		INIT_LIST_HEAD(&man->list);
		ret = drm_ht_create(&man->resources, VMW_CMDBUF_RES_MAN_HT_ORDER);
		if (ret == 0)
		return man;

		kfree(man);
		return ERR_PTR(ret);
		}

		/**
		* vmw_cmdbuf_res_man_destroy - Destroy a command buffer managed resource
		* manager.
		*
		* @man: Pointer to the manager to destroy.
		*
		* This function destroys a command buffer managed resource manager and
		* unreferences / frees all command buffer managed resources and -entries
		* associated with it.
		*/
		void vmw_cmdbuf_res_man_destroy(struct vmw_cmdbuf_res_manager *man)
		{
		struct vmw_cmdbuf_res entry, next;

		list_for_each_entry_safe(entry, next, &man->list, head)
		vmw_cmdbuf_res_free(man, entry);

		kfree(man);
		}

		/**
		*
		* vmw_cmdbuf_res_man_size - Return the size of a command buffer managed
		* resource manager
		*
		* Returns the approximate allocation size of a command buffer managed
		* resource manager.
		*/
		size_t vmw_cmdbuf_res_man_size(void)
		{
		static size_t res_man_size;

		if (unlikely(res_man_size == 0))
		res_man_size =
		ttm_round_pot(sizeof(struct vmw_cmdbuf_res_manager)) +
		ttm_round_pot(sizeof(struct hlist_head) <<
		VMW_CMDBUF_RES_MAN_HT_ORDER);

		return res_man_size;
		}

drivers/gpu/drm/vmwgfx/vmwgfx_context.c

+28 −10

Original line number	Diff line number	Diff line
		@@ -33,6 +33,7 @@ struct vmw_user_context {
		struct ttm_base_object base;
		struct vmw_resource res;
		struct vmw_ctx_binding_state cbs;
		struct vmw_cmdbuf_res_manager *man;
		};


		@@ -103,7 +104,8 @@ static const vmw_scrub_func vmw_scrub_funcs[vmw_ctx_binding_max] = {

		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;
		@@ -113,9 +115,9 @@ static void vmw_hw_context_destroy(struct vmw_resource *res)

		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);
		(void) vmw_context_binding_state_kill
		(&container_of(res, struct vmw_user_context, res)->cbs);
		(void) vmw_context_binding_state_kill(&uctx->cbs);
		(void) vmw_gb_context_destroy(res);
		mutex_unlock(&dev_priv->binding_mutex);
		if (dev_priv->pinned_bo != NULL &&
		@@ -152,13 +154,16 @@ static int vmw_gb_context_init(struct vmw_private *dev_priv,
		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))
		goto out_err;

		if (unlikely(ret != 0)) {
		if (res_free)
		res_free(res);
		else
		kfree(res);
		return ret;
		if (dev_priv->has_mob) {
		uctx->man = vmw_cmdbuf_res_man_create(dev_priv);
		if (unlikely(IS_ERR(uctx->man))) {
		ret = PTR_ERR(uctx->man);
		uctx->man = NULL;
		goto out_err;
		}
		}

		memset(&uctx->cbs, 0, sizeof(uctx->cbs));
		@@ -166,6 +171,13 @@ static int vmw_gb_context_init(struct vmw_private *dev_priv,

		vmw_resource_activate(res, vmw_hw_context_destroy);
		return 0;

		out_err:
		if (res_free)
		res_free(res);
		else
		kfree(res);
		return ret;
		}

		static int vmw_context_init(struct vmw_private *dev_priv,
		@@ -471,7 +483,8 @@ int vmw_context_define_ioctl(struct drm_device dev, void data,
		*/

		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(&dev_priv->reservation_sem, true);
		if (unlikely(ret != 0))
		@@ -901,3 +914,8 @@ 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;
		}

drivers/gpu/drm/vmwgfx/vmwgfx_drv.c

+0 −7

Original line number	Diff line number	Diff line
		@@ -946,7 +946,6 @@ static void vmw_postclose(struct drm_device *dev,
		drm_master_put(&vmw_fp->locked_master);
		}

		vmw_compat_shader_man_destroy(vmw_fp->shman);
		ttm_object_file_release(&vmw_fp->tfile);
		kfree(vmw_fp);
		}
		@@ -966,16 +965,10 @@ static int vmw_driver_open(struct drm_device dev, struct drm_file file_priv)
		if (unlikely(vmw_fp->tfile == NULL))
		goto out_no_tfile;

		vmw_fp->shman = vmw_compat_shader_man_create(dev_priv);
		if (IS_ERR(vmw_fp->shman))
		goto out_no_shman;

		file_priv->driver_priv = vmw_fp;

		return 0;

		out_no_shman:
		ttm_object_file_release(&vmw_fp->tfile);
		out_no_tfile:
		kfree(vmw_fp);
		return ret;

drivers/gpu/drm/vmwgfx/vmwgfx_drv.h

+50 −24

Original line number	Diff line number	Diff line
		@@ -40,10 +40,10 @@
		#include <drm/ttm/ttm_module.h>
		#include "vmwgfx_fence.h"

		#define VMWGFX_DRIVER_DATE "20140325"
		#define VMWGFX_DRIVER_DATE "20140704"
		#define VMWGFX_DRIVER_MAJOR 2
		#define VMWGFX_DRIVER_MINOR 6
		#define VMWGFX_DRIVER_PATCHLEVEL 0
		#define VMWGFX_DRIVER_PATCHLEVEL 1
		#define VMWGFX_FILE_PAGE_OFFSET 0x00100000
		#define VMWGFX_FIFO_STATIC_SIZE (1024*1024)
		#define VMWGFX_MAX_RELOCATIONS 2048
		@@ -75,14 +75,11 @@
		#define VMW_RES_FENCE ttm_driver_type3
		#define VMW_RES_SHADER ttm_driver_type4

		struct vmw_compat_shader_manager;

		struct vmw_fpriv {
		struct drm_master *locked_master;
		struct ttm_object_file *tfile;
		struct list_head fence_events;
		bool gb_aware;
		struct vmw_compat_shader_manager *shman;
		};

		struct vmw_dma_buffer {
		@@ -124,6 +121,10 @@ struct vmw_resource {
		void (hw_destroy) (struct vmw_resource res);
		};


		/*
		* Resources that are managed using ioctls.
		*/
		enum vmw_res_type {
		vmw_res_context,
		vmw_res_surface,
		@@ -132,6 +133,15 @@ enum vmw_res_type {
		vmw_res_max
		};

		/*
		* Resources that are managed using command streams.
		*/
		enum vmw_cmdbuf_res_type {
		vmw_cmdbuf_res_compat_shader
		};

		struct vmw_cmdbuf_res_manager;

		struct vmw_cursor_snooper {
		struct drm_crtc *crtc;
		size_t age;
		@@ -341,7 +351,7 @@ struct vmw_sw_context{
		bool needs_post_query_barrier;
		struct vmw_resource *error_resource;
		struct vmw_ctx_binding_state staged_bindings;
		struct list_head staged_shaders;
		struct list_head staged_cmd_res;
		};

		struct vmw_legacy_display;
		@@ -974,7 +984,8 @@ extern void vmw_context_binding_res_list_kill(struct list_head *head);
		extern void vmw_context_binding_res_list_scrub(struct list_head *head);
		extern int vmw_context_rebind_all(struct vmw_resource *ctx);
		extern struct list_head vmw_context_binding_list(struct vmw_resource ctx);

		extern struct vmw_cmdbuf_res_manager *
		vmw_context_res_man(struct vmw_resource *ctx);
		/*
		* Surface management - vmwgfx_surface.c
		*/
		@@ -1008,27 +1019,42 @@ extern int vmw_shader_define_ioctl(struct drm_device dev, void data,
		struct drm_file *file_priv);
		extern int vmw_shader_destroy_ioctl(struct drm_device dev, void data,
		struct drm_file *file_priv);
		extern int vmw_compat_shader_lookup(struct vmw_compat_shader_manager *man,
		extern int vmw_compat_shader_add(struct vmw_private *dev_priv,
		struct vmw_cmdbuf_res_manager *man,
		u32 user_key, const void *bytecode,
		SVGA3dShaderType shader_type,
		u32 *user_key);
		extern void vmw_compat_shaders_commit(struct vmw_compat_shader_manager *man,
		size_t size,
		struct list_head *list);
		extern void vmw_compat_shaders_revert(struct vmw_compat_shader_manager *man,
		extern int vmw_compat_shader_remove(struct vmw_cmdbuf_res_manager *man,
		u32 user_key, SVGA3dShaderType shader_type,
		struct list_head *list);
		extern int vmw_compat_shader_remove(struct vmw_compat_shader_manager *man,
		extern struct vmw_resource *
		vmw_compat_shader_lookup(struct vmw_cmdbuf_res_manager *man,
		u32 user_key, SVGA3dShaderType shader_type);

		/*
		* Command buffer managed resources - vmwgfx_cmdbuf_res.c
		*/

		extern struct vmw_cmdbuf_res_manager *
		vmw_cmdbuf_res_man_create(struct vmw_private *dev_priv);
		extern void vmw_cmdbuf_res_man_destroy(struct vmw_cmdbuf_res_manager *man);
		extern size_t vmw_cmdbuf_res_man_size(void);
		extern struct vmw_resource *
		vmw_cmdbuf_res_lookup(struct vmw_cmdbuf_res_manager *man,
		enum vmw_cmdbuf_res_type res_type,
		u32 user_key);
		extern void vmw_cmdbuf_res_revert(struct list_head *list);
		extern void vmw_cmdbuf_res_commit(struct list_head *list);
		extern int vmw_cmdbuf_res_add(struct vmw_cmdbuf_res_manager *man,
		enum vmw_cmdbuf_res_type res_type,
		u32 user_key,
		SVGA3dShaderType shader_type,
		struct vmw_resource *res,
		struct list_head *list);
		extern int vmw_compat_shader_add(struct vmw_compat_shader_manager *man,
		u32 user_key, const void *bytecode,
		SVGA3dShaderType shader_type,
		size_t size,
		struct ttm_object_file *tfile,
		extern int vmw_cmdbuf_res_remove(struct vmw_cmdbuf_res_manager *man,
		enum vmw_cmdbuf_res_type res_type,
		u32 user_key,
		struct list_head *list);
		extern struct vmw_compat_shader_manager *
		vmw_compat_shader_man_create(struct vmw_private *dev_priv);
		extern void
		vmw_compat_shader_man_destroy(struct vmw_compat_shader_manager *man);


		/**