Merge tag 'armsoc-defconfig' of git://git.kernel.org/pub/scm/linux/kernel/git/arm...

[karo-tx-linux.git] / drivers / dma-buf / sync_file.c

diff --git a/drivers/dma-buf/sync_file.c b/drivers/dma-buf/sync_file.c
index b29a9e817320a844ce0a0f8a89711266a17211a0..6d802f2d2881e21f2c02b5bc3c99abac53e8ed78 100644 (file)
--- a/drivers/dma-buf/sync_file.c
+++ b/drivers/dma-buf/sync_file.c
@@ -54,7 +54,7 @@ err:
        return NULL;
 }
 
-static void fence_check_cb_func(struct fence *f, struct fence_cb *cb)
+static void fence_check_cb_func(struct dma_fence *f, struct dma_fence_cb *cb)
 {
        struct sync_file *sync_file;
 
@@ -71,7 +71,7 @@ static void fence_check_cb_func(struct fence *f, struct fence_cb *cb)
  * takes ownership of @fence. The sync_file can be released with
  * fput(sync_file->file). Returns the sync_file or NULL in case of error.
  */
-struct sync_file *sync_file_create(struct fence *fence)
+struct sync_file *sync_file_create(struct dma_fence *fence)
 {
        struct sync_file *sync_file;
 
@@ -79,7 +79,7 @@ struct sync_file *sync_file_create(struct fence *fence)
        if (!sync_file)
                return NULL;
 
-       sync_file->fence = fence;
+       sync_file->fence = dma_fence_get(fence);
 
        snprintf(sync_file->name, sizeof(sync_file->name), "%s-%s%llu-%d",
                 fence->ops->get_driver_name(fence),
@@ -121,16 +121,16 @@ err:
  * Ensures @fd references a valid sync_file and returns a fence that
  * represents all fence in the sync_file. On error NULL is returned.
  */
-struct fence *sync_file_get_fence(int fd)
+struct dma_fence *sync_file_get_fence(int fd)
 {
        struct sync_file *sync_file;
-       struct fence *fence;
+       struct dma_fence *fence;
 
        sync_file = sync_file_fdget(fd);
        if (!sync_file)
                return NULL;
 
-       fence = fence_get(sync_file->fence);
+       fence = dma_fence_get(sync_file->fence);
        fput(sync_file->file);
 
        return fence;
@@ -138,22 +138,23 @@ struct fence *sync_file_get_fence(int fd)
 EXPORT_SYMBOL(sync_file_get_fence);
 
 static int sync_file_set_fence(struct sync_file *sync_file,
-                              struct fence **fences, int num_fences)
+                              struct dma_fence **fences, int num_fences)
 {
-       struct fence_array *array;
+       struct dma_fence_array *array;
 
        /*
         * The reference for the fences in the new sync_file and held
         * in add_fence() during the merge procedure, so for num_fences == 1
         * we already own a new reference to the fence. For num_fence > 1
-        * we own the reference of the fence_array creation.
+        * we own the reference of the dma_fence_array creation.
         */
        if (num_fences == 1) {
                sync_file->fence = fences[0];
                kfree(fences);
        } else {
-               array = fence_array_create(num_fences, fences,
-                                          fence_context_alloc(1), 1, false);
+               array = dma_fence_array_create(num_fences, fences,
+                                              dma_fence_context_alloc(1),
+                                              1, false);
                if (!array)
                        return -ENOMEM;
 
@@ -163,10 +164,11 @@ static int sync_file_set_fence(struct sync_file *sync_file,
        return 0;
 }
 
-static struct fence **get_fences(struct sync_file *sync_file, int *num_fences)
+static struct dma_fence **get_fences(struct sync_file *sync_file,
+                                    int *num_fences)
 {
-       if (fence_is_array(sync_file->fence)) {
-               struct fence_array *array = to_fence_array(sync_file->fence);
+       if (dma_fence_is_array(sync_file->fence)) {
+               struct dma_fence_array *array = to_dma_fence_array(sync_file->fence);
 
                *num_fences = array->num_fences;
                return array->fences;
@@ -176,12 +178,13 @@ static struct fence **get_fences(struct sync_file *sync_file, int *num_fences)
        return &sync_file->fence;
 }
 
-static void add_fence(struct fence **fences, int *i, struct fence *fence)
+static void add_fence(struct dma_fence **fences,
+                     int *i, struct dma_fence *fence)
 {
        fences[*i] = fence;
 
-       if (!fence_is_signaled(fence)) {
-               fence_get(fence);
+       if (!dma_fence_is_signaled(fence)) {
+               dma_fence_get(fence);
                (*i)++;
        }
 }
@@ -200,7 +203,7 @@ static struct sync_file *sync_file_merge(const char *name, struct sync_file *a,
                                         struct sync_file *b)
 {
        struct sync_file *sync_file;
-       struct fence **fences, **nfences, **a_fences, **b_fences;
+       struct dma_fence **fences, **nfences, **a_fences, **b_fences;
        int i, i_a, i_b, num_fences, a_num_fences, b_num_fences;
 
        sync_file = sync_file_alloc();
@@ -226,8 +229,8 @@ static struct sync_file *sync_file_merge(const char *name, struct sync_file *a,
         * and sync_file_create, this is a reasonable assumption.
         */
        for (i = i_a = i_b = 0; i_a < a_num_fences && i_b < b_num_fences; ) {
-               struct fence *pt_a = a_fences[i_a];
-               struct fence *pt_b = b_fences[i_b];
+               struct dma_fence *pt_a = a_fences[i_a];
+               struct dma_fence *pt_b = b_fences[i_b];
 
                if (pt_a->context < pt_b->context) {
                        add_fence(fences, &i, pt_a);
@@ -255,7 +258,7 @@ static struct sync_file *sync_file_merge(const char *name, struct sync_file *a,
                add_fence(fences, &i, b_fences[i_b]);
 
        if (i == 0)
-               fences[i++] = fence_get(a_fences[0]);
+               fences[i++] = dma_fence_get(a_fences[0]);
 
        if (num_fences > i) {
                nfences = krealloc(fences, i * sizeof(*fences),
@@ -286,8 +289,8 @@ static void sync_file_free(struct kref *kref)
                                                     kref);
 
        if (test_bit(POLL_ENABLED, &sync_file->fence->flags))
-               fence_remove_callback(sync_file->fence, &sync_file->cb);
-       fence_put(sync_file->fence);
+               dma_fence_remove_callback(sync_file->fence, &sync_file->cb);
+       dma_fence_put(sync_file->fence);
        kfree(sync_file);
 }
 
@@ -305,14 +308,13 @@ static unsigned int sync_file_poll(struct file *file, poll_table *wait)
 
        poll_wait(file, &sync_file->wq, wait);
 
-       if (!poll_does_not_wait(wait) &&
-           !test_and_set_bit(POLL_ENABLED, &sync_file->fence->flags)) {
-               if (fence_add_callback(sync_file->fence, &sync_file->cb,
-                                      fence_check_cb_func) < 0)
+       if (!test_and_set_bit(POLL_ENABLED, &sync_file->fence->flags)) {
+               if (dma_fence_add_callback(sync_file->fence, &sync_file->cb,
+                                          fence_check_cb_func) < 0)
                        wake_up_all(&sync_file->wq);
        }
 
-       return fence_is_signaled(sync_file->fence) ? POLLIN : 0;
+       return dma_fence_is_signaled(sync_file->fence) ? POLLIN : 0;
 }
 
 static long sync_file_ioctl_merge(struct sync_file *sync_file,
@@ -370,14 +372,14 @@ err_put_fd:
        return err;
 }
 
-static void sync_fill_fence_info(struct fence *fence,
+static void sync_fill_fence_info(struct dma_fence *fence,
                                 struct sync_fence_info *info)
 {
        strlcpy(info->obj_name, fence->ops->get_timeline_name(fence),
                sizeof(info->obj_name));
        strlcpy(info->driver_name, fence->ops->get_driver_name(fence),
                sizeof(info->driver_name));
-       if (fence_is_signaled(fence))
+       if (dma_fence_is_signaled(fence))
                info->status = fence->status >= 0 ? 1 : fence->status;
        else
                info->status = 0;
@@ -389,7 +391,7 @@ static long sync_file_ioctl_fence_info(struct sync_file *sync_file,
 {
        struct sync_file_info info;
        struct sync_fence_info *fence_info = NULL;
-       struct fence **fences;
+       struct dma_fence **fences;
        __u32 size;
        int num_fences, ret, i;
 
@@ -429,7 +431,7 @@ static long sync_file_ioctl_fence_info(struct sync_file *sync_file,
 
 no_fences:
        strlcpy(info.name, sync_file->name, sizeof(info.name));
-       info.status = fence_is_signaled(sync_file->fence);
+       info.status = dma_fence_is_signaled(sync_file->fence);
        info.num_fences = num_fences;
 
        if (copy_to_user((void __user *)arg, &info, sizeof(info)))