int ttm_pl_synccpu_ioctl(struct ttm_object_file *tfile, void *data)
{
struct ttm_pl_synccpu_arg *arg = data;
struct ttm_bo_user_object *user_bo;
struct ttm_buffer_object *bo;
struct ttm_base_object *base;
bool existed;
int ret;
switch (arg->op) {
case TTM_PL_SYNCCPU_OP_GRAB:
user_bo = ttm_bo_user_lookup(tfile, arg->handle);
if (unlikely(user_bo == NULL)) {
printk(KERN_ERR
"Could not find buffer object for synccpu.\n");
return -EINVAL;
}
bo = &user_bo->bo;
base = &user_bo->base;
ret = ttm_bo_synccpu_write_grab(bo,
arg->access_mode &
TTM_PL_SYNCCPU_MODE_NO_BLOCK);
if (unlikely(ret != 0)) {
ttm_base_object_unref(&base);
goto out;
}
ret = ttm_ref_object_add(tfile, &user_bo->base,
TTM_REF_SYNCCPU_WRITE, &existed);
if (existed || ret != 0)
ttm_bo_synccpu_write_release(bo);
ttm_base_object_unref(&base);
break;
case TTM_PL_SYNCCPU_OP_RELEASE:
ret = ttm_ref_object_base_unref(tfile, arg->handle,
TTM_REF_SYNCCPU_WRITE);
break;
default:
ret = -EINVAL;
break;
}
out:
return ret;
}
int ttm_vt_unlock(struct ttm_lock *lock)
{
return ttm_ref_object_base_unref(lock->vt_holder,
lock->base.hash.key, TTM_REF_USAGE);
}
int ttm_pl_unref_ioctl(struct ttm_object_file *tfile, void *data)
{
struct ttm_pl_reference_req *arg = data;
return ttm_ref_object_base_unref(tfile, arg->handle, TTM_REF_USAGE);
}
void psb_fence_or_sync(struct drm_file *file_priv,
uint32_t engine,
uint32_t fence_types,
uint32_t fence_flags,
struct list_head *list,
struct psb_ttm_fence_rep *fence_arg,
struct ttm_fence_object **fence_p)
{
struct drm_device *dev = file_priv->minor->dev;
struct drm_psb_private *dev_priv = psb_priv(dev);
struct ttm_fence_device *fdev = &dev_priv->fdev;
int ret;
struct ttm_fence_object *fence;
struct ttm_object_file *tfile = psb_fpriv(file_priv)->tfile;
uint32_t handle;
ret = ttm_fence_user_create(fdev, tfile,
engine, fence_types,
TTM_FENCE_FLAG_EMIT, &fence, &handle);
if (ret) {
/*
* Fence creation failed.
* Fall back to synchronous operation and idle the engine.
*/
if (!(fence_flags & DRM_PSB_FENCE_NO_USER)) {
/*
* Communicate to user-space that
* fence creation has failed and that
* the engine is idle.
*/
fence_arg->handle = ~0;
fence_arg->error = ret;
}
ttm_eu_backoff_reservation(list);
if (fence_p)
*fence_p = NULL;
return;
}
ttm_eu_fence_buffer_objects(list, fence);
if (!(fence_flags & DRM_PSB_FENCE_NO_USER)) {
struct ttm_fence_info info = ttm_fence_get_info(fence);
fence_arg->handle = handle;
fence_arg->fence_class = ttm_fence_class(fence);
fence_arg->fence_type = ttm_fence_types(fence);
fence_arg->signaled_types = info.signaled_types;
fence_arg->error = 0;
} else {
ret =
ttm_ref_object_base_unref(tfile, handle,
ttm_fence_type);
BUG_ON(ret);
}
if (fence_p)
*fence_p = fence;
else if (fence)
ttm_fence_object_unref(&fence);
}
