Merge branch 'vmwgfx-fixes-3.13' of git://people.freedesktop.org/~thomash/linux into drm-fixes (28adb302) · Commits · e / devices / android_kernel_samsung_universal8890

drivers/gpu/drm/ttm/ttm_execbuf_util.c

+19 −13

Original line number	Diff line number	Diff line
		@@ -32,8 +32,7 @@
		#include <linux/sched.h>
		#include <linux/module.h>

		static void ttm_eu_backoff_reservation_locked(struct list_head *list,
		struct ww_acquire_ctx *ticket)
		static void ttm_eu_backoff_reservation_locked(struct list_head *list)
		{
		struct ttm_validate_buffer *entry;

		@@ -93,7 +92,8 @@ void ttm_eu_backoff_reservation(struct ww_acquire_ctx *ticket,
		entry = list_first_entry(list, struct ttm_validate_buffer, head);
		glob = entry->bo->glob;
		spin_lock(&glob->lru_lock);
		ttm_eu_backoff_reservation_locked(list, ticket);
		ttm_eu_backoff_reservation_locked(list);
		if (ticket)
		ww_acquire_fini(ticket);
		spin_unlock(&glob->lru_lock);
		}
		@@ -130,6 +130,7 @@ int ttm_eu_reserve_buffers(struct ww_acquire_ctx *ticket,
		entry = list_first_entry(list, struct ttm_validate_buffer, head);
		glob = entry->bo->glob;

		if (ticket)
		ww_acquire_init(ticket, &reservation_ww_class);
		retry:
		list_for_each_entry(entry, list, head) {
		@@ -139,16 +140,17 @@ retry:
		if (entry->reserved)
		continue;


		ret = ttm_bo_reserve_nolru(bo, true, false, true, ticket);
		ret = ttm_bo_reserve_nolru(bo, true, (ticket == NULL), true,
		ticket);

		if (ret == -EDEADLK) {
		/* uh oh, we lost out, drop every reservation and try
		* to only reserve this buffer, then start over if
		* this succeeds.
		*/
		BUG_ON(ticket == NULL);
		spin_lock(&glob->lru_lock);
		ttm_eu_backoff_reservation_locked(list, ticket);
		ttm_eu_backoff_reservation_locked(list);
		spin_unlock(&glob->lru_lock);
		ttm_eu_list_ref_sub(list);
		ret = ww_mutex_lock_slow_interruptible(&bo->resv->lock,
		@@ -175,6 +177,7 @@ retry:
		}
		}

		if (ticket)
		ww_acquire_done(ticket);
		spin_lock(&glob->lru_lock);
		ttm_eu_del_from_lru_locked(list);
		@@ -184,12 +187,14 @@ retry:

		err:
		spin_lock(&glob->lru_lock);
		ttm_eu_backoff_reservation_locked(list, ticket);
		ttm_eu_backoff_reservation_locked(list);
		spin_unlock(&glob->lru_lock);
		ttm_eu_list_ref_sub(list);
		err_fini:
		if (ticket) {
		ww_acquire_done(ticket);
		ww_acquire_fini(ticket);
		}
		return ret;
		}
		EXPORT_SYMBOL(ttm_eu_reserve_buffers);
		@@ -224,6 +229,7 @@ void ttm_eu_fence_buffer_objects(struct ww_acquire_ctx *ticket,
		}
		spin_unlock(&bdev->fence_lock);
		spin_unlock(&glob->lru_lock);
		if (ticket)
		ww_acquire_fini(ticket);

		list_for_each_entry(entry, list, head) {

drivers/gpu/drm/ttm/ttm_object.c

+248 −6

Original line number	Diff line number	Diff line
		/**************************************************************************
		*
		* Copyright (c) 2009 VMware, Inc., Palo Alto, CA., USA
		* Copyright (c) 2009-2013 VMware, Inc., Palo Alto, CA., USA
		* All Rights Reserved.
		*
		* Permission is hereby granted, free of charge, to any person obtaining a
		@@ -26,6 +26,12 @@
		**************************************************************************/
		/*
		* Authors: Thomas Hellstrom <thellstrom-at-vmware-dot-com>
		*
		* While no substantial code is shared, the prime code is inspired by
		* drm_prime.c, with
		* Authors:
		* Dave Airlie <airlied@redhat.com>
		* Rob Clark <rob.clark@linaro.org>
		*/
		/** @file ttm_ref_object.c
		*
		@@ -34,6 +40,7 @@
		* and release on file close.
		*/


		/**
		* struct ttm_object_file
		*
		@@ -84,6 +91,9 @@ struct ttm_object_device {
		struct drm_open_hash object_hash;
		atomic_t object_count;
		struct ttm_mem_global *mem_glob;
		struct dma_buf_ops ops;
		void (dmabuf_release)(struct dma_buf dma_buf);
		size_t dma_buf_size;
		};

		/**
		@@ -116,6 +126,8 @@ struct ttm_ref_object {
		struct ttm_object_file *tfile;
		};

		static void ttm_prime_dmabuf_release(struct dma_buf *dma_buf);

		static inline struct ttm_object_file *
		ttm_object_file_ref(struct ttm_object_file *tfile)
		{
		@@ -416,9 +428,10 @@ out_err:
		}
		EXPORT_SYMBOL(ttm_object_file_init);

		struct ttm_object_device *ttm_object_device_init(struct ttm_mem_global
		*mem_glob,
		unsigned int hash_order)
		struct ttm_object_device *
		ttm_object_device_init(struct ttm_mem_global *mem_glob,
		unsigned int hash_order,
		const struct dma_buf_ops *ops)
		{
		struct ttm_object_device tdev = kmalloc(sizeof(tdev), GFP_KERNEL);
		int ret;
		@@ -430,10 +443,17 @@ struct ttm_object_device *ttm_object_device_init(struct ttm_mem_global
		spin_lock_init(&tdev->object_lock);
		atomic_set(&tdev->object_count, 0);
		ret = drm_ht_create(&tdev->object_hash, hash_order);

		if (likely(ret == 0))
		if (ret != 0)
		goto out_no_object_hash;

		tdev->ops = *ops;
		tdev->dmabuf_release = tdev->ops.release;
		tdev->ops.release = ttm_prime_dmabuf_release;
		tdev->dma_buf_size = ttm_round_pot(sizeof(struct dma_buf)) +
		ttm_round_pot(sizeof(struct file));
		return tdev;

		out_no_object_hash:
		kfree(tdev);
		return NULL;
		}
		@@ -452,3 +472,225 @@ void ttm_object_device_release(struct ttm_object_device **p_tdev)
		kfree(tdev);
		}
		EXPORT_SYMBOL(ttm_object_device_release);

		/**
		* get_dma_buf_unless_doomed - get a dma_buf reference if possible.
		*
		* @dma_buf: Non-refcounted pointer to a struct dma-buf.
		*
		* Obtain a file reference from a lookup structure that doesn't refcount
		* the file, but synchronizes with its release method to make sure it has
		* not been freed yet. See for example kref_get_unless_zero documentation.
		* Returns true if refcounting succeeds, false otherwise.
		*
		* Nobody really wants this as a public API yet, so let it mature here
		* for some time...
		*/
		static bool __must_check get_dma_buf_unless_doomed(struct dma_buf *dmabuf)
		{
		return atomic_long_inc_not_zero(&dmabuf->file->f_count) != 0L;
		}

		/**
		* ttm_prime_refcount_release - refcount release method for a prime object.
		*
		* @p_base: Pointer to ttm_base_object pointer.
		*
		* This is a wrapper that calls the refcount_release founction of the
		* underlying object. At the same time it cleans up the prime object.
		* This function is called when all references to the base object we
		* derive from are gone.
		*/
		static void ttm_prime_refcount_release(struct ttm_base_object **p_base)
		{
		struct ttm_base_object base = p_base;
		struct ttm_prime_object *prime;

		*p_base = NULL;
		prime = container_of(base, struct ttm_prime_object, base);
		BUG_ON(prime->dma_buf != NULL);
		mutex_destroy(&prime->mutex);
		if (prime->refcount_release)
		prime->refcount_release(&base);
		}

		/**
		* ttm_prime_dmabuf_release - Release method for the dma-bufs we export
		*
		* @dma_buf:
		*
		* This function first calls the dma_buf release method the driver
		* provides. Then it cleans up our dma_buf pointer used for lookup,
		* and finally releases the reference the dma_buf has on our base
		* object.
		*/
		static void ttm_prime_dmabuf_release(struct dma_buf *dma_buf)
		{
		struct ttm_prime_object *prime =
		(struct ttm_prime_object *) dma_buf->priv;
		struct ttm_base_object *base = &prime->base;
		struct ttm_object_device *tdev = base->tfile->tdev;

		if (tdev->dmabuf_release)
		tdev->dmabuf_release(dma_buf);
		mutex_lock(&prime->mutex);
		if (prime->dma_buf == dma_buf)
		prime->dma_buf = NULL;
		mutex_unlock(&prime->mutex);
		ttm_mem_global_free(tdev->mem_glob, tdev->dma_buf_size);
		ttm_base_object_unref(&base);
		}

		/**
		* ttm_prime_fd_to_handle - Get a base object handle from a prime fd
		*
		* @tfile: A struct ttm_object_file identifying the caller.
		* @fd: The prime / dmabuf fd.
		* @handle: The returned handle.
		*
		* This function returns a handle to an object that previously exported
		* a dma-buf. Note that we don't handle imports yet, because we simply
		* have no consumers of that implementation.
		*/
		int ttm_prime_fd_to_handle(struct ttm_object_file *tfile,
		int fd, u32 *handle)
		{
		struct ttm_object_device *tdev = tfile->tdev;
		struct dma_buf *dma_buf;
		struct ttm_prime_object *prime;
		struct ttm_base_object *base;
		int ret;

		dma_buf = dma_buf_get(fd);
		if (IS_ERR(dma_buf))
		return PTR_ERR(dma_buf);

		if (dma_buf->ops != &tdev->ops)
		return -ENOSYS;

		prime = (struct ttm_prime_object *) dma_buf->priv;
		base = &prime->base;
		*handle = base->hash.key;
		ret = ttm_ref_object_add(tfile, base, TTM_REF_USAGE, NULL);

		dma_buf_put(dma_buf);

		return ret;
		}
		EXPORT_SYMBOL_GPL(ttm_prime_fd_to_handle);

		/**
		* ttm_prime_handle_to_fd - Return a dma_buf fd from a ttm prime object
		*
		* @tfile: Struct ttm_object_file identifying the caller.
		* @handle: Handle to the object we're exporting from.
		* @flags: flags for dma-buf creation. We just pass them on.
		* @prime_fd: The returned file descriptor.
		*
		*/
		int ttm_prime_handle_to_fd(struct ttm_object_file *tfile,
		uint32_t handle, uint32_t flags,
		int *prime_fd)
		{
		struct ttm_object_device *tdev = tfile->tdev;
		struct ttm_base_object *base;
		struct dma_buf *dma_buf;
		struct ttm_prime_object *prime;
		int ret;

		base = ttm_base_object_lookup(tfile, handle);
		if (unlikely(base == NULL \|\|
		base->object_type != ttm_prime_type)) {
		ret = -ENOENT;
		goto out_unref;
		}

		prime = container_of(base, struct ttm_prime_object, base);
		if (unlikely(!base->shareable)) {
		ret = -EPERM;
		goto out_unref;
		}

		ret = mutex_lock_interruptible(&prime->mutex);
		if (unlikely(ret != 0)) {
		ret = -ERESTARTSYS;
		goto out_unref;
		}

		dma_buf = prime->dma_buf;
		if (!dma_buf \|\| !get_dma_buf_unless_doomed(dma_buf)) {

		/*
		* Need to create a new dma_buf, with memory accounting.
		*/
		ret = ttm_mem_global_alloc(tdev->mem_glob, tdev->dma_buf_size,
		false, true);
		if (unlikely(ret != 0)) {
		mutex_unlock(&prime->mutex);
		goto out_unref;
		}

		dma_buf = dma_buf_export(prime, &tdev->ops,
		prime->size, flags);
		if (IS_ERR(dma_buf)) {
		ret = PTR_ERR(dma_buf);
		ttm_mem_global_free(tdev->mem_glob,
		tdev->dma_buf_size);
		mutex_unlock(&prime->mutex);
		goto out_unref;
		}

		/*
		* dma_buf has taken the base object reference
		*/
		base = NULL;
		prime->dma_buf = dma_buf;
		}
		mutex_unlock(&prime->mutex);

		ret = dma_buf_fd(dma_buf, flags);
		if (ret >= 0) {
		*prime_fd = ret;
		ret = 0;
		} else
		dma_buf_put(dma_buf);

		out_unref:
		if (base)
		ttm_base_object_unref(&base);
		return ret;
		}
		EXPORT_SYMBOL_GPL(ttm_prime_handle_to_fd);

		/**
		* ttm_prime_object_init - Initialize a ttm_prime_object
		*
		* @tfile: struct ttm_object_file identifying the caller
		* @size: The size of the dma_bufs we export.
		* @prime: The object to be initialized.
		* @shareable: See ttm_base_object_init
		* @type: See ttm_base_object_init
		* @refcount_release: See ttm_base_object_init
		* @ref_obj_release: See ttm_base_object_init
		*
		* Initializes an object which is compatible with the drm_prime model
		* for data sharing between processes and devices.
		*/
		int ttm_prime_object_init(struct ttm_object_file *tfile, size_t size,
		struct ttm_prime_object *prime, bool shareable,
		enum ttm_object_type type,
		void (refcount_release) (struct ttm_base_object *),
		void (ref_obj_release) (struct ttm_base_object ,
		enum ttm_ref_type ref_type))
		{
		mutex_init(&prime->mutex);
		prime->size = PAGE_ALIGN(size);
		prime->real_type = type;
		prime->dma_buf = NULL;
		prime->refcount_release = refcount_release;
		return ttm_base_object_init(tfile, &prime->base, shareable,
		ttm_prime_type,
		ttm_prime_refcount_release,
		ref_obj_release);
		}
		EXPORT_SYMBOL(ttm_prime_object_init);

drivers/gpu/drm/vmwgfx/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -6,6 +6,6 @@ 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_surface.o vmwgfx_prime.o

		obj-$(CONFIG_DRM_VMWGFX) := vmwgfx.o

drivers/gpu/drm/vmwgfx/vmwgfx_drv.c

+5 −2

Original line number	Diff line number	Diff line
		@@ -677,7 +677,7 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
		}

		dev_priv->tdev = ttm_object_device_init
		(dev_priv->mem_global_ref.object, 12);
		(dev_priv->mem_global_ref.object, 12, &vmw_prime_dmabuf_ops);

		if (unlikely(dev_priv->tdev == NULL)) {
		DRM_ERROR("Unable to initialize TTM object management.\n");
		@@ -1210,7 +1210,7 @@ static const struct file_operations vmwgfx_driver_fops = {

		static struct drm_driver driver = {
		.driver_features = DRIVER_HAVE_IRQ \| DRIVER_IRQ_SHARED \|
		DRIVER_MODESET,
		DRIVER_MODESET \| DRIVER_PRIME,
		.load = vmw_driver_load,
		.unload = vmw_driver_unload,
		.lastclose = vmw_lastclose,
		@@ -1235,6 +1235,9 @@ static struct drm_driver driver = {
		.dumb_map_offset = vmw_dumb_map_offset,
		.dumb_destroy = vmw_dumb_destroy,

		.prime_fd_to_handle = vmw_prime_fd_to_handle,
		.prime_handle_to_fd = vmw_prime_handle_to_fd,

		.fops = &vmwgfx_driver_fops,
		.name = VMWGFX_DRIVER_NAME,
		.desc = VMWGFX_DRIVER_DESC,

drivers/gpu/drm/vmwgfx/vmwgfx_drv.h

+14 −0

Original line number	Diff line number	Diff line
		@@ -818,6 +818,20 @@ int vmw_overlay_num_free_overlays(struct vmw_private *dev_priv);

		extern const struct ttm_mem_type_manager_func vmw_gmrid_manager_func;

		/**
		* Prime - vmwgfx_prime.c
		*/

		extern const struct dma_buf_ops vmw_prime_dmabuf_ops;
		extern int vmw_prime_fd_to_handle(struct drm_device *dev,
		struct drm_file *file_priv,
		int fd, u32 *handle);
		extern int vmw_prime_handle_to_fd(struct drm_device *dev,
		struct drm_file *file_priv,
		uint32_t handle, uint32_t flags,
		int *prime_fd);


		/**
		* Inline helper functions
		*/