Subversion Repositories Kolibri OS

	list_del_init(&res->lru_head);

	list_del_init(&res->lru_head);

	write_unlock(&dev_priv->resource_lock);

	write_unlock(&dev_priv->resource_lock);

	if (res->backup) {

	if (res->backup) {

		struct ttm_buffer_object *bo = &res->backup->base;

		struct ttm_buffer_object *bo = &res->backup->base;

		ttm_bo_reserve(bo, false, false, false, 0);

		ttm_bo_reserve(bo, false, false, false, NULL);

		if (!list_empty(&res->mob_head) &&

		if (!list_empty(&res->mob_head) &&

		    res->func->unbind != NULL) {

		    res->func->unbind != NULL) {

			struct ttm_validate_buffer val_buf;

			struct ttm_validate_buffer val_buf;

		list_del_init(&res->mob_head);

		list_del_init(&res->mob_head);

		ttm_bo_unreserve(bo);

		ttm_bo_unreserve(bo);

		vmw_dmabuf_unreference(&res->backup);

		vmw_dmabuf_unreference(&res->backup);

	}

	}

	if (likely(res->hw_destroy != NULL))

	if (likely(res->hw_destroy != NULL)) {

		res->hw_destroy(res);

	}

	id = res->id;

	id = res->id;

	if (res->res_free != NULL)

	if (res->res_free != NULL)

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

			  (user) ? ttm_bo_type_device :

	ret = ttm_bo_init(bdev, &vmw_bo->base, size,

			  ttm_bo_type_kernel, placement,

			  ttm_bo_type_device, placement,

			  0, interruptible,

			  0, interruptible,

			  NULL, acc_size, NULL, bo_free);

			  NULL, acc_size, NULL, bo_free);

	if (unlikely(bo->destroy != vmw_user_dmabuf_destroy))

	if (unlikely(bo->destroy != vmw_user_dmabuf_destroy))

		return -EPERM;

		return -EPERM;

	return (vmw_user_bo->prime.base.tfile == tfile ||

	DRM_ERROR("Could not grant buffer access.\n");

		vmw_user_bo->prime.base.shareable) ? 0 : -EPERM;

	return -EPERM;

}

}

					struct ttm_object_file *tfile,

					struct ttm_object_file *tfile,

					uint32_t flags)

					uint32_t flags)

{

{

	struct ttm_buffer_object *bo = &user_bo->dma.base;

	struct ttm_buffer_object *bo = &user_bo->dma.base;

	bool existed;

	bool existed;

	if (flags & drm_vmw_synccpu_allow_cs) {

	if (flags & drm_vmw_synccpu_allow_cs) {

		struct ttm_bo_device *bdev = bo->bdev;

		struct ttm_bo_device *bdev = bo->bdev;

	    (union drm_vmw_alloc_dmabuf_arg *)data;

	    (union drm_vmw_alloc_dmabuf_arg *)data;

	struct drm_vmw_alloc_dmabuf_req *req = &arg->req;

	struct drm_vmw_alloc_dmabuf_req *req = &arg->req;

	struct drm_vmw_dmabuf_rep *rep = &arg->rep;

	struct drm_vmw_dmabuf_rep *rep = &arg->rep;

	struct vmw_dma_buffer *dma_buf;

	struct vmw_dma_buffer *dma_buf;

	uint32_t handle;

	uint32_t handle;

	int ret;

	int ret;

	ret = ttm_read_lock(&vmaster->lock, true);

	ret = ttm_read_lock(&dev_priv->reservation_sem, true);

	if (unlikely(ret != 0))

	if (unlikely(ret != 0))

		return ret;

		return ret;

	rep->cur_gmr_offset = 0;

	rep->cur_gmr_offset = 0;

	vmw_dmabuf_unreference(&dma_buf);

	vmw_dmabuf_unreference(&dma_buf);

out_no_dmabuf:

out_no_dmabuf:

	ttm_read_unlock(&vmaster->lock);

	ttm_read_unlock(&dev_priv->reservation_sem);

{

{

	struct vmw_user_stream *stream =

	struct vmw_user_stream *stream =

	    container_of(res, struct vmw_user_stream, stream.res);

	    container_of(res, struct vmw_user_stream, stream.res);

	struct vmw_private *dev_priv = res->dev_priv;

	struct vmw_private *dev_priv = res->dev_priv;

//   ttm_base_object_kfree(stream, base);

	ttm_base_object_kfree(stream, base);

	ttm_mem_global_free(vmw_mem_glob(dev_priv),

	ttm_mem_global_free(vmw_mem_glob(dev_priv),

			    vmw_user_stream_size);

			    vmw_user_stream_size);

}

}

	struct vmw_user_stream *stream;

	struct vmw_user_stream *stream;

	struct vmw_resource *res;

	struct vmw_resource *res;

	struct vmw_resource *tmp;

	struct vmw_resource *tmp;

	struct drm_vmw_stream_arg *arg = (struct drm_vmw_stream_arg *)data;

	struct drm_vmw_stream_arg *arg = (struct drm_vmw_stream_arg *)data;

	struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;

	struct ttm_object_file *tfile = vmw_fpriv(file_priv)->tfile;

	int ret;

	int ret;

	/*

	/*

	 * Approximate idr memory usage with 128 bytes. It will be limited

	 * Approximate idr memory usage with 128 bytes. It will be limited

	 * by maximum number_of streams anyway?

	 * by maximum number_of streams anyway?

	 */

	 */

		vmw_user_stream_size = ttm_round_pot(sizeof(*stream)) + 128;

		vmw_user_stream_size = ttm_round_pot(sizeof(*stream)) + 128;

	ret = ttm_read_lock(&vmaster->lock, true);

	ret = ttm_read_lock(&dev_priv->reservation_sem, true);

	if (unlikely(ret != 0))

	if (unlikely(ret != 0))

	arg->stream_id = res->id;

	arg->stream_id = res->id;

out_err:

out_err:

	vmw_resource_unreference(&res);

	vmw_resource_unreference(&res);

	ttm_read_unlock(&vmaster->lock);

	ttm_read_unlock(&dev_priv->reservation_sem);

	return ret;

	return ret;

}

}

#endif

#endif

	int ret;

	int ret;

	args->pitch = args->width * ((args->bpp + 7) / 8);

	args->pitch = args->width * ((args->bpp + 7) / 8);

	ret = ttm_read_lock(&vmaster->lock, true);

	ret = ttm_read_lock(&dev_priv->reservation_sem, true);

	if (unlikely(ret != 0))

	if (unlikely(ret != 0))

		return ret;

		return ret;

	if (unlikely(ret != 0))

	if (unlikely(ret != 0))

		goto out_no_dmabuf;

		goto out_no_dmabuf;

	vmw_dmabuf_unreference(&dma_buf);

	vmw_dmabuf_unreference(&dma_buf);

	ttm_read_unlock(&vmaster->lock);

	ttm_read_unlock(&dev_priv->reservation_sem);

	return ret;

	return ret;

}

}

#endif

#endif