static struct sync_pt *kgsl_sync_pt_dup(struct sync_pt *pt)
{
struct kgsl_sync_pt *kpt = (struct kgsl_sync_pt *) pt;
return kgsl_sync_pt_create(pt->parent, kpt->timestamp);
}
int kgsl_add_fence_event(struct kgsl_device *device,
u32 context_id, u32 timestamp, void __user *data, int len,
struct kgsl_device_private *owner)
{
struct kgsl_fence_event_priv *event;
struct kgsl_timestamp_event_fence priv;
struct kgsl_context *context;
struct sync_pt *pt;
struct sync_fence *fence = NULL;
int ret = -EINVAL;
char fence_name[sizeof(fence->name)] = {};
priv.fence_fd = -1;
if (len != sizeof(priv))
return -EINVAL;
event = kzalloc(sizeof(*event), GFP_KERNEL);
if (event == NULL)
return -ENOMEM;
kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
context = kgsl_context_get_owner(owner, context_id);
if (context == NULL)
goto unlock;
event->context = context;
event->timestamp = timestamp;
pt = kgsl_sync_pt_create(context->timeline, timestamp);
if (pt == NULL) {
KGSL_DRV_ERR(device, "kgsl_sync_pt_create failed\n");
ret = -ENOMEM;
goto unlock;
}
snprintf(fence_name, sizeof(fence_name),
"%s-pid-%d-ctx-%d-ts-%d",
device->name, current->group_leader->pid,
context_id, timestamp);
fence = sync_fence_create(fence_name, pt);
if (fence == NULL) {
/* only destroy pt when not added to fence */
kgsl_sync_pt_destroy(pt);
KGSL_DRV_ERR(device, "sync_fence_create failed\n");
ret = -ENOMEM;
goto unlock;
}
priv.fence_fd = get_unused_fd_flags(0);
if (priv.fence_fd < 0) {
KGSL_DRV_ERR(device, "Unable to get a file descriptor: %d\n",
priv.fence_fd);
ret = priv.fence_fd;
goto unlock;
}
/* Unlock the mutex before copying to user */
kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
if (copy_to_user(data, &priv, sizeof(priv))) {
ret = -EFAULT;
goto out;
}
/*
* Hold the context ref-count for the event - it will get released in
* the callback
*/
ret = kgsl_add_event(device, &context->events, timestamp,
kgsl_fence_event_cb, event);
if (ret)
goto out;
sync_fence_install(fence, priv.fence_fd);
return 0;
unlock:
kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
out:
if (priv.fence_fd >= 0)
put_unused_fd(priv.fence_fd);
if (fence)
sync_fence_put(fence);
kgsl_context_put(context);
kfree(event);
return ret;
}
int kgsl_add_fence_event(struct kgsl_device *device,
u32 context_id, u32 timestamp, void __user *data, int len,
struct kgsl_device_private *owner)
{
struct kgsl_fence_event_priv *event;
struct kgsl_timestamp_event_fence priv;
struct kgsl_context *context;
struct sync_pt *pt;
struct sync_fence *fence = NULL;
int ret = -EINVAL;
if (len != sizeof(priv))
return -EINVAL;
context = kgsl_find_context(owner, context_id);
if (context == NULL)
return -EINVAL;
event = kzalloc(sizeof(*event), GFP_KERNEL);
if (event == NULL)
return -ENOMEM;
event->context = context;
event->timestamp = timestamp;
kgsl_context_get(context);
pt = kgsl_sync_pt_create(context->timeline, timestamp);
if (pt == NULL) {
KGSL_DRV_ERR(device, "kgsl_sync_pt_create failed\n");
ret = -ENOMEM;
goto fail_pt;
}
fence = sync_fence_create("kgsl-fence", pt);
if (fence == NULL) {
/* only destroy pt when not added to fence */
kgsl_sync_pt_destroy(pt);
KGSL_DRV_ERR(device, "sync_fence_create failed\n");
ret = -ENOMEM;
goto fail_fence;
}
priv.fence_fd = get_unused_fd_flags(0);
if (priv.fence_fd < 0) {
KGSL_DRV_ERR(device, "invalid fence fd\n");
ret = -EINVAL;
goto fail_fd;
}
sync_fence_install(fence, priv.fence_fd);
if (copy_to_user(data, &priv, sizeof(priv))) {
ret = -EFAULT;
goto fail_copy_fd;
}
ret = kgsl_add_event(device, context_id, timestamp,
kgsl_fence_event_cb, event, owner);
if (ret)
goto fail_event;
return 0;
fail_event:
fail_copy_fd:
/* clean up sync_fence_install */
put_unused_fd(priv.fence_fd);
fail_fd:
/* clean up sync_fence_create */
sync_fence_put(fence);
fail_fence:
fail_pt:
kgsl_context_put(context);
kfree(event);
return ret;
}
int kgsl_add_fence_event(struct kgsl_device *device,
u32 context_id, u32 timestamp, void __user *data, int len,
struct kgsl_device_private *owner)
{
struct kgsl_timestamp_event_fence priv;
struct kgsl_context *context;
struct sync_pt *pt;
struct sync_fence *fence = NULL;
int ret = -EINVAL;
char fence_name[sizeof(fence->name)] = {};
unsigned int cur;
priv.fence_fd = -1;
if (len != sizeof(priv))
return -EINVAL;
kgsl_mutex_lock(&device->mutex, &device->mutex_owner);
context = kgsl_context_get_owner(owner, context_id);
if (context == NULL)
goto unlock;
pt = kgsl_sync_pt_create(context->timeline, context, timestamp);
if (pt == NULL) {
KGSL_DRV_ERR(device, "kgsl_sync_pt_create failed\n");
ret = -ENOMEM;
goto unlock;
}
snprintf(fence_name, sizeof(fence_name),
"%s-pid-%d-ctx-%d-ts-%d",
device->name, current->group_leader->pid,
context_id, timestamp);
fence = sync_fence_create(fence_name, pt);
if (fence == NULL) {
/* only destroy pt when not added to fence */
kgsl_sync_pt_destroy(pt);
KGSL_DRV_ERR(device, "sync_fence_create failed\n");
ret = -ENOMEM;
goto unlock;
}
priv.fence_fd = get_unused_fd_flags(0);
if (priv.fence_fd < 0) {
KGSL_DRV_ERR(device, "Unable to get a file descriptor: %d\n",
priv.fence_fd);
ret = priv.fence_fd;
goto unlock;
}
sync_fence_install(fence, priv.fence_fd);
/*
* If the timestamp hasn't expired yet create an event to trigger it.
* Otherwise, just signal the fence - there is no reason to go through
* the effort of creating a fence we don't need.
*/
cur = kgsl_readtimestamp(device, context, KGSL_TIMESTAMP_RETIRED);
if (timestamp_cmp(cur, timestamp) >= 0)
kgsl_sync_timeline_signal(context->timeline, cur);
else {
ret = _add_fence_event(device, context, timestamp);
if (ret)
goto unlock;
}
kgsl_context_put(context);
/* Unlock the mutex before copying to user */
kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
if (copy_to_user(data, &priv, sizeof(priv))) {
ret = -EFAULT;
goto out;
}
return 0;
unlock:
kgsl_mutex_unlock(&device->mutex, &device->mutex_owner);
out:
if (priv.fence_fd >= 0)
put_unused_fd(priv.fence_fd);
if (fence)
sync_fence_put(fence);
kgsl_context_put(context);
return ret;
}
