static struct sync_pt *
viv_sync_pt_dup(
struct sync_pt * sync_pt
)
{
gceSTATUS status;
struct viv_sync_pt *pt;
struct viv_sync_pt *src;
struct viv_sync_timeline *obj;
src = (struct viv_sync_pt *) sync_pt;
obj = (struct viv_sync_timeline *) sync_pt->parent;
/* Create the new sync_pt. */
pt = (struct viv_sync_pt *)
sync_pt_create(&obj->obj, sizeof(struct viv_sync_pt));
pt->stamp = src->stamp;
pt->sync = src->sync;
/* Reference sync point. */
status = gckOS_ReferenceSyncPoint(obj->os, pt->sync);
if (gcmIS_ERROR(status))
{
sync_pt_free((struct sync_pt *)pt);
return NULL;
}
return (struct sync_pt *)pt;
}
static struct sync_fence *adf_sw_complete_fence(struct adf_device *dev)
{
struct sync_pt *pt;
struct sync_fence *complete_fence;
if (!dev->timeline) {
dev->timeline = sw_sync_timeline_create(dev->base.name);
if (!dev->timeline)
return ERR_PTR(-ENOMEM);
dev->timeline_max = 1;
}
dev->timeline_max++;
pt = sw_sync_pt_create(dev->timeline, dev->timeline_max);
if (!pt)
goto err_pt_create;
complete_fence = sync_fence_create(dev->base.name, pt);
if (!complete_fence)
goto err_fence_create;
return complete_fence;
err_fence_create:
sync_pt_free(pt);
err_pt_create:
dev->timeline_max--;
return ERR_PTR(-ENOSYS);
}
struct sync_pt *
viv_sync_pt_create(
struct viv_sync_timeline * obj,
gctSYNC_POINT SyncPoint
)
{
gceSTATUS status;
struct viv_sync_pt * pt;
pt = (struct viv_sync_pt *)
sync_pt_create(&obj->obj, sizeof(struct viv_sync_pt));
pt->stamp = obj->stamp++;
pt->sync = SyncPoint;
/* Dup signal. */
status = gckOS_ReferenceSyncPoint(obj->os, SyncPoint);
if (gcmIS_ERROR(status))
{
sync_pt_free((struct sync_pt *)pt);
return NULL;
}
return (struct sync_pt *) pt;
}
int k3fb_buf_sync_create_fence(struct k3_fb_data_type *k3fd, unsigned value)
{
int fd = -1;
struct sync_fence *fence = NULL;
struct sync_pt *pt = NULL;
BUG_ON(k3fd == NULL);
fd = get_unused_fd();
if (fd < 0) {
K3_FB_ERR("get_unused_fd failed!\n");
return fd;
}
pt = sw_sync_pt_create(k3fd->buf_sync_ctrl.timeline, value);
if (pt == NULL) {
return -ENOMEM;
}
fence = sync_fence_create(BUF_SYNC_FENCE_NAME, pt);
if (fence == NULL) {
sync_pt_free(pt);
return -ENOMEM;
}
sync_fence_install(fence, fd);
return fd;
}
int fence_create(struct sw_sync_timeline *obj, struct fence_data *data)
{
int fd = get_unused_fd();
int err;
struct sync_pt *pt;
struct sync_fence *fence;
if (fd < 0)
return fd;
pt = sw_sync_pt_create(obj, data->value);
if (pt == NULL) {
err = -ENOMEM;
goto err;
}
data->name[sizeof(data->name) - 1] = '\0';
fence = sync_fence_create(data->name, pt);
if (fence == NULL) {
sync_pt_free(pt);
err = -ENOMEM;
goto err;
}
data->fence = fd;
sync_fence_install(fence, fd);
return 0;
err:
put_unused_fd(fd);
return err;
}
void i915_sync_cancel_request(void *handle,
struct drm_i915_gem_execbuffer2 *args,
struct intel_ring_buffer *ring)
{
struct sync_pt *pt = (struct sync_pt *)handle;
if (pt)
sync_pt_free(pt);
}
int mali_stream_create_fence(mali_sync_pt *pt)
{
struct sync_fence *fence;
struct fdtable * fdt;
struct files_struct * files;
int fd = -1;
fence = sync_fence_create("mali_fence", pt);
if (!fence)
{
sync_pt_free(pt);
fd = -EFAULT;
goto out;
}
/* create a fd representing the fence */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,6,0)
fd = get_unused_fd_flags(O_CLOEXEC);
if (fd < 0)
{
sync_fence_put(fence);
goto out;
}
#else
fd = get_unused_fd();
if (fd < 0)
{
sync_fence_put(fence);
goto out;
}
files = current->files;
spin_lock(&files->file_lock);
fdt = files_fdtable(files);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,4,0)
__set_close_on_exec(fd, fdt);
#else
FD_SET(fd, fdt->close_on_exec);
#endif
spin_unlock(&files->file_lock);
#endif /* Linux > 3.6 */
/* bind fence to the new fd */
sync_fence_install(fence, fd);
out:
return fd;
}
static long sw_sync_ioctl_create_fence(struct sw_sync_timeline *obj,
unsigned long arg)
{
int fd = get_unused_fd_flags(O_CLOEXEC);
int err;
struct sync_pt *pt;
struct sync_fence *fence;
struct sw_sync_create_fence_data data;
if (fd < 0)
return fd;
if (copy_from_user(&data, (void __user *)arg, sizeof(data))) {
err = -EFAULT;
goto err;
}
pt = sw_sync_pt_create(obj, data.value);
if (pt == NULL) {
err = -ENOMEM;
goto err;
}
data.name[sizeof(data.name) - 1] = '\0';
fence = sync_fence_create(data.name, pt);
if (fence == NULL) {
sync_pt_free(pt);
err = -ENOMEM;
goto err;
}
data.fence = fd;
if (copy_to_user((void __user *)arg, &data, sizeof(data))) {
sync_fence_put(fence);
err = -EFAULT;
goto err;
}
sync_fence_install(fence, fd);
return 0;
err:
put_unused_fd(fd);
return err;
}
/**
* _sde_fence_create_fd - create fence object and return an fd for it
* This function is NOT thread-safe.
* @timeline: Timeline to associate with fence
* @name: Name for fence
* @val: Timeline value at which to signal the fence
* Return: File descriptor on success, or error code on error
*/
static int _sde_fence_create_fd(void *timeline, const char *name, uint32_t val)
{
struct sync_pt *sync_pt;
struct sync_fence *fence;
signed int fd = -EINVAL;
if (!timeline) {
SDE_ERROR("invalid timeline\n");
goto exit;
}
if (!name)
name = "sde_fence";
/* create sync point */
sync_pt = sw_sync_pt_create(timeline, val);
if (sync_pt == NULL) {
SDE_ERROR("failed to create sync point, %s\n", name);
goto exit;
}
/* create fence */
fence = sync_fence_create(name, sync_pt);
if (fence == NULL) {
sync_pt_free(sync_pt);
SDE_ERROR("couldn't create fence, %s\n", name);
goto exit;
}
/* create fd */
fd = get_unused_fd_flags(0);
if (fd < 0) {
SDE_ERROR("failed to get_unused_fd_flags(), %s\n", name);
sync_fence_put(fence);
goto exit;
}
sync_fence_install(fence, fd);
exit:
return fd;
}
STATIC int balong_ade_overlay_fence_create(struct sw_sync_timeline * timeline,
const char * fence_name, unsigned value)
{
int fd;
struct sync_fence *fence;
struct sync_pt *pt;
if (timeline == NULL){
return -EINVAL;
}
fd = get_unused_fd();
if (fd < 0) {
balongfb_loge("failed to get fd in create fence!\n");
return fd;
}
pt = sw_sync_pt_create(timeline, value);
if (pt == NULL) {
put_unused_fd(fd);
balongfb_loge("failed to create pt in create fence!\n");
return -ENOMEM;
}
fence = sync_fence_create(fence_name, pt);
if (fence == NULL) {
sync_pt_free(pt);
put_unused_fd(fd);
balongfb_loge("failed to create fence in create fence!\n");
return -ENOMEM;
}
sync_fence_install(fence, fd);
return fd;
}
int kbase_stream_create_fence(int tl_fd)
{
struct sync_timeline *tl;
struct sync_pt *pt;
struct sync_fence *fence;
#if LINUX_VERSION_CODE < KERNEL_VERSION(3, 7, 0)
struct files_struct *files;
struct fdtable *fdt;
#endif
int fd;
struct file *tl_file;
tl_file = fget(tl_fd);
if (tl_file == NULL)
return -EBADF;
if (tl_file->f_op != &stream_fops) {
fd = -EBADF;
goto out;
}
tl = tl_file->private_data;
pt = kbase_sync_pt_alloc(tl);
if (!pt) {
fd = -EFAULT;
goto out;
}
fence = sync_fence_create("mali_fence", pt);
if (!fence) {
sync_pt_free(pt);
fd = -EFAULT;
goto out;
}
/* from here the fence owns the sync_pt */
/* create a fd representing the fence */
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 0)
fd = get_unused_fd_flags(O_RDWR | O_CLOEXEC);
if (fd < 0) {
sync_fence_put(fence);
goto out;
}
#else
fd = get_unused_fd();
if (fd < 0) {
sync_fence_put(fence);
goto out;
}
files = current->files;
spin_lock(&files->file_lock);
fdt = files_fdtable(files);
#if LINUX_VERSION_CODE >= KERNEL_VERSION(3, 4, 0)
__set_close_on_exec(fd, fdt);
#else
FD_SET(fd, fdt->close_on_exec);
#endif
spin_unlock(&files->file_lock);
#endif /* LINUX_VERSION_CODE >= KERNEL_VERSION(3, 7, 0) */
/* bind fence to the new fd */
sync_fence_install(fence, fd);
out:
fput(tl_file);
return fd;
}
/*
* This should only be called on sync_pts which have been created but
* not added to a fence.
*/
void kgsl_sync_pt_destroy(struct sync_pt *pt)
{
sync_pt_free(pt);
}
int sprd_fence_create(struct ion_fence_data *data, char *name)
{
int fd = get_unused_fd();
struct sync_pt *pt;
struct sync_fence *fence;
struct sync_timeline_data *parent = NULL;
if (data == NULL || name == NULL)
{
printk(KERN_ERR "sprd_fence_create input para is NULL\n");
return -EFAULT;
}
if (fd < 0)
{
fd = get_unused_fd();
if (fd < 0)
{
printk(KERN_ERR "sprd_sync_pt_create failed to get fd\n");
}
return -EFAULT;
}
if (data->device_type == SPRD_DEVICE_PRIMARY_SYNC)
{
parent = &sprd_timeline;
}
else if (data->device_type == SPRD_DEVICE_VIRTUAL_SYNC)
{
parent = &sprd_timeline_virtual;
}
if (parent == NULL)
{
printk(KERN_ERR "sprd_fence_create failed to get sync timeline\n");
return -EFAULT;
}
mutex_lock(&(parent->sync_mutex));
pt = sprd_sync_pt_create(parent->timeline, parent->timeline_value + data->life_value);
if (pt == NULL)
{
printk(KERN_ERR "sprd_sync_pt_create failed\n");
goto err;
}
fence = sync_fence_create(name, pt);
if (fence == NULL)
{
sync_pt_free(pt);
printk(KERN_ERR "sprd_create_fence failed\n");
goto err;
}
sync_fence_install(fence, fd);
mutex_unlock(&(parent->sync_mutex));
pr_debug("create a fence: %p, fd: %d, life_value: %d, name: %s\n",
(void *)fence, fd, data->life_value, name);
return fd;
err:
put_unused_fd(fd);
mutex_unlock(&(parent->sync_mutex));
return -ENOMEM;
}
