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

 #include
 #include
 #include
 #include "vmwgfx_resource_priv.h"
+#define VMW_RES_EVICT_ERR_COUNT 10
 struct vmw_user_dma_buffer {
-	struct ttm_base_object base;
+	struct ttm_prime_object prime;
 	struct vmw_dma_buffer dma;
 };
 	res->avail = false;
 	res->dev_priv = dev_priv;
 	res->func = func;
 	INIT_LIST_HEAD(&res->lru_head);
 	INIT_LIST_HEAD(&res->mob_head);
+	INIT_LIST_HEAD(&res->binding_head);
 	res->id = -1;
 	res->backup = NULL;
 	res->backup_offset = 0;
 	res->backup_dirty = false;
 	res->res_dirty = false;
 	base = ttm_base_object_lookup(tfile, handle);
 	if (unlikely(base == NULL))
 		return -EINVAL;
-	if (unlikely(base->object_type != converter->object_type))
+	if (unlikely(ttm_base_object_type(base) != converter->object_type))
 		goto out_bad_resource;
+}
 /**
  * Buffer management.
+ */
+/**
+ * vmw_dmabuf_acc_size - Calculate the pinned memory usage of buffers
+ *
+ * @dev_priv: Pointer to a struct vmw_private identifying the device.
+ * @size: The requested buffer size.
+ * @user: Whether this is an ordinary dma buffer or a user dma buffer.
+ */
+static size_t vmw_dmabuf_acc_size(struct vmw_private *dev_priv, size_t size,
+				  bool user)
+{
+	static size_t struct_size, user_struct_size;
+	size_t num_pages = PAGE_ALIGN(size) >> PAGE_SHIFT;
+	size_t page_array_size = ttm_round_pot(num_pages * sizeof(void *));
+	if (unlikely(struct_size == 0)) {
+		size_t backend_size = ttm_round_pot(vmw_tt_size);
+		struct_size = backend_size +
+			ttm_round_pot(sizeof(struct vmw_dma_buffer));
+		user_struct_size = backend_size +
+			ttm_round_pot(sizeof(struct vmw_user_dma_buffer));
+	}
+	if (dev_priv->map_mode == vmw_dma_alloc_coherent)
+		page_array_size +=
+			ttm_round_pot(num_pages * sizeof(dma_addr_t));
+	return ((user) ? user_struct_size : struct_size) +
+		page_array_size;
+}
  */
 void vmw_dmabuf_bo_free(struct ttm_buffer_object *bo)
+{
 	struct vmw_dma_buffer *vmw_bo = vmw_dma_buffer(bo);
+	kfree(vmw_bo);
+}
+static void vmw_user_dmabuf_destroy(struct ttm_buffer_object *bo)
+{
+	struct vmw_user_dma_buffer *vmw_user_bo = vmw_user_dma_buffer(bo);
-	kfree(vmw_bo);
+//   ttm_prime_object_kfree(vmw_user_bo, prime);
+}
 int vmw_dmabuf_init(struct vmw_private *dev_priv,
 		    struct vmw_dma_buffer *vmw_bo,
 		    size_t size, struct ttm_placement *placement,
 		    bool interruptible,
 		    void (*bo_free) (struct ttm_buffer_object *bo))
+{
+	struct ttm_bo_device *bdev = &dev_priv->bdev;
-	struct ttm_bo_device *bdev = &dev_priv->bdev;
+	size_t acc_size;
-	size_t acc_size;
+	int ret;
-	int ret;
+	bool user = (bo_free == &vmw_user_dmabuf_destroy);
-	BUG_ON(!bo_free);
+	BUG_ON(!bo_free && (!user && (bo_free != vmw_dmabuf_bo_free)));
+	acc_size = vmw_dmabuf_acc_size(dev_priv, size, user);
-	acc_size = ttm_bo_acc_size(bdev, size, sizeof(struct vmw_dma_buffer));
+	memset(vmw_bo, 0, sizeof(*vmw_bo));
 	memset(vmw_bo, 0, sizeof(*vmw_bo));
 	INIT_LIST_HEAD(&vmw_bo->res_list);
 	INIT_LIST_HEAD(&vmw_bo->res_list);
-	ret = ttm_bo_init(bdev, &vmw_bo->base, size,
-			  ttm_bo_type_device, placement,
-, interruptible,
-			  NULL, acc_size, NULL, bo_free);
-	return ret;
-}
 	ret = ttm_bo_init(bdev, &vmw_bo->base, size,
-static void vmw_user_dmabuf_destroy(struct ttm_buffer_object *bo)
+			  (user) ? ttm_bo_type_device :
 			  ttm_bo_type_kernel, placement,
-	struct vmw_user_dma_buffer *vmw_user_bo = vmw_user_dma_buffer(bo);
+, interruptible,
 			  NULL, acc_size, NULL, bo_free);
 	*p_base = NULL;
 	if (unlikely(base == NULL))
 		return;
 	vmw_user_bo = container_of(base, struct vmw_user_dma_buffer,
-	vmw_user_bo = container_of(base, struct vmw_user_dma_buffer, base);
+				   prime.base);
 	bo = &vmw_user_bo->dma.base;
+	ttm_bo_unref(&bo);
+}
+static void vmw_user_dmabuf_ref_obj_release(struct ttm_base_object *base,
+					    enum ttm_ref_type ref_type)
+{
+	struct vmw_user_dma_buffer *user_bo;
+	user_bo = container_of(base, struct vmw_user_dma_buffer, prime.base);
+	switch (ref_type) {
+	case TTM_REF_SYNCCPU_WRITE:
+		ttm_bo_synccpu_write_release(&user_bo->dma.base);
+		break;
+	default:
+		BUG();
 	ttm_bo_unref(&bo);
+}
 /**
  * vmw_user_dmabuf_alloc - Allocate a user dma buffer
 		DRM_ERROR("Failed to allocate a buffer.\n");
 		return -ENOMEM;
+	}
+	ret = vmw_dmabuf_init(dev_priv, &user_bo->dma, size,
+			      (dev_priv->has_mob) ?
-	ret = vmw_dmabuf_init(dev_priv, &user_bo->dma, size,
+			      &vmw_sys_placement :
 			      &vmw_vram_sys_placement, true,
 			      &vmw_user_dmabuf_destroy);
 	if (unlikely(ret != 0))
 		return ret;
+	tmp = ttm_bo_reference(&user_bo->dma.base);
+/*
-	tmp = ttm_bo_reference(&user_bo->dma.base);
+    ret = ttm_prime_object_init(tfile,
-	ret = ttm_base_object_init(tfile,
+				    size,
-				   &user_bo->base,
+				    &user_bo->prime,
 				   shareable,
+				   ttm_buffer_type,
-				   ttm_buffer_type,
+				    &vmw_user_dmabuf_release,
-				   &vmw_user_dmabuf_release, NULL);
+				    &vmw_user_dmabuf_ref_obj_release);
 	if (unlikely(ret != 0)) {
 		ttm_bo_unref(&tmp);
+		goto out_no_base_object;
 		goto out_no_base_object;
-	}
+*/
 	*p_dma_buf = &user_bo->dma;
-	*handle = user_bo->base.hash.key;
+	*handle = user_bo->prime.base.hash.key;
 	if (unlikely(bo->destroy != vmw_user_dmabuf_destroy))
 		return -EPERM;
 	vmw_user_bo = vmw_user_dma_buffer(bo);
+	return (vmw_user_bo->prime.base.tfile == tfile ||
+		vmw_user_bo->prime.base.shareable) ? 0 : -EPERM;
+}
+/**
+ * vmw_user_dmabuf_synccpu_grab - Grab a struct vmw_user_dma_buffer for cpu
+ * access, idling previous GPU operations on the buffer and optionally
+ * blocking it for further command submissions.
+ *
+ * @user_bo: Pointer to the buffer object being grabbed for CPU access
+ * @tfile: Identifying the caller.
+ * @flags: Flags indicating how the grab should be performed.
+ *
+ * A blocking grab will be automatically released when @tfile is closed.
+ */
+static int vmw_user_dmabuf_synccpu_grab(struct vmw_user_dma_buffer *user_bo,
+					struct ttm_object_file *tfile,
+					uint32_t flags)
+{
+	struct ttm_buffer_object *bo = &user_bo->dma.base;
+	bool existed;
+    int ret=0;
+	if (flags & drm_vmw_synccpu_allow_cs) {
+		struct ttm_bo_device *bdev = bo->bdev;
+//       spin_lock(&bdev->fence_lock);
+//       ret = ttm_bo_wait(bo, false, true,
+//                 !!(flags & drm_vmw_synccpu_dontblock));
+//       spin_unlock(&bdev->fence_lock);
+		return ret;
+	}
+//   ret = ttm_bo_synccpu_write_grab
+//       (bo, !!(flags & drm_vmw_synccpu_dontblock));
+//   if (unlikely(ret != 0))
+//       return ret;
+	ret = ttm_ref_object_add(tfile, &user_bo->prime.base,
+				 TTM_REF_SYNCCPU_WRITE, &existed);
+//   if (ret != 0 || existed)
+//       ttm_bo_synccpu_write_release(&user_bo->dma.base);
+	return ret;
+}
+/**
+ * vmw_user_dmabuf_synccpu_release - Release a previous grab for CPU access,
+ * and unblock command submission on the buffer if blocked.
+ *
+ * @handle: Handle identifying the buffer object.
+ * @tfile: Identifying the caller.
+ * @flags: Flags indicating the type of release.
+ */
+static int vmw_user_dmabuf_synccpu_release(uint32_t handle,
+					   struct ttm_object_file *tfile,
+					   uint32_t flags)
+{
+	if (!(flags & drm_vmw_synccpu_allow_cs))
+		return ttm_ref_object_base_unref(tfile, handle,
+						 TTM_REF_SYNCCPU_WRITE);
+	return 0;
+}
+/**
+ * vmw_user_dmabuf_synccpu_release - ioctl function implementing the synccpu
+ * functionality.
+ *
+ * @dev: Identifies the drm device.
+ * @data: Pointer to the ioctl argument.
+ * @file_priv: Identifies the caller.
+ *
+ * This function checks the ioctl arguments for validity and calls the
+ * relevant synccpu functions.
+ */
+int vmw_user_dmabuf_synccpu_ioctl(struct drm_device *dev, void *data,
+				  struct drm_file *file_priv)
+{
+	struct drm_vmw_synccpu_arg *arg =
+		(struct drm_vmw_synccpu_arg *) data;
+	struct vmw_dma_buffer *dma_buf;
+	struct vmw_user_dma_buffer *user_bo;
+	struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;
+	int ret;
+	if ((arg->flags & (drm_vmw_synccpu_read | drm_vmw_synccpu_write)) == 0
+	    || (arg->flags & ~(drm_vmw_synccpu_read | drm_vmw_synccpu_write |
+			       drm_vmw_synccpu_dontblock |
+			       drm_vmw_synccpu_allow_cs)) != 0) {
+		DRM_ERROR("Illegal synccpu flags.\n");
+		return -EINVAL;
+	}
+	switch (arg->op) {
+	case drm_vmw_synccpu_grab:
+		ret = vmw_user_dmabuf_lookup(tfile, arg->handle, &dma_buf);
+		if (unlikely(ret != 0))
+			return ret;
+		user_bo = container_of(dma_buf, struct vmw_user_dma_buffer,
+				       dma);
+		ret = vmw_user_dmabuf_synccpu_grab(user_bo, tfile, arg->flags);
+		vmw_dmabuf_unreference(&dma_buf);
+		if (unlikely(ret != 0 && ret != -ERESTARTSYS &&
+			     ret != -EBUSY)) {
+			DRM_ERROR("Failed synccpu grab on handle 0x%08x.\n",
+				  (unsigned int) arg->handle);
+			return ret;
+		}
+		break;
+	case drm_vmw_synccpu_release:
+		ret = vmw_user_dmabuf_synccpu_release(arg->handle, tfile,
+						      arg->flags);
+		if (unlikely(ret != 0)) {
+			DRM_ERROR("Failed synccpu release on handle 0x%08x.\n",
+				  (unsigned int) arg->handle);
+			return ret;
+		}
+		break;
+	default:
+		DRM_ERROR("Invalid synccpu operation.\n");
+		return -EINVAL;
+	}
 	return (vmw_user_bo->base.tfile == tfile ||
-	vmw_user_bo->base.shareable) ? 0 : -EPERM;
+	return 0;
+}
 		printk(KERN_ERR "Invalid buffer object handle 0x%08lx.\n",
 		       (unsigned long)handle);
 		return -ESRCH;
+	}
-	if (unlikely(base->object_type != ttm_buffer_type)) {
+	if (unlikely(ttm_base_object_type(base) != ttm_buffer_type)) {
 		ttm_base_object_unref(&base);
 		printk(KERN_ERR "Invalid buffer object handle 0x%08lx.\n",
 		       (unsigned long)handle);
 		return -EINVAL;
 	}
 	vmw_user_bo = container_of(base, struct vmw_user_dma_buffer,
-	vmw_user_bo = container_of(base, struct vmw_user_dma_buffer, base);
+				   prime.base);
 	(void)ttm_bo_reference(&vmw_user_bo->dma.base);
 	ttm_base_object_unref(&base);
 	*out = &vmw_user_bo->dma;
 	return 0;
+}
 int vmw_user_dmabuf_reference(struct ttm_object_file *tfile,
-int vmw_user_dmabuf_reference(struct ttm_object_file *tfile,
+			      struct vmw_dma_buffer *dma_buf,
-			      struct vmw_dma_buffer *dma_buf)
+			      uint32_t *handle)
+{
+	struct vmw_user_dma_buffer *user_bo;
-	struct vmw_user_dma_buffer *user_bo;
+	if (dma_buf->base.destroy != vmw_user_dmabuf_destroy)
+		return -EINVAL;
-	if (dma_buf->base.destroy != vmw_user_dmabuf_destroy)
+	user_bo = container_of(dma_buf, struct vmw_user_dma_buffer, dma);
 		return -EINVAL;
 	*handle = user_bo->prime.base.hash.key;
 		    struct drm_device *dev,
 		    struct drm_mode_create_dumb *args)
+{
 	struct vmw_private *dev_priv = vmw_priv(dev);
 	struct vmw_master *vmaster = vmw_master(file_priv->master);
-	struct vmw_user_dma_buffer *vmw_user_bo;
+	struct vmw_dma_buffer *dma_buf;
-	struct ttm_buffer_object *tmp;
 	int ret;
 	args->pitch = args->width * ((args->bpp + 7) / 8);
-	args->size = args->pitch * args->height;
-	vmw_user_bo = kzalloc(sizeof(*vmw_user_bo), GFP_KERNEL);
-	if (vmw_user_bo == NULL)
-		return -ENOMEM;
+	args->size = args->pitch * args->height;
-	ret = ttm_read_lock(&vmaster->lock, true);
-	if (ret != 0) {
+	ret = ttm_read_lock(&vmaster->lock, true);
-		kfree(vmw_user_bo);
-		return ret;
-	}
-	ret = vmw_dmabuf_init(dev_priv, &vmw_user_bo->dma, args->size,
-			      &vmw_vram_sys_placement, true,
-			      &vmw_user_dmabuf_destroy);
-	if (ret != 0)
-		goto out_no_dmabuf;
+	if (unlikely(ret != 0))
+		return ret;
-	tmp = ttm_bo_reference(&vmw_user_bo->dma.base);
-	ret = ttm_base_object_init(vmw_fpriv(file_priv)->tfile,
-				   &vmw_user_bo->base,
-				   false,
+	ret = vmw_user_dmabuf_alloc(dev_priv, vmw_fpriv(file_priv)->tfile,
-				   ttm_buffer_type,
+				    args->size, false, &args->handle,
-				   &vmw_user_dmabuf_release, NULL);
-	if (unlikely(ret != 0))
-		goto out_no_base_object;
+				    &dma_buf);
-	args->handle = vmw_user_bo->base.hash.key;
+	if (unlikely(ret != 0))
 		goto out_no_dmabuf;
 out_no_base_object:
-	ttm_bo_unref(&tmp);
+	vmw_dmabuf_unreference(&dma_buf);
 out_no_dmabuf:
+	ttm_read_unlock(&vmaster->lock);
+	return ret;
+}
+#endif
+/**
+ * vmw_dumb_map_offset - Return the address space offset of a dumb buffer
+ *
+ * @file_priv: Pointer to a struct drm_file identifying the caller.
+ * @dev: Pointer to the drm device.
-	ttm_read_unlock(&vmaster->lock);
+ * @handle: Handle identifying the dumb buffer.
-	return ret;
+ * @offset: The address space offset returned.
+ *
-#endif
+ * This is a driver callback for the core drm dumb_map_offset functionality.
  */
 	*offset = drm_vma_node_offset_addr(&out_buf->base.vma_node);
 	vmw_dmabuf_unreference(&out_buf);
 	return 0;
+}
+/**
+ * vmw_dumb_destroy - Destroy a dumb boffer
+ *
+ * @file_priv: Pointer to a struct drm_file identifying the caller.
+ * @dev: Pointer to the drm device.
+ * @handle: Handle identifying the dumb buffer.
+ *
+ * This is a driver callback for the core drm dumb_destroy functionality.
  */
 int vmw_dumb_destroy(struct drm_file *file_priv,
 		     struct drm_device *dev,
 		     uint32_t handle)
+{
 		list_add_tail(&res->mob_head, &new_backup->res_list);
+	}
 	if (new_backup)
 		res->backup_offset = new_backup_offset;
-	if (!res->func->may_evict)
+	if (!res->func->may_evict || res->id == -1)
 		return;
 	write_lock(&dev_priv->resource_lock);
  * @val_buf:        On successful return contains data about the
  *                  reserved and validated backup buffer.
  */
 static int
 vmw_resource_check_buffer(struct vmw_resource *res,
-			  struct ww_acquire_ctx *ticket,
 			  bool interruptible,
 			  struct ttm_validate_buffer *val_buf)
+{
 	struct list_head val_list;
 	bool backup_dirty = false;
+	}
 	INIT_LIST_HEAD(&val_list);
 	val_buf->bo = ttm_bo_reference(&res->backup->base);
 	list_add_tail(&val_buf->head, &val_list);
-	ret = ttm_eu_reserve_buffers(ticket, &val_list);
+	ret = ttm_eu_reserve_buffers(NULL, &val_list);
 	if (unlikely(ret != 0))
 		goto out_no_reserve;
 		goto out_no_validate;
 	return 0;
 out_no_validate:
-	ttm_eu_backoff_reservation(ticket, &val_list);
+	ttm_eu_backoff_reservation(NULL, &val_list);
 out_no_reserve:
 	ttm_bo_unref(&val_buf->bo);
  *                                    backup buffer
  *.
  * @val_buf:        Backup buffer information.
  */
 static void
-vmw_resource_backoff_reservation(struct ww_acquire_ctx *ticket,
+vmw_resource_backoff_reservation(struct ttm_validate_buffer *val_buf)
-				 struct ttm_validate_buffer *val_buf)
+{
 	struct list_head val_list;
 	if (likely(val_buf->bo == NULL))
 		return;
 	INIT_LIST_HEAD(&val_list);
 	list_add_tail(&val_buf->head, &val_list);
-	ttm_eu_backoff_reservation(ticket, &val_list);
+	ttm_eu_backoff_reservation(NULL, &val_list);
 	ttm_bo_unref(&val_buf->bo);
+}
 /**
  * vmw_resource_do_evict - Evict a resource, and transfer its data
+ *                         to a backup buffer.
  *                         to a backup buffer.
- *
+ * @res:            The resource to evict.
- * @res:            The resource to evict.
+ * @interruptible:  Whether to wait interruptible.
  */
-int vmw_resource_do_evict(struct vmw_resource *res)
+int vmw_resource_do_evict(struct vmw_resource *res, bool interruptible)
-{
 	struct ttm_validate_buffer val_buf;
-	const struct vmw_res_func *func = res->func;
+	struct ttm_validate_buffer val_buf;
-	struct ww_acquire_ctx ticket;
+	const struct vmw_res_func *func = res->func;
 	int ret;
 	BUG_ON(!func->may_evict);
 	val_buf.bo = NULL;
+	}
 	ret = func->destroy(res);
 	res->backup_dirty = true;
 	res->res_dirty = false;
 out_no_unbind:
-	vmw_resource_backoff_reservation(&ticket, &val_buf);
+	vmw_resource_backoff_reservation(&val_buf);
 	return ret;
 	int ret;
 	struct vmw_resource *evict_res;
 	struct vmw_private *dev_priv = res->dev_priv;
 	struct list_head *lru_list = &dev_priv->res_lru[res->func->res_type];
 	struct ttm_validate_buffer val_buf;
+	unsigned err_count = 0;
 	if (likely(!res->func->may_evict))
 		return 0;
 		if (likely(ret != -EBUSY))
 			break;
 		write_lock(&dev_priv->resource_lock);
 		if (list_empty(lru_list) || !res->func->may_evict) {
-			DRM_ERROR("Out of device device id entries "
+			DRM_ERROR("Out of device device resources "
 				  "for %s.\n", res->func->type_name);
 			ret = -EBUSY;
 			write_unlock(&dev_priv->resource_lock);
 			break;
 			(list_first_entry(lru_list, struct vmw_resource,
 					  lru_head));
 		list_del_init(&evict_res->lru_head);
+		write_unlock(&dev_priv->resource_lock);
-		write_unlock(&dev_priv->resource_lock);
+		ret = vmw_resource_do_evict(evict_res, true);
+		if (unlikely(ret != 0)) {
+			write_lock(&dev_priv->resource_lock);
+			list_add_tail(&evict_res->lru_head, lru_list);
+			write_unlock(&dev_priv->resource_lock);
+			if (ret == -ERESTARTSYS ||
+			    ++err_count > VMW_RES_EVICT_ERR_COUNT) {
+				vmw_resource_unreference(&evict_res);
+				goto out_no_validate;
+			}
+		}
 		vmw_resource_do_evict(evict_res);
 		vmw_resource_unreference(&evict_res);
 	} while (1);
+ *
  * @bo:             The TTM buffer object about to move.
  * @mem:            The truct ttm_mem_reg indicating to what memory
  *                  region the move is taking place.
+ *
+ * Evicts the Guest Backed hardware resource if the backup
+ * buffer is being moved out of MOB memory.
+ * Note that this function should not race with the resource
+ * validation code as long as it accesses only members of struct
+ * resource that remain static while bo::res is !NULL and
+ * while we have @bo reserved. struct resource::backup is *not* a
+ * static member. The resource validation code will take care
+ * to set @bo::res to NULL, while having @bo reserved when the
+ * buffer is no longer bound to the resource, so @bo:res can be
+ * used to determine whether there is a need to unbind and whether
- * For now does nothing.
+ * it is safe to unbind.
  */
 void vmw_resource_move_notify(struct ttm_buffer_object *bo,
 			      struct ttm_mem_reg *mem)
+{
+}
+ *
  * @dev_priv:       Pointer to a device private struct
  * @type:           The resource type to evict
+ *
  * To avoid thrashing starvation or as part of the hibernation sequence,
- * evict all evictable resources of a specific type.
+ * try to evict all evictable resources of a specific type.
  */
 static void vmw_resource_evict_type(struct vmw_private *dev_priv,
 				    enum vmw_res_type type)
+{
 	struct list_head *lru_list = &dev_priv->res_lru[type];
 	struct vmw_resource *evict_res;
+	unsigned err_count = 0;
+	int ret;
 	do {
 		write_lock(&dev_priv->resource_lock);
 		evict_res = vmw_resource_reference(
 			list_first_entry(lru_list, struct vmw_resource,
 					 lru_head));
 		list_del_init(&evict_res->lru_head);
 		write_unlock(&dev_priv->resource_lock);
-		vmw_resource_do_evict(evict_res);
+		ret = vmw_resource_do_evict(evict_res, false);
+		if (unlikely(ret != 0)) {
+			write_lock(&dev_priv->resource_lock);
+			list_add_tail(&evict_res->lru_head, lru_list);
+			write_unlock(&dev_priv->resource_lock);
+			if (++err_count > VMW_RES_EVICT_ERR_COUNT) {
+				vmw_resource_unreference(&evict_res);
+				return;
+			}
+		}
 		vmw_resource_unreference(&evict_res);
 	} while (1);
 out_unlock:

Subversion Repositories Kolibri OS

(root)/drivers/video/drm/vmwgfx/vmwgfx_resource.c – Rev 4111 → 4569